auto upstream

25 files changed, 370 insertions, 518 deletions

diff --git a/ChangeLog b/ChangeLog
index f1b134aa8f3..9cb50f67d7b 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2013-02-11  Glenn Morris  <rgm@gnu.org>
+
+        * configure.ac (emacs_config_options): Record some env vars.
+
 2013-02-10  Glenn Morris  <rgm@gnu.org>
 
         * configure.ac (emacs_config_options): Strip out the (internal)
diff --git a/autogen/configure b/autogen/configure
index 1251680b942..8226d489f72 100755
--- a/autogen/configure
+++ b/autogen/configure
@@ -3367,7 +3367,19 @@ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 
+
 emacs_config_options="$@"
+## Add some environment variables, if they were passed via the environment
+## rather than on the command-line.
+for var in CFLAGS CPPFLAGS LDFLAGS; do
+    case "$emacs_config_options" in
+      *$var=*) continue ;;
+    esac
+    eval val="\$${var}"
+    test x"$val" = x && continue
+    emacs_config_options="${emacs_config_options}${emacs_config_options:+ }$var=$val"
+done
+
 ac_config_headers="$ac_config_headers src/config.h:src/config.in"
 
 
diff --git a/configure.ac b/configure.ac
index 7d79db32568..8dfc5c9ba47 100644
--- a/configure.ac
+++ b/configure.ac
@@ -23,9 +23,21 @@ dnl  along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 AC_PREREQ(2.65)
 AC_INIT(emacs, 24.3.50)
+
 dnl This is the documented way to record the args passed to configure,
 dnl rather than $ac_configure_args.
 emacs_config_options="$@"
+## Add some environment variables, if they were passed via the environment
+## rather than on the command-line.
+for var in CFLAGS CPPFLAGS LDFLAGS; do
+    case "$emacs_config_options" in
+      *$var=*) continue ;;
+    esac
+    eval val="\$${var}"
+    test x"$val" = x && continue
+    emacs_config_options="${emacs_config_options}${emacs_config_options:+ }$var=$val"
+done
+
 AC_CONFIG_HEADER(src/config.h:src/config.in)
 AC_CONFIG_SRCDIR(src/lisp.h)
 AC_CONFIG_AUX_DIR(build-aux)
diff --git a/etc/ChangeLog b/etc/ChangeLog
index f6f47d6d1a8..d1b5aac955d 100644
--- a/etc/ChangeLog
+++ b/etc/ChangeLog
@@ -1,3 +1,7 @@
+2013-02-11  Michael Albinus  <michael.albinus@gmx.de>
+
+        * NEWS: Add autorevert changes.
+
 2013-02-05  Jan Djärv  <jan.h.d@swipnet.se>
 
         * NEWS: Mention ns-use-native-fullscreen.
diff --git a/etc/NEWS b/etc/NEWS
index 91ebe803904..a29c8eb054e 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -28,7 +28,10 @@ This happens by default if a suitable support library is found at
 build time, like libacl on GNU/Linux.  To prevent this, use the
 configure option `--without-acl'.
 
+
 * Startup Changes in Emacs 24.4
+
+
 * Changes in Emacs 24.4
 
 +++
@@ -42,6 +45,10 @@ non-nil, they output the same results.
 ** `eval-defun' on an already defined defcustom calls the :set function,
 if there is one.
 
+** If the new variable `enable-dir-local-variables' is nil,
+directory local variables are ignored.  May be useful for some modes
+that want to ignore directory-locals while still respecting file-locals.
+
 ** The option `set-mark-default-inactive' has been deleted.
 This unfinished feature was introduced by accident in Emacs 23.1;
 simply disabling Transient Mark mode does the same thing.
@@ -63,13 +70,7 @@ Available only on X, this option allows to control over-scrolling
 using the scroll bar (i.e. dragging the thumb down even when the end
 of the buffer is visible).
 
-** Nextstep (GNUstep / Mac OS X) port
-
-*** Improved fullscreen support.
-Both native (>= OSX 10.7) and "old style" fullscreen are supported.
-Customize ns-use-native-fullscreen to change style.  For >= 10.7
-native is the default.
-
+
 * Editing Changes in Emacs 24.4
 
 ** New commands `toggle-frame-fullscreen' and `toggle-frame-maximized',
@@ -206,8 +207,11 @@ It is layered as:
 - advice-add/advice-remove to add/remove a piece of advice on a named function,
   much like `defadvice' does.
 
+
 * Incompatible Lisp Changes in Emacs 24.4
 
+** Removed inhibit-local-menu-bar-menus.
+
 ** frame-local variables that affect redisplay do not work any more.
 More specifically, the redisplay does not bother to check for a frame-local
 value when looking up variables.
@@ -229,7 +233,8 @@ alist of extended attributes as returned by the new function
 `file-extended-attributes'.  The attributes can be applied to another
 file using `set-file-extended-attributes'.
 
-* Lisp changes in Emacs 24.4
+
+* Lisp Changes in Emacs 24.4
 
 ** Support for filesystem notifications.
 Emacs now supports notifications of filesystem changes, such as
@@ -237,6 +242,20 @@ creation, modification, and deletion of files.  This requires the
 'inotify' API on GNU/Linux systems.  On MS-Windows systems, this is
 supported for Windows XP and newer versions.
 
+** Changes in autorevert.el
+
+---
+*** If Emacs is compiled with file notification support, notifications
+are used instead of checking the time stamp of the files.  You can
+disable this by setting the user option `auto-revert-use-notify' to
+nil.  Alternatively, a regular expression of directories to be
+excluded from file notifications can be specified by
+`auto-revert-notify-exclude-dir-regexp'.
+
+---
+*** The new user option `auto-revert-remote-files' enables reversion
+of remote files when set to non-nil.
+
 ** Face changes
 
 *** The `face-spec-set' is now analogous to `setq' for face specs.
@@ -273,7 +292,8 @@ used in place of the 9th element of `file-attributes'.
 `preserve-extended-attributes' as it now handles both SELinux context
 and ACL entries.
 
-* Changes in Emacs 24.4 on non-free operating systems
+
+* Changes in Emacs 24.4 on Non-Free Operating Systems
 
 +++
 ** The "generate a backtrace on fatal error" feature now works on MS Windows.
@@ -286,6 +306,11 @@ Setting it has no effect, and %t in the mode-line format is ignored.
 Likewise, `file-name-buffer-file-type-alist' is now obsolete, and
 modifying it has no effect.
 
+** Improved fullscreen support on Mac OS X.
+Both native (>= OSX 10.7) and "old style" fullscreen are supported.
+Customize `ns-use-native-fullscreen' to change style.  For >= 10.7
+native is the default.
+
 
 * Installation Changes in Emacs 24.3
 
diff --git a/etc/PROBLEMS b/etc/PROBLEMS
index 2a588c159c9..441ad7b4df4 100644
--- a/etc/PROBLEMS
+++ b/etc/PROBLEMS
@@ -3198,39 +3198,6 @@ floating point option: -fsoft.
 
 This seems to be due to a GCC bug; it is fixed in GCC 2.8.1.
 
-** Vax C compiler bugs affecting Emacs.
-
-You may get one of these problems compiling Emacs:
-
-   foo.c line nnn: compiler error: no table entry for op STASG
-   foo.c: fatal error in /lib/ccom
-
-These are due to bugs in the C compiler; the code is valid C.
-Unfortunately, the bugs are unpredictable: the same construct
-may compile properly or trigger one of these bugs, depending
-on what else is in the source file being compiled.  Even changes
-in header files that should not affect the file being compiled
-can affect whether the bug happens.  In addition, sometimes files
-that compile correctly on one machine get this bug on another machine.
-
-As a result, it is hard for me to make sure this bug will not affect
-you.  I have attempted to find and alter these constructs, but more
-can always appear.  However, I can tell you how to deal with it if it
-should happen.  The bug comes from having an indexed reference to an
-array of Lisp_Objects, as an argument in a function call:
-  Lisp_Object *args;
-  ...
-   ... foo (5, args[i], ...)...
-putting the argument into a temporary variable first, as in
-  Lisp_Object *args;
-  Lisp_Object tem;
-  ...
-   tem = args[i];
-   ... foo (r, tem, ...)...
-causes the problem to go away.
-The `contents' field of a Lisp vector is an array of Lisp_Objects,
-so you may see the problem happening with indexed references to that.
-
 
 This file is part of GNU Emacs.
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 2878db6271f..fd2186fcfb2 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,7 +1,30 @@
+2013-02-11  Elias Pipping  <pipping@lavabit.com>
+
+        * doc-view.el (doc-view-current-cache-dir): Beware % escapes
+        (bug#13689).
+
+2013-02-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * cus-start.el (all): Remove inhibit-local-menu-bar-menus.
+
+2013-02-11  Glenn Morris  <rgm@gnu.org>
+
+        * vc/diff.el (diff-use-labels): New variable.
+        (diff-no-select): Use --label rather than -L, and first
+        check that it is supported.  (Bug#11067)
+
+        * files.el (enable-dir-local-variables): New variable.
+        (hack-dir-local-variables): Respect enable-dir-local-variables.
+        * tutorial.el (help-with-tutorial):
+        Ignore directory-local variables.  (Bug#11127)
+
+        * vc/vc-svn.el (vc-svn-command): Move --non-interactive from here...
+        (vc-svn-global-switches): ... to here.  (Bug#13513)
+
 2013-02-10  Christopher Schmidt  <christopher@ch.ristopher.com>
 
-        * minibuf-eldef.el (minibuffer-default--in-prompt-regexps): Handle
-        "foo (bar, default: xxx): " prompts.
+        * minibuf-eldef.el (minibuffer-default--in-prompt-regexps):
+        Handle "foo (bar, default: xxx): " prompts.
 
 2013-02-10  Chong Yidong  <cyd@gnu.org>
 
diff --git a/lisp/cus-start.el b/lisp/cus-start.el
index 2bc47426332..2e442b6c944 100644
--- a/lisp/cus-start.el
+++ b/lisp/cus-start.el
@@ -286,7 +286,6 @@ Leaving \"Default\" unchecked is equivalent with specifying a default of
              (double-click-time mouse (restricted-sexp
                                        :match-alternatives (integerp 'nil 't)))
              (double-click-fuzz mouse integer "22.1")
-             (inhibit-local-menu-bar-menus menu boolean)
              (help-char keyboard character)
              (help-event-list keyboard (repeat (sexp :format "%v")))
              (menu-prompting menu boolean)
@@ -301,15 +300,15 @@ Leaving \"Default\" unchecked is equivalent with specifying a default of
                                      (const :tag "When sent SIGUSR2" sigusr2))
                              "24.1")
 
-;; This is not good news because it will use the wrong
-;; version-specific directories when you upgrade.  We need
-;; customization of the front of the list, maintaining the standard
-;; value intact at the back.
-;;;          (load-path environment
-;;;                     (repeat (choice :tag "[Current dir?]"
-;;;                                     :format "%[Current dir?%] %v"
-;;;                                     (const :tag " current dir" nil)
-;;;                                     (directory :format "%v"))))
+             ;; This is not good news because it will use the wrong
+             ;; version-specific directories when you upgrade.  We need
+             ;; customization of the front of the list, maintaining the
+             ;; standard value intact at the back.
+             ;;(load-path environment
+             ;;         (repeat (choice :tag "[Current dir?]"
+             ;;                         :format "%[Current dir?%] %v"
+             ;;                         (const :tag " current dir" nil)
+             ;;                         (directory :format "%v"))))
              ;; minibuf.c
              (enable-recursive-minibuffers minibuffer boolean)
              (history-length minibuffer
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index e7d1ebc35ff..edd59a7b518 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -686,7 +686,8 @@ It's a subdirectory of `doc-view-cache-directory'."
     (setq doc-view-current-cache-dir
           (file-name-as-directory
            (expand-file-name
-            (concat (file-name-nondirectory doc-view-buffer-file-name)
+            (concat (subst-char-in-string ?% ?_ ;; bug#13679
+                     (file-name-nondirectory doc-view-buffer-file-name))
                     "-"
                     (let ((file doc-view-buffer-file-name))
                       (with-temp-buffer
diff --git a/lisp/erc/erc-match.el b/lisp/erc/erc-match.el
index 7ca86b5ac95..1da838557f7 100644
--- a/lisp/erc/erc-match.el
+++ b/lisp/erc/erc-match.el
@@ -447,16 +447,24 @@ Use this defun with `erc-insert-modify-hook'."
                         (nth 0 (erc-parse-user nickuserhost))))
          (old-pt (point))
          (nick-beg (and nickname
-                        (re-search-forward (regexp-quote nickname)
+                        (re-search-forward "\\(\\* \\)?"(regexp-quote nickname)
                                            (point-max) t)
                         (match-beginning 0)))
          (nick-end (when nick-beg
                      (match-end 0)))
-         (message (buffer-substring (if (and nick-end
-                                             (<= (+ 2 nick-end) (point-max)))
-                                        (+ 2 nick-end)
-                                      (point-min))
-                                    (point-max))))
+         (message (buffer-substring
+                   (if (and nick-end
+                            (<= (+ 2 nick-end) (point-max)))
+                       (+ nick-end
+                          ;; Message starts 2 characters after the nick except
+                          ;; for CTCP ACTION messages.
+                          (if (string= "* "
+                                       (buffer-substring (- nick-beg 2)
+                                                         nick-beg))
+                              1
+                            2))
+                     (point-min))
+                   (point-max))))
     (when (and vector
                (not (and erc-match-exclude-server-buffer
                          (erc-server-buffer-p))))
diff --git a/lisp/files.el b/lisp/files.el
index c9e5d2763fe..890834d4af0 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -507,6 +507,11 @@ and ignores this variable."
                  (other :tag "Query" other))
   :group 'find-file)
 
+(defvar enable-dir-local-variables t
+  "Non-nil means enable use of directory-local variables.
+Some modes may wish to set this to nil to prevent directory-local
+settings being applied, but still respect file-local ones.")
+
 ;; This is an odd variable IMO.
 ;; You might wonder why it is needed, when we could just do:
 ;; (set (make-local-variable 'enable-local-variables) nil)
@@ -3659,8 +3664,12 @@ is found.  Returns the new class name."
 (defun hack-dir-local-variables ()
   "Read per-directory local variables for the current buffer.
 Store the directory-local variables in `dir-local-variables-alist'
-and `file-local-variables-alist', without applying them."
+and `file-local-variables-alist', without applying them.
+
+This does nothing if either `enable-local-variables' or
+`enable-dir-local-variables' are nil."
   (when (and enable-local-variables
+             enable-dir-local-variables
              (or enable-remote-dir-locals
                  (not (file-remote-p (or (buffer-file-name)
                                          default-directory)))))
diff --git a/lisp/net/ange-ftp.el b/lisp/net/ange-ftp.el
index ea318ec3250..5e9ba6d9cea 100644
--- a/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@ -5133,7 +5133,7 @@ Other orders of $ and _ seem to all work just fine.")
         (forward-line 1))
       ;; Would like to look for a "Total" line, or a "Directory" line to
       ;; make sure that the listing isn't complete garbage before putting
-      ;; in "." and "..", but we can't even count on all VAX's giving us
+      ;; in "." and "..", but we can't count on VMS giving us
       ;; either of these.
       (puthash "." t tbl)
       (puthash ".." t tbl))
diff --git a/lisp/tutorial.el b/lisp/tutorial.el
index 011461119fc..39eb9e8b9aa 100644
--- a/lisp/tutorial.el
+++ b/lisp/tutorial.el
@@ -829,10 +829,9 @@ Run the Viper tutorial? "))
             (progn
               (insert-file-contents (tutorial--saved-file))
               (let ((enable-local-variables :safe)
-                    (enable-local-eval nil))
+                    (enable-local-eval nil)
+                    (enable-dir-local-variables nil)) ; bug#11127
                 (hack-local-variables))
-              ;; FIXME?  What we actually want is to ignore dir-locals (?).
-              (setq buffer-read-only nil) ; bug#11118
               (goto-char (point-min))
               (setq old-tut-point
                     (string-to-number
@@ -849,10 +848,9 @@ Run the Viper tutorial? "))
               (setq tutorial--point-before-chkeys (point-marker)))
           (insert-file-contents (expand-file-name filename tutorial-directory))
           (let ((enable-local-variables :safe)
-                (enable-local-eval nil))
+                (enable-local-eval nil)
+                (enable-dir-local-variables nil)) ; bug#11127
             (hack-local-variables))
-          ;; FIXME?  What we actually want is to ignore dir-locals (?).
-          (setq buffer-read-only nil) ; bug#11118
           (forward-line)
           (setq tutorial--point-before-chkeys (point-marker)))
 
diff --git a/lisp/vc/diff.el b/lisp/vc/diff.el
index 8b4ff792969..0fc0d2e3f73 100644
--- a/lisp/vc/diff.el
+++ b/lisp/vc/diff.el
@@ -114,6 +114,13 @@ specified in the variable `diff-switches' are passed to the diff command."
           tempfile))
     (file-local-copy file-or-buf)))
 
+(defvar diff-use-labels 'check
+  "Whether `diff-command' understands the \"--label\" option.
+Possible values are:
+  t     -- yes, it does
+  nil   -- no, it does not
+  check -- try to probe whether it does")
+
 (defun diff-no-select (old new &optional switches no-async buf)
   ;; Noninteractive helper for creating and reverting diff buffers
   (unless (bufferp new) (setq new (expand-file-name new)))
@@ -121,6 +128,11 @@ specified in the variable `diff-switches' are passed to the diff command."
   (or switches (setq switches diff-switches)) ; If not specified, use default.
   (unless (listp switches) (setq switches (list switches)))
   (or buf (setq buf (get-buffer-create "*Diff*")))
+  (when (eq 'check diff-use-labels)
+    (setq diff-use-labels
+          (with-temp-buffer
+            (when (ignore-errors (call-process diff-command nil t nil "--help"))
+              (if (search-backward "--label" nil t) t)))))
   (let* ((old-alt (diff-file-local-copy old))
          (new-alt (diff-file-local-copy new))
          (command
@@ -130,11 +142,14 @@ specified in the variable `diff-switches' are passed to the diff command."
                        ,@switches
                        ,@(mapcar #'shell-quote-argument
                                  (nconc
-                                  (when (or old-alt new-alt)
-                                    (list "-L" (if (stringp old)
-                                                   old (prin1-to-string old))
-                                          "-L" (if (stringp new)
-                                                   new (prin1-to-string new))))
+                                  (and (or old-alt new-alt)
+                                       (eq diff-use-labels t)
+                                       (list "--label"
+                                             (if (stringp old) old
+                                               (prin1-to-string old))
+                                             "--label"
+                                             (if (stringp new) new
+                                               (prin1-to-string new))))
                                   (list (or old-alt old)
                                         (or new-alt new)))))
                      " "))
diff --git a/lisp/vc/vc-svn.el b/lisp/vc/vc-svn.el
index fcdd792a69b..923888b460b 100644
--- a/lisp/vc/vc-svn.el
+++ b/lisp/vc/vc-svn.el
@@ -50,14 +50,21 @@
   :type 'string
   :group 'vc-svn)
 
-(defcustom vc-svn-global-switches nil
-  "Global switches to pass to any SVN command."
+;; Might be nice if svn defaulted to non-interactive if stdin not tty.
+;; http://svn.haxx.se/dev/archive-2008-05/0762.shtml
+;; http://svn.haxx.se/dev/archive-2009-04/0094.shtml
+;; Maybe newer ones do?
+(defcustom vc-svn-global-switches (unless (eq system-type 'darwin) ; bug#13513
+                                    '("--non-interactive"))
+  "Global switches to pass to any SVN command.
+The option \"--non-interactive\" is often needed to prevent SVN
+hanging while prompting for authorization."
   :type '(choice (const :tag "None" nil)
                  (string :tag "Argument String")
                  (repeat :tag "Argument List"
                          :value ("")
                          string))
-  :version "22.1"
+  :version "24.4"
   :group 'vc-svn)
 
 (defcustom vc-svn-register-switches nil
@@ -600,19 +607,11 @@ NAME is assumed to be a URL."
 (defun vc-svn-command (buffer okstatus file-or-list &rest flags)
   "A wrapper around `vc-do-command' for use in vc-svn.el.
 The difference to vc-do-command is that this function always invokes `svn',
-and that it passes \"--non-interactive\" and `vc-svn-global-switches' to
-it before FLAGS."
-  ;; Might be nice if svn defaulted to non-interactive if stdin not tty.
-  ;; http://svn.haxx.se/dev/archive-2008-05/0762.shtml
-  ;; http://svn.haxx.se/dev/archive-2009-04/0094.shtml
-  ;; Maybe newer ones do?
-  (or (member "--non-interactive"
-              (setq flags (if (stringp vc-svn-global-switches)
-             (cons vc-svn-global-switches flags)
-                            (append vc-svn-global-switches flags))))
-      (setq flags (cons "--non-interactive" flags)))
+and that it passes `vc-svn-global-switches' to it before FLAGS."
   (apply 'vc-do-command (or buffer "*vc*") okstatus vc-svn-program file-or-list
-         flags))
+         (if (stringp vc-svn-global-switches)
+             (cons vc-svn-global-switches flags)
+           (append vc-svn-global-switches flags))))
 
 (defun vc-svn-repository-hostname (dirname)
   (with-temp-buffer
diff --git a/src/ChangeLog b/src/ChangeLog
index 9d8540075de..b3d3958853b 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,7 +1,47 @@
+2013-02-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Clean up read_key_sequence a tiny bit more.
+        * keyboard.c (read_char_x_menu_prompt) [HAVE_MENUS]:
+        (read_key_sequence): Remove unused locals.
+
+2013-02-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Clean up read_key_sequence a bit; reread active keymaps after first event.
+        * keyboard.c (read_char, read_char_x_menu_prompt)
+        (read_char_minibuf_menu_prompt):
+        Replace nmaps+maps with a single `map' arg.
+        (follow_key): Operate on a single map.
+        (active_maps): New function.
+        (test_undefined): Also return true for nil bindings.
+        (read_key_sequence): Use active_maps to replace the arrays of keymaps with
+        a single (composed) keymap.  Remember `first_event' to choose the right
+        set of active keymaps.  Recompute the set of keymaps after receiving
+        the first event.  Remove GOBBLE_FIRST_EVENT.
+        (syms_of_keyboard): Remove inhibit_local_menu_bar_menus.
+        * keyboard.h (read_char): Update declaration.
+        * lread.c (read_filtered_event): Adjust call to read_char.
+
+2013-02-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (move_it_vertically_backward, move_it_by_lines):
+        Don't use the limitation on backwards movement when lines are truncated
+        in the window.  (Bug#13675)
+
+2013-02-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * marker.c (set_marker_internal): If desired position is passed
+        as a marker, avoid call to buf_charpos_to_bytepos.
+        * window.c (Fset_window_point): Omit redundant type checking.
+        (Fset_window_start): Likewise.  Format comment.
+        (window_scroll_pixel_based): Use set_marker_restricted_both
+        with character and byte positions obtained from an iterator.
+        (Fset_window_configuration): Use set_marker_restricted_both.
+        * xdisp.c (message_dolog): Likewise.
+
 2013-02-10  Eli Zaretskii  <eliz@gnu.org>
 
-        * xdisp.c (move_it_vertically_backward, move_it_by_lines): When
-        text lines are longer than window's screen lines, don't move back
+        * xdisp.c (move_it_vertically_backward, move_it_by_lines):
+        When text lines are longer than window's screen lines, don't move back
         too far.  This speeds up some redisplay operations.  (Bug#13675)
 
 2013-02-10  Dmitry Antipov  <dmantipov@yandex.ru>
@@ -123,8 +163,8 @@
         * xdisp.c (window_buffer_changed): region_showing can be negative,
         which still means region is being displayed.
         (redisplay_internal): Resurrect code that forced redisplay of the
-        whole window when showing region and the mark has changed.  Record
-        the new mark position to allow redisplay optimizations.
+        whole window when showing region and the mark has changed.
+        Record the new mark position to allow redisplay optimizations.
         (display_line): If it->region_beg_charpos is non-zero, set the
         window's region_showing member to -1.  (Bug#13623)  (Bug#13626)
 
@@ -179,8 +219,8 @@
         * dired.c (file_name_completion): Don't call Fdirectory_file_name
         with an encoded file name.
 
-        * w32proc.c (Fw32_short_file_name, Fw32_long_file_name): Adjust
-        calls to dostounix_filename.
+        * w32proc.c (Fw32_short_file_name, Fw32_long_file_name):
+        Adjust calls to dostounix_filename.
 
         * w32fns.c (Fx_file_dialog): Adjust call to dostounix_filename.
 
@@ -275,8 +315,8 @@
         closing it.  (Bug#13546)
 
         * w32.c (parse_root, get_volume_info, readdir, read_unc_volume)
-        (logon_network_drive, stat_worker, symlink, chase_symlinks): Use
-        CharNextExA and CharPrevExA to iterate over file names encoded in
+        (logon_network_drive, stat_worker, symlink, chase_symlinks):
+        Use CharNextExA and CharPrevExA to iterate over file names encoded in
         DBCS.  (Bug#13553)
 
         * w32.c (w32_get_long_filename, init_environment, readlink):
@@ -316,8 +356,8 @@
         (normalize_filename, readdir): Use it to detect locales where ANSI
         encoding of file names uses a double-byte character set (DBCS).
         If a DBCS encoding is used, advance by characters using
-        CharNextExA, instead of incrementing a 'char *' pointer.  Use
-        _mbslwr instead of _strlwr.  (Bug#13515)
+        CharNextExA, instead of incrementing a 'char *' pointer.
+        Use _mbslwr instead of _strlwr.  (Bug#13515)
 
         * w32heap.c (allocate_heap) [!_WIN64]: Decrease the initial
         request of memory reservation to 1.7GB.  (Bug#13065)
@@ -458,8 +498,8 @@
         segfault when there are lots of overlays.
 
         * buffer.c (sort_overlays): Use SAFE_NALLOCA, to avoid segfault
-        when there are lots of overlays.  See
-        http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00421.html
+        when there are lots of overlays.
+        See http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00421.html
         for the details and a way to reproduce.
 
 2013-01-19  Paul Eggert  <eggert@cs.ucla.edu>
@@ -517,8 +557,8 @@
 
 2013-01-18  Dmitry Antipov  <dmantipov@yandex.ru>
 
-        Fix crash when inserting data from non-regular files.  See
-        http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00406.html
+        Fix crash when inserting data from non-regular files.
+        See http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00406.html
         for the error description produced by valgrind.
         * fileio.c (read_non_regular): Rename to read_contents.
         Free Lisp_Save_Value object used to pass parameters.
@@ -570,8 +610,8 @@
         (map_keymap_char_table_item): Adjust accordingly.
         * fileio.c (non_regular_fd, non_regular_inserted)
         (non_regular_nbytes): Remove.
-        (Finsert_file_contents): Convert trytry to ptrdiff_t.  Use
-        format_save_value to pass parameters to read_non_regular.
+        (Finsert_file_contents): Convert trytry to ptrdiff_t.
+        Use format_save_value to pass parameters to read_non_regular.
         (read_non_regular): Use XSAVE_ macros to extract parameters.
         Adjust comment.
         * xmenu.c (xmenu_show) [!USE_X_TOOLKIT && !USE_GTK]: Use
@@ -698,8 +738,8 @@
 
 2013-01-11  Aaron S. Hawley  <Aaron.Hawley@vtinfo.com>
 
-        * insdel.c (Fcombine_after_change_execute, syms_of_insdel): Fix
-         ambiguous doc string cross-reference(s).
+        * insdel.c (Fcombine_after_change_execute, syms_of_insdel):
+        Fix ambiguous doc string cross-reference(s).
 
         * keyboard.c (Fcommand_execute, syms_of_keyboard): Fix ambiguous
          doc string cross-reference(s).
diff --git a/src/cm.c b/src/cm.c
index 842633aceec..3a5f927eda3 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -28,8 +28,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "termchar.h"
 #include "tparam.h"
 
-#define BIG     9999            /* 9999 good on VAXen.  For 16 bit machines
-                                   use about 2000.... */
+#define BIG     9999            /* Good on 32-bit hosts.  */
 
 int cost;               /* sums up costs */
 
diff --git a/src/fileio.c b/src/fileio.c
index ddf23867104..98a9b32ea91 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -133,9 +133,6 @@ static Lisp_Object Qwrite_region_annotate_functions;
    is added here.  */
 static Lisp_Object Vwrite_region_annotation_buffers;
 
-#ifdef HAVE_FSYNC
-#endif
-
 static Lisp_Object Qdelete_by_moving_to_trash;
 
 /* Lisp function for moving files to trash.  */
@@ -4965,7 +4962,7 @@ This calls `write-region-annotate-functions' at the start, and
   immediate_quit = 0;
 
 #ifdef HAVE_FSYNC
-  /* Note fsync appears to change the modtime on BSD4.2 (both vax and sun).
+  /* fsync appears to change the modtime on BSD4.2.
      Disk full in NFS may be reported here.  */
   /* mib says that closing the file will try to write as fast as NFS can do
      it, and that means the fsync here is not crucial for autosave files.  */
diff --git a/src/keyboard.c b/src/keyboard.c
index f5728009cf7..4a92cea30c8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -420,10 +420,9 @@ static void (*keyboard_init_hook) (void);
 
 static bool get_input_pending (int);
 static bool readable_events (int);
-static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
+static Lisp_Object read_char_x_menu_prompt (Lisp_Object,
                                             Lisp_Object, bool *);
-static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
-                                                  Lisp_Object *);
+static Lisp_Object read_char_minibuf_menu_prompt (int, Lisp_Object);
 static Lisp_Object make_lispy_event (struct input_event *);
 static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
                                         enum scroll_bar_part,
@@ -2234,13 +2233,12 @@ do { if (! polling_stopped_here) stop_polling ();	\
 do { if (polling_stopped_here) start_polling ();        \
        polling_stopped_here = 0; } while (0)
 
-/* read a character from the keyboard; call the redisplay if needed */
+/* Read a character from the keyboard; call the redisplay if needed.  */
 /* commandflag 0 means do not autosave, but do redisplay.
    -1 means do not redisplay, but do autosave.
    1 means do both.  */
 
-/* The arguments MAPS and NMAPS are for menu prompting.
-   MAPS is an array of keymaps;  NMAPS is the length of MAPS.
+/* The arguments MAP is for menu prompting.  MAP is a keymap.
 
    PREV_EVENT is the previous input event, or nil if we are reading
    the first event of a key sequence (or not reading a key sequence).
@@ -2262,7 +2260,7 @@ do { if (polling_stopped_here) start_polling ();	\
    Value is t if we showed a menu and the user rejected it.  */
 
 Lisp_Object
-read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
+read_char (int commandflag, Lisp_Object map,
            Lisp_Object prev_event,
            bool *used_mouse_menu, EMACS_TIME *end_time)
 {
@@ -2410,7 +2408,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       goto reread_first;
     }
 
-  /* if redisplay was requested */
+  /* If redisplay was requested.  */
   if (commandflag >= 0)
     {
       bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
@@ -2419,7 +2417,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
            user-visible, such as X selection_request events.  */
       if (input_pending
           || detect_input_pending_run_timers (0))
-        swallow_events (0);             /* may clear input_pending */
+        swallow_events (0);             /* May clear input_pending.  */
 
       /* Redisplay if no pending input.  */
       while (!input_pending)
@@ -2489,13 +2487,13 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
      menu prompting. If EVENT_HAS_PARAMETERS then we are reading
      after a mouse event so don't try a minibuf menu.  */
   c = Qnil;
-  if (nmaps > 0 && INTERACTIVE
+  if (KEYMAPP (map) && INTERACTIVE
       && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events)
       && !detect_input_pending_run_timers (0))
     {
-      c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
+      c = read_char_minibuf_menu_prompt (commandflag, map);
 
       if (INTEGERP (c) && XINT (c) == -2)
         return c;               /* wrong_kboard_jmpbuf */
@@ -2619,7 +2617,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
      because the recursive call of read_char in read_char_minibuf_menu_prompt
      does not pass on any keymaps.  */
 
-  if (nmaps > 0 && INTERACTIVE
+  if (KEYMAPP (map) && INTERACTIVE
       && !NILP (prev_event)
       && EVENT_HAS_PARAMETERS (prev_event)
       && !EQ (XCAR (prev_event), Qmenu_bar)
@@ -2627,7 +2625,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events))
     {
-      c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
+      c = read_char_x_menu_prompt (map, prev_event, used_mouse_menu);
 
       /* Now that we have read an event, Emacs is not idle.  */
       if (!end_time)
@@ -3005,7 +3003,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
 
       /* If we are not reading a key sequence,
          never use the echo area.  */
-      if (maps == 0)
+      if (!KEYMAPP (map))
         {
           specbind (Qinput_method_use_echo_area, Qt);
         }
@@ -3098,7 +3096,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
   last_input_event = c;
   num_input_events++;
 
-  /* Process the help character specially if enabled */
+  /* Process the help character specially if enabled.  */
   if (!NILP (Vhelp_form) && help_char_p (c))
     {
       ptrdiff_t count = SPECPDL_INDEX ();
@@ -3112,13 +3110,13 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       cancel_echoing ();
       do
         {
-          c = read_char (0, 0, 0, Qnil, 0, NULL);
+          c = read_char (0, Qnil, Qnil, 0, NULL);
           if (EVENT_HAS_PARAMETERS (c)
               && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_click))
             XSETCAR (help_form_saved_window_configs, Qnil);
         }
       while (BUFFERP (c));
-      /* Remove the help from the frame */
+      /* Remove the help from the frame.  */
       unbind_to (count, Qnil);
 
       redisplay ();
@@ -3126,7 +3124,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
         {
           cancel_echoing ();
           do
-            c = read_char (0, 0, 0, Qnil, 0, NULL);
+            c = read_char (0, Qnil, Qnil, 0, NULL);
           while (BUFFERP (c));
         }
     }
@@ -8332,9 +8330,9 @@ init_tool_bar_items (Lisp_Object reuse)
 static void
 append_tool_bar_item (void)
 {
-  ptrdiff_t incr =
-    (ntool_bar_items
-     - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
+  ptrdiff_t incr
+    = (ntool_bar_items
+       - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
 
   /* Enlarge tool_bar_items_vector if necessary.  */
   if (0 < incr)
@@ -8352,8 +8350,8 @@ append_tool_bar_item (void)
 
 
 
-/* Read a character using menus based on maps in the array MAPS.
-   NMAPS is the length of MAPS.  Return nil if there are no menus in the maps.
+/* Read a character using menus based on the keymap MAP.
+   Return nil if there are no menus in the maps.
    Return t if we displayed a menu but the user rejected it.
 
    PREV_EVENT is the previous input event, or nil if we are reading
@@ -8373,28 +8371,17 @@ append_tool_bar_item (void)
    and do auto-saving in the inner call of read_char.  */
 
 static Lisp_Object
-read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
+read_char_x_menu_prompt (Lisp_Object map,
                          Lisp_Object prev_event, bool *used_mouse_menu)
 {
-#ifdef HAVE_MENUS
-  ptrdiff_t mapno;
-#endif
-
   if (used_mouse_menu)
     *used_mouse_menu = 0;
 
-  /* Use local over global Menu maps */
+  /* Use local over global Menu maps.  */
 
   if (! menu_prompting)
     return Qnil;
 
-  /* Optionally disregard all but the global map.  */
-  if (inhibit_local_menu_bar_menus)
-    {
-      maps += (nmaps - 1);
-      nmaps = 1;
-    }
-
 #ifdef HAVE_MENUS
   /* If we got to this point via a mouse click,
      use a real menu for mouse selection.  */
@@ -8403,16 +8390,9 @@ read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
       && !EQ (XCAR (prev_event), Qtool_bar))
     {
       /* Display the menu and get the selection.  */
-      Lisp_Object *realmaps = alloca (nmaps * sizeof *realmaps);
       Lisp_Object value;
-      ptrdiff_t nmaps1 = 0;
 
-      /* Use the maps that are not nil.  */
-      for (mapno = 0; mapno < nmaps; mapno++)
-        if (!NILP (maps[mapno]))
-          realmaps[nmaps1++] = maps[mapno];
-
-      value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
+      value = Fx_popup_menu (prev_event, get_keymap (map, 0, 1));
       if (CONSP (value))
         {
           Lisp_Object tem;
@@ -8454,9 +8434,8 @@ read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
 
 static Lisp_Object
 read_char_minibuf_menu_prompt (int commandflag,
-                               ptrdiff_t nmaps, Lisp_Object *maps)
+                               Lisp_Object map)
 {
-  ptrdiff_t mapno;
   register Lisp_Object name;
   ptrdiff_t nlength;
   /* FIXME: Use the minibuffer's frame width.  */
@@ -8467,18 +8446,12 @@ read_char_minibuf_menu_prompt (int commandflag,
   Lisp_Object prompt_strings = Qnil;
 
   vector = Qnil;
-  name = Qnil;
 
   if (! menu_prompting)
     return Qnil;
 
-  /* Get the menu name from the first map that has one (a prompt string).  */
-  for (mapno = 0; mapno < nmaps; mapno++)
-    {
-      name = Fkeymap_prompt (maps[mapno]);
-      if (!NILP (name))
-        break;
-    }
+  map = get_keymap (map, 0, 1);
+  name = Fkeymap_prompt (map);
 
   /* If we don't have any menus, just read a character normally.  */
   if (!STRINGP (name))
@@ -8486,15 +8459,13 @@ read_char_minibuf_menu_prompt (int commandflag,
 
 #define PUSH_C_STR(str, listvar) \
   listvar = Fcons (make_unibyte_string (str, strlen (str)), listvar)
-  
+
   /* Prompt string always starts with map's prompt, and a space.  */
   prompt_strings = Fcons (name, prompt_strings);
   PUSH_C_STR (": ", prompt_strings);
   nlength = SCHARS (name) + 2;
 
-  /* Start prompting at start of first map.  */
-  mapno = 0;
-  rest = maps[mapno];
+  rest = map;
 
   /* Present the documented bindings, a line at a time.  */
   while (1)
@@ -8512,18 +8483,14 @@ read_char_minibuf_menu_prompt (int commandflag,
 
           /* FIXME: Use map_keymap to handle new keymap formats.  */
 
-          /* If reached end of map, start at beginning of next map.  */
+          /* At end of map, wrap around if just starting,
+             or end this line if already have something on it.  */
           if (NILP (rest))
             {
-              mapno++;
-              /* At end of last map, wrap around to first map if just starting,
-                 or end this line if already have something on it.  */
-              if (mapno == nmaps)
-                {
-                  mapno = 0;
-                  if (notfirst || nobindings) break;
-                }
-              rest = maps[mapno];
+              if (notfirst || nobindings)
+                break;
+              else
+                rest = map;
             }
 
           /* Look at the next element of the map.  */
@@ -8657,7 +8624,7 @@ read_char_minibuf_menu_prompt (int commandflag,
         }
 
       /* Prompt with that and read response.  */
-      message3_nolog (apply1 (intern ("concat"), menu_strings));
+      message3_nolog (apply1 (intern ("concat"), Fnreverse (menu_strings)));
 
       /* Make believe it's not a keyboard macro in case the help char
          is pressed.  Help characters are not recorded because menu prompting
@@ -8665,7 +8632,7 @@ read_char_minibuf_menu_prompt (int commandflag,
       orig_defn_macro = KVAR (current_kboard, defining_kbd_macro);
       kset_defining_kbd_macro (current_kboard, Qnil);
       do
-        obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
+        obj = read_char (commandflag, Qnil, Qt, 0, NULL);
       while (BUFFERP (obj));
       kset_defining_kbd_macro (current_kboard, orig_defn_macro);
 
@@ -8686,46 +8653,18 @@ read_char_minibuf_menu_prompt (int commandflag,
 
 /* Reading key sequences.  */
 
-/* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
-   in DEFS[0..NMAPS-1].  Set NEXT[i] to DEFS[i] if DEFS[i] is a
-   keymap, or nil otherwise.  Return the index of the first keymap in
-   which KEY has any binding, or NMAPS if no map has a binding.
-
-   If KEY is a meta ASCII character, treat it like meta-prefix-char
-   followed by the corresponding non-meta character.  Keymaps in
-   CURRENT with non-prefix bindings for meta-prefix-char become nil in
-   NEXT.
-
-   If KEY has no bindings in any of the CURRENT maps, NEXT is left
-   unmodified.
-
-   NEXT may be the same array as CURRENT.  */
-
-static int
-follow_key (Lisp_Object key, ptrdiff_t nmaps, Lisp_Object *current,
-            Lisp_Object *defs, Lisp_Object *next)
+static Lisp_Object
+follow_key (Lisp_Object keymap, Lisp_Object key)
 {
-  ptrdiff_t i, first_binding;
-
-  first_binding = nmaps;
-  for (i = nmaps - 1; i >= 0; i--)
-    {
-      if (! NILP (current[i]))
-        {
-          defs[i] = access_keymap (current[i], key, 1, 0, 1);
-          if (! NILP (defs[i]))
-            first_binding = i;
-        }
-      else
-        defs[i] = Qnil;
-    }
-
-  /* Given the set of bindings we've found, produce the next set of maps.  */
-  if (first_binding < nmaps)
-    for (i = 0; i < nmaps; i++)
-      next[i] = NILP (defs[i]) ? Qnil : get_keymap (defs[i], 0, 1);
+  return access_keymap (get_keymap (keymap, 0, 1),
+                        key, 1, 0, 1);
+}
 
-  return first_binding;
+static Lisp_Object
+active_maps (Lisp_Object first_event)
+{
+  Lisp_Object position = INTEGERP (first_event) ? Qnil : first_event;
+  return Fcons (Qkeymap, Fcurrent_active_maps (Qt, position));
 }
 
 /* Structure used to keep track of partial application of key remapping
@@ -8857,8 +8796,9 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
 static bool
 test_undefined (Lisp_Object binding)
 {
-  return (EQ (binding, Qundefined)
-          || (!NILP (binding) && SYMBOLP (binding)
+  return (NILP (binding)
+          || EQ (binding, Qundefined)
+          || (SYMBOLP (binding)
               && EQ (Fcommand_remapping (binding, Qnil, Qnil), Qundefined)));
 }
 
@@ -8904,7 +8844,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                    bool dont_downcase_last, bool can_return_switch_frame,
                    bool fix_current_buffer)
 {
-  Lisp_Object from_string;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   /* How many keys there are in the current key sequence.  */
@@ -8915,34 +8854,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   ptrdiff_t echo_start IF_LINT (= 0);
   ptrdiff_t keys_start;
 
-  /* The number of keymaps we're scanning right now, and the number of
-     keymaps we have allocated space for.  */
-  ptrdiff_t nmaps;
-  ptrdiff_t nmaps_allocated = 0;
-
-  /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
-     the current keymaps.  */
-  Lisp_Object *defs = NULL;
-
-  /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
-     in the current keymaps, or nil where it is not a prefix.  */
-  Lisp_Object *submaps = NULL;
-
-  /* The local map to start out with at start of key sequence.  */
-  Lisp_Object orig_local_map;
+  Lisp_Object current_binding = Qnil;
+  Lisp_Object first_event = Qnil;
 
-  /* The map from the `keymap' property to start out with at start of
-     key sequence.  */
-  Lisp_Object orig_keymap;
-
-  /* Positive if we have already considered switching to the local-map property
-     of the place where a mouse click occurred.  */
-  int localized_local_map = 0;
-
-  /* The index in submaps[] of the first keymap that has a binding for
-     this key sequence.  In other words, the lowest i such that
-     submaps[i] is non-nil.  */
-  ptrdiff_t first_binding;
   /* Index of the first key that has no binding.
      It is useless to try fkey.start larger than that.  */
   int first_unbound;
@@ -8985,11 +8899,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      While we're reading, we keep the event here.  */
   Lisp_Object delayed_switch_frame;
 
-  /* See the comment below...  */
-#if defined (GOBBLE_FIRST_EVENT)
-  Lisp_Object first_event;
-#endif
-
   Lisp_Object original_uppercase IF_LINT (= Qnil);
   int original_uppercase_position = -1;
 
@@ -9001,10 +8910,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   /* List of events for which a fake prefix key has been generated.  */
   Lisp_Object fake_prefixed_keys = Qnil;
 
-#if defined (GOBBLE_FIRST_EVENT)
-  int junk;
-#endif
-
   struct gcpro gcpro1;
 
   GCPRO1 (fake_prefixed_keys);
@@ -9040,21 +8945,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   keys_start = this_command_key_count;
   this_single_command_key_start = keys_start;
 
-#if defined (GOBBLE_FIRST_EVENT)
-  /* This doesn't quite work, because some of the things that read_char
-     does cannot safely be bypassed.  It seems too risky to try to make
-     this work right.  */
-
-  /* Read the first char of the sequence specially, before setting
-     up any keymaps, in case a filter runs and switches buffers on us.  */
-  first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
-                           &junk, NULL);
-#endif /* GOBBLE_FIRST_EVENT */
-
-  orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-  orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
-  from_string = Qnil;
-
   /* We jump here when we need to reinitialize fkey and keytran; this
      happens if we switch keyboards between rescans.  */
  replay_entire_sequence:
@@ -9079,59 +8969,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      keybuf with its symbol, or if the sequence starts with a mouse
      click and we need to switch buffers, we jump back here to rebuild
      the initial keymaps from the current buffer.  */
-  nmaps = 0;
-
-  if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
-    {
-      if (2 > nmaps_allocated)
-        {
-          submaps = alloca (2 * sizeof *submaps);
-          defs    = alloca (2 * sizeof *defs);
-          nmaps_allocated = 2;
-        }
-      submaps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
-    }
-  else if (!NILP (Voverriding_local_map))
-    {
-      if (2 > nmaps_allocated)
-        {
-          submaps = alloca (2 * sizeof *submaps);
-          defs    = alloca (2 * sizeof *defs);
-          nmaps_allocated = 2;
-        }
-      submaps[nmaps++] = Voverriding_local_map;
-    }
-  else
-    {
-      ptrdiff_t nminor;
-      ptrdiff_t total;
-      Lisp_Object *maps;
-
-      nminor = current_minor_maps (0, &maps);
-      total = nminor + (!NILP (orig_keymap) ? 3 : 2);
-
-      if (total > nmaps_allocated)
-        {
-          submaps = alloca (total * sizeof *submaps);
-          defs    = alloca (total * sizeof *defs);
-          nmaps_allocated = total;
-        }
-
-      if (!NILP (orig_keymap))
-        submaps[nmaps++] = orig_keymap;
-
-      memcpy (submaps + nmaps, maps, nminor * sizeof (submaps[0]));
-
-      nmaps += nminor;
-
-      submaps[nmaps++] = orig_local_map;
-    }
-  submaps[nmaps++] = current_global_map;
-
-  /* Find an accurate initial value for first_binding.  */
-  for (first_binding = 0; first_binding < nmaps; first_binding++)
-    if (! NILP (submaps[first_binding]))
-      break;
+  current_binding = active_maps (first_event);
 
   /* Start from the beginning in keybuf.  */
   t = 0;
@@ -9145,9 +8983,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   /* If the best binding for the current key sequence is a keymap, or
      we may be looking at a function key's escape sequence, keep on
      reading.  */
-  while (first_binding < nmaps
+  while (!NILP (current_binding)
          /* Keep reading as long as there's a prefix binding.  */
-         ? !NILP (submaps[first_binding])
+         ? KEYMAPP (current_binding)
          /* Don't return in the middle of a possible function key sequence,
             if the only bindings we found were via case conversion.
             Thus, if ESC O a has a function-key-map translation
@@ -9171,7 +9009,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          just one key.  */
       ptrdiff_t echo_local_start IF_LINT (= 0);
       int keys_local_start;
-      ptrdiff_t local_first_binding;
+      Lisp_Object new_binding;
 
       eassert (indec.end == t || (indec.end > t && indec.end <= mock_input));
       eassert (indec.start <= indec.end);
@@ -9208,7 +9046,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       if (INTERACTIVE)
         echo_local_start = echo_length ();
       keys_local_start = this_command_key_count;
-      local_first_binding = first_binding;
 
     replay_key:
       /* These are no-ops, unless we throw away a keystroke below and
@@ -9218,7 +9055,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       if (INTERACTIVE && t < mock_input)
         echo_truncate (echo_local_start);
       this_command_key_count = keys_local_start;
-      first_binding = local_first_binding;
 
       /* By default, assume each event is "real".  */
       last_real_key_start = t;
@@ -9243,8 +9079,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           {
             KBOARD *interrupted_kboard = current_kboard;
             struct frame *interrupted_frame = SELECTED_FRAME ();
-            key = read_char (NILP (prompt), nmaps,
-                             (Lisp_Object *) submaps, last_nonmenu_event,
+            key = read_char (NILP (prompt),
+                             current_binding, last_nonmenu_event,
                              &used_mouse_menu, NULL);
             if ((INTEGERP (key) && XINT (key) == -2) /* wrong_kboard_jmpbuf */
                 /* When switching to a new tty (with a new keyboard),
@@ -9299,8 +9135,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                               KVAR (interrupted_kboard, kbd_queue)));
                   }
                 mock_input = 0;
-                orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-                orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
                 goto replay_entire_sequence;
               }
           }
@@ -9341,12 +9175,11 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 {
                   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                     Fkill_emacs (Qnil);
-                  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
+                  if (XBUFFER (XWINDOW (selected_window)->buffer)
+                      != current_buffer)
                     Fset_buffer (XWINDOW (selected_window)->buffer);
                 }
 
-              orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-              orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
               goto replay_sequence;
             }
 
@@ -9363,8 +9196,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
               keybuf[t++] = key;
               mock_input = t;
               Vquit_flag = Qnil;
-              orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-              orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
               goto replay_sequence;
             }
 
@@ -9384,6 +9215,22 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 }
             }
 
+          if (NILP (first_event))
+            {
+              first_event = key;
+              /* Even if first_event does not specify a particular
+                 window/position, it's important to recompute the maps here
+                 since a long time might have passed since we entered
+                 read_key_sequence, and a timer (or process-filter or
+                 special-event-map, ...) might have switched the current buffer
+                 or the selected window from under us in the mean time.  */
+              if (fix_current_buffer
+                  && (XBUFFER (XWINDOW (selected_window)->buffer)
+                      != current_buffer))
+                Fset_buffer (XWINDOW (selected_window)->buffer);
+              current_binding = active_maps (first_event);
+            }
+
           GROW_RAW_KEYBUF;
           ASET (raw_keybuf, raw_keybuf_count, key);
           raw_keybuf_count++;
@@ -9405,16 +9252,11 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          or when user programs play with this-command-keys.  */
       if (EVENT_HAS_PARAMETERS (key))
         {
-          Lisp_Object kind;
-          Lisp_Object string;
-
-          kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
+          Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
           if (EQ (kind, Qmouse_click))
             {
-              Lisp_Object window, posn;
-
-              window = POSN_WINDOW (EVENT_START (key));
-              posn   = POSN_POSN (EVENT_START (key));
+              Lisp_Object window = POSN_WINDOW (EVENT_START (key));
+              Lisp_Object posn = POSN_POSN (EVENT_START (key));
 
               if (CONSP (posn)
                   || (!NILP (fake_prefixed_keys)
@@ -9457,58 +9299,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                       if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                         Fkill_emacs (Qnil);
                       set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
-                      orig_local_map = get_local_map (PT, current_buffer,
-                                                      Qlocal_map);
-                      orig_keymap = get_local_map (PT, current_buffer,
-                                                   Qkeymap);
                       goto replay_sequence;
                     }
-
-                  /* For a mouse click, get the local text-property keymap
-                     of the place clicked on, rather than point.  */
-                  if (CONSP (XCDR (key))
-                      && ! localized_local_map)
-                    {
-                      Lisp_Object map_here, start, pos;
-
-                      localized_local_map = 1;
-                      start = EVENT_START (key);
-
-                      if (CONSP (start) && POSN_INBUFFER_P (start))
-                        {
-                          pos = POSN_BUFFER_POSN (start);
-                          if (INTEGERP (pos)
-                              && XINT (pos) >= BEGV
-                              && XINT (pos) <= ZV)
-                            {
-                              map_here = get_local_map (XINT (pos),
-                                                        current_buffer,
-                                                        Qlocal_map);
-                              if (!EQ (map_here, orig_local_map))
-                                {
-                                  orig_local_map = map_here;
-                                  ++localized_local_map;
-                                }
-
-                              map_here = get_local_map (XINT (pos),
-                                                        current_buffer,
-                                                        Qkeymap);
-                              if (!EQ (map_here, orig_keymap))
-                                {
-                                  orig_keymap = map_here;
-                                  ++localized_local_map;
-                                }
-
-                              if (localized_local_map > 1)
-                                {
-                                  keybuf[t] = key;
-                                  mock_input = t + 1;
-
-                                  goto replay_sequence;
-                                }
-                            }
-                        }
-                    }
                 }
 
               /* Expand mode-line and scroll-bar events into two events:
@@ -9529,63 +9321,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                      prevent proper action when the event is pushed
                      back into unread-command-events.  */
                   fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
-
-                  /* If on a mode line string with a local keymap,
-                     reconsider the key sequence with that keymap.  */
-                  if (string = POSN_STRING (EVENT_START (key)),
-                      (CONSP (string) && STRINGP (XCAR (string))))
-                    {
-                      Lisp_Object pos, map, map2;
-
-                      pos = XCDR (string);
-                      string = XCAR (string);
-                      if (XINT (pos) >= 0
-                          && XINT (pos) < SCHARS (string))
-                        {
-                          map = Fget_text_property (pos, Qlocal_map, string);
-                          if (!NILP (map))
-                            orig_local_map = map;
-                          map2 = Fget_text_property (pos, Qkeymap, string);
-                          if (!NILP (map2))
-                            orig_keymap = map2;
-                          if (!NILP (map) || !NILP (map2))
-                            goto replay_sequence;
-                        }
-                    }
-
                   goto replay_key;
                 }
-              else if (NILP (from_string)
-                       && (string = POSN_STRING (EVENT_START (key)),
-                           (CONSP (string) && STRINGP (XCAR (string)))))
-                {
-                  /* For a click on a string, i.e. overlay string or a
-                     string displayed via the `display' property,
-                     consider `local-map' and `keymap' properties of
-                     that string.  */
-                  Lisp_Object pos, map, map2;
-
-                  pos = XCDR (string);
-                  string = XCAR (string);
-                  if (XINT (pos) >= 0
-                      && XINT (pos) < SCHARS (string))
-                    {
-                      map = Fget_text_property (pos, Qlocal_map, string);
-                      if (!NILP (map))
-                        orig_local_map = map;
-                      map2 = Fget_text_property (pos, Qkeymap, string);
-                      if (!NILP (map2))
-                        orig_keymap = map2;
-
-                      if (!NILP (map) || !NILP (map2))
-                        {
-                          from_string = string;
-                          keybuf[t++] = key;
-                          mock_input = t;
-                          goto replay_sequence;
-                        }
-                    }
-                }
             }
           else if (CONSP (XCDR (key))
                    && CONSP (EVENT_START (key))
@@ -9601,7 +9338,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                   if (bufsize - t <= 1)
                     error ("Key sequence too long");
                   keybuf[t] = posn;
-                  keybuf[t+1] = key;
+                  keybuf[t + 1] = key;
 
                   /* Zap the position in key, so we know that we've
                      expanded it, and don't try to do so again.  */
@@ -9624,15 +9361,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
 
       /* We have finally decided that KEY is something we might want
          to look up.  */
-      first_binding = (follow_key (key,
-                                   nmaps   - first_binding,
-                                   submaps + first_binding,
-                                   defs    + first_binding,
-                                   submaps + first_binding)
-                       + first_binding);
+      new_binding = follow_key (current_binding, key);
 
       /* If KEY wasn't bound, we'll try some fallbacks.  */
-      if (first_binding < nmaps)
+      if (!NILP (new_binding))
         /* This is needed for the following scenario:
            event 0: a down-event that gets dropped by calling replay_key.
            event 1: some normal prefix like C-h.
@@ -9769,20 +9501,13 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                       new_click
                         = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
 
-                      /* Look for a binding for this new key.  follow_key
-                         promises that it didn't munge submaps the
-                         last time we called it, since key was unbound.  */
-                      first_binding
-                        = (follow_key (new_click,
-                                       nmaps   - local_first_binding,
-                                       submaps + local_first_binding,
-                                       defs    + local_first_binding,
-                                       submaps + local_first_binding)
-                           + local_first_binding);
+                      /* Look for a binding for this new key.  */
+                      new_binding = follow_key (current_binding, new_click);
 
                       /* If that click is bound, go for it.  */
-                      if (first_binding < nmaps)
+                      if (!NILP (new_binding))
                         {
+                          current_binding = new_binding;
                           key = new_click;
                           break;
                         }
@@ -9791,6 +9516,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 }
             }
         }
+      current_binding = new_binding;
 
       keybuf[t++] = key;
       /* Normally, last_nonmenu_event gets the previous key we read.
@@ -9822,9 +9548,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
             }
         }
 
-      if (first_binding < nmaps
-          && NILP (submaps[first_binding])
-          && !test_undefined (defs[first_binding])
+      if (!KEYMAPP (current_binding)
+          && !test_undefined (current_binding)
           && indec.start >= t)
         /* There is a binding and it's not a prefix.
            (and it doesn't have any input-decode-map translation pending).
@@ -9853,8 +9578,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                                      first_binding >= nmaps) we don't want
                                      to apply this function-key-mapping.  */
                                   fkey.end + 1 == t
-                                  && (first_binding >= nmaps
-                                      || test_undefined (defs[first_binding])),
+                                  && (test_undefined (current_binding)),
                                   &diff, prompt);
             UNGCPRO;
             if (done)
@@ -9897,7 +9621,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          and cannot be part of a function key or translation,
          and is an upper case letter
          use the corresponding lower-case letter instead.  */
-      if (first_binding >= nmaps
+      if (NILP (current_binding)
           && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
           && INTEGERP (key)
           && ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
@@ -9928,7 +9652,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          and cannot be part of a function key or translation,
          and is a shifted function key,
          use the corresponding unshifted function key instead.  */
-      if (first_binding >= nmaps
+      if (NILP (current_binding)
           && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t)
         {
           Lisp_Object breakdown = parse_modifiers (key);
@@ -9969,9 +9693,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
         }
     }
   if (!dummyflag)
-    read_key_sequence_cmd = (first_binding < nmaps
-                             ? defs[first_binding]
-                             : Qnil);
+    read_key_sequence_cmd = current_binding;
   read_key_sequence_remapped
     /* Remap command through active keymaps.
        Do the remapping here, before the unbind_to so it uses the keymaps
@@ -9985,7 +9707,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
 
   /* Don't downcase the last character if the caller says don't.
      Don't downcase it if the result is undefined, either.  */
-  if ((dont_downcase_last || first_binding >= nmaps)
+  if ((dont_downcase_last || NILP (current_binding))
       && t > 0
       && t - 1 == original_uppercase_position)
     {
@@ -10082,7 +9804,7 @@ will read just one key sequence.  */)
 
   memset (keybuf, 0, sizeof keybuf);
   GCPRO1 (keybuf[0]);
-  gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
+  gcpro1.nvars = (sizeof keybuf / sizeof (keybuf[0]));
 
   if (NILP (continue_echo))
     {
@@ -11692,10 +11414,6 @@ This variable is also the threshold for motion of the mouse
 to count as a drag.  */);
   double_click_fuzz = 3;
 
-  DEFVAR_BOOL ("inhibit-local-menu-bar-menus", inhibit_local_menu_bar_menus,
-               doc: /* Non-nil means inhibit local map menu bar menus.  */);
-  inhibit_local_menu_bar_menus = 0;
-
   DEFVAR_INT ("num-input-keys", num_input_keys,
               doc: /* Number of complete key sequences read as input so far.
 This includes key sequences read from keyboard macros.
diff --git a/src/keyboard.h b/src/keyboard.h
index 7ffb436754b..c6ade35dd52 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -482,7 +482,7 @@ struct input_event;
 
 extern Lisp_Object parse_modifiers (Lisp_Object);
 extern Lisp_Object reorder_modifiers (Lisp_Object);
-extern Lisp_Object read_char (int, ptrdiff_t, Lisp_Object *, Lisp_Object,
+extern Lisp_Object read_char (int, Lisp_Object, Lisp_Object,
                               bool *, EMACS_TIME *);
 extern int parse_solitary_modifier (Lisp_Object symbol);
 
diff --git a/src/keymap.c b/src/keymap.c
index 1e201e06dc3..922c1703edf 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1244,7 +1244,7 @@ remapping in all currently active keymaps.  */)
   return INTEGERP (command) ? Qnil : command;
 }
 
-/* Value is number if KEY is too long; nil if valid but has no definition. */
+/* Value is number if KEY is too long; nil if valid but has no definition.  */
 /* GC is possible in this function.  */
 
 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
@@ -1536,7 +1536,7 @@ DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps,
        doc: /* Return a list of the currently active keymaps.
 OLP if non-nil indicates that we should obey `overriding-local-map' and
 `overriding-terminal-local-map'.  POSITION can specify a click position
-like in the respective argument of `key-binding'. */)
+like in the respective argument of `key-binding'.  */)
   (Lisp_Object olp, Lisp_Object position)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -1545,7 +1545,7 @@ like in the respective argument of `key-binding'. */)
 
   /* If a mouse click position is given, our variables are based on
      the buffer clicked on, not the current buffer.  So we may have to
-     switch the buffer here. */
+     switch the buffer here.  */
 
   if (CONSP (position))
     {
diff --git a/src/lread.c b/src/lread.c
index c62c62a5e5a..e7af86aa664 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -614,17 +614,17 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
       end_time = add_emacs_time (current_emacs_time (), wait_time);
     }
 
-/* Read until we get an acceptable event.  */
+  /* Read until we get an acceptable event.  */
  retry:
   do
-    val = read_char (0, 0, 0, (input_method ? Qnil : Qt), 0,
+    val = read_char (0, Qnil, (input_method ? Qnil : Qt), 0,
                      NUMBERP (seconds) ? &end_time : NULL);
   while (INTEGERP (val) && XINT (val) == -2); /* wrong_kboard_jmpbuf */
 
   if (BUFFERP (val))
     goto retry;
 
-  /* switch-frame events are put off until after the next ASCII
+  /* `switch-frame' events are put off until after the next ASCII
      character.  This is better than signaling an error just because
      the last characters were typed to a separate minibuffer frame,
      for example.  Eventually, some code which can deal with
diff --git a/src/marker.c b/src/marker.c
index a03a0b104ca..0d992c0abfa 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -499,11 +499,29 @@ set_marker_internal (Lisp_Object marker, Lisp_Object position,
     {
       register ptrdiff_t charpos, bytepos;
 
-      CHECK_NUMBER_COERCE_MARKER (position);
-      charpos = clip_to_bounds (restricted ? BUF_BEGV (b) : BUF_BEG (b),
-                               XINT (position),
-                               restricted ? BUF_ZV (b) : BUF_Z (b));
-      bytepos = buf_charpos_to_bytepos (b, charpos);
+      /* Do not use CHECK_NUMBER_COERCE_MARKER because we
+         don't want to call buf_charpos_to_bytepos if POSTION
+         is a marker and so we know the bytepos already.  */
+      if (INTEGERP (position))
+        charpos = XINT (position), bytepos = -1;
+      else if (MARKERP (position))
+        {
+          charpos = XMARKER (position)->charpos;
+          bytepos = XMARKER (position)->bytepos;
+        }
+      else
+        wrong_type_argument (Qinteger_or_marker_p, position);
+
+      charpos = clip_to_bounds
+        (restricted ? BUF_BEGV (b) : BUF_BEG (b), charpos,
+         restricted ? BUF_ZV (b) : BUF_Z (b));
+      if (bytepos == -1)
+        bytepos = buf_charpos_to_bytepos (b, charpos);
+      else
+        bytepos = clip_to_bounds
+          (restricted ? BUF_BEGV_BYTE (b) : BUF_BEG_BYTE (b),
+           bytepos, restricted ? BUF_ZV_BYTE (b) : BUF_Z_BYTE (b));
+
       attach_marker (m, b, charpos, bytepos);
     }
   return marker;
diff --git a/src/window.c b/src/window.c
index 68dcf28f52f..587ed8365c6 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1545,7 +1545,7 @@ Return POS.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  CHECK_NUMBER_COERCE_MARKER (pos);
+  /* Type of POS is checked by Fgoto_char or set_marker_restricted ...  */
 
   if (w == XWINDOW (selected_window))
     {
@@ -1555,6 +1555,8 @@ Return POS.  */)
         {
           struct buffer *old_buffer = current_buffer;
 
+          /* ... but here we want to catch type error before buffer change.  */
+          CHECK_NUMBER_COERCE_MARKER (pos);
           set_buffer_internal (XBUFFER (w->buffer));
           Fgoto_char (pos);
           set_buffer_internal (old_buffer);
@@ -1580,9 +1582,8 @@ overriding motion of point in order to display at this exact start.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
-  /* this is not right, but much easier than doing what is right. */
+  /* This is not right, but much easier than doing what is right.  */
   w->start_at_line_beg = 0;
   if (NILP (noforce))
     w->force_start = 1;
@@ -4619,8 +4620,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
         }
 
       /* Set the window start, and set up the window for redisplay.  */
-      set_marker_restricted (w->start, make_number (pos),
-                             w->buffer);
+      set_marker_restricted_both (w->start, w->buffer, IT_CHARPOS (it),
+                                  IT_BYTEPOS (it));
       bytepos = marker_byte_position (w->start);
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
@@ -5799,8 +5800,7 @@ the return value is nil.  Otherwise the value is t.  */)
              {
                /* Set window markers at start of visible range.  */
                if (XMARKER (w->start)->buffer == 0)
-                 set_marker_restricted (w->start, make_number (0),
-                                        w->buffer);
+                 set_marker_restricted_both (w->start, w->buffer, 0, 0);
                if (XMARKER (w->pointm)->buffer == 0)
                  set_marker_restricted_both
                    (w->pointm, w->buffer,
@@ -5818,10 +5818,8 @@ the return value is nil.  Otherwise the value is t.  */)
               wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
               /* This will set the markers to beginning of visible
                  range.  */
-              set_marker_restricted (w->start,
-                                     make_number (0), w->buffer);
-              set_marker_restricted (w->pointm,
-                                     make_number (0), w->buffer);
+              set_marker_restricted_both (w->start, w->buffer, 0, 0);
+              set_marker_restricted_both (w->pointm, w->buffer, 0, 0);
               w->start_at_line_beg = 1;
               if (!NILP (w->dedicated))
                 /* Record this window as dead.  */
diff --git a/src/xdisp.c b/src/xdisp.c
index 5b2eb1e84c8..2e357a6e321 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -9057,7 +9057,10 @@ move_it_vertically_backward (struct it *it, int dy)
 
   /* Estimate how many newlines we must move back.  */
   nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
-  pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
+  if (it->line_wrap == TRUNCATE)
+    pos_limit = BEGV;
+  else
+    pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
 
   /* Set the iterator's position that many lines back.  But don't go
      back more than NLINES full screen lines -- this wins a day with
@@ -9307,7 +9310,10 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
       /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
          screen lines, and reseat the iterator there.  */
       start_charpos = IT_CHARPOS (*it);
-      pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
+      if (it->line_wrap == TRUNCATE)
+        pos_limit = BEGV;
+      else
+        pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
       for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > pos_limit; --i)
         back_to_previous_visible_line_start (it);
       reseat (it, it->current.pos, 1);
@@ -9450,11 +9456,11 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       bset_undo_list (current_buffer, Qt);
 
       oldpoint = message_dolog_marker1;
-      set_marker_restricted (oldpoint, make_number (PT), Qnil);
+      set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
       oldbegv = message_dolog_marker2;
-      set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
+      set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
       oldzv = message_dolog_marker3;
-      set_marker_restricted (oldzv, make_number (ZV), Qnil);
+      set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
       GCPRO1 (old_deactivate_mark);
 
       if (PT == Z)