auto upstream

39 files changed, 520 insertions, 288 deletions

diff --git a/ChangeLog b/ChangeLog
index bddec07fc19..ab81d73e45c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2012-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * make-dist (nt): Adjust to changes in names of the *.manifest files.
+
 2012-11-24  Ken Brown  <kbrown@cornell.edu>
 
         * configure.ac (HAVE_MOUSE): Remove.
diff --git a/admin/make-tarball.txt b/admin/make-tarball.txt
index ea9c4a3c2d1..eda28b639d2 100644
--- a/admin/make-tarball.txt
+++ b/admin/make-tarball.txt
@@ -57,8 +57,7 @@ For each step, check for possible errors.
     M-x ediff.  Especially check that Info files aren't built.
 
 10.  cd EMACS_ROOT_DIR; bzr tag TAG
-    TAG is EMACS_PRETEST_XX_YY_ZZZ for a pretest, EMACS_XX_YY for a
-    release.
+    TAG is emacs-XX.Y.ZZ for a pretest, emacs-XX.Y for a release.
 
     Shortly before the release, cut the version branch also, and open
     a Savannah support request asking for commits to the new branch to
diff --git a/lib-src/ChangeLog b/lib-src/ChangeLog
index b85ba12a5b2..a74d4b90b9f 100644
--- a/lib-src/ChangeLog
+++ b/lib-src/ChangeLog
@@ -1,3 +1,8 @@
+2012-11-27  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume POSIX 1003.1-1988 or later for errno.h (Bug#12968).
+        * movemail.c (main): Assume EAGAIN and EBUSY.
+
 2012-11-23  Paul Eggert  <eggert@cs.ucla.edu>
 
         movemail: treat EACCES etc. failures as permanent
diff --git a/lib-src/movemail.c b/lib-src/movemail.c
index 264b3d292c6..f2b2484c8e3 100644
--- a/lib-src/movemail.c
+++ b/lib-src/movemail.c
@@ -430,22 +430,10 @@ main (int argc, char **argv)
          for certain failure codes.  */
       if (status < 0)
         {
-          if (++lockcount <= 5)
+          if (++lockcount <= 5 && (errno == EAGAIN || errno == EBUSY))
             {
-#ifdef EAGAIN
-              if (errno == EAGAIN)
-                {
-                  sleep (1);
-                  goto retry_lock;
-                }
-#endif
-#ifdef EBUSY
-              if (errno == EBUSY)
-                {
-                  sleep (1);
-                  goto retry_lock;
-                }
-#endif
+              sleep (1);
+              goto retry_lock;
             }
 
           pfatal_with_name (inname);
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 9e403af6416..20de699a5ed 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,101 @@
+2012-11-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/etags.el (visit-tags-table-buffer): Give a more precise
+        error message when the file doesn't exist (bug#12974).
+
+2012-11-29  Kelly Dean  <kellydeanch@yahoo.com>  (tiny change)
+
+        * simple.el (activate-mark): Run activate-mark-hook (bug#13027).
+
+2012-11-29  Glenn Morris  <rgm@gnu.org>
+
+        * files.el (hack-dir-local-variables): Warn if try to set
+        coding via dir-locals, since it doesn't work.  (Bug#7169)
+
+        Add desktop support for restoring vc-dir buffers.  (Bug#10606)
+        * vc/vc-dir.el (vc-dir-mode): Autoload it (for desktop restore).
+        Set buffer-local value of desktop-save-buffer.
+        (vc-dir-desktop-buffer-misc-data, vc-dir-restore-desktop-buffer):
+        New functions.
+        (desktop-buffer-mode-handlers): Add vc-dir-mode entry.
+        * desktop.el (desktop-save-buffer-p): Treat vc-dir like dired.
+
+        * files.el (inhibit-local-variables-ignore-case): New.  (Bug#10610)
+        (inhibit-local-variables-p): Use inhibit-local-variables-ignore-case.
+        Doc fix.
+        (inhibit-local-variables-regexps, inhibit-local-variables-suffixes):
+        Doc fixes.
+
+2012-11-28  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calc-forms.el (calc-date-notation): Fix regexp
+        used to find time codes.  Fix symbol for seconds.
+
+2012-11-27  Glenn Morris  <rgm@gnu.org>
+
+        * emacs-lisp/derived.el (derived-mode-make-docstring):
+        Don't mention "abbrev" or "syntax" if nil.  (Bug#11277)
+
+2012-11-27  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * textmodes/table.el (table-insert): Don't use `symbol-name' on
+        lexically scoped variables (bug#13005).
+
+2012-11-27  Glenn Morris  <rgm@gnu.org>
+
+        * vc/vc-hooks.el (vc-mistrust-permissions):
+        Default to t, to avoid data-loss.  (Bug#11490)
+
+2012-11-27  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el (python-indent-guess-indent-offset):
+        If indentation is guessed make python-indent-offset buffer-local.
+
+        Fix Imenu regression.
+        * progmodes/python.el (python-nav-beginning-of-defun):
+        Fix forward movement when statement(s) separates point from defun.
+        (python-imenu-prev-index-position): New function.
+
+2012-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * subr.el (buffer-file-type): Declare with defvar-local.  Doc fix.
+
+        * dos-w32.el (find-file-not-found-set-buffer-file-coding-system):
+        Don't set buffer-file-type.  Return nil.  (Bug#12989)
+
+2012-11-27  Glenn Morris  <rgm@gnu.org>
+
+        * hippie-exp.el (hippie-expand-try-functions-list):
+        Re-autoload it.  (Bug#12982)
+
+2012-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * descr-text.el (describe-char-padded-string):
+        Call internal-char-font only on GUI frames.  (Bug#11964)
+
+2012-11-27  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * buff-menu.el (Buffer-menu-buffer+size-width): Fix customize type
+        and obsoletion message.
+
+2012-11-27  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/cl-macs.el (cl--transform-lambda): Add back `declare' in
+        the constructs to keep outside of the `cl-block' (bug#12977).
+
+2012-11-27  Chong Yidong  <cyd@gnu.org>
+
+        * mouse.el (mouse-drag-line): Even if the line is not draggable,
+        keep reading until we get the up-event anyway, in order to process
+        the up-event for mouse-1-click-follows-link (Bug#12971).
+
+2012-11-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/advice.el (ad-should-compile): Don't compile advice if the
+        base function is not yet defined (bug#12965).
+        (ad-activate-advised-definition): Use ad-compile-function.
+        (ad-activate): Use cond.
+
 2012-11-25  Leo Liu  <sdl.web@gmail.com>
 
         * textmodes/sgml-mode.el (sgml-tag): Fix indentation for closing tag.
@@ -10,14 +108,14 @@
         Texinfo integration.
 
         * textmodes/reftex.el (reftex-section-pre-regexp)
-        (reftex-section-post-regexp, reftex-section-info-function): New
-        variable.
-        (reftex-compile-variables): Use variables
-        reftex-section-pre-regexp, reftex-section-post-regexp, and
-        reftex-section-info-function in order to be compatible with Texinfo integration.
+        (reftex-section-post-regexp, reftex-section-info-function):
+        New variable.
+        (reftex-compile-variables): Use variables reftex-section-pre-regexp,
+        reftex-section-post-regexp, and reftex-section-info-function in order
+        to be compatible with Texinfo integration.
 
-        * textmodes/reftex-toc.el (reftex-toc-promote-action): use
-        reftex-section-pre-regexp variable in order to be compatible with
+        * textmodes/reftex-toc.el (reftex-toc-promote-action):
+        use reftex-section-pre-regexp variable in order to be compatible with
         Texinfo integration.
 
 2012-11-25  Chong Yidong  <cyd@gnu.org>
diff --git a/lisp/buff-menu.el b/lisp/buff-menu.el
index 6ab6e548ab5..01035f8727d 100644
--- a/lisp/buff-menu.el
+++ b/lisp/buff-menu.el
@@ -55,12 +55,12 @@ If nil, use `Buffer-menu-name-width' and `Buffer-menu-size-width'.
 If non-nil, the value of `Buffer-menu-name-width' is overridden;
 the name column is assigned width `Buffer-menu-buffer+size-width'
 minus `Buffer-menu-size-width'.  This use is deprecated."
-  :type 'number
+  :type '(choice (const nil) number)
   :group 'Buffer-menu
   :version "24.3")
 
 (make-obsolete-variable 'Buffer-menu-buffer+size-width
-                        "`Buffer-menu-name-width' and `Buffer-menu-size-width'"
+                        "use `Buffer-menu-name-width' and `Buffer-menu-size-width' instead."
                         "24.3")
 
 (defcustom Buffer-menu-name-width 19
diff --git a/lisp/calc/calc-forms.el b/lisp/calc/calc-forms.el
index 98b22550f75..15a153059a8 100644
--- a/lisp/calc/calc-forms.el
+++ b/lisp/calc/calc-forms.el
@@ -94,7 +94,8 @@
         (setcar (nthcdr arg calc-standard-date-formats) fmt))
    (let ((case-fold-search nil))
      (and (not (string-match "<.*>" fmt))
-          (string-match "\\`[^hHspP]*\\([^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*[bBhHmpPsS]+[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*\\)[^hHspP]*\\'" fmt)
+          ;; Find time part to put in <...>
+          (string-match "\\`[^hHspP]*\\([^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*\\(bs\\|bm\\|bh\\|BS\\|BH\\|[hHmpPsS]\\)+[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*\\)[^hHspP]*\\'" fmt)
           (string-match (concat "[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*"
                                 (regexp-quote (math-match-substring fmt 1))
                                 "[^ac-gi-lnoqrt-zAC-GI-OQRT-Z]*") fmt)
@@ -140,7 +141,7 @@
                                 W www Www Wwww WWW WWWW
                                 h hh bh H HH BH
                                 p P pp PP pppp PPPP
-                                m mm bm s ss bss SS BS C
+                                m mm bm s ss bs SS BS C
                                 N n J j U b))
                   (and (eq sym 'X) (not lfmt) (not fullfmt))
                   (error "Bad format code: %s" sym))
diff --git a/lisp/descr-text.el b/lisp/descr-text.el
index c384b96df86..d531e15546a 100644
--- a/lisp/descr-text.el
+++ b/lisp/descr-text.el
@@ -354,7 +354,8 @@ This function is semi-obsolete.  Use `get-char-code-property'."
 ;; Return a string of CH with composition for padding on both sides.
 ;; It is displayed without overlapping with the left/right columns.
 (defsubst describe-char-padded-string (ch)
-  (if (internal-char-font nil ch)
+  (if (and (display-multi-font-p)
+           (internal-char-font nil ch))
       (compose-string (string ch) 0 1 (format "\t%c\t" ch))
     (string ch)))
 
diff --git a/lisp/desktop.el b/lisp/desktop.el
index c8023bb43ed..5589dd025bc 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -825,7 +825,7 @@ MODE is the major mode.
          (or (and filename
                   (stringp desktop-files-not-to-save)
                   (not (string-match desktop-files-not-to-save filename)))
-             (and (eq mode 'dired-mode)
+             (and (memq mode '(dired-mode vc-dir-mode))
                   (with-current-buffer bufname
                     (not (setq dired-skip
                                (string-match desktop-files-not-to-save
diff --git a/lisp/dos-w32.el b/lisp/dos-w32.el
index 4839d6b9239..cb043ce8559 100644
--- a/lisp/dos-w32.el
+++ b/lisp/dos-w32.el
@@ -210,7 +210,7 @@ set to the appropriate coding system, and the value of
                      (untranslated-file-p (buffer-file-name))))
         (setq coding (coding-system-change-eol-conversion coding 0))
         (setq buffer-file-coding-system coding))
-      (setq buffer-file-type (eq buffer-file-coding-system 'no-conversion)))))
+      nil)))
 
 ;;; To set the default coding system on new files.
 (add-hook 'find-file-not-found-functions
diff --git a/lisp/emacs-lisp/advice.el b/lisp/emacs-lisp/advice.el
index c2ebb3bbdc6..a947dceccc9 100644
--- a/lisp/emacs-lisp/advice.el
+++ b/lisp/emacs-lisp/advice.el
@@ -2900,19 +2900,18 @@ If COMPILE is non-nil and not a negative number then it returns t.
 If COMPILE is a negative number then it returns nil.
 If COMPILE is nil then the result depends on the value of
 `ad-default-compilation-action' (which see)."
-  (if (integerp compile)
-      (>= compile 0)
-    (if compile
-        compile
-      (cond ((eq ad-default-compilation-action 'never)
-             nil)
-            ((eq ad-default-compilation-action 'always)
-             t)
-            ((eq ad-default-compilation-action 'like-original)
-             (or (ad-subr-p (ad-get-orig-definition function))
-                 (ad-compiled-p (ad-get-orig-definition function))))
-            ;; everything else means `maybe':
-            (t (featurep 'byte-compile))))))
+  (cond
+   ;; Don't compile until the real function definition is known (bug#12965).
+   ((not (ad-real-orig-definition function)) nil)
+   ((integerp compile) (>= compile 0))
+   (compile)
+   ((eq ad-default-compilation-action 'never) nil)
+   ((eq ad-default-compilation-action 'always) t)
+   ((eq ad-default-compilation-action 'like-original)
+    (or (ad-subr-p (ad-get-orig-definition function))
+        (ad-compiled-p (ad-get-orig-definition function))))
+   ;; everything else means `maybe':
+   (t (featurep 'byte-compile))))
 
 (defun ad-activate-advised-definition (function compile)
   "Redefine FUNCTION with its advised definition from cache or scratch.
@@ -2927,7 +2926,7 @@ The current definition and its cache-id will be put into the cache."
               (ad-make-advised-definition function)))
     (advice-add function :around advicefunname)
     (if (ad-should-compile function compile)
-        (byte-compile advicefunname))
+        (ad-compile-function function))
     (if verified-cached-definition
         (if (not (eq verified-cached-definition
                      (symbol-function advicefunname)))
@@ -3003,20 +3002,20 @@ definition will always be cached for later usage."
   (interactive
    (list (ad-read-advised-function "Activate advice of")
          current-prefix-arg))
-  (if (not (ad-is-advised function))
-      (error "ad-activate: `%s' is not advised" function)
-    ;; Just return for forward advised and not yet defined functions:
-    (if (ad-get-orig-definition function)
-        (if (not (ad-has-any-advice function))
-            (ad-unadvise function)
-          ;; Otherwise activate the advice:
-          (cond ((ad-has-redefining-advice function)
-                 (ad-activate-advised-definition function compile)
-                 (ad-set-advice-info-field function 'active t)
-                 (eval (ad-make-hook-form function 'activation))
-                 function)
-                ;; Here we are if we have all disabled advices:
-                (t (ad-deactivate function)))))))
+  (cond
+   ((not (ad-is-advised function))
+    (error "ad-activate: `%s' is not advised" function))
+   ;; Just return for forward advised and not yet defined functions:
+   ((not (ad-get-orig-definition function)) nil)
+   ((not (ad-has-any-advice function)) (ad-unadvise function))
+   ;; Otherwise activate the advice:
+   ((ad-has-redefining-advice function)
+    (ad-activate-advised-definition function compile)
+    (ad-set-advice-info-field function 'active t)
+    (eval (ad-make-hook-form function 'activation))
+    function)
+   ;; Here we are if we have all disabled advices:
+   (t (ad-deactivate function))))
 
 (defalias 'ad-activate-on 'ad-activate)
 
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index 7481e2d0b2b..743c24ffd91 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -267,7 +267,7 @@ including `cl-block' and `cl-eval-when'.
 ;;;;;;  cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when
 ;;;;;;  cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp
 ;;;;;;  cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
-;;;;;;  "cl-macs" "cl-macs.el" "93b43ab1ba3868dbad9ddedc54771a66")
+;;;;;;  "cl-macs" "cl-macs.el" "6e610d63ae75ac7b631e09c76f75c258")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'cl--compiler-macro-list* "cl-macs" "\
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index f8c18339ff2..41c54bee448 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -216,12 +216,17 @@ The name is made by appending a number to PREFIX, default \"G\"."
 (defvar cl--bind-inits) (defvar cl--bind-lets) (defvar cl--bind-forms)
 
 (defun cl--transform-lambda (form bind-block)
+  "Transform a function form FORM of name BIND-BLOCK.
+BIND-BLOCK is the name of the symbol to which the function will be bound,
+and which will be used for the name of the `cl-block' surrounding the
+function's body.
+FORM is of the form (ARGS . BODY)."
   (let* ((args (car form)) (body (cdr form)) (orig-args args)
          (cl--bind-block bind-block) (cl--bind-defs nil) (cl--bind-enquote nil)
          (cl--bind-inits nil) (cl--bind-lets nil) (cl--bind-forms nil)
          (header nil) (simple-args nil))
     (while (or (stringp (car body))
-               (memq (car-safe (car body)) '(interactive cl-declare)))
+               (memq (car-safe (car body)) '(interactive declare cl-declare)))
       (push (pop body) header))
     (setq args (if (listp args) (cl-copy-list args) (list '&rest args)))
     (let ((p (last args))) (if (cdr p) (setcdr p (list '&rest (cdr p)))))
diff --git a/lisp/emacs-lisp/derived.el b/lisp/emacs-lisp/derived.el
index 8c8d37b2194..f4b79eb3016 100644
--- a/lisp/emacs-lisp/derived.el
+++ b/lisp/emacs-lisp/derived.el
@@ -295,16 +295,32 @@ is not very useful."
       ;; Use a default docstring.
       (setq docstring
             (if (null parent)
-                (format "Major-mode.
-Uses keymap `%s', abbrev table `%s' and syntax-table `%s'." map abbrev syntax)
+                ;; FIXME filling.
+                (format "Major-mode.\nUses keymap `%s'%s%s." map
+                        (if abbrev (format "%s abbrev table `%s'"
+                                           (if syntax "," " and") abbrev) "")
+                        (if syntax (format " and syntax-table `%s'" syntax) ""))
               (format "Major mode derived from `%s' by `define-derived-mode'.
-It inherits all of the parent's attributes, but has its own keymap,
-abbrev table and syntax table:
-
-  `%s', `%s' and `%s'
-
-which more-or-less shadow %s's corresponding tables."
-                      parent map abbrev syntax parent))))
+It inherits all of the parent's attributes, but has its own keymap%s:
+
+  `%s'%s
+
+which more-or-less shadow%s %s's corresponding table%s."
+                      parent
+                      (cond ((and abbrev syntax)
+                             ",\nabbrev table and syntax table")
+                            (abbrev "\nand abbrev table")
+                            (syntax "\nand syntax table")
+                            (t ""))
+                      map
+                      (cond ((and abbrev syntax)
+                             (format ", `%s' and `%s'" abbrev syntax))
+                            ((or abbrev syntax)
+                             (format " and `%s'" (or abbrev syntax)))
+                            (t ""))
+                      (if (or abbrev syntax) "" "s")
+                      parent
+                      (if (or abbrev syntax) "s" "")))))
 
     (unless (string-match (regexp-quote (symbol-name hook)) docstring)
       ;; Make sure the docstring mentions the mode's hook.
diff --git a/lisp/files.el b/lisp/files.el
index 496f9bf8fa4..e03b02193a4 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -2502,25 +2502,31 @@ They may happen to contain sequences that look like local variable
 specifications, but are not really, or they may be containers for
 member files with their own local variable sections, which are
 not appropriate for the containing file.
-See also `inhibit-local-variables-suffixes'.")
+The function `inhibit-local-variables-p' uses this.")
 
 (define-obsolete-variable-alias 'inhibit-first-line-modes-suffixes
   'inhibit-local-variables-suffixes "24.1")
 
 (defvar inhibit-local-variables-suffixes nil
   "List of regexps matching suffixes to remove from file names.
-When checking `inhibit-local-variables-regexps', we first discard
-from the end of the file name anything that matches one of these regexps.")
+The function `inhibit-local-variables-p' uses this: when checking
+a file name, it first discards from the end of the name anything that
+matches one of these regexps.")
+
+;; Can't think of any situation in which you'd want this to be nil...
+(defvar inhibit-local-variables-ignore-case t
+  "Non-nil means `inhibit-local-variables-p' ignores case.")
 
-;; TODO explicitly add case-fold-search t?
 (defun inhibit-local-variables-p ()
   "Return non-nil if file local variables should be ignored.
 This checks the file (or buffer) name against `inhibit-local-variables-regexps'
-and `inhibit-local-variables-suffixes'."
+and `inhibit-local-variables-suffixes'.  If
+`inhibit-local-variables-ignore-case' is non-nil, this ignores case."
   (let ((temp inhibit-local-variables-regexps)
         (name (if buffer-file-name
                   (file-name-sans-versions buffer-file-name)
-                (buffer-name))))
+                (buffer-name)))
+        (case-fold-search inhibit-local-variables-ignore-case))
     (while (let ((sufs inhibit-local-variables-suffixes))
              (while (and sufs (not (string-match (car sufs) name)))
                (setq sufs (cdr sufs)))
@@ -3676,10 +3682,13 @@ and `file-local-variables-alist', without applying them."
                 (dir-locals-get-class-variables class) dir-name nil)))
           (when variables
             (dolist (elt variables)
-              (unless (memq (car elt) '(eval mode))
-                (setq dir-local-variables-alist
-                      (assq-delete-all (car elt) dir-local-variables-alist)))
-              (push elt dir-local-variables-alist))
+              (if (eq (car elt) 'coding)
+                  (display-warning :warning
+                                   "Coding cannot be specified by dir-locals")
+                (unless (memq (car elt) '(eval mode))
+                  (setq dir-local-variables-alist
+                        (assq-delete-all (car elt) dir-local-variables-alist)))
+                (push elt dir-local-variables-alist)))
             (hack-local-variables-filter variables dir-name)))))))
 
 (defun hack-dir-local-variables-non-file-buffer ()
diff --git a/lisp/hippie-exp.el b/lisp/hippie-exp.el
index 2f0a6e3af59..d2c69c70b75 100644
--- a/lisp/hippie-exp.el
+++ b/lisp/hippie-exp.el
@@ -199,6 +199,8 @@
 
 (defvar he-search-window ())
 
+;;; Autoloaded for historical reasons (bug#12982)
+;;;###autoload
 (defcustom hippie-expand-try-functions-list
   '(try-complete-file-name-partially
     try-complete-file-name
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 61d70404bd6..60a3d390889 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -425,7 +425,7 @@ must be one of the symbols `header', `mode', or `vertical'."
                                    (frame-parameters frame)))
                         'right)))
          (draggable t)
-         event position growth dragged)
+         finished event position growth dragged)
     (cond
      ((eq line 'header)
       ;; Check whether header-line can be dragged at all.
@@ -457,7 +457,7 @@ must be one of the symbols `header', `mode', or `vertical'."
     ;; Start tracking.
     (track-mouse
       ;; Loop reading events and sampling the position of the mouse.
-      (while draggable
+      (while (not finished)
         (setq event (read-event))
         (setq position (mouse-position))
         ;; Do nothing if
@@ -472,7 +472,7 @@ must be one of the symbols `header', `mode', or `vertical'."
         ;;   - there is a keyboard event or some other unknown event.
         (cond
          ((not (consp event))
-          (setq draggable nil))
+          (setq finished t))
          ((memq (car event) '(switch-frame select-window))
           nil)
          ((not (memq (car event) '(mouse-movement scroll-bar-movement)))
@@ -480,15 +480,15 @@ must be one of the symbols `header', `mode', or `vertical'."
             ;; Do not unread a drag-mouse-1 event to avoid selecting
             ;; some other window.  For vertical line dragging do not
             ;; unread mouse-1 events either (but only if we dragged at
-            ;; least once to allow mouse-1 clicks get through.
+            ;; least once to allow mouse-1 clicks get through).
             (unless (and dragged
                          (if (eq line 'vertical)
                              (memq (car event) '(drag-mouse-1 mouse-1))
                            (eq (car event) 'drag-mouse-1)))
               (push event unread-command-events)))
-          (setq draggable nil))
-         ((or (not (eq (car position) frame))
-              (null (car (cdr position))))
+          (setq finished t))
+         ((not (and (eq (car position) frame)
+                    (cadr position)))
           nil)
          ((eq line 'vertical)
           ;; Drag vertical divider.
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 071a0fb6037..067d89781d2 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -702,7 +702,9 @@ Returns t if it visits a tags table, or nil if there are no more in the list."
         (kill-local-variable 'tags-file-name)
         (if (eq local-tags-file-name tags-file-name)
             (setq tags-file-name nil))
-        (user-error "File %s is not a valid tags table"
+        (user-error (if (file-exists-p local-tags-file-name)
+                        "File %s is not a valid tags table"
+                      "File %s does not exist")
                     local-tags-file-name)))))
 
 (defun tags-reset-tags-tables ()
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 550c5f5a129..a2c8453a011 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -33,7 +33,7 @@
 ;; Implements Syntax highlighting, Indentation, Movement, Shell
 ;; interaction, Shell completion, Shell virtualenv support, Pdb
 ;; tracking, Symbol completion, Skeletons, FFAP, Code Check, Eldoc,
-;; imenu.
+;; Imenu.
 
 ;; Syntax highlighting: Fontification of code is provided and supports
 ;; python's triple quoted strings properly.
@@ -169,10 +169,12 @@
 ;; might guessed you should run `python-shell-send-buffer' from time
 ;; to time to get better results too.
 
-;; imenu: This mode supports imenu in its most basic form, letting it
+;; Imenu: This mode supports Imenu in its most basic form, letting it
 ;; build the necessary alist via `imenu-default-create-index-function'
 ;; by having set `imenu-extract-index-name-function' to
-;; `python-info-current-defun'.
+;; `python-info-current-defun' and
+;; `imenu-prev-index-position-function' to
+;; `python-imenu-prev-index-position'.
 
 ;; If you used python-mode.el you probably will miss auto-indentation
 ;; when inserting newlines.  To achieve the same behavior you have
@@ -656,7 +658,7 @@ These make `python-indent-calculate-indentation' subtract the value of
                  (python-util-forward-comment)
                  (current-indentation))))
           (if indentation
-              (setq python-indent-offset indentation)
+              (set (make-local-variable 'python-indent-offset) indentation)
             (message "Can't guess python-indent-offset, using defaults: %s"
                      python-indent-offset)))))))
 
@@ -1098,12 +1100,12 @@ With positive ARG search backwards, else search forwards."
          (beg-indentation
           (and (> arg 0)
                (save-excursion
-                 (and (python-info-current-line-empty-p)
-                      (python-util-forward-comment -1))
-                 (python-nav-beginning-of-statement)
-                 (if (python-info-looking-at-beginning-of-defun)
-                     (+ (current-indentation) python-indent-offset)
-                   (current-indentation)))))
+                 (while (and
+                         (not (python-info-looking-at-beginning-of-defun))
+                         (python-nav-backward-block)))
+                 (or (and (python-info-looking-at-beginning-of-defun)
+                          (+ (current-indentation) python-indent-offset))
+                     0))))
          (found
           (progn
             (when (and (< arg 0)
@@ -2881,6 +2883,19 @@ Interactively, prompt for symbol."
              "^Eldoc needs an inferior Python process running.")
 
 
+;;; Imenu
+
+(defun python-imenu-prev-index-position ()
+  "Python mode's `imenu-prev-index-position-function'."
+  (let ((found))
+    (while (and (setq found
+                      (re-search-backward python-nav-beginning-of-defun-regexp nil t))
+                (not (python-info-looking-at-beginning-of-defun))))
+    (and found
+         (python-info-looking-at-beginning-of-defun)
+         (python-info-current-defun))))
+
+
 ;;; Misc helpers
 
 (defun python-info-current-defun (&optional include-type)
@@ -3225,6 +3240,9 @@ if that value is non-nil."
   (set (make-local-variable 'imenu-extract-index-name-function)
        #'python-info-current-defun)
 
+  (set (make-local-variable 'imenu-prev-index-position-function)
+       #'python-imenu-prev-index-position)
+
   (set (make-local-variable 'add-log-current-defun-function)
        #'python-info-current-defun)
 
diff --git a/lisp/simple.el b/lisp/simple.el
index 5867561da26..ecd02545b41 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -4012,7 +4012,8 @@ run `deactivate-mark-hook'."
   (when (mark t)
     (setq mark-active t)
     (unless transient-mark-mode
-      (setq transient-mark-mode 'lambda))))
+      (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!
diff --git a/lisp/subr.el b/lisp/subr.el
index c0479d35987..c0cb026fdf9 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2622,13 +2622,14 @@ When the hook runs, the temporary buffer is current.
 This hook is normally set up with a function to put the buffer in Help
 mode.")
 
-;; Avoid compiler warnings about this variable,
-;; which has a special meaning on certain system types.
-(defvar buffer-file-type nil
+(defvar-local buffer-file-type nil
   "Non-nil if the visited file is a binary file.
-This variable is meaningful on MS-DOG and Windows NT.
+This variable is meaningful on MS-DOG and MS-Windows.
 On those systems, it is automatically local in every buffer.
-On other systems, this variable is normally always nil.")
+On other systems, this variable is normally always nil.
+
+WARNING: This variable is obsolete and will disapper Real Soon Now.
+Don't use it!")
 
 ;; The `assert' macro from the cl package signals
 ;; `cl-assertion-failed' at runtime so always define it.
diff --git a/lisp/textmodes/table.el b/lisp/textmodes/table.el
index 6db15b7ec2a..cbfc746dc56 100644
--- a/lisp/textmodes/table.el
+++ b/lisp/textmodes/table.el
@@ -1570,8 +1570,7 @@ results.
 
 Inside a table cell has a special keymap.
 
-\\{table-cell-map}
-"
+\\{table-cell-map}"
   (interactive
    (progn
      (barf-if-buffer-read-only)
@@ -1583,41 +1582,47 @@ Inside a table cell has a special keymap.
                ("Cell width(s)" . table-cell-width-history)
                ("Cell height(s)" . table-cell-height-history)))))
   (table--make-cell-map)
-  ;; reform the arguments.
+  ;; Reform the arguments.
   (if (null cell-width) (setq cell-width (car table-cell-width-history)))
   (if (null cell-height) (setq cell-height (car table-cell-height-history)))
   (if (stringp columns) (setq columns (string-to-number columns)))
   (if (stringp rows) (setq rows (string-to-number rows)))
-  (if (stringp cell-width) (setq cell-width (table--string-to-number-list cell-width)))
-  (if (stringp cell-height) (setq cell-height (table--string-to-number-list cell-height)))
+  (if (stringp cell-width)
+      (setq cell-width (table--string-to-number-list cell-width)))
+  (if (stringp cell-height)
+      (setq cell-height (table--string-to-number-list cell-height)))
   (if (numberp cell-width) (setq cell-width (cons cell-width nil)))
   (if (numberp cell-height) (setq cell-height (cons cell-height nil)))
-  ;; test validity of the arguments.
-  (mapc (lambda (arg)
-          (let* ((value (symbol-value arg))
-                 (error-handler
-                  (function (lambda ()
-                    (error "%s must be a positive integer%s" arg
-                           (if (listp value) " or a list of positive integers" ""))))))
-            (if (null value) (funcall error-handler))
-            (mapcar (function (lambda (arg1)
-                      (if (or (not (integerp arg1))
-                              (< arg1 1))
-                          (funcall error-handler))))
-                    (if (listp value) value
-                      (cons value nil)))))
-        '(columns rows cell-width cell-height))
+  ;; Test validity of the arguments.
+  (dolist (arg `((columns . ,columns)
+                 (rows . ,rows)
+                 (cell-width . ,cell-width)
+                 (cell-height . ,cell-height)))
+    (let* ((value (cdr arg))
+           (error-handler
+            (lambda ()
+              (error "%s must be a positive integer%s" (car arg)
+                     (if (listp value)
+                         " or a list of positive integers" "")))))
+      (if (null value) (funcall error-handler))
+      (dolist (arg1 (if (listp value) value
+                      (cons value nil)))
+        (if (or (not (integerp arg1))
+                (< arg1 1))
+            (funcall error-handler)))))
   (let ((orig-coord (table--get-coordinate))
         (coord (table--get-coordinate))
         r i cw ch cell-str border-str)
-    ;; prefabricate the building blocks border-str and cell-str.
+    ;; Prefabricate the building blocks border-str and cell-str.
     (with-temp-buffer
-      ;; construct border-str
+      ;; Construct border-str.
       (insert table-cell-intersection-char)
       (setq cw cell-width)
       (setq i 0)
       (while (< i columns)
-        (insert (make-string (car cw) (string-to-char table-cell-horizontal-chars)) table-cell-intersection-char)
+        (insert (make-string (car cw)
+                             (string-to-char table-cell-horizontal-chars))
+                table-cell-intersection-char)
         (if (cdr cw) (setq cw (cdr cw)))
         (setq i (1+ i)))
       (setq border-str (buffer-substring (point-min) (point-max)))
diff --git a/lisp/vc/vc-dir.el b/lisp/vc/vc-dir.el
index 455f48c50d3..a9df6fdee8d 100644
--- a/lisp/vc/vc-dir.el
+++ b/lisp/vc/vc-dir.el
@@ -930,6 +930,8 @@ If it is a file, return the corresponding cons for the file itself."
 
 (defvar use-vc-backend)  ;; dynamically bound
 
+;; Autoload cookie needed by desktop.el.
+;;;###autoload
 (define-derived-mode vc-dir-mode special-mode "VC dir"
   "Major mode for VC directory buffers.
 Marking/Unmarking key bindings and actions:
@@ -967,6 +969,8 @@ the *vc-dir* buffer.
 
 \\{vc-dir-mode-map}"
   (set (make-local-variable 'vc-dir-backend) use-vc-backend)
+  (set (make-local-variable 'desktop-save-buffer)
+       'vc-dir-desktop-buffer-misc-data)
   (setq buffer-read-only t)
   (when (boundp 'tool-bar-map)
     (set (make-local-variable 'tool-bar-map) vc-dir-tool-bar-map))
@@ -1288,6 +1292,31 @@ These are the commands available for use in the file status buffer:
   "Default absence of extra information returned for a file."
   nil)
 
+
+;;; Support for desktop.el (adapted from what dired.el does).
+
+(declare-function desktop-file-name "desktop" (filename dirname))
+
+(defun vc-dir-desktop-buffer-misc-data (dirname)
+  "Auxiliary information to be saved in desktop file."
+  (cons (desktop-file-name default-directory dirname) vc-dir-backend))
+
+(defun vc-dir-restore-desktop-buffer (_filename _buffername misc-data)
+  "Restore a `vc-dir' buffer specified in a desktop file."
+  (let ((dir (car misc-data))
+        (backend (cdr misc-data)))
+    (if (file-directory-p dir)
+        (progn
+          (vc-dir dir backend)
+          (current-buffer))
+      (message "Desktop: Directory %s no longer exists." dir)
+      (when desktop-missing-file-warning (sit-for 1))
+      nil)))
+
+(add-to-list 'desktop-buffer-mode-handlers
+             '(vc-dir-mode . vc-dir-restore-desktop-buffer))
+
+
 (provide 'vc-dir)
 
 ;;; vc-dir.el ends here
diff --git a/lisp/vc/vc-hooks.el b/lisp/vc/vc-hooks.el
index 07a292ae435..ef900cb5257 100644
--- a/lisp/vc/vc-hooks.el
+++ b/lisp/vc/vc-hooks.el
@@ -107,10 +107,12 @@ control systems."
   :type 'boolean
   :group 'vc)
 
-(defcustom vc-mistrust-permissions nil
+;; If you fix bug#11490, probably you can set this back to nil.
+(defcustom vc-mistrust-permissions t
   "If non-nil, don't assume permissions/ownership track version-control status.
 If nil, do rely on the permissions.
 See also variable `vc-consult-headers'."
+  :version "24.3"                       ; nil->t, bug#11490
   :type 'boolean
   :group 'vc)
 
diff --git a/make-dist b/make-dist
index 7a17fa02372..a7f4b74e97e 100755
--- a/make-dist
+++ b/make-dist
@@ -381,9 +381,9 @@ echo "Making links to \`m4'"
 
 echo "Making links to \`nt'"
 (cd nt
- ln emacs.manifest emacs.rc emacsclient.rc config.nt ../${tempdir}/nt
- ln emacs-src.tags nmake.defs gmake.defs subdirs.el ../${tempdir}/nt
- ln [a-z]*.bat [a-z]*.[ch] ../${tempdir}/nt
+ ln emacs-x86.manifest emacs-x64.manifest emacs.rc ../${tempdir}/nt
+ ln config.nt emacsclient.rc emacs-src.tags ../${tempdir}/nt
+ ln nmake.defs gmake.defs subdirs.el [a-z]*.bat [a-z]*.[ch] ../${tempdir}/nt
  ln ChangeLog INSTALL README README.W32 makefile.w32-in ../${tempdir}/nt)
 
 echo "Making links to \`nt/inc' and its subdirectories"
diff --git a/src/ChangeLog b/src/ChangeLog
index c612c4dd365..b19ecc926d0 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,67 @@
+2012-11-29  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xdisp.c (window_outdated): Remove eassert since it hits
+        some suspicious corner cases (see Bug#13007 and Bug#13012).
+        (mode_line_update_needed): New function.
+        (redisplay_internal, redisplay_window): Use it.
+        (ensure_selected_frame): New function.
+        (redisplay_internal, unwind_redisplay): Use it.
+        (redisplay_internal): Move comment about buffer_shared...
+        (buffer_shared_and_changed): ...near to its real use.
+
+2012-11-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * callproc.c (Fcall_process): Don't misreport vfork failure.
+
+2012-11-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * callproc.c (Fcall_process): Fix vfork portability problems.
+        Do not assume that fd[0], count, filefd, and save_environ survive
+        vfork.  Fix bug whereby wrong errno value could be reported for
+        pipe failure.  Some minor cleanups, too, as follows.  Move buf and
+        bufsize to the context where they're needed.  Change new_argv to
+        be of type char **, as this is more convenient and avoids casts.
+        (CALLPROC_BUFFER_SIZE_MIN, CALLPROC_BUFFER_SIZE_MAX):
+        Now local constants, not macros.
+
+2012-11-18  Kenichi Handa  <handa@gnu.org>
+
+        * font.c (font_unparse_xlfd): Fix previous change.  Keep "const"
+        for the variable "f".
+
+2012-11-13  Kenichi Handa  <handa@gnu.org>
+
+        * font.c (font_unparse_xlfd): Exclude special characters from the
+        generating XLFD name.
+
+2012-11-27  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume POSIX 1003.1-1988 or later for grp.h, pwd.h.
+        * dired.c (stat_uname, stat_gname):
+        * fileio.c (Fexpand_file_name): Remove no-longer-needed casts.
+
+        Assume POSIX 1003.1-1988 or later for errno.h (Bug#12968).
+        * dired.c (directory_files_internal, file_name_completion):
+        Assume EAGAIN and EINTR are defined.
+
+        * fileio.c (Fcopy_file): Assume EISDIR is defined.
+        * gmalloc.c (ENOMEM, EINVAL): Assume they're defined.
+        * gnutls.c (emacs_gnutls_write): Assume EAGAIN is defined.
+        * lread.c (readbyte_from_file): Assume EINTR is defined.
+        * process.c (wait_reading_process_output, send_process) [subprocesses]:
+        Assume EIO and EAGAIN are defined.
+        * unexcoff.c (write_segment): Assume EFAULT is defined.
+
+2012-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * fontset.c (Finternal_char_font): Return nil on non-GUI frames.
+        (Bug#11964)
+
+        * xdisp.c (draw_glyphs): Don't draw in mouse face if mouse
+        highlighting on the frame was cleared.  Prevents assertion
+        violations when repeatedly clicking on the "Top" link of the
+        "bread-crumbs" in Info buffers.
+
 2012-11-25  Paul Eggert  <eggert@cs.ucla.edu>
 
         * sysdep.c (sys_subshell): Don't assume pid_t fits in int.
diff --git a/src/callproc.c b/src/callproc.c
index c9a504746b3..167663a45c6 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -183,16 +183,11 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 {
   Lisp_Object infile, buffer, current_dir, path, cleanup_info_tail;
   bool display_p;
-  int fd[2];
-  int filefd;
-#define CALLPROC_BUFFER_SIZE_MIN (16 * 1024)
-#define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN)
-  char buf[CALLPROC_BUFFER_SIZE_MAX];
-  int bufsize = CALLPROC_BUFFER_SIZE_MIN;
+  int fd0, fd1, filefd;
   ptrdiff_t count = SPECPDL_INDEX ();
   USE_SAFE_ALLOCA;
 
-  register const unsigned char **new_argv;
+  char **new_argv;
   /* File to use for stderr in the child.
      t means use same as standard output.  */
   Lisp_Object error_file;
@@ -204,6 +199,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 #else
   pid_t pid;
 #endif
+  int vfork_errno;
   int fd_output = -1;
   struct coding_system process_coding; /* coding-system of process output */
   struct coding_system argument_coding; /* coding-system of arguments */
@@ -432,12 +428,12 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
         }
       UNGCPRO;
       for (i = 4; i < nargs; i++)
-        new_argv[i - 3] = SDATA (args[i]);
+        new_argv[i - 3] = SSDATA (args[i]);
       new_argv[i - 3] = 0;
     }
   else
     new_argv[1] = 0;
-  new_argv[0] = SDATA (path);
+  new_argv[0] = SSDATA (path);
 
 #ifdef MSDOS /* MW, July 1993 */
 
@@ -466,29 +462,35 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     }
   else
     outfilefd = fd_output;
-  fd[0] = filefd;
-  fd[1] = outfilefd;
+  fd0 = filefd;
+  fd1 = outfilefd;
 #endif /* MSDOS */
 
   if (INTEGERP (buffer))
-    fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1;
+    {
+      fd0 = -1;
+      fd1 = emacs_open (NULL_DEVICE, O_WRONLY, 0);
+    }
   else
     {
 #ifndef MSDOS
-      errno = 0;
+      int fd[2];
       if (pipe (fd) == -1)
         {
+          int pipe_errno = errno;
           emacs_close (filefd);
+          errno = pipe_errno;
           report_file_error ("Creating process pipe", Qnil);
         }
+      fd0 = fd[0];
+      fd1 = fd[1];
 #endif
     }
 
   {
     /* child_setup must clobber environ in systems with true vfork.
        Protect it from permanent change.  */
-    register char **save_environ = environ;
-    register int fd1 = fd[1];
+    char **save_environ = environ;
     int fd_error = fd1;
 
     if (fd_output >= 0)
@@ -520,8 +522,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     if (fd_error < 0)
       {
         emacs_close (filefd);
-        if (fd[0] != filefd)
-          emacs_close (fd[0]);
+        if (fd0 != filefd)
+          emacs_close (fd0);
         if (fd1 >= 0)
           emacs_close (fd1);
 #ifdef MSDOS
@@ -538,8 +540,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     /* Note that on MSDOS `child_setup' actually returns the child process
        exit status, not its PID, so we assign it to `synch_process_retcode'
        below.  */
-    pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv,
-                       0, current_dir);
+    pid = child_setup (filefd, outfilefd, fd_error, new_argv, 0, current_dir);
 
     /* Record that the synchronous process exited and note its
        termination status.  */
@@ -559,8 +560,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       {
         /* Since CRLF is converted to LF within `decode_coding', we
            can always open a file with binary mode.  */
-        fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
-        if (fd[0] < 0)
+        fd0 = emacs_open (tempfile, O_RDONLY | O_BINARY, 0);
+        if (fd0 < 0)
           {
             unlink (tempfile);
             emacs_close (filefd);
@@ -569,11 +570,10 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
           }
       }
     else
-      fd[0] = -1; /* We are not going to read from tempfile.   */
+      fd0 = -1; /* We are not going to read from tempfile.   */
 #else /* not MSDOS */
 #ifdef WINDOWSNT
-    pid = child_setup (filefd, fd1, fd_error, (char **) new_argv,
-                       0, current_dir);
+    pid = child_setup (filefd, fd1, fd_error, new_argv, 0, current_dir);
 #else  /* not WINDOWSNT */
 
     block_input ();
@@ -586,11 +586,15 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       bool volatile display_p_volatile = display_p;
       bool volatile output_to_buffer_volatile = output_to_buffer;
       bool volatile sa_must_free_volatile = sa_must_free;
+      int volatile fd0_volatile = fd0;
       int volatile fd1_volatile = fd1;
       int volatile fd_error_volatile = fd_error;
       int volatile fd_output_volatile = fd_output;
+      int volatile filefd_volatile = filefd;
+      ptrdiff_t volatile count_volatile = count;
       ptrdiff_t volatile sa_count_volatile = sa_count;
-      unsigned char const **volatile new_argv_volatile = new_argv;
+      char **volatile new_argv_volatile = new_argv;
+      char **volatile new_save_environ = save_environ;
 
       pid = vfork ();
 
@@ -598,29 +602,33 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       coding_systems = coding_systems_volatile;
       current_dir = current_dir_volatile;
       display_p = display_p_volatile;
+      output_to_buffer = output_to_buffer_volatile;
+      sa_must_free = sa_must_free_volatile;
+      fd0 = fd0_volatile;
       fd1 = fd1_volatile;
       fd_error = fd_error_volatile;
       fd_output = fd_output_volatile;
-      output_to_buffer = output_to_buffer_volatile;
-      sa_must_free = sa_must_free_volatile;
+      filefd = filefd_volatile;
+      count = count_volatile;
       sa_count = sa_count_volatile;
       new_argv = new_argv_volatile;
+      save_environ = new_save_environ;
     }
 
     if (pid == 0)
       {
-        if (fd[0] >= 0)
-          emacs_close (fd[0]);
+        if (fd0 >= 0)
+          emacs_close (fd0);
 
         setsid ();
 
         /* Emacs ignores SIGPIPE, but the child should not.  */
         signal (SIGPIPE, SIG_DFL);
 
-        child_setup (filefd, fd1, fd_error, (char **) new_argv,
-                     0, current_dir);
+        child_setup (filefd, fd1, fd_error, new_argv, 0, current_dir);
       }
 
+    vfork_errno = errno;
     unblock_input ();
 
 #endif /* not WINDOWSNT */
@@ -632,7 +640,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
     environ = save_environ;
 
-    /* Close most of our fd's, but not fd[0]
+    /* Close most of our file descriptors, but not fd0
        since we will use that to read input from.  */
     emacs_close (filefd);
     if (fd_output >= 0)
@@ -643,15 +651,16 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
   if (pid < 0)
     {
-      if (fd[0] >= 0)
-        emacs_close (fd[0]);
+      if (fd0 >= 0)
+        emacs_close (fd0);
+      errno = vfork_errno;
       report_file_error ("Doing vfork", Qnil);
     }
 
   if (INTEGERP (buffer))
     {
-      if (fd[0] >= 0)
-        emacs_close (fd[0]);
+      if (fd0 >= 0)
+        emacs_close (fd0);
       return Qnil;
     }
 
@@ -666,7 +675,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 #endif /* not MSDOS */
   record_unwind_protect (call_process_cleanup,
                          Fcons (Fcurrent_buffer (),
-                                Fcons (INTEGER_TO_CONS (fd[0]),
+                                Fcons (INTEGER_TO_CONS (fd0),
                                        cleanup_info_tail)));
 
   if (BUFFERP (buffer))
@@ -723,6 +732,10 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
   if (output_to_buffer)
     {
+      enum { CALLPROC_BUFFER_SIZE_MIN = 16 * 1024 };
+      enum { CALLPROC_BUFFER_SIZE_MAX = 4 * CALLPROC_BUFFER_SIZE_MIN };
+      char buf[CALLPROC_BUFFER_SIZE_MAX];
+      int bufsize = CALLPROC_BUFFER_SIZE_MIN;
       int nread;
       bool first = 1;
       EMACS_INT total_read = 0;
@@ -739,7 +752,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
           nread = carryover;
           while (nread < bufsize - 1024)
             {
-              int this_read = emacs_read (fd[0], buf + nread,
+              int this_read = emacs_read (fd0, buf + nread,
                                           bufsize - nread);
 
               if (this_read < 0)
diff --git a/src/dired.c b/src/dired.c
index 3530b74ecb4..bdb71c46364 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -193,19 +193,15 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
 
       errno = 0;
       dp = readdir (d);
-
-      if (dp == NULL && (0
-#ifdef EAGAIN
-                         || errno == EAGAIN
-#endif
-#ifdef EINTR
-                         || errno == EINTR
-#endif
-                         ))
-        { QUIT; continue; }
-
-      if (dp == NULL)
-        break;
+      if (!dp)
+        {
+          if (errno == EAGAIN || errno == EINTR)
+            {
+              QUIT;
+              continue;
+            }
+          break;
+        }
 
       len = dirent_namelen (dp);
       name = finalname = make_unibyte_string (dp->d_name, len);
@@ -480,17 +476,15 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
 
       errno = 0;
       dp = readdir (d);
-      if (dp == NULL && (0
-# ifdef EAGAIN
-                         || errno == EAGAIN
-# endif
-# ifdef EINTR
-                         || errno == EINTR
-# endif
-                         ))
-        { QUIT; continue; }
-
-      if (!dp) break;
+      if (!dp)
+        {
+          if (errno == EAGAIN || errno == EINTR)
+            {
+              QUIT;
+              continue;
+            }
+          break;
+        }
 
       len = dirent_namelen (dp);
 
@@ -826,7 +820,7 @@ stat_uname (struct stat *st)
 #ifdef WINDOWSNT
   return st->st_uname;
 #else
-  struct passwd *pw = (struct passwd *) getpwuid (st->st_uid);
+  struct passwd *pw = getpwuid (st->st_uid);
 
   if (pw)
     return pw->pw_name;
@@ -841,7 +835,7 @@ stat_gname (struct stat *st)
 #ifdef WINDOWSNT
   return st->st_gname;
 #else
-  struct group *gr = (struct group *) getgrgid (st->st_gid);
+  struct group *gr = getgrgid (st->st_gid);
 
   if (gr)
     return gr->gr_name;
diff --git a/src/dispextern.h b/src/dispextern.h
index 22fcee331c5..55fd852ea3b 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1582,12 +1582,12 @@ struct face
   /* Pixmap width and height.  */
   unsigned int pixmap_w, pixmap_h;
 
-  /* Non-zero means characters in this face have a box that thickness
-     around them.  If it is negative, the absolute value indicates the
-     thickness, and the horizontal lines of box (top and bottom) are
-     drawn inside of characters glyph area.  The vertical lines of box
-     (left and right) are drawn as the same way as the case that this
-     value is positive.  */
+  /* Non-zero means characters in this face have a box of that
+     thickness around them.  If this value is negative, its absolute
+     value indicates the thickness, and the horizontal (top and
+     bottom) borders of box are drawn inside of the character glyphs'
+     area.  The vertical (left and right) borders of the box are drawn
+     in the same way as when this value is positive.  */
   int box_line_width;
 
   /* Type of box drawn.  A value of FACE_NO_BOX means no box is drawn
diff --git a/src/fileio.c b/src/fileio.c
index 442c66550d3..48dbf20b88f 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1042,7 +1042,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           o [p - nm] = 0;
 
           block_input ();
-          pw = (struct passwd *) getpwnam (o + 1);
+          pw = getpwnam (o + 1);
           unblock_input ();
           if (pw)
             {
@@ -1995,10 +1995,8 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
     {
       if (!(S_ISREG (st.st_mode)) && !(S_ISLNK (st.st_mode)))
         {
-#if defined (EISDIR)
           /* Get a better looking error message. */
           errno = EISDIR;
-#endif /* EISDIR */
           report_file_error ("Non-regular file", Fcons (file, Qnil));
         }
     }
diff --git a/src/font.c b/src/font.c
index 41dbfd7a757..f6b6fa026c0 100644
--- a/src/font.c
+++ b/src/font.c
@@ -1234,8 +1234,21 @@ font_unparse_xlfd (Lisp_Object font, int pixel_size, char *name, int nbytes)
         f[j] = "*";
       else
         {
+          int c, k, l;
+          ptrdiff_t alloc;
+
           val = SYMBOL_NAME (val);
-          f[j] = SSDATA (val);
+          alloc = SBYTES (val) + 1;
+          if (nbytes <= alloc)
+            return -1;
+          f[j] = p = alloca (alloc);
+          /* Copy the name while excluding '-', '?', ',', and '"'.  */
+          for (k = l = 0; k < alloc; k++)
+            {
+              c = SREF (val, k);
+              if (c != '-' && c != '?' && c != ',' && c != '"')
+                p[l++] = c;
+            }
         }
     }
 
diff --git a/src/fontset.c b/src/fontset.c
index b76a216bac2..660ca432fad 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1876,6 +1876,8 @@ DEFUN ("internal-char-font", Finternal_char_font, Sinternal_char_font, 1, 2, 0,
     }
   if (! CHAR_VALID_P (c))
     return Qnil;
+  if (!FRAME_WINDOW_P (f))
+    return Qnil;
   face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
   face = FACE_FROM_ID (f, face_id);
   if (face->font)
diff --git a/src/gmalloc.c b/src/gmalloc.c
index dc584955661..c325ca79910 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -1645,14 +1645,6 @@ memalign (size_t alignment, size_t size)
   return result;
 }
 
-#ifndef ENOMEM
-#define ENOMEM 12
-#endif
-
-#ifndef EINVAL
-#define EINVAL 22
-#endif
-
 int
 posix_memalign (void **memptr, size_t alignment, size_t size)
 {
diff --git a/src/gnutls.c b/src/gnutls.c
index e3d84a0b61b..03f753fa8cc 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -359,12 +359,7 @@ emacs_gnutls_write (struct Lisp_Process *proc, const char *buf, ptrdiff_t nbyte)
 
   if (proc->gnutls_initstage != GNUTLS_STAGE_READY)
     {
-#ifdef EWOULDBLOCK
-      errno = EWOULDBLOCK;
-#endif
-#ifdef EAGAIN
       errno = EAGAIN;
-#endif
       return 0;
     }
 
@@ -384,14 +379,7 @@ emacs_gnutls_write (struct Lisp_Process *proc, const char *buf, ptrdiff_t nbyte)
                  appropriately so that send_process retries the
                  correct way instead of erroring out. */
               if (rtnval == GNUTLS_E_AGAIN)
-                {
-#ifdef EWOULDBLOCK
-                  errno = EWOULDBLOCK;
-#endif
-#ifdef EAGAIN
-                  errno = EAGAIN;
-#endif
-                }
+                errno = EAGAIN;
               break;
             }
         }
diff --git a/src/keyboard.c b/src/keyboard.c
index 5980ae89522..30b4db5e077 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -6976,10 +6976,7 @@ tty_read_avail_input (struct terminal *terminal,
             an EAGAIN error.  Does anybody know of a situation
             where a retry is actually needed?  */
 #if 0
-         nread < 0 && (errno == EAGAIN
-#ifdef EFAULT
-                       || errno == EFAULT
-#endif
+         nread < 0 && (errno == EAGAIN || errno == EFAULT
 #ifdef EBADSLT
                        || errno == EBADSLT
 #endif
diff --git a/src/lread.c b/src/lread.c
index 6d0ff9f780e..6647382a254 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -440,7 +440,6 @@ readbyte_from_file (int c, Lisp_Object readcharfun)
   block_input ();
   c = getc (instream);
 
-#ifdef EINTR
   /* Interrupted reads have been observed while reading over the network.  */
   while (c == EOF && ferror (instream) && errno == EINTR)
     {
@@ -450,7 +449,6 @@ readbyte_from_file (int c, Lisp_Object readcharfun)
       clearerr (instream);
       c = getc (instream);
     }
-#endif
 
   unblock_input ();
 
diff --git a/src/process.c b/src/process.c
index 0036ce595f5..b23f06fd025 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4432,14 +4432,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                   total_nread += nread;
                   got_some_input = 1;
                 }
-#ifdef EIO
-              else if (nread == -1 && EIO == errno)
+              else if (nread == -1 && (errno == EIO || errno == EAGAIN))
                 break;
-#endif
-#ifdef EAGAIN
-              else if (nread == -1 && EAGAIN == errno)
-                break;
-#endif
 #ifdef EWOULDBLOCK
               else if (nread == -1 && EWOULDBLOCK == errno)
                 break;
@@ -5517,13 +5511,10 @@ send_process (Lisp_Object proc, const char *buf, ptrdiff_t len,
 
           if (rv < 0)
             {
-              if (0
+              if (errno == EAGAIN
 #ifdef EWOULDBLOCK
                   || errno == EWOULDBLOCK
 #endif
-#ifdef EAGAIN
-                  || errno == EAGAIN
-#endif
                   )
                 /* Buffer is full.  Wait, accepting input;
                    that may allow the program
diff --git a/src/unexcoff.c b/src/unexcoff.c
index 966dd58cb6e..6e29951a962 100644
--- a/src/unexcoff.c
+++ b/src/unexcoff.c
@@ -332,11 +332,7 @@ write_segment (int new, const char *ptr, const char *end)
          a gap between the old text segment and the old data segment.
          This gap has probably been remapped into part of the text segment.
          So write zeros for it.  */
-      if (ret == -1
-#ifdef EFAULT
-          && errno == EFAULT
-#endif
-          )
+      if (ret == -1 && errno == EFAULT)
         {
           /* Write only a page of zeros at once,
              so that we don't overshoot the start
diff --git a/src/xdisp.c b/src/xdisp.c
index f212c39607f..af83eba8544 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -10948,16 +10948,18 @@ echo_area_display (int update_frame_p)
 static int
 buffer_shared_and_changed (void)
 {
+  /* The variable buffer_shared is set in redisplay_window and
+     indicates that we redisplay a buffer in different windows. */
   return (buffer_shared > 1 && UNCHANGED_MODIFIED < MODIFF);
 }
 
-/* Nonzero if W doesn't reflect the actual state of
-   current buffer due to its text or overlays change.  */
+/* Nonzero if W doesn't reflect the actual state of current buffer due
+   to its text or overlays change.  FIXME: this may be called when
+   XBUFFER (w->buffer) != current_buffer, which looks suspicious.  */
 
 static int
 window_outdated (struct window *w)
 {
-  eassert (XBUFFER (w->buffer) == current_buffer);
   return (w->last_modified < MODIFF 
           || w->last_overlay_modified < OVERLAY_MODIFF);
 }
@@ -10977,6 +10979,16 @@ window_buffer_changed (struct window *w)
               != !NILP (w->region_showing)));
 }
 
+/* Nonzero if W has %c in its mode line and mode line should be updated.  */
+
+static int
+mode_line_update_needed (struct window *w)
+{
+  return (!NILP (w->column_number_displayed)
+          && !(PT == w->last_point && !window_outdated (w))
+          && (XFASTINT (w->column_number_displayed) != current_column ()));
+}
+
 /***********************************************************************
                      Mode Lines and Frame Titles
  ***********************************************************************/
@@ -13021,6 +13033,15 @@ select_frame_for_redisplay (Lisp_Object frame)
   } while (!EQ (frame, old) && (frame = old, 1));
 }
 
+/* Make sure that previously selected OLD_FRAME is selected unless it has been
+   deleted (by an X connection failure during redisplay, for example).  */
+
+static void
+ensure_selected_frame (Lisp_Object old_frame)
+{
+  if (!EQ (old_frame, selected_frame) && FRAME_LIVE_P (XFRAME (old_frame)))
+    select_frame_for_redisplay (old_frame);
+}
 
 #define STOP_POLLING                                    \
 do { if (! polling_stopped_here) stop_polling ();       \
@@ -13106,13 +13127,11 @@ redisplay_internal (void)
   /* Remember the currently selected window.  */
   sw = w;
 
-  if (!EQ (old_frame, selected_frame)
-      && FRAME_LIVE_P (XFRAME (old_frame)))
-    /* When running redisplay, we play a bit fast-and-loose and allow e.g.
-       selected_frame and selected_window to be temporarily out-of-sync so
-       when we come back here via `goto retry', we need to resync because we
-       may need to run Elisp code (via prepare_menu_bars).  */
-    select_frame_for_redisplay (old_frame);
+  /* When running redisplay, we play a bit fast-and-loose and allow e.g.
+     selected_frame and selected_window to be temporarily out-of-sync so
+     when we come back here via `goto retry', we need to resync because we
+     may need to run Elisp code (via prepare_menu_bars).  */
+  ensure_selected_frame (old_frame);
 
   pending = 0;
   reconsider_clip_changes (w, current_buffer);
@@ -13198,21 +13217,13 @@ redisplay_internal (void)
   count1 = SPECPDL_INDEX ();
   specbind (Qinhibit_point_motion_hooks, Qt);
 
-  /* If %c is in the mode line, update it if needed.  */
-  if (!NILP (w->column_number_displayed)
-      /* This alternative quickly identifies a common case
-         where no change is needed.  */
-      && !(PT == w->last_point && !window_outdated (w))
-      && (XFASTINT (w->column_number_displayed) != current_column ()))
+  if (mode_line_update_needed (w))
     w->update_mode_line = 1;
 
   unbind_to (count1, Qnil);
 
   FRAME_SCROLL_BOTTOM_VPOS (XFRAME (w->frame)) = -1;
 
-  /* The variable buffer_shared is set in redisplay_window and
-     indicates that we redisplay a buffer in different windows.  See
-     there.  */
   consider_all_windows_p = (update_mode_lines
                             || buffer_shared_and_changed ()
                             || cursor_type_changed);
@@ -13594,14 +13605,11 @@ redisplay_internal (void)
             }
         }
 
-      if (!EQ (old_frame, selected_frame)
-          && FRAME_LIVE_P (XFRAME (old_frame)))
-        /* We played a bit fast-and-loose above and allowed selected_frame
-           and selected_window to be temporarily out-of-sync but let's make
-           sure this stays contained.  */
-        select_frame_for_redisplay (old_frame);
-      eassert (EQ (XFRAME (selected_frame)->selected_window,
-                   selected_window));
+      /* We played a bit fast-and-loose above and allowed selected_frame
+         and selected_window to be temporarily out-of-sync but let's make
+         sure this stays contained.  */
+      ensure_selected_frame (old_frame);
+      eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
 
       if (!pending)
         {
@@ -13820,17 +13828,13 @@ redisplay_preserve_echo_area (int from_where)
 
 
 /* Function registered with record_unwind_protect in redisplay_internal.
-   Clear redisplaying_p.  Also, select the previously
-   selected frame, unless it has been deleted (by an X connection
-   failure during redisplay, for example).  */
+   Clear redisplaying_p.  Also select the previously selected frame.  */
 
 static Lisp_Object
 unwind_redisplay (Lisp_Object old_frame)
 {
   redisplaying_p = 0;
-  if (! EQ (old_frame, selected_frame)
-      && FRAME_LIVE_P (XFRAME (old_frame)))
-    select_frame_for_redisplay (old_frame);
+  ensure_selected_frame (old_frame);
   return Qnil;
 }
 
@@ -15626,12 +15630,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   if (BYTEPOS (opoint) < CHARPOS (opoint))
     emacs_abort ();
 
-  /* If %c is in mode line, update it if needed.  */
-  if (!NILP (w->column_number_displayed)
-      /* This alternative quickly identifies a common case
-         where no change is needed.  */
-      && !(PT == w->last_point && !window_outdated (w))
-      && (XFASTINT (w->column_number_displayed) != current_column ()))
+  if (mode_line_update_needed (w))
     update_mode_line = 1;
 
   /* Count number of windows showing the selected buffer.  An indirect
@@ -23665,7 +23664,9 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
 
       /* If mouse highlighting is on, we may need to draw adjacent
          glyphs using mouse-face highlighting.  */
-      if (area == TEXT_AREA && row->mouse_face_p)
+      if (area == TEXT_AREA && row->mouse_face_p
+          && hlinfo->mouse_face_beg_row >= 0
+          && hlinfo->mouse_face_end_row >= 0)
         {
           struct glyph_row *mouse_beg_row, *mouse_end_row;