upstream

46 files changed, 1066 insertions, 280 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 5e848134cb2..8401578abf4 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,193 @@
+2012-07-30  Stefan Merten  <smerten@oekonux.de>
+
+        * rst.el: Silence `checkdoc-ispell'.
+        (rst-cvs-header, rst-svn-rev, rst-svn-timestamp)
+        (rst-official-version, rst-official-cvs-rev)
+        (rst-package-emacs-version-alist): Update to upstream V1.3.1.
+        (rst-mode-map): New key binding.
+
+2012-07-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Update .PHONY listings in makefiles.
+        * Makefile.in (.PHONY): Add all, doit, custom-deps, finder-data,
+        autoloads, update-subdirs, updates, bzr-update, update-authors,
+        compile-onefile, compile-calc, backup-compiled-files,
+        compile-after-backup, compile-one-process, mh-autoloads,
+        bootstrap-clean, distclean, maintainer-clean.
+
+2012-07-29  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calc.el (calc-simplify-mode): Make 'alg the default value.
+        (calc-set-mode-line): Don't display "AlgSimp ".
+
+        * calc/calc-mode.el (calc-alg-simplify-mode): Remove function.
+        (calc-lim-simplify-mode): New function.
+        (calc-set-simplify-mode): Default to 'alg.
+        (calc-default-simplify-mode): Make algebraic simplifications
+        the default.
+
+        * calc/calc-ext.el (calc-init-extensions): Remove binding for
+        `calc-alg-simplify-mode'.  Add binding for `calc-lim-simplify-mode'.
+
+        * calc/calc-help (calc-m-prefix-help): Change messages to
+        indicate new simplification modes.
+
+        * calc/README: Mention new default simplification mode.
+
+        * calc/calc.el (math-normalize-error): New variable.
+        (math-normalize): Set `math-normalize-error' to t
+        when there's an error.
+
+        * calc/calc-alg.el (math-simplify): Don't simplify when
+        `math-normalize' returns an error.
+
+2012-07-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * international/mule-cmds.el (set-locale-environment): Revert last
+        change, since display-graphic-p returns nil when this function is
+        called during startup.  Instead...
+
+        * term/w32console.el (terminal-init-w32console): ...setup the
+        keyboard and terminal encoding for TTY sessions here.  (Bug#12082)
+
+2012-07-29  Juri Linkov  <juri@jurta.org>
+
+        * simple.el (goto-line): Don't display default line number in the
+        prompt because it should be displayed by `read-number' (bug#9952).
+        Add the current line number to the defaults of `goto-line' to
+        allow its easier modification by users with `M-n' (bug#9201).
+
+        * subr.el (read-number): Support multiple default values like in
+        other minibuffer reading functions.  Replace `read' with
+        `string-to-number' for consistency with `number-to-string'.
+
+2012-07-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        deactive->inactive, inactivate->deactivate spelling fixes (Bug#10150)
+        * emulation/viper-init.el (viper-deactivate-input-method-action):
+        Rename from viper-inactivate-input-method-action.
+        (viper-deactivate-input-method):
+        Rename from viper-inactivate-input-method.
+        * follow.el (follow-inactive-menu): Rename from follow-deactive-menu.
+        * international/mule-cmds.el (deactivate-input-method):
+        Rename from inactivate-input-method.
+        Also run input-method-deactivate-hook.
+        (deactivate-current-input-method-function):
+        Rename from inactivate-current-input-method-function.
+        (input-method-deactivate-hook): New hook.
+        (input-method-inactivate-hook): Mark obsolete.
+        (inactivate-input-method): Mark obsolete.
+
+        * international/quail.el (quail-activate):
+        Also run quail-deactivate-hook.
+        (quail-deactivate): Rename from quail-inactivate.
+        * international/robin.el (robin-activate):
+        Also run robin-deactivate-hook.
+        (robin-deactivate): Rename from robin-inactivate.
+
+2012-07-29  Chong Yidong  <cyd@gnu.org>
+
+        * simple.el (indicate-copied-region): New function.
+        (kill-ring-save): Split off from here.
+
+        * rect.el (copy-rectangle-as-kill): Call indicate-copied-region.
+        (kill-rectangle): Set deactivate-mark to t on read-only error.
+
+        * register.el (copy-to-register, copy-rectangle-to-register):
+        Deactivate the mark, and use indicate-copied-region (Bug#10056).
+        (append-to-register, prepend-to-register): Call
+
+2012-07-29  Juri Linkov  <juri@jurta.org>
+
+        * simple.el (async-shell-command-buffer): New defcustom.
+        (shell-command): Use it.  (Bug#4719)
+
+2012-07-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * international/mule-cmds.el (set-locale-environment): In a
+        console session on MS-Windows, set up keyboard and terminal
+        encoding from the OEM codepage, not the ANSI codepage.
+        (Bug#12055)
+
+2012-07-28  Chong Yidong  <cyd@gnu.org>
+
+        * progmodes/gdb-mi.el (gdb-place-breakpoints): Fix the call to
+        gdb-get-location.
+
+2012-07-25  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/cc-menus.el (cc-imenu-objc-function): Avoid leaving nil in
+        the alist (bug#12029).
+
+2012-07-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in (custom-deps, finder-data, updates, compile)
+        (compile-always, compile-first)
+        ($(lisp)/calendar/cal-loaddefs.el)
+        ($(lisp)/calendar/diary-loaddefs.el)
+        ($(lisp)/calendar/hol-loaddefs.el, $(lisp)/mh-e/mh-loaddefs.el)
+        ($(lisp)/net/tramp-loaddefs.el, bootstrap)
+        ($(lisp)/progmodes/cc-mode.elc): Depend on $(lisp)subdirs.el,
+        instead of on update-subdirs.
+        (bootstrap-clean): Delete $(lisp)/subdirs.el.
+
+2012-07-28  Chong Yidong  <cyd@gnu.org>
+
+        * vc/vc.el (vc-root-diff, vc-print-root-log): Prompt for a
+        directory if vc-deduce-backend returns nil (Bug#7350).
+
+        * simple.el (delete-trailing-lines): New option.
+        (delete-trailing-whitespace): Obey it (Bug#11879).
+
+2012-07-28  David Engster  <deng@randomsample.de>
+
+        * xml.el (xml-node-name, xml-parse-file, xml-parse-region):
+        Explanation of new 'symbol-qnames feature in doc-strings.
+        (xml-maybe-do-ns): Return expanded names as plain symbols if
+        'symbol-qnames was provided in XML-NS argument (Bug#11916).
+        (xml-parse-tag-1): Deal with new definition of PARSE-NS argument.
+
+2012-07-27  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        Consistent completion in inferior python with emacs -nw.
+        * progmodes/python.el (inferior-python-mode): replace "<tab>"
+        binding in inferior-python-mode-map with "\t".
+        (python-shell-completion-complete-at-point)
+        (python-completion-complete-at-point): Remove interactive spec.
+
+2012-07-27  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calccomp.el (math-compose-expr): Undo previous change.
+
+2012-07-27  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el (python-mode-map): Added keybinding for
+        run-python.
+        (python-shell-make-comint): Fix pop-to-buffer call.
+        (run-python): Autoload.  New arg SHOW.
+        (python-shell-get-or-create-process): Do not pop python process
+        buffer.
+
+2012-07-27  Michael Albinus  <michael.albinus@gmx.de>
+
+        * notifications.el (notifications-on-action-signal)
+        (notifications-on-closed-signal): Use also the bus address for the map.
+        (notifications-notify, notifications-close-notification)
+        (notifications-get-capabilities):  Add optional argument BUS.
+
+2012-07-27  Tassilo Horn  <tsdh@gnu.org>
+
+        * textmodes/reftex-vars.el (reftex-label-alist-builtin): Add
+        support for the lstlisting and minted environments, and for the
+        ctable macro.
+        * textmodes/reftex.el (reftex-compile-variables): Also recognize
+        labels written in keyvals syntax.
+
+2012-07-27  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calccomp.el (math-compose-expr): Use parentheses when
+        there is a product in the denominator of a fraction.
+
 2012-07-26  Eli Zaretskii  <eliz@gnu.org>
 
         * makefile.w32-in ($(lisp)/calendar/cal-loaddefs.el)
@@ -10309,7 +10499,7 @@
         (tramp-completion-file-name-regexp-unified)
         (tramp-completion-file-name-regexp-separate)
         (tramp-completion-file-name-regexp-url): Don't use leading volume
-        letter on win32 systems.  (Bug#5303, Bug#9311)
+        letter on w32 systems.  (Bug#5303, Bug#9311)
         (tramp-drop-volume-letter): Simplify definition.
         Suggested by Stefan Monnier <monnier@iro.umontreal.ca>.
 
diff --git a/lisp/ChangeLog.8 b/lisp/ChangeLog.8
index ccc9b473de3..0380fb117db 100644
--- a/lisp/ChangeLog.8
+++ b/lisp/ChangeLog.8
@@ -6906,7 +6906,7 @@
         standard `print' and `nprint' programs, as well as `lpr' and
         similar programs.  Only write directly to the printer port if no
         print program is specified.  Work around a bug in Windows 9x
-        affecting Win32 version of Emacs by invoking command.com to write
+        affecting the w32 version of Emacs by invoking command.com to write
         to the printer port instead of writing directly.
         (direct-print-region-function): Use direct-print-region-helper to
         do most of the work.
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index 0cb142a7267..643b698c6e8 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -139,6 +139,8 @@ all: compile-main $(lisp)/cus-load.el $(lisp)/finder-inf.el
 
 doit:
 
+.PHONY: all doit custom-deps finder-data autoloads update-subdirs
+
 # custom-deps and finder-data both used to scan _all_ the *.el files.
 # This could lead to problems in parallel builds if automatically
 # generated *.el files (eg loaddefs etc) were being changed at the same time.
@@ -184,6 +186,8 @@ update-subdirs: doit
            $(top_srcdir)/build-aux/update-subdirs $$file; \
         done;
 
+.PHONY: updates bzr-update update-authors
+
 # Some modes of make-dist use this.
 updates: update-subdirs autoloads finder-data custom-deps
 
@@ -215,6 +219,7 @@ TAGS TAGS-LISP: $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptags
 # src/Makefile.in to rebuild a particular Lisp file, no questions asked.
 # Use byte-compile-refresh-preloaded to try and work around some of
 # the most common problems of not bootstrapping from a clean state.
+.PHONY: compile-onefile
 compile-onefile:
         @echo Compiling $(THEFILE)
         @# Use byte-compile-refresh-preloaded to try and work around some of
@@ -302,6 +307,8 @@ compile-always: doit
         cd $(lisp); rm -f *.elc */*.elc */*/*.elc */*/*/*.elc
         $(MAKE) $(MFLAGS) compile EMACS=$(EMACS)
 
+.PHONY: compile-calc backup-compiled-files compile-after-backup
+
 compile-calc:
         for el in $(lisp)/calc/*.el; do \
           echo Compiling $$el; \
@@ -334,6 +341,7 @@ compile-after-backup: backup-compiled-files compile-always
 # files that use byte-compile-dynamic are updated.
 # There is no reason to use this rule unless you only have a single
 # core and CPU time is an issue.
+.PHONY: compile-one-process
 compile-one-process: doit $(LOADDEFS) compile-first $(lisp)/progmodes/cc-mode.elc
         $(emacs) $(BYTE_COMPILE_FLAGS) \
             --eval "(batch-byte-recompile-directory 0)" $(lisp)
@@ -356,6 +364,7 @@ MH_E_SRC = $(MH_E_DIR)/mh-acros.el $(MH_E_DIR)/mh-alias.el    \
         $(MH_E_DIR)/mh-tool-bar.el $(MH_E_DIR)/mh-utils.el    \
         $(MH_E_DIR)/mh-xface.el
 
+.PHONY: mh-autoloads
 mh-autoloads: $(MH_E_DIR)/mh-loaddefs.el
 $(MH_E_DIR)/mh-loaddefs.el: $(MH_E_SRC)
         $(emacs) -l autoload \
@@ -418,6 +427,8 @@ $(CAL_DIR)/hol-loaddefs.el: $(CAL_SRC)
            --eval "(setq make-backup-files nil)" \
            -f batch-update-autoloads $(CAL_DIR)
 
+.PHONY: bootstrap-clean distclean maintainer-clean
+
 bootstrap-clean:
         cd $(lisp); rm -f *.elc */*.elc */*/*.elc */*/*/*.elc $(AUTOGENEL)
 
diff --git a/lisp/calc/README b/lisp/calc/README
index e4b681d5625..b09ac6f79eb 100644
--- a/lisp/calc/README
+++ b/lisp/calc/README
@@ -70,6 +70,12 @@ opinions.
 Summary of changes to "Calc"
 ------- -- ------- --  ----
 
+Emacs 24.2
+
+Algebraic simplification mode is now the default.
+To restrict to the limited simplifications given by the former
+default simplification mode, use `m L'.
+
 Emacs 24.1
 
 * Support for musical notes added.
diff --git a/lisp/calc/calc-alg.el b/lisp/calc/calc-alg.el
index 50b31400a6a..3182e85a8c6 100644
--- a/lisp/calc/calc-alg.el
+++ b/lisp/calc/calc-alg.el
@@ -356,6 +356,8 @@
 ;; math-simplify-step, which is called by math-simplify.
 (defvar math-top-only)
 
+;; math-normalize-error is declared in calc.el.
+(defvar math-normalize-error)
 (defun math-simplify (top-expr)
   (let ((math-simplifying t)
         (math-top-only (consp calc-simplify-mode))
@@ -383,10 +385,12 @@
       (calc-with-default-simplification
        (while (let ((r simp-rules))
                 (setq res (math-normalize top-expr))
-                (while r
-                  (setq res (math-rewrite res (car r))
-                        r (cdr r)))
-                (not (equal top-expr (setq res (math-simplify-step res)))))
+                (if (not math-normalize-error)
+                    (progn
+                      (while r
+                        (setq res (math-rewrite res (car r))
+                              r (cdr r)))
+                      (not (equal top-expr (setq res (math-simplify-step res)))))))
          (setq top-expr res)))))
   top-expr)
 
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 818b19757be..954251f842b 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -454,12 +454,12 @@
   (define-key calc-mode-map "mv" 'calc-matrix-mode)
   (define-key calc-mode-map "mw" 'calc-working)
   (define-key calc-mode-map "mx" 'calc-always-load-extensions)
-  (define-key calc-mode-map "mA" 'calc-alg-simplify-mode)
   (define-key calc-mode-map "mB" 'calc-bin-simplify-mode)
   (define-key calc-mode-map "mC" 'calc-auto-recompute)
   (define-key calc-mode-map "mD" 'calc-default-simplify-mode)
   (define-key calc-mode-map "mE" 'calc-ext-simplify-mode)
   (define-key calc-mode-map "mF" 'calc-settings-file-name)
+  (define-key calc-mode-map "mL" 'calc-limited-simplify-mode)
   (define-key calc-mode-map "mM" 'calc-more-recursion-depth)
   (define-key calc-mode-map "mN" 'calc-num-simplify-mode)
   (define-key calc-mode-map "mO" 'calc-no-simplify-mode)
@@ -1093,7 +1093,7 @@ calc-pi calc-radians-mode calc-sec calc-sech
 calc-sin calc-sincos calc-sinh calc-sqrt
 calc-tan calc-tanh calc-to-degrees calc-to-radians)
 
- ("calc-mode" calc-alg-simplify-mode calc-algebraic-mode
+ ("calc-mode" calc-limited-simplify-mode calc-algebraic-mode
 calc-always-load-extensions calc-auto-recompute calc-auto-why
 calc-bin-simplify-mode calc-break-vectors calc-center-justify
 calc-default-simplify-mode calc-display-raw calc-eng-notation
diff --git a/lisp/calc/calc-help.el b/lisp/calc/calc-help.el
index 8ef917fb5f4..f48fae388d5 100644
--- a/lisp/calc/calc-help.el
+++ b/lisp/calc/calc-help.el
@@ -642,7 +642,7 @@ C-w  Describe how there is no warranty for Calc."
    '("Deg, Rad, HMS; Frac; Polar; Inf; Alg, Total; Symb; Vec/mat"
      "Working; Xtensions; Mode-save; preserve Embedded modes"
      "SHIFT + Shifted-prefixes, mode-Filename; Record; reCompute"
-     "SHIFT + simplify: Off, Num, Default, Bin, Alg, Ext, Units")
+     "SHIFT + simplify: Off, Num, Limited, Default, Bin, Ext, Units")
    "mode" ?m))
 
 
diff --git a/lisp/calc/calc-mode.el b/lisp/calc/calc-mode.el
index 3f583192bcf..8403d7f7de9 100644
--- a/lisp/calc/calc-mode.el
+++ b/lisp/calc/calc-mode.el
@@ -504,7 +504,7 @@
                            mode)))
   (message "%s" (if (eq calc-simplify-mode mode)
                msg
-             "Default simplifications enabled")))
+             "Default algebraic simplifications enabled")))
 
 (defun calc-no-simplify-mode (arg)
   (interactive "P")
@@ -519,15 +519,18 @@
                            "Default simplifications apply only if arguments are numeric")))
 
 (defun calc-default-simplify-mode (arg)
-  (interactive "p")
-  (cond ((= arg 1)
+  (interactive "P")
+  (cond ((or (not arg) (= arg 3))
+         (calc-wrapper
+          (calc-set-simplify-mode
+           'alg nil "Default algebraic simplifications enabled")))
+         ((= arg 1)
          (calc-wrapper
           (calc-set-simplify-mode
-           nil nil "Usual default simplifications are enabled")))
+           nil nil "Limited simplifications occur by default")))
         ((= arg 0) (calc-num-simplify-mode 1))
         ((< arg 0) (calc-no-simplify-mode 1))
         ((= arg 2) (calc-bin-simplify-mode 1))
-        ((= arg 3) (calc-alg-simplify-mode 1))
         ((= arg 4) (calc-ext-simplify-mode 1))
         ((= arg 5) (calc-units-simplify-mode 1))
         (t (error "Prefix argument out of range"))))
@@ -539,11 +542,11 @@
                            (format "Binary simplification occurs by default (word size=%d)"
                                    calc-word-size))))
 
-(defun calc-alg-simplify-mode (arg)
+(defun calc-limited-simplify-mode (arg)
   (interactive "P")
   (calc-wrapper
-   (calc-set-simplify-mode 'alg arg
-                           "Algebraic simplification occurs by default")))
+   (calc-set-simplify-mode nil arg
+                           "Limited simplifications occur by default")))
 
 (defun calc-ext-simplify-mode (arg)
   (interactive "P")
diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index 7fb9148535a..dd1efd014fb 100644
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -698,11 +698,11 @@ If `C' is present, display outer brackets for matrices (centered).")
 (defcalcmodevar calc-previous-modulo nil
   "Most recently used value of M in a modulo form.")
 
-(defcalcmodevar calc-simplify-mode nil
+(defcalcmodevar calc-simplify-mode 'alg
   "Type of simplification applied to results.
 If `none', results are not simplified when pushed on the stack.
 If `num', functions are simplified only when args are constant.
-If nil, only fast simplifications are applied.
+If nil, only limited simplifications are applied.
 If `binary', `math-clip' is applied if appropriate.
 If `alg', `math-simplify' is applied.
 If `ext', `math-simplify-extended' is applied.
@@ -1757,10 +1757,10 @@ See calc-keypad for details."
                            ((eq calc-simplify-mode 'num) "NumSimp ")
                            ((eq calc-simplify-mode 'binary)
                             (format "BinSimp%d " calc-word-size))
-                           ((eq calc-simplify-mode 'alg) "AlgSimp ")
+                           ((eq calc-simplify-mode 'alg) "")
                            ((eq calc-simplify-mode 'ext) "ExtSimp ")
                            ((eq calc-simplify-mode 'units) "UnitSimp ")
-                           (t ""))
+                           (t "LimSimp "))
 
                      ;; Display modes
                      (cond ((= calc-number-radix 10) "")
@@ -2583,7 +2583,11 @@ largest Emacs integer.")
 ;;; Reduce an object to canonical (normalized) form.  [O o; Z Z] [Public]
 
 (defvar math-normalize-a)
+(defvar math-normalize-error nil
+  "Non-nil if the last call the `math-normalize' returned an error.")
+
 (defun math-normalize (math-normalize-a)
+  (setq math-normalize-error nil)
   (cond
    ((not (consp math-normalize-a))
     (if (integerp math-normalize-a)
@@ -2672,31 +2676,38 @@ largest Emacs integer.")
                                         (fboundp (car math-normalize-a))))
                                (apply (car math-normalize-a) args)))))
                 (wrong-number-of-arguments
+                 (setq math-normalize-error t)
                  (calc-record-why "*Wrong number of arguments"
                                   (cons (car math-normalize-a) args))
                  nil)
                 (wrong-type-argument
+                 (setq math-normalize-error t)
                  (or calc-next-why
                      (calc-record-why "Wrong type of argument"
                                       (cons (car math-normalize-a) args)))
                  nil)
                 (args-out-of-range
+                 (setq math-normalize-error t)
                  (calc-record-why "*Argument out of range"
                                   (cons (car math-normalize-a) args))
                  nil)
                 (inexact-result
+                 (setq math-normalize-error t)
                  (calc-record-why "No exact representation for result"
                                   (cons (car math-normalize-a) args))
                  nil)
                 (math-overflow
+                 (setq math-normalize-error t)
                  (calc-record-why "*Floating-point overflow occurred"
                                   (cons (car math-normalize-a) args))
                  nil)
                 (math-underflow
+                 (setq math-normalize-error t)
                  (calc-record-why "*Floating-point underflow occurred"
                                   (cons (car math-normalize-a) args))
                  nil)
                 (void-variable
+                 (setq math-normalize-error t)
                  (if (eq (nth 1 err) 'var-EvalRules)
                      (progn
                        (setq var-EvalRules nil)
diff --git a/lisp/cedet/ChangeLog b/lisp/cedet/ChangeLog
index d98ef42438c..b946e756ff8 100644
--- a/lisp/cedet/ChangeLog
+++ b/lisp/cedet/ChangeLog
@@ -1,3 +1,10 @@
+2012-07-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        inaccessable -> inaccessible spelling fix (Bug#10052)
+        * semantic/wisent/comp.el (wisent-inaccessible-symbols):
+        Rename from wisent-inaccessable-symbols, fixing a misspelling.
+        Caller changed.
+
 2012-07-09  Andreas Schwab  <schwab@linux-m68k.org>
 
         * ede/project-am.el: Fix typo.
diff --git a/lisp/cedet/semantic/wisent/comp.el b/lisp/cedet/semantic/wisent/comp.el
index b0daabd1063..30dbafaa6cc 100644
--- a/lisp/cedet/semantic/wisent/comp.el
+++ b/lisp/cedet/semantic/wisent/comp.el
@@ -550,7 +550,7 @@ S must be a vector of integers."
               N  Ns)))
     (setq N Np)))
 
-(defun wisent-inaccessable-symbols ()
+(defun wisent-inaccessible-symbols ()
   "Find out which productions are reachable and which symbols are used."
   ;; Starting with an empty set of productions and a set of symbols
   ;; which only has the start symbol in it, iterate over all
@@ -709,7 +709,7 @@ S must be a vector of integers."
         nuseless-productions  0)
 
   (wisent-useless-nonterminals)
-  (wisent-inaccessable-symbols)
+  (wisent-inaccessible-symbols)
 
   (when (> (+ nuseless-nonterminals nuseless-productions) 0)
     (wisent-total-useless)
diff --git a/lisp/dos-w32.el b/lisp/dos-w32.el
index f68af7a73be..4839d6b9239 100644
--- a/lisp/dos-w32.el
+++ b/lisp/dos-w32.el
@@ -361,7 +361,7 @@ filesystem mounted on drive Z:, FILESYSTEM could be \"Z:\"."
           (apply 'call-process lpr-prog nil errbuf nil rest))
          ;; Run command.com to access printer port on Windows 9x, unless
          ;; we are supposed to append to an existing (non-empty) file,
-         ;; to work around a bug in Windows 9x that prevents Win32
+         ;; to work around a bug in Windows 9x that prevents Windows
          ;; programs from accessing LPT ports reliably.
          ((and (eq system-type 'windows-nt)
                (getenv "winbootdir")
diff --git a/lisp/emulation/viper-init.el b/lisp/emulation/viper-init.el
index 76a8c410676..9f0826bf515 100644
--- a/lisp/emulation/viper-init.el
+++ b/lisp/emulation/viper-init.el
@@ -316,7 +316,7 @@ Use `M-x viper-set-expert-level' to change this.")
     ))
 
 ;; viper hook to run on input-method deactivation
-(defun viper-inactivate-input-method-action ()
+(defun viper-deactivate-input-method-action ()
   (if (null viper-mule-hook-flag)
       ()
     (setq viper-special-input-method nil)
@@ -328,9 +328,9 @@ Use `M-x viper-set-expert-level' to change this.")
                              (or current-input-method default-input-method))
                    "")))))
 
-(defun viper-inactivate-input-method ()
-  (cond ((and (featurep 'emacs) (fboundp 'inactivate-input-method))
-         (inactivate-input-method))
+(defun viper-deactivate-input-method ()
+  (cond ((and (featurep 'emacs) (fboundp 'deactivate-input-method))
+         (deactivate-input-method))
         ((and (featurep 'xemacs) (boundp 'current-input-method))
          ;; XEmacs had broken quail-mode for some time, so we are working around
          ;; it here
@@ -339,7 +339,9 @@ Use `M-x viper-set-expert-level' to change this.")
              (quail-delete-overlays))
          (setq describe-current-input-method-function nil)
          (setq current-input-method nil)
-         (run-hooks 'input-method-inactivate-hook)
+         (run-hooks
+          'input-method-inactivate-hook ; for backward compatibility
+          'input-method-deactivate-hook)
          (force-mode-line-update))
         ))
 (defun viper-activate-input-method ()
@@ -356,7 +358,7 @@ Use `M-x viper-set-expert-level' to change this.")
            ;; activate input method
            (viper-activate-input-method))
           (t ; deactivate input method
-           (viper-inactivate-input-method)))
+           (viper-deactivate-input-method)))
     ))
 
 
diff --git a/lisp/emulation/viper.el b/lisp/emulation/viper.el
index 4219688a4ba..81fbfb0394c 100644
--- a/lisp/emulation/viper.el
+++ b/lisp/emulation/viper.el
@@ -971,9 +971,9 @@ It also can't undo some Viper settings."
   (if (featurep 'emacs)
       (eval-after-load "mule-cmds"
         '(progn
-           (defadvice inactivate-input-method (after viper-mule-advice activate)
+           (defadvice deactivate-input-method (after viper-mule-advice activate)
              "Set viper-special-input-method to disable intl. input methods."
-             (viper-inactivate-input-method-action))
+             (viper-deactivate-input-method-action))
            (defadvice activate-input-method (after viper-mule-advice activate)
              "Set viper-special-input-method to enable intl. input methods."
              (viper-activate-input-method-action))
@@ -985,14 +985,14 @@ It also can't undo some Viper settings."
       '(progn
          (add-hook 'input-method-activate-hook
                    'viper-activate-input-method-action t)
-         (add-hook 'input-method-inactivate-hook
-                   'viper-inactivate-input-method-action t)))
+         (add-hook 'input-method-deactivate-hook
+                   'viper-deactivate-input-method-action t)))
     )
   (eval-after-load "mule-cmds"
     '(defadvice toggle-input-method (around viper-mule-advice activate)
        "Adjust input-method toggling in vi-state."
        (if (and viper-special-input-method (eq viper-current-state 'vi-state))
-           (viper-inactivate-input-method)
+           (viper-deactivate-input-method)
          ad-do-it)))
 
   ) ; viper-set-hooks
diff --git a/lisp/follow.el b/lisp/follow.el
index 0dea1917f85..a74862cb5d0 100644
--- a/lisp/follow.el
+++ b/lisp/follow.el
@@ -334,8 +334,8 @@ property `follow-mode-use-cache' to non-nil.")
 (defvar follow-active-menu nil
   "The menu visible when Follow mode is active.")
 
-(defvar follow-deactive-menu nil
-  "The menu visible when Follow mode is deactivated.")
+(defvar follow-inactive-menu nil
+  "The menu visible when Follow mode is inactive.")
 
 (defvar follow-inside-post-command-hook nil
   "Non-nil when inside Follow modes `post-command-hook'.
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 83cb55d3594..b123b77273e 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,26 @@
+2012-07-29  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * auth-source.el (auth-sources, auth-source-backend-parse)
+        (auth-source-macos-keychain-search)
+        (auth-source-macos-keychain-search-items)
+        (auth-source-macos-keychain-result-append)
+        (auth-source-macos-keychain-create): Support Mac OS X Keychains in
+        auth-source.el through the /usr/bin/security utility.
+        (auth-sources): Fix syntax error.
+        (auth-source-macos-keychain-result-append): Fix variable name.
+        (auth-sources, auth-source-macos-keychain-result-append): More fixes.
+
+2012-07-27  Julien Danjou  <julien@danjou.info>
+
+        * message.el (fboundp): Add a defalias on `mail-dont-reply-to' for
+        Emacs < 24.1
+
+2012-07-27  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * message.el (message-kill-address): Don't kill last newline.
+        (message-skip-to-next-address): Don't move to the next header.
+        (message-fill-field-address): Work properly.
+
 2012-07-25  Julien Danjou  <julien@danjou.info>
 
         * gnus-art.el (gnus-kill-sticky-article-buffers): Reintroduce.
diff --git a/lisp/gnus/auth-source.el b/lisp/gnus/auth-source.el
index 47359500dc4..79358b401b8 100644
--- a/lisp/gnus/auth-source.el
+++ b/lisp/gnus/auth-source.el
@@ -254,6 +254,13 @@ can get pretty complex."
                   (const :tag "Default Secrets API Collection" 'default)
                   (const :tag "Login Secrets API Collection" "secrets:Login")
                   (const :tag "Temp Secrets API Collection" "secrets:session")
+
+                  (const :tag "Default internet Mac OS Keychain"
+                         'macos-keychain-internet)
+
+                  (const :tag "Default generic Mac OS Keychain"
+                         'macos-keychain-generic)
+
                   (list :tag "Source definition"
                         (const :format "" :value :source)
                         (choice :tag "Authentication backend choice"
@@ -266,7 +273,21 @@ can get pretty complex."
                                          (const :tag "Default" 'default)
                                          (const :tag "Login" "Login")
                                          (const
-                                          :tag "Temporary" "session"))))
+                                          :tag "Temporary" "session")))
+                                (list
+                                 :tag "Mac OS internet Keychain"
+                                 (const :format ""
+                                        :value :macos-keychain-internet)
+                                 (choice :tag "Collection to use"
+                                         (string :tag "internet Keychain path")
+                                         (const :tag "default" 'default)))
+                                (list
+                                 :tag "Mac OS generic Keychain"
+                                 (const :format ""
+                                        :value :macos-keychain-generic)
+                                 (choice :tag "Collection to use"
+                                         (string :tag "generic Keychain path")
+                                         (const :tag "default" 'default))))
                         (repeat :tag "Extra Parameters" :inline t
                                 (choice :tag "Extra parameter"
                                         (list
@@ -377,6 +398,10 @@ with \"[a/b/c] \" if CHOICES is '\(?a ?b ?c\)."
 ;; (auth-source-backend-parse "myfile.gpg")
 ;; (auth-source-backend-parse 'default)
 ;; (auth-source-backend-parse "secrets:Login")
+;; (auth-source-backend-parse 'macos-keychain-internet)
+;; (auth-source-backend-parse 'macos-keychain-generic)
+;; (auth-source-backend-parse "macos-keychain-internet:/path/here.keychain")
+;; (auth-source-backend-parse "macos-keychain-generic:/path/here.keychain")
 
 (defun auth-source-backend-parse (entry)
   "Creates an auth-source-backend from an ENTRY in `auth-sources'."
@@ -391,6 +416,28 @@ with \"[a/b/c] \" if CHOICES is '\(?a ?b ?c\)."
     ;; matching any user, host, and protocol
     ((and (stringp entry) (string-match "^secrets:\\(.+\\)" entry))
      (auth-source-backend-parse `(:source (:secrets ,(match-string 1 entry)))))
+
+    ;; take 'macos-keychain-internet and recurse to get it as a Mac OS
+    ;; Keychain collection matching any user, host, and protocol
+    ((eq entry 'macos-keychain-internet)
+     (auth-source-backend-parse '(:source (:macos-keychain-internet default))))
+    ;; take 'macos-keychain-generic and recurse to get it as a Mac OS
+    ;; Keychain collection matching any user, host, and protocol
+    ((eq entry 'macos-keychain-generic)
+     (auth-source-backend-parse '(:source (:macos-keychain-generic default))))
+    ;; take macos-keychain-internet:XYZ and recurse to get it as MacOS
+    ;; Keychain "XYZ" matching any user, host, and protocol
+    ((and (stringp entry) (string-match "^macos-keychain-internet:\\(.+\\)"
+                                        entry))
+     (auth-source-backend-parse `(:source (:macos-keychain-internet
+                                           ,(match-string 1 entry)))))
+    ;; take macos-keychain-generic:XYZ and recurse to get it as MacOS
+    ;; Keychain "XYZ" matching any user, host, and protocol
+    ((and (stringp entry) (string-match "^macos-keychain-generic:\\(.+\\)"
+                                        entry))
+     (auth-source-backend-parse `(:source (:macos-keychain-generic
+                                           ,(match-string 1 entry)))))
+
     ;; take just a file name and recurse to get it as a netrc file
     ;; matching any user, host, and protocol
     ((stringp entry)
@@ -413,6 +460,33 @@ with \"[a/b/c] \" if CHOICES is '\(?a ?b ?c\)."
         :search-function 'auth-source-netrc-search
         :create-function 'auth-source-netrc-create)))
 
+    ;; the MacOS Keychain
+    ((and
+      (not (null (plist-get entry :source))) ; the source must not be nil
+      (listp (plist-get entry :source))      ; and it must be a list
+      (or
+       (plist-get (plist-get entry :source) :macos-keychain-generic)
+       (plist-get (plist-get entry :source) :macos-keychain-internet)))
+
+     (let* ((source-spec (plist-get entry :source))
+            (keychain-generic (plist-get source-spec :macos-keychain-generic))
+            (keychain-type (if keychain-generic
+                               'macos-keychain-generic
+                             'macos-keychain-internet))
+            (source (plist-get source-spec (if keychain-generic
+                                               :macos-keychain-generic
+                                             :macos-keychain-internet))))
+
+       (when (symbolp source)
+         (setq source (symbol-name source)))
+
+       (auth-source-backend
+        (format "Mac OS Keychain (%s)" source)
+        :source source
+        :type keychain-type
+        :search-function 'auth-source-macos-keychain-search
+        :create-function 'auth-source-macos-keychain-create)))
+
     ;; the Secrets API.  We require the package, in order to have a
     ;; defined value for `secrets-enabled'.
     ((and
@@ -694,6 +768,7 @@ must call it to obtain the actual value."
         (let* ((bmatches (apply
                           (slot-value backend 'search-function)
                           :backend backend
+                          :type (slot-value backend :type)
                           ;; note we're overriding whatever the spec
                           ;; has for :require, :create, and :delete
                           :require require
@@ -1515,6 +1590,193 @@ authentication tokens:
   ;; (apply 'secrets-create-item (auth-get-source entry) name passwd spec)
   (debug spec))
 
+;;; Backend specific parsing: Mac OS Keychain (using /usr/bin/security) backend
+
+;; (let ((auth-sources '(macos-keychain-internet))) (auth-source-search :max 1 :create t))
+;; (let ((auth-sources '(macos-keychain-internet))) (auth-source-search :max 1 :delete t))
+;; (let ((auth-sources '(macos-keychain-internet))) (auth-source-search :max 1))
+;; (let ((auth-sources '(macos-keychain-internet))) (auth-source-search))
+
+;; (let ((auth-sources '(macos-keychain-generic))) (auth-source-search :max 1 :create t))
+;; (let ((auth-sources '(macos-keychain-generic))) (auth-source-search :max 1 :delete t))
+;; (let ((auth-sources '(macos-keychain-generic))) (auth-source-search :max 1))
+;; (let ((auth-sources '(macos-keychain-generic))) (auth-source-search))
+
+;; (let ((auth-sources '("macos-keychain-internet:/Users/tzz/Library/Keychains/login.keychain"))) (auth-source-search :max 1))
+;; (let ((auth-sources '("macos-keychain-generic:Login"))) (auth-source-search :max 1 :host "git.gnus.org"))
+
+(defun* auth-source-macos-keychain-search (&rest
+                                    spec
+                                    &key backend create delete label
+                                    type max host user port
+                                    &allow-other-keys)
+  "Search the MacOS Keychain; spec is like `auth-source'.
+
+All search keys must match exactly.  If you need substring
+matching, do a wider search and narrow it down yourself.
+
+You'll get back all the properties of the token as a plist.
+
+The :type key is either 'macos-keychain-internet or
+'macos-keychain-generic.
+
+For the internet keychain type, the :label key searches the
+item's labels (\"-l LABEL\" passed to \"/usr/bin/security\").
+Similarly, :host maps to \"-s HOST\", :user maps to \"-a USER\",
+and :port maps to \"-P PORT\" or \"-r PROT\"
+(note PROT has to be a 4-character string).
+
+For the generic keychain type, the :label key searches the item's
+labels (\"-l LABEL\" passed to \"/usr/bin/security\").
+Similarly, :host maps to \"-c HOST\" (the \"creator\" keychain
+field), :user maps to \"-a USER\", and :port maps to \"-s PORT\".
+
+Here's an example that looks for the first item in the default
+generic MacOS Keychain:
+
+ \(let ((auth-sources '(macos-keychain-generic)))
+    (auth-source-search :max 1)
+
+Here's another that looks for the first item in the internet
+MacOS Keychain collection whose label is 'gnus':
+
+ \(let ((auth-sources '(macos-keychain-internet)))
+    (auth-source-search :max 1 :label \"gnus\")
+
+And this one looks for the first item in the internet keychain
+entries for git.gnus.org:
+
+ \(let ((auth-sources '(macos-keychain-internet\")))
+    (auth-source-search :max 1 :host \"git.gnus.org\"))
+"
+  ;; TODO
+  (assert (not create) nil
+          "The MacOS Keychain auth-source backend doesn't support creation yet")
+  ;; TODO
+  ;; (macos-keychain-delete-item coll elt)
+  (assert (not delete) nil
+          "The MacOS Keychain auth-source backend doesn't support deletion yet")
+
+  (let* ((coll (oref backend source))
+         (max (or max 5000))     ; sanity check: default to stop at 5K
+         (ignored-keys '(:create :delete :max :backend :label))
+         (search-keys (loop for i below (length spec) by 2
+                            unless (memq (nth i spec) ignored-keys)
+                            collect (nth i spec)))
+         ;; build a search spec without the ignored keys
+         ;; if a search key is nil or t (match anything), we skip it
+         (search-spec (apply 'append (mapcar
+                                      (lambda (k)
+                                        (if (or (null (plist-get spec k))
+                                                (eq t (plist-get spec k)))
+                                            nil
+                                          (list k (plist-get spec k))))
+                                      search-keys)))
+         ;; needed keys (always including host, login, port, and secret)
+         (returned-keys (mm-delete-duplicates (append
+                                               '(:host :login :port :secret)
+                                               search-keys)))
+         (items (apply 'auth-source-macos-keychain-search-items
+                       coll
+                       type
+                       max
+                       search-spec))
+
+         ;; ensure each item has each key in `returned-keys'
+         (items (mapcar (lambda (plist)
+                          (append
+                           (apply 'append
+                                  (mapcar (lambda (req)
+                                            (if (plist-get plist req)
+                                                nil
+                                              (list req nil)))
+                                          returned-keys))
+                           plist))
+                        items)))
+    items))
+
+(defun* auth-source-macos-keychain-search-items (coll type max
+                                                      &rest spec
+                                                      &key label type
+                                                      host user port
+                                                      &allow-other-keys)
+
+  (let* ((keychain-generic (eq type 'macos-keychain-generic))
+         (args `(,(if keychain-generic
+                      "find-generic-password"
+                    "find-internet-password")
+                 "-g"))
+         (ret (list :type type)))
+    (when label
+      (setq args (append args (list "-l" label))))
+    (when host
+      (setq args (append args (list (if keychain-generic "-c" "-s") host))))
+    (when user
+      (setq args (append args (list "-a" user))))
+
+    (when port
+      (if keychain-generic
+          (setq args (append args (list "-s" port)))
+        (setq args (append args (list
+                                 (if (string-match "[0-9]+" port) "-P" "-r")
+                                 port)))))
+
+      (unless (equal coll "default")
+        (setq args (append args (list coll))))
+
+      (with-temp-buffer
+        (apply 'call-process "/usr/bin/security" nil t nil args)
+        (goto-char (point-min))
+        (while (not (eobp))
+          (cond
+           ((looking-at "^password: \"\\(.+\\)\"$")
+            (auth-source-macos-keychain-result-append
+             ret
+             keychain-generic
+             "secret"
+             (lexical-let ((v (match-string 1)))
+               (lambda () v))))
+           ;; TODO: check if this is really the label
+           ;; match 0x00000007 <blob>="AppleID"
+           ((looking-at "^[ ]+0x00000007 <blob>=\"\\(.+\\)\"")
+            (auth-source-macos-keychain-result-append
+             ret
+             keychain-generic
+             "label"
+             (match-string 1)))
+           ;; match "crtr"<uint32>="aapl"
+           ;; match "svce"<blob>="AppleID"
+           ((looking-at "^[ ]+\"\\([a-z]+\\)\"[^=]+=\"\\(.+\\)\"")
+            (auth-source-macos-keychain-result-append
+             ret
+             keychain-generic
+             (match-string 1)
+             (match-string 2))))
+            (forward-line)))
+      ;; return `ret' iff it has the :secret key
+      (and (plist-get ret :secret) (list ret))))
+
+(defun auth-source-macos-keychain-result-append (result generic k v)
+  (push v result)
+  (setq k (cond
+           ((equal k "acct") "user")
+           ;; for generic keychains, creator is host, service is port
+           ((and generic (equal k "crtr")) "host")
+           ((and generic (equal k "svce")) "port")
+           ;; for internet keychains, protocol is port, server is host
+           ((and (not generic) (equal k "ptcl")) "port")
+           ((and (not generic) (equal k "srvr")) "host")
+           (t k)))
+
+  (push (intern (format ":%s" k)) result))
+
+(defun* auth-source-macos-keychain-create (&rest
+                                           spec
+                                           &key backend type max host user port
+                                           &allow-other-keys)
+  ;; TODO
+  (debug spec))
+
 ;;; Backend specific parsing: PLSTORE backend
 
 (defun* auth-source-plstore-search (&rest
diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index ecc797314c4..939d56bbfd8 100644
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -1933,10 +1933,13 @@ You must have the \"hashcash\" binary installed, see `hashcash-path'."
 (autoload 'nndraft-request-associate-buffer "nndraft")
 (autoload 'nndraft-request-expire-articles "nndraft")
 (autoload 'nnvirtual-find-group-art "nnvirtual")
-(autoload 'mail-dont-reply-to "mail-utils")
 (autoload 'rmail-msg-is-pruned "rmail")
 (autoload 'rmail-output "rmailout")
 
+;; Emacs < 24.1 do not have mail-dont-reply-to
+(unless (fboundp 'mail-dont-reply-to)
+  (defalias 'mail-dont-reply-to 'rmail-dont-reply-to))
+
 
 
 ;;;
@@ -2603,7 +2606,7 @@ Point is left at the beginning of the narrowed-to region."
   (interactive)
   (let ((start (point)))
     (message-skip-to-next-address)
-    (kill-region start (point))))
+    (kill-region start (if (bolp) (1- (point)) (point)))))
 
 
 (autoload 'Info-goto-node "info")
@@ -6099,7 +6102,7 @@ Headers already prepared in the buffer are not modified."
     (while (and (not (= (point) end))
                 (or (not (eq char ?,))
                     quoted))
-      (skip-chars-forward "^,\"" (point-max))
+      (skip-chars-forward "^,\"" end)
       (when (eq (setq char (following-char)) ?\")
         (setq quoted (not quoted)))
       (unless (= (point) end)
@@ -6136,17 +6139,22 @@ If the current line has `message-yank-prefix', insert it on the new line."
       (point-max))))
 
 (defun message-fill-field-address ()
-  (while (not (eobp))
-    (message-skip-to-next-address)
-    (let (last)
-      (if (and (> (current-column) 78)
-               last)
-          (progn
-            (save-excursion
-              (goto-char last)
-              (insert "\n\t"))
-            (setq last (1+ (point))))
-        (setq last (1+ (point)))))))
+  (let (end last)
+    (while (not end)
+      (message-skip-to-next-address)
+      (cond ((bolp)
+             (end-of-line 0)
+             (setq end 1))
+            ((eobp)
+             (setq end 0)))
+      (when (and (> (current-column) 78)
+                 last)
+        (save-excursion
+          (goto-char last)
+          (delete-char (- (skip-chars-backward " \t")))
+          (insert "\n\t")))
+      (setq last (point)))
+    (forward-line end)))
 
 (defun message-fill-field-general ()
   (let ((begin (point))
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index 93c0cbf47f1..a6ea2c1796c 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -92,7 +92,7 @@
     (bindings--define-key map [set-keyboard-coding-system]
       '(menu-item "For Keyboard" set-keyboard-coding-system
         :help "How to decode keyboard input"))
-    
+
     (bindings--define-key map [separator-2] menu-bar-separator)
     (bindings--define-key map [set-file-name-coding-system]
       '(menu-item "For File Name" set-file-name-coding-system
@@ -128,7 +128,7 @@
       `(menu-item "Describe Language Environment"
             ,describe-language-environment-map
             :help "Show multilingual settings for a specific language"))
-    
+
     (bindings--define-key map [separator-coding-system] menu-bar-separator)
     (bindings--define-key map [view-hello-file]
       '(menu-item "Show Multilingual Sample Text" view-hello-file
@@ -1331,15 +1331,15 @@ of `history-length', which see.")
 (make-variable-buffer-local 'input-method-history)
 (put 'input-method-history 'permanent-local t)
 
-(defvar inactivate-current-input-method-function nil
-  "Function to call for inactivating the current input method.
+(defvar deactivate-current-input-method-function nil
+  "Function to call for deactivating the current input method.
 Every input method should set this to an appropriate value when activated.
 This function is called with no argument.
 
 This function should never change the value of `current-input-method'.
-It is set to nil by the function `inactivate-input-method'.")
-(make-variable-buffer-local 'inactivate-current-input-method-function)
-(put 'inactivate-current-input-method-function 'permanent-local t)
+It is set to nil by the function `deactivate-input-method'.")
+(make-variable-buffer-local 'deactivate-current-input-method-function)
+(put 'deactivate-current-input-method-function 'permanent-local t)
 
 (defvar describe-current-input-method-function nil
   "Function to call for describing the current input method.
@@ -1426,7 +1426,7 @@ If INPUT-METHOD is nil, deactivate any current input method."
       (setq input-method (symbol-name input-method)))
   (if (and current-input-method
            (not (string= current-input-method input-method)))
-      (inactivate-input-method))
+      (deactivate-input-method))
   (unless (or current-input-method (null input-method))
     (let ((slot (assoc input-method input-method-alist)))
       (if (null slot)
@@ -1447,7 +1447,7 @@ If INPUT-METHOD is nil, deactivate any current input method."
           (run-hooks 'input-method-activate-hook)
         (force-mode-line-update)))))
 
-(defun inactivate-input-method ()
+(defun deactivate-input-method ()
   "Turn off the current input method."
   (when current-input-method
     (if input-method-history
@@ -1460,12 +1460,18 @@ If INPUT-METHOD is nil, deactivate any current input method."
         (progn
           (setq input-method-function nil
                 current-input-method-title nil)
-          (funcall inactivate-current-input-method-function))
+          (funcall deactivate-current-input-method-function))
       (unwind-protect
-          (run-hooks 'input-method-inactivate-hook)
+          (run-hooks
+           'input-method-inactivate-hook ; for backward compatibility
+           'input-method-deactivate-hook)
         (setq current-input-method nil)
         (force-mode-line-update)))))
 
+(define-obsolete-function-alias
+  'inactivate-input-method
+  'deactivate-input-method "24.2")
+
 (defun set-input-method (input-method &optional interactive)
   "Select and activate input method INPUT-METHOD for the current buffer.
 This also sets the default input method to the one you specify.
@@ -1476,7 +1482,7 @@ When called interactively, the optional arg INTERACTIVE is non-nil,
 which marks the variable `default-input-method' as set for Custom buffers.
 
 To deactivate the input method interactively, use \\[toggle-input-method].
-To deactivate it programmatically, use `inactivate-input-method'."
+To deactivate it programmatically, use `deactivate-input-method'."
   (interactive
    (let* ((default (or (car input-method-history) default-input-method)))
      (list (read-input-method-name
@@ -1513,7 +1519,7 @@ which marks the variable `default-input-method' as set for Custom buffers."
   (if toggle-input-method-active
       (error "Recursive use of `toggle-input-method'"))
   (if (and current-input-method (not arg))
-      (inactivate-input-method)
+      (deactivate-input-method)
     (let ((toggle-input-method-active t)
           (default (or (car input-method-history) default-input-method)))
       (if (and arg default (equal current-input-method default)
@@ -1640,13 +1646,18 @@ just activated."
   :type 'hook
   :group 'mule)
 
-(defcustom input-method-inactivate-hook nil
-  "Normal hook run just after an input method is inactivated.
+(define-obsolete-variable-alias
+  'input-method-inactivate-hook
+  'input-method-deactivate-hook "24.2")
+
+(defcustom input-method-deactivate-hook nil
+  "Normal hook run just after an input method is deactivated.
 
 The variable `current-input-method' still keeps the input method name
-just inactivated."
+just deactivated."
   :type 'hook
-  :group 'mule)
+  :group 'mule
+  :version "24.2")
 
 (defcustom input-method-after-insert-chunk-hook nil
   "Normal hook run just after an input method insert some chunk of text."
@@ -2662,15 +2673,6 @@ See also `locale-charset-language-names', `locale-language-names',
           (unless frame (setq locale-coding-system code-page-coding))
           (set-keyboard-coding-system code-page-coding frame)
           (set-terminal-coding-system code-page-coding frame)
-          ;; Set default-file-name-coding-system last, so that Emacs
-          ;; doesn't try to use cpNNNN when it defines keyboard and
-          ;; terminal encoding.  That's because the above two lines
-          ;; will want to load code-pages.el, where cpNNNN are
-          ;; defined; if default-file-name-coding-system were set to
-          ;; cpNNNN while these two lines run, Emacs will want to use
-          ;; it for encoding the file name it wants to load.  And that
-          ;; will fail, since cpNNNN is not yet usable until
-          ;; code-pages.el finishes loading.
           (setq default-file-name-coding-system code-page-coding))))
 
     (when (eq system-type 'darwin)
diff --git a/lisp/international/quail.el b/lisp/international/quail.el
index fecc9427731..65ef807c238 100644
--- a/lisp/international/quail.el
+++ b/lisp/international/quail.el
@@ -540,32 +540,36 @@ non-Quail commands."
   (if (and (overlayp quail-conv-overlay) (overlay-start quail-conv-overlay))
       (delete-overlay quail-conv-overlay)))
 
-(defun quail-inactivate ()
-  "Inactivate Quail input method.
+(defun quail-deactivate ()
+  "Deactivate Quail input method.
 
-This function runs the normal hook `quail-inactivate-hook'."
+This function runs the normal hook `quail-deactivate-hook'."
   (interactive)
   (quail-activate -1))
 
+(define-obsolete-function-alias 'quail-inactivate 'quail-deactivate "24.2")
+
 (defun quail-activate (&optional arg)
   "Activate Quail input method.
 With ARG, activate Quail input method if and only if arg is positive.
 
 This function runs `quail-activate-hook' if it activates the input
-method, `quail-inactivate-hook' if it deactivates it.
+method, `quail-deactivate-hook' if it deactivates it.
 
 While this input method is active, the variable
 `input-method-function' is bound to the function `quail-input-method'."
   (if (and arg
           (< (prefix-numeric-value arg) 0))
-      ;; Let's inactivate Quail input method.
+      ;; Let's deactivate Quail input method.
       (unwind-protect
           (progn
             (quail-delete-overlays)
             (setq describe-current-input-method-function nil)
             (quail-hide-guidance)
             (remove-hook 'post-command-hook 'quail-show-guidance t)
-            (run-hooks 'quail-inactivate-hook))
+            (run-hooks
+             'quail-inactivate-hook ; for backward compatibility
+             'quail-deactivate-hook))
         (kill-local-variable 'input-method-function))
     ;; Let's activate Quail input method.
     (if (null quail-current-package)
@@ -575,7 +579,7 @@ While this input method is active, the variable
               (setq name (car (car quail-package-alist)))
             (error "No Quail package loaded"))
           (quail-select-package name)))
-    (setq inactivate-current-input-method-function 'quail-inactivate)
+    (setq deactivate-current-input-method-function 'quail-deactivate)
     (setq describe-current-input-method-function 'quail-help)
     (quail-delete-overlays)
     (setq quail-guidance-str "")
@@ -589,8 +593,12 @@ While this input method is active, the variable
     (make-local-variable 'input-method-function)
     (setq input-method-function 'quail-input-method)))
 
+(define-obsolete-variable-alias
+  'quail-inactivate-hook
+  'quail-deactivate-hook "24.2")
+
 (defun quail-exit-from-minibuffer ()
-  (inactivate-input-method)
+  (deactivate-input-method)
   (if (<= (minibuffer-depth) 1)
       (remove-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer)))
 
diff --git a/lisp/international/robin.el b/lisp/international/robin.el
index 73a06bb2ccd..fee4c330e6e 100644
--- a/lisp/international/robin.el
+++ b/lisp/international/robin.el
@@ -390,12 +390,14 @@ A nil value means no package is selected.")
     (setq robin-current-package-name name)
     (robin-activate)))
 
-(defun robin-inactivate ()
-  "Inactivate robin input method."
+(defun robin-deactivate ()
+  "Deactivate robin input method."
 
   (interactive)
   (robin-activate -1))
 
+(define-obsolete-function-alias 'robin-inactivate 'robin-deactivate "24.2")
+
 (defun robin-activate (&optional arg)
   "Activate robin input method.
 
@@ -406,18 +408,20 @@ While this input method is active, the variable
   (if (and arg
            (< (prefix-numeric-value arg) 0))
 
-      ;; inactivate robin input method.
+      ;; deactivate robin input method.
       (unwind-protect
           (progn
             (setq robin-mode nil)
             (setq describe-current-input-method-function nil)
-            (run-hooks 'robin-inactivate-hook))
+            (run-hooks
+             'robin-inactivate-hook ; for backward compatibility
+             'robin-deactivate-hook))
         (kill-local-variable 'input-method-function))
 
     ;; activate robin input method.
     (setq robin-mode t
           describe-current-input-method-function 'robin-help
-          inactivate-current-input-method-function 'robin-inactivate)
+          deactivate-current-input-method-function 'robin-deactivate)
     (if (eq (selected-window) (minibuffer-window))
         (add-hook 'minibuffer-exit-hook 'robin-exit-from-minibuffer))
     (run-hooks 'input-method-activate-hook
@@ -425,8 +429,12 @@ While this input method is active, the variable
     (set (make-local-variable 'input-method-function)
          'robin-input-method)))
 
+(define-obsolete-variable-alias
+  'robin-inactivate-hook
+  'robin-deactivate-hook "24.2")
+
 (defun robin-exit-from-minibuffer ()
-  (inactivate-input-method)
+  (deactivate-input-method)
   (if (<= (minibuffer-depth) 1)
       (remove-hook 'minibuffer-exit-hook 'robin-exit-from-minibuffer)))
 
diff --git a/lisp/language/korea-util.el b/lisp/language/korea-util.el
index ee8ebb7b2e7..abd5b29ba6e 100644
--- a/lisp/language/korea-util.el
+++ b/lisp/language/korea-util.el
@@ -41,7 +41,7 @@
   "Turn on or off a Korean text input method for the current buffer."
   (interactive)
   (if current-input-method
-      (inactivate-input-method)
+      (deactivate-input-method)
     (activate-input-method
      (concat "korean-hangul" default-korean-keyboard))))
 
diff --git a/lisp/mail/feedmail.el b/lisp/mail/feedmail.el
index c6d1d228780..520271940f2 100644
--- a/lisp/mail/feedmail.el
+++ b/lisp/mail/feedmail.el
@@ -2334,7 +2334,7 @@ mapped to mostly alphanumerics for safety."
     (if (and is-fqm is-in-this-dir)
         (setq filename buffer-file-name)
       (setq filename (feedmail-create-queue-filename queue-directory)))
-    ;; make binary file on DOS/Win95/WinNT, etc
+    ;; make binary file on DOS/Windows 95/Windows NT, etc
     (let ((buffer-file-type feedmail-force-binary-write))
       (write-file filename))
     ;; convenient for moving from draft to q, for example
diff --git a/lisp/mail/sendmail.el b/lisp/mail/sendmail.el
index 3b262e3fb53..b75841489c9 100644
--- a/lisp/mail/sendmail.el
+++ b/lisp/mail/sendmail.el
@@ -616,7 +616,7 @@ This also saves the value of `send-mail-function' via Customize."
   ;; (kill-local-variable 'enable-multibyte-characters)
   (set-buffer-multibyte (default-value 'enable-multibyte-characters))
   (if current-input-method
-      (inactivate-input-method))
+      (deactivate-input-method))
 
   ;; Local variables for Mail mode.
   (setq mail-send-actions actions)
diff --git a/lisp/makefile.w32-in b/lisp/makefile.w32-in
index 92d939af018..756d2b949fa 100644
--- a/lisp/makefile.w32-in
+++ b/lisp/makefile.w32-in
@@ -1,4 +1,4 @@
-# -*- Makefile -*- for GNU Emacs on the Microsoft W32 API.
+# -*- Makefile -*- for GNU Emacs on the Microsoft Windows API.
 # Copyright (C) 2000-2012 Free Software Foundation, Inc.
 
 # This file is part of GNU Emacs.
@@ -168,12 +168,12 @@ $(lisp)/cus-load.el:
 
 # WARNING: Do NOT split the part inside $(ARGQUOTE)s into multiple lines as
 #          this can break with GNU Make 3.81 and later if sh.exe is used.
-custom-deps: $(lisp)/cus-load.el $(lisp)/loaddefs.el doit
+custom-deps: $(lisp)/cus-load.el $(lisp)/loaddefs.el $(lisp)/subdirs.el doit
         @echo Directories: $(WINS_UPDATES)
         -$(emacs) -l cus-dep --eval $(ARGQUOTE)(setq find-file-hook nil)$(ARGQUOTE) \
                   -f custom-make-dependencies $(lisp) $(WINS_UPDATES)
 
-finder-data: $(lisp)/loaddefs.el doit
+finder-data: $(lisp)/loaddefs.el $(lisp)/subdirs.el doit
         @echo Directories: $(WINS_UPDATES)
         $(emacs) -l finder -f finder-compile-keywords-make-dist $(lisp) $(WINS_UPDATES)
 
@@ -243,7 +243,7 @@ update-subdirs-SH: doit
            $(srcdir)/build-aux/update-subdirs $$file; \
         done;
 
-updates: update-subdirs autoloads mh-autoloads finder-data custom-deps
+updates: $(lisp)/subdirs.el autoloads mh-autoloads finder-data custom-deps
 
 # This is useful after "bzr up".
 bzr-update: recompile autoloads finder-data custom-deps
@@ -311,7 +311,7 @@ TAGS-LISP-CMD: $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptagsf
 # compiled find the right files.
 
 # Need separate version for sh and native cmd.exe
-compile: update-subdirs compile-$(SHELLTYPE) doit
+compile: $(lisp)/subdirs.el compile-$(SHELLTYPE) doit
 
 compile-CMD: autoloads
 #       -for %%f in ($(lisp) $(WINS)) do for %%g in (%%f\*.elc) do @attrib -r %%g
@@ -340,7 +340,7 @@ compile-SH: autoloads
 # unconditionally.  Some files don't actually get compiled because they
 # set the local variable no-byte-compile.
 
-compile-always: update-subdirs compile-always-$(SHELLTYPE) doit
+compile-always: $(lisp)/subdirs.el compile-always-$(SHELLTYPE) doit
 
 compile-always-CMD:
 #       -for %%f in ($(lisp) $(WINS)) do for %%g in (%%f\*.elc) do @attrib -r %%g
@@ -383,7 +383,7 @@ backup-compiled-files:
 compile-after-backup: backup-compiled-files compile-always
 
 compile-first:  $(lisp)/emacs-lisp/bytecomp.elc $(lisp)/emacs-lisp/byte-opt.elc \
-        $(lisp)/emacs-lisp/autoload.elc
+        $(lisp)/emacs-lisp/autoload.elc $(lisp)/subdirs.el
 
 # Recompile all Lisp files which are newer than their .elc files.
 # Note that this doesn't create .elc files.  It only recompiles if an
@@ -393,7 +393,7 @@ compile-first: 	$(lisp)/emacs-lisp/bytecomp.elc $(lisp)/emacs-lisp/byte-opt.elc
 recompile: compile-first autoloads doit $(lisp)/progmodes/cc-mode.elc
         $(emacs) --eval $(ARGQUOTE)(batch-byte-recompile-directory 0)$(ARGQUOTE) $(lisp)
 
-$(lisp)/calendar/cal-loaddefs.el: update-subdirs
+$(lisp)/calendar/cal-loaddefs.el: $(lisp)/subdirs.el
         "$(EMACS)" $(EMACSOPT) -l autoload \
            --eval "(setq generate-autoload-cookie \";;;###cal-autoload\")" \
            --eval "(setq find-file-suppress-same-file-warnings t)" \
@@ -401,7 +401,7 @@ $(lisp)/calendar/cal-loaddefs.el: update-subdirs
            -f w32-batch-update-autoloads "$(lisp)/calendar/cal-loaddefs.el" \
               $(MAKE) ./calendar
 
-$(lisp)/calendar/diary-loaddefs.el: update-subdirs
+$(lisp)/calendar/diary-loaddefs.el: $(lisp)/subdirs.el
         "$(EMACS)" $(EMACSOPT) -l autoload \
            --eval "(setq generate-autoload-cookie \";;;###diary-autoload\")" \
            --eval "(setq find-file-suppress-same-file-warnings t)" \
@@ -409,7 +409,7 @@ $(lisp)/calendar/diary-loaddefs.el: update-subdirs
            -f w32-batch-update-autoloads $(lisp)/calendar/diary-loaddefs.el \
               $(MAKE) ./calendar
 
-$(lisp)/calendar/hol-loaddefs.el: update-subdirs
+$(lisp)/calendar/hol-loaddefs.el: $(lisp)/subdirs.el
         "$(EMACS)" $(EMACSOPT) -l autoload \
            --eval "(setq generate-autoload-cookie \";;;###holiday-autoload\")" \
            --eval "(setq find-file-suppress-same-file-warnings t)" \
@@ -437,7 +437,7 @@ MH_E_SRC = $(lisp)/mh-e/mh-acros.el $(lisp)/mh-e/mh-alias.el	\
 # See the commentary for autoloads above for why we use ./mh-e below
 # instead of $(lisp)/mh-e.
 mh-autoloads: $(lisp)/mh-e/mh-loaddefs.el
-$(lisp)/mh-e/mh-loaddefs.el: $(MH_E_SRC) update-subdirs
+$(lisp)/mh-e/mh-loaddefs.el: $(MH_E_SRC) $(lisp)/subdirs.el
         "$(EMACS)" $(EMACSOPT) \
            -l autoload \
            --eval $(ARGQUOTE)(setq generate-autoload-cookie $(DQUOTE);;;###mh-autoload$(DQUOTE))$(ARGQUOTE) \
@@ -456,7 +456,7 @@ TRAMP_SRC = $(lisp)/net/tramp.el  $(lisp)/net/tramp-cache.el  \
         $(lisp)/net/tramp-smb.el  $(lisp)/net/tramp-uu.el     \
         $(lisp)/net/trampver.el
 
-$(lisp)/net/tramp-loaddefs.el: $(TRAMP_SRC) update-subdirs
+$(lisp)/net/tramp-loaddefs.el: $(TRAMP_SRC) $(lisp)/subdirs.el
         "$(EMACS)" $(EMACSOPT) \
            -l autoload \
            --eval $(ARGQUOTE)(setq generate-autoload-cookie $(DQUOTE);;;###tramp-autoload$(DQUOTE))$(ARGQUOTE) \
@@ -481,6 +481,7 @@ $(lisp)/net/tramp-loaddefs.el: $(TRAMP_SRC) update-subdirs
 # Need separate version for sh and native cmd.exe
 bootstrap-clean:
         - $(DEL) $(lisp)/loaddefs.el
+        - $(DEL) $(lisp)/subdirs.el
         $(MAKE) $(MFLAGS) bootstrap-clean-$(SHELLTYPE)
 
 bootstrap-clean-CMD:
@@ -496,7 +497,7 @@ bootstrap-clean-SH:
 # When done, remove bootstrap-emacs from ../bin, so that
 # it will not be mistaken for an installed binary.
 
-bootstrap: update-subdirs compile finder-data custom-deps
+bootstrap: $(lisp)/subdirs.el compile finder-data custom-deps
         - $(DEL) "$(EMACS)"
 
 #
@@ -600,7 +601,8 @@ $(lisp)/progmodes/cc-langs.elc: $(lisp)/progmodes/cc-vars.elc \
 $(lisp)/progmodes/cc-mode.elc: $(lisp)/progmodes/cc-langs.elc \
    $(lisp)/progmodes/cc-vars.elc $(lisp)/progmodes/cc-engine.elc \
    $(lisp)/progmodes/cc-styles.elc $(lisp)/progmodes/cc-cmds.elc \
-   $(lisp)/progmodes/cc-align.elc $(lisp)/progmodes/cc-menus.elc
+   $(lisp)/progmodes/cc-align.elc $(lisp)/progmodes/cc-menus.elc \
+   $(lisp)/subdirs.el
 
 $(lisp)/progmodes/cc-styles.elc: $(lisp)/progmodes/cc-vars.elc \
    $(lisp)/progmodes/cc-align.elc
diff --git a/lisp/mh-e/ChangeLog.1 b/lisp/mh-e/ChangeLog.1
index 94ac7a2f3b7..15b7380b737 100644
--- a/lisp/mh-e/ChangeLog.1
+++ b/lisp/mh-e/ChangeLog.1
@@ -9493,9 +9493,9 @@
         * mh-utils.el (mh-find-progs): Run PATH search only when mh-progs,
         mh-lib and mh-lib-progs are not all already set.  This allows the
         user to set them using a simple setq prior to loading mh-e.  This
-        is useful for implementation of mh-e on win32.  Note that many
+        is useful for implementation of mh-e on w32.  Note that many
         commands still call mh-find-path which also parses the mh_profile
-        file (that may still fail on win32), so this is still done often.
+        file (that may still fail on w32), so this is still done often.
         But it lets us change the mh_profile file and have mh-e see the
         changed file without exiting emacs and starting over so I left
         that in.
diff --git a/lisp/net/ange-ftp.el b/lisp/net/ange-ftp.el
index dd695c29c78..1501fa41baa 100644
--- a/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@ -2618,7 +2618,7 @@ away in the internal cache."
                                           (format
                                            "list data file %s not readable"
                                            temp))))
-                      ;; remove ^M inserted by the win32 ftp client
+                      ;; remove ^M inserted by the w32 ftp client
                       (while (re-search-forward "\r$" nil t)
                         (replace-match ""))
                       (goto-char 1)
diff --git a/lisp/notifications.el b/lisp/notifications.el
index c762bb104ee..792298c26b7 100644
--- a/lisp/notifications.el
+++ b/lisp/notifications.el
@@ -93,8 +93,9 @@
 
 (defun notifications-on-action-signal (id action)
   "Dispatch signals to callback functions from `notifications-on-action-map'."
-  (let* ((unique-name (dbus-event-service-name last-input-event))
-         (entry (assoc (cons unique-name id) notifications-on-action-map)))
+  (let* ((bus (dbus-event-bus-name last-input-event))
+         (unique-name (dbus-event-service-name last-input-event))
+         (entry (assoc (list bus unique-name id) notifications-on-action-map)))
     (when entry
       (funcall (cadr entry) id action)
       (when (and (not (setq notifications-on-action-map
@@ -107,8 +108,9 @@
   "Dispatch signals to callback functions from `notifications-on-closed-map'."
   ;; notification-daemon prior 0.4.0 does not send a reason.  So we
   ;; make it optional, and assume `undefined' as default.
-  (let* ((unique-name (dbus-event-service-name last-input-event))
-         (entry (assoc (cons unique-name id) notifications-on-close-map))
+  (let* ((bus (dbus-event-bus-name last-input-event))
+         (unique-name (dbus-event-service-name last-input-event))
+         (entry (assoc (list bus unique-name id) notifications-on-close-map))
          (reason (or reason 4)))
     (when entry
       (funcall (cadr entry)
@@ -123,6 +125,7 @@
   "Send notification via D-Bus using the Freedesktop notification protocol.
 Various PARAMS can be set:
 
+ :bus            The D-Bus bus, if different from `:session'.
  :title          The notification title.
  :body           The notification body text.
  :app-name       The name of the application sending the notification.
@@ -196,7 +199,8 @@ This function returns a notification id, an integer, which can be
 used to manipulate the notification item with
 `notifications-close-notification' or the `:replaces-id' argument
 of another `notifications-notify' call."
-  (let ((title (plist-get params :title))
+  (let ((bus (or (plist-get params :bus) :session))
+        (title (plist-get params :title))
         (body (plist-get params :body))
         (app-name (plist-get params :app-name))
         (replaces-id (plist-get params :replaces-id))
@@ -272,9 +276,9 @@ of another `notifications-notify' call."
     (when y
       (add-to-list 'hints `(:dict-entry "y" (:variant :int32 ,y)) t))
 
-    ;; Call Notify method
+    ;; Call Notify method.
     (setq id
-          (dbus-call-method :session
+          (dbus-call-method bus
                             notifications-service
                             notifications-path
                             notifications-interface
@@ -302,14 +306,14 @@ of another `notifications-notify' call."
     ;; restarted.
     (let ((on-action (plist-get params :on-action))
           (on-close (plist-get params :on-close))
-          (unique-name (dbus-get-name-owner :session notifications-service)))
+          (unique-name (dbus-get-name-owner bus notifications-service)))
       (when on-action
         (add-to-list 'notifications-on-action-map
-                     (list (cons unique-name id) on-action))
+                     (list (list bus unique-name id) on-action))
         (unless notifications-on-action-object
           (setq notifications-on-action-object
                 (dbus-register-signal
-                 :session
+                 bus
                  nil
                  notifications-path
                  notifications-interface
@@ -318,11 +322,11 @@ of another `notifications-notify' call."
 
       (when on-close
         (add-to-list 'notifications-on-close-map
-                     (list (cons unique-name id) on-close))
+                     (list (list bus unique-name id) on-close))
         (unless notifications-on-close-object
           (setq notifications-on-close-object
                 (dbus-register-signal
-                 :session
+                 bus
                  nil
                  notifications-path
                  notifications-interface
@@ -332,9 +336,10 @@ of another `notifications-notify' call."
     ;; Return notification id
     id))
 
-(defun notifications-close-notification (id)
-  "Close a notification with identifier ID."
-  (dbus-call-method :session
+(defun notifications-close-notification (id &optional bus)
+  "Close a notification with identifier ID.
+BUS can be a string denoting a D-Bus connection, the default is `:session'."
+  (dbus-call-method (or bus :session)
                     notifications-service
                     notifications-path
                     notifications-interface
@@ -343,8 +348,9 @@ of another `notifications-notify' call."
 
 (defvar dbus-debug) ; used in the macroexpansion of dbus-ignore-errors
 
-(defun notifications-get-capabilities ()
+(defun notifications-get-capabilities (&optional bus)
   "Return the capabilities of the notification server, a list of strings.
+BUS can be a string denoting a D-Bus connection, the default is `:session'.
 The following capabilities can be expected:
 
   :actions         The server will provide the specified actions
@@ -367,7 +373,7 @@ Further vendor-specific caps start with `:x-vendor', like `:x-gnome-foo-cap'."
   (dbus-ignore-errors
    (mapcar
     (lambda (x) (intern (concat ":" x)))
-    (dbus-call-method :session
+    (dbus-call-method (or bus :session)
                       notifications-service
                       notifications-path
                       notifications-interface
diff --git a/lisp/org/ChangeLog b/lisp/org/ChangeLog
index eae83f044a0..cf9c32006ac 100644
--- a/lisp/org/ChangeLog
+++ b/lisp/org/ChangeLog
@@ -1,3 +1,12 @@
+2012-07-29  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Don't use the abbreviation "win" to refer to Windows (Bug#10421).
+        * ob-lilypond.el (ly-w32-ly-path): Rename from ly-win32-ly-path.
+        (ly-w32-pdf-path): Rename from ly-win32-pdf-path.
+        (ly-w32-midi-path): Rename from ly-win32-midi-path.
+        (ly-determine-ly-path, ly-determine-pdf-path, ly-determine-midi-path):
+        Check for "windows-nt", not "win32", in system-type.
+
 2012-06-02  Chong Yidong  <cyd@gnu.org>
 
         * org-clock.el (org-clock-string-limit)
diff --git a/lisp/org/ob-lilypond.el b/lisp/org/ob-lilypond.el
index a1e4c9f83e4..b3e77f32e55 100644
--- a/lisp/org/ob-lilypond.el
+++ b/lisp/org/ob-lilypond.el
@@ -66,9 +66,9 @@ the midi file is not automatically played. Default value is t")
 (defvar ly-nix-pdf-path "evince")
 (defvar ly-nix-midi-path "timidity")
 
-(defvar ly-win32-ly-path "lilypond")
-(defvar ly-win32-pdf-path "")
-(defvar ly-win32-midi-path "")
+(defvar ly-w32-ly-path "lilypond")
+(defvar ly-w32-pdf-path "")
+(defvar ly-w32-midi-path "")
 
 (defvar ly-gen-png nil
 "Image generation (png) can be turned on by default by setting
@@ -329,8 +329,8 @@ If TEST is non-nil, it contains a simulation of the OS for test purposes"
          (or test system-type)))
     (cond ((string= sys-type  "darwin")
            ly-OSX-ly-path)
-          ((string= sys-type "win32")
-           ly-win32-ly-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-ly-path)
           (t ly-nix-ly-path))))
 
 (defun ly-determine-pdf-path (&optional test)
@@ -341,8 +341,8 @@ If TEST is non-nil, it contains a simulation of the OS for test purposes"
          (or test system-type)))
     (cond ((string= sys-type  "darwin")
            ly-OSX-pdf-path)
-          ((string= sys-type "win32")
-           ly-win32-pdf-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-pdf-path)
           (t ly-nix-pdf-path))))
 
 (defun ly-determine-midi-path (&optional test)
@@ -353,8 +353,8 @@ If TEST is non-nil, it contains a simulation of the OS for test purposes"
          (or test test system-type)))
     (cond ((string= sys-type  "darwin")
            ly-OSX-midi-path)
-          ((string= sys-type "win32")
-           ly-win32-midi-path)
+          ((string= sys-type "windows-nt")
+           ly-w32-midi-path)
           (t ly-nix-midi-path))))
 
 (defun ly-toggle-midi-play ()
diff --git a/lisp/printing.el b/lisp/printing.el
index bf5b8a91f01..0152ed63dbb 100644
--- a/lisp/printing.el
+++ b/lisp/printing.el
@@ -2141,7 +2141,7 @@ Useful links:
   `http://bama.ua.edu/cgi-bin/man-cgi?lp'
   `http://www.mediacollege.com/cgi-bin/man/page.cgi?section=all&topic=lp'
 
-* GNU utilities for Win32 (cp.exe)
+* GNU utilities for w32 (cp.exe)
   `http://unxutils.sourceforge.net/'
 "
   :type '(repeat
diff --git a/lisp/progmodes/cc-menus.el b/lisp/progmodes/cc-menus.el
index a53d65f6307..76e3002abd2 100644
--- a/lisp/progmodes/cc-menus.el
+++ b/lisp/progmodes/cc-menus.el
@@ -399,14 +399,10 @@ Example:
                 str2 "@protocol")))
         (setq str (cc-imenu-objc-remove-white-space str))
         (setq methodlist (cons (cons str2
-                              (match-beginning langnum))
+                                     (match-beginning langnum))
                                methodlist))
-        (setq toplist (cons nil (cons (cons str
-                                          methodlist) toplist))
+        (setq toplist (cons (cons str methodlist) toplist)
               methodlist nil))))
-    ;;
-    (if (eq (car toplist) nil)
-        (setq toplist (cdr toplist)))
 
     ;; In this buffer, there is only one or zero @{interface|implementation|protocol}.
     (if (< classcount 2)
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 23a34b85194..80afdc0bedf 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -2487,20 +2487,23 @@ HANDLER-NAME handler uses customization of CUSTOM-DEFUN. See
         (let ((file (bindat-get-field breakpoint 'fullname))
               (flag (bindat-get-field breakpoint 'enabled))
               (bptno (bindat-get-field breakpoint 'number)))
-          (unless (file-exists-p file)
+          (unless (and file (file-exists-p file))
             (setq file (cdr (assoc bptno gdb-location-alist))))
-          (if (and file
-                   (not (string-equal file "File not found")))
-              (with-current-buffer
-                  (find-file-noselect file 'nowarn)
-                (gdb-init-buffer)
-                ;; Only want one breakpoint icon at each location.
-                (gdb-put-breakpoint-icon (string-equal flag "y") bptno
-                                         (string-to-number line)))
-            (gdb-input (concat "list " file ":1") 'ignore)
-            (gdb-input "-file-list-exec-source-file"
-                       `(lambda () (gdb-get-location
-                                    ,bptno ,line ,flag)))))))))
+          (if (or (null file)
+                  (string-equal file "File not found"))
+              ;; If the full filename is not recorded in the
+              ;; breakpoint structure or in `gdb-location-alist', use
+              ;; -file-list-exec-source-file to extract it.
+              (when (setq file (bindat-get-field breakpoint 'file))
+                (gdb-input (concat "list " file ":1") 'ignore)
+                (gdb-input "-file-list-exec-source-file"
+                           `(lambda () (gdb-get-location
+                                        ,bptno ,line ,flag))))
+            (with-current-buffer (find-file-noselect file 'nowarn)
+              (gdb-init-buffer)
+              ;; Only want one breakpoint icon at each location.
+              (gdb-put-breakpoint-icon (string-equal flag "y") bptno
+                                       (string-to-number line)))))))))
 
 (defvar gdb-source-file-regexp "fullname=\"\\(.*?\\)\"")
 
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 132951aedc8..4617ecc420d 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -250,6 +250,7 @@
     (define-key map "\C-c\C-tt" 'python-skeleton-try)
     (define-key map "\C-c\C-tw" 'python-skeleton-while)
     ;; Shell interaction
+    (define-key map "\C-c\C-p" 'run-python)
     (define-key map "\C-c\C-s" 'python-shell-send-string)
     (define-key map "\C-c\C-r" 'python-shell-send-region)
     (define-key map "\C-\M-x" 'python-shell-send-defun)
@@ -1544,7 +1545,7 @@ variable.
             'python-shell-completion-complete-at-point nil 'local)
   (add-to-list (make-local-variable 'comint-dynamic-complete-functions)
                'python-shell-completion-complete-at-point)
-  (define-key inferior-python-mode-map (kbd "<tab>")
+  (define-key inferior-python-mode-map "\t"
     'python-shell-completion-complete-or-indent)
   (when python-shell-enable-font-lock
     (set (make-local-variable 'font-lock-defaults)
@@ -1571,30 +1572,33 @@ non-nil the buffer is shown."
           (with-current-buffer buffer
             (inferior-python-mode)
             (python-util-clone-local-variables current-buffer))))
-      (when pop
-        (pop-to-buffer proc-buffer-name))
+      (and pop (pop-to-buffer proc-buffer-name t))
       proc-buffer-name)))
 
-(defun run-python (dedicated cmd)
+;;;###autoload
+(defun run-python (cmd &optional dedicated show)
   "Run an inferior Python process.
 Input and output via buffer named after
 `python-shell-buffer-name'.  If there is a process already
 running in that buffer, just switch to it.
-With argument, allows you to define DEDICATED, so a dedicated
-process for the current buffer is open, and define CMD so you can
-edit the command used to call the interpreter (default is value
-of `python-shell-interpreter' and arguments defined in
-`python-shell-interpreter-args').  Runs the hook
-`inferior-python-mode-hook' (after the `comint-mode-hook' is
-run).
-\(Type \\[describe-mode] in the process buffer for a list of commands.)"
+
+With argument, allows you to define CMD so you can edit the
+command used to call the interpreter and define DEDICATED, so a
+dedicated process for the current buffer is open.  When numeric
+prefix arg is other than 0 or 4 do not SHOW.
+
+Runs the hook `inferior-python-mode-hook' (after the
+`comint-mode-hook' is run).  \(Type \\[describe-mode] in the
+process buffer for a list of commands.)"
   (interactive
    (if current-prefix-arg
        (list
+        (read-string "Run Python: " (python-shell-parse-command))
         (y-or-n-p "Make dedicated process? ")
-        (read-string "Run Python: " (python-shell-parse-command)))
-     (list nil (python-shell-parse-command))))
-  (python-shell-make-comint cmd (python-shell-get-process-name dedicated))
+        (= (prefix-numeric-value current-prefix-arg) 4))
+     (list (python-shell-parse-command) nil t)))
+  (python-shell-make-comint
+   cmd (python-shell-get-process-name dedicated) show)
   dedicated)
 
 (defun run-python-internal ()
@@ -1611,7 +1615,6 @@ with user shells.  Runs the hook
 `inferior-python-mode-hook' (after the `comint-mode-hook' is
 run).  \(Type \\[describe-mode] in the process buffer for a list
 of commands.)"
-  (interactive)
   (set-process-query-on-exit-flag
    (get-buffer-process
     (python-shell-make-comint
@@ -1638,7 +1641,7 @@ of commands.)"
          (global-proc-buffer-name (format "*%s*" global-proc-name))
          (dedicated-running (comint-check-proc dedicated-proc-buffer-name))
          (global-running (comint-check-proc global-proc-buffer-name))
-         (current-prefix-arg 4))
+         (current-prefix-arg 16))
     (when (and (not dedicated-running) (not global-running))
       (if (call-interactively 'run-python)
           (setq dedicated-running t)
@@ -1945,7 +1948,6 @@ completions on the current context."
 
 (defun python-shell-completion-complete-at-point ()
   "Perform completion at point in inferior Python process."
-  (interactive)
   (and comint-last-prompt-overlay
        (> (point-marker) (overlay-end comint-last-prompt-overlay))
        (python-shell-completion--do-completion-at-point
@@ -2060,7 +2062,6 @@ Argument OUTPUT is a string with the output from the comint process."
 For this to work the best as possible you should call
 `python-shell-send-buffer' from time to time so context in
 inferior python process is updated properly."
-  (interactive)
   (let ((process (python-shell-get-process)))
     (if (not process)
         (error "Completion needs an inferior Python process running")
diff --git a/lisp/rect.el b/lisp/rect.el
index 1bf7364e20d..c5e9a790ca2 100644
--- a/lisp/rect.el
+++ b/lisp/rect.el
@@ -219,6 +219,7 @@ even beep.)"
   (condition-case nil
       (setq killed-rectangle (delete-extract-rectangle start end fill))
     ((buffer-read-only text-read-only)
+     (setq deactivate-mark t)
      (setq killed-rectangle (extract-rectangle start end))
      (if kill-read-only-ok
          (progn (message "Read only text copied to kill ring") nil)
@@ -230,7 +231,9 @@ even beep.)"
   "Copy the region-rectangle and save it as the last killed one."
   (interactive "r")
   (setq killed-rectangle (extract-rectangle start end))
-  (setq deactivate-mark t))
+  (setq deactivate-mark t)
+  (if (called-interactively-p 'interactive)
+      (indicate-copied-region (length (car killed-rectangle)))))
 
 ;;;###autoload
 (defun yank-rectangle ()
diff --git a/lisp/register.el b/lisp/register.el
index 52c236e49be..2816c9831de 100644
--- a/lisp/register.el
+++ b/lisp/register.el
@@ -336,7 +336,11 @@ Called from program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions indicating what to copy."
   (interactive "cCopy to register: \nr\nP")
   (set-register register (filter-buffer-substring start end))
-  (if delete-flag (delete-region start end)))
+  (setq deactivate-mark t)
+  (cond (delete-flag
+         (delete-region start end))
+        ((called-interactively-p 'interactive)
+         (indicate-copied-region))))
 
 (defun append-to-register (register start end &optional delete-flag)
   "Append region to text in register REGISTER.
@@ -350,7 +354,10 @@ START and END are buffer positions indicating what to append."
      register (cond ((not reg) text)
                     ((stringp reg) (concat reg text))
                     (t (error "Register does not contain text")))))
-  (if delete-flag (delete-region start end)))
+  (cond (delete-flag
+         (delete-region start end))
+        ((called-interactively-p 'interactive)
+         (indicate-copied-region))))
 
 (defun prepend-to-register (register start end &optional delete-flag)
   "Prepend region to text in register REGISTER.
@@ -364,7 +371,10 @@ START and END are buffer positions indicating what to prepend."
      register (cond ((not reg) text)
                     ((stringp reg) (concat text reg))
                     (t (error "Register does not contain text")))))
-  (if delete-flag (delete-region start end)))
+  (cond (delete-flag
+         (delete-region start end))
+        ((called-interactively-p 'interactive)
+         (indicate-copied-region))))
 
 (defun copy-rectangle-to-register (register start end &optional delete-flag)
   "Copy rectangular region into register REGISTER.
@@ -374,10 +384,15 @@ To insert this register in the buffer, use \\[insert-register].
 Called from a program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions giving two corners of rectangle."
   (interactive "cCopy rectangle to register: \nr\nP")
-  (set-register register
-                (if delete-flag
-                    (delete-extract-rectangle start end)
-                  (extract-rectangle start end))))
+  (let ((rectangle (if delete-flag
+                       (delete-extract-rectangle start end)
+                     (extract-rectangle start end))))
+    (set-register register rectangle)
+    (when (and (null delete-flag)
+               (called-interactively-p 'interactive))
+      (setq deactivate-mark t)
+      (indicate-copied-region (length (car rectangle))))))
+
 
 (provide 'register)
 ;;; register.el ends here
diff --git a/lisp/simple.el b/lisp/simple.el
index 3240ede0299..e1d6760e72b 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -564,13 +564,28 @@ On nonblank line, delete any immediately following blank lines."
     (if (looking-at "^[ \t]*\n\\'")
         (delete-region (point) (point-max)))))
 
+(defcustom delete-trailing-lines t
+  "If non-nil, \\[delete-trailing-whitespace] deletes trailing lines.
+Trailing lines are deleted only if `delete-trailing-whitespace'
+is called on the entire buffer (rather than an active region)."
+  :type 'boolean
+  :group 'editing
+  :version "24.2")
+
 (defun delete-trailing-whitespace (&optional start end)
-  "Delete all the trailing whitespace across the current buffer.
-All whitespace after the last non-whitespace character in a line is deleted.
-This respects narrowing, created by \\[narrow-to-region] and friends.
-A formfeed is not considered whitespace by this function.
-If END is nil, also delete all trailing lines at the end of the buffer.
-If the region is active, only delete whitespace within the region."
+  "Delete trailing whitespace between START and END.
+If called interactively, START and END are the start/end of the
+region if the mark is active, or of the buffer's accessible
+portion if the mark is inactive.
+
+This command deletes whitespace characters after the last
+non-whitespace character in each line between START and END.  It
+does not consider formfeed characters to be whitespace.
+
+If this command acts on the entire buffer (i.e. if called
+interactively with the mark inactive, or called from Lisp with
+END nil), it also deletes all trailing lines at the end of the
+buffer if the variable `delete-trailing-lines' is non-nil."
   (interactive (progn
                  (barf-if-buffer-read-only)
                  (if (use-region-p)
@@ -590,6 +605,7 @@ If the region is active, only delete whitespace within the region."
         ;; Delete trailing empty lines.
         (goto-char end-marker)
         (when (and (not end)
+                   delete-trailing-lines
                    ;; Really the end of buffer.
                    (save-restriction (widen) (eobp))
                    (<= (skip-chars-backward "\n") -2))
@@ -932,11 +948,8 @@ rather than line counts."
                  (concat " in " (buffer-name buffer))
                "")))
        ;; Read the argument, offering that number (if any) as default.
-       (list (read-number (format (if default "Goto line%s (%s): "
-                                    "Goto line%s: ")
-                                  buffer-prompt
-                                  default)
-                          default)
+       (list (read-number (format "Goto line%s: " buffer-prompt)
+                          (list default (line-number-at-pos)))
              buffer))))
   ;; Switch to the desired buffer, one way or another.
   (if buffer
@@ -2248,6 +2261,33 @@ to `shell-command-history'."
            (or hist 'shell-command-history)
            args)))
 
+(defcustom async-shell-command-buffer 'confirm-new-buffer
+  "What to do when the output buffer is used by another shell command.
+This option specifies how to resolve the conflict where a new command
+wants to direct its output to the buffer `*Async Shell Command*',
+but this buffer is already taken by another running shell command.
+
+The value `confirm-kill-process' is used to ask for confirmation before
+killing the already running process and running a new process
+in the same buffer, `confirm-new-buffer' for confirmation before running
+the command in a new buffer with a name other than the default buffer name,
+`new-buffer' for doing the same without confirmation,
+`confirm-rename-buffer' for confirmation before renaming the existing
+output buffer and running a new command in the default buffer,
+`rename-buffer' for doing the same without confirmation."
+  :type '(choice (const :tag "Confirm killing of running command"
+                        confirm-kill-process)
+                 (const :tag "Confirm creation of a new buffer"
+                        confirm-new-buffer)
+                 (const :tag "Create a new buffer"
+                        new-buffer)
+                 (const :tag "Confirm renaming of existing buffer"
+                        confirm-rename-buffer)
+                 (const :tag "Rename the existing buffer"
+                        rename-buffer))
+  :group 'shell
+  :version "24.2")
+
 (defun async-shell-command (command &optional output-buffer error-buffer)
   "Execute string COMMAND asynchronously in background.
 
@@ -2402,12 +2442,40 @@ the use of a shell (with its need to quote arguments)."
                     proc)
                 ;; Remove the ampersand.
                 (setq command (substring command 0 (match-beginning 0)))
-                ;; If will kill a process, query first.
+                ;; Ask the user what to do with already running process.
                 (setq proc (get-buffer-process buffer))
-                (if proc
-                    (if (yes-or-no-p "A command is running.  Kill it? ")
+                (when proc
+                  (cond
+                   ((eq async-shell-command-buffer 'confirm-kill-process)
+                    ;; If will kill a process, query first.
+                    (if (yes-or-no-p "A command is running in the default buffer.  Kill it? ")
                         (kill-process proc)
                       (error "Shell command in progress")))
+                   ((eq async-shell-command-buffer 'confirm-new-buffer)
+                    ;; If will create a new buffer, query first.
+                    (if (yes-or-no-p "A command is running in the default buffer.  Use a new buffer? ")
+                        (setq buffer (generate-new-buffer
+                                      (or output-buffer "*Async Shell Command*")))
+                      (error "Shell command in progress")))
+                   ((eq async-shell-command-buffer 'new-buffer)
+                    ;; It will create a new buffer.
+                    (setq buffer (generate-new-buffer
+                                  (or output-buffer "*Async Shell Command*"))))
+                   ((eq async-shell-command-buffer 'confirm-rename-buffer)
+                    ;; If will rename the buffer, query first.
+                    (if (yes-or-no-p "A command is running in the default buffer.  Rename it? ")
+                        (progn
+                          (with-current-buffer buffer
+                            (rename-uniquely))
+                          (setq buffer (get-buffer-create
+                                        (or output-buffer "*Async Shell Command*"))))
+                      (error "Shell command in progress")))
+                   ((eq async-shell-command-buffer 'rename-buffer)
+                    ;; It will rename the buffer.
+                    (with-current-buffer buffer
+                      (rename-uniquely))
+                    (setq buffer (get-buffer-create
+                                  (or output-buffer "*Async Shell Command*"))))))
                 (with-current-buffer buffer
                   (setq buffer-read-only nil)
                   ;; Setting buffer-read-only to nil doesn't suffice
@@ -3337,38 +3405,50 @@ This command is similar to `copy-region-as-kill', except that it gives
 visual feedback indicating the extent of the region being copied."
   (interactive "r")
   (copy-region-as-kill beg end)
-  ;; This use of called-interactively-p is correct
-  ;; because the code it controls just gives the user visual feedback.
+  ;; This use of called-interactively-p is correct because the code it
+  ;; controls just gives the user visual feedback.
   (if (called-interactively-p 'interactive)
-      (let ((other-end (if (= (point) beg) end beg))
-            (opoint (point))
-            ;; Inhibit quitting so we can make a quit here
-            ;; look like a C-g typed as a command.
-            (inhibit-quit t))
-        (if (pos-visible-in-window-p other-end (selected-window))
-            ;; Swap point-and-mark quickly so as to show the region that
-            ;; was selected.  Don't do it if the region is highlighted.
-            (unless (and (region-active-p)
-                         (face-background 'region))
-              ;; Swap point and mark.
-              (set-marker (mark-marker) (point) (current-buffer))
-              (goto-char other-end)
-              (sit-for blink-matching-delay)
-              ;; Swap back.
-              (set-marker (mark-marker) other-end (current-buffer))
-              (goto-char opoint)
-              ;; If user quit, deactivate the mark
-              ;; as C-g would as a command.
-              (and quit-flag mark-active
-                   (deactivate-mark)))
-          (let* ((killed-text (current-kill 0))
-                 (message-len (min (length killed-text) 40)))
-            (if (= (point) beg)
-                ;; Don't say "killed"; that is misleading.
-                (message "Saved text until \"%s\""
-                        (substring killed-text (- message-len)))
-              (message "Saved text from \"%s\""
-                      (substring killed-text 0 message-len))))))))
+      (indicate-copied-region)))
+
+(defun indicate-copied-region (&optional message-len)
+  "Indicate that the region text has been copied interactively.
+If the mark is visible in the selected window, blink the cursor
+between point and mark if there is currently no active region
+highlighting.
+
+If the mark lies outside the selected window, display an
+informative message containing a sample of the copied text.  The
+optional argument MESSAGE-LEN, if non-nil, specifies the length
+of this sample text; it defaults to 40."
+  (let ((mark (mark t))
+        (point (point))
+        ;; Inhibit quitting so we can make a quit here
+        ;; look like a C-g typed as a command.
+        (inhibit-quit t))
+    (if (pos-visible-in-window-p mark (selected-window))
+        ;; Swap point-and-mark quickly so as to show the region that
+        ;; was selected.  Don't do it if the region is highlighted.
+        (unless (and (region-active-p)
+                     (face-background 'region))
+          ;; Swap point and mark.
+          (set-marker (mark-marker) (point) (current-buffer))
+          (goto-char mark)
+          (sit-for blink-matching-delay)
+          ;; Swap back.
+          (set-marker (mark-marker) mark (current-buffer))
+          (goto-char point)
+          ;; If user quit, deactivate the mark
+          ;; as C-g would as a command.
+          (and quit-flag mark-active
+               (deactivate-mark)))
+      (let ((len (min (abs (- mark point))
+                      (or message-len 40))))
+        (if (< point mark)
+            ;; Don't say "killed"; that is misleading.
+            (message "Saved text until \"%s\""
+                     (buffer-substring-no-properties (- mark len) mark))
+          (message "Saved text from \"%s\""
+                   (buffer-substring-no-properties mark (+ mark len))))))))
 
 (defun append-next-kill (&optional interactive)
   "Cause following command, if it kills, to append to previous kill.
diff --git a/lisp/subr.el b/lisp/subr.el
index 76fec5dd5ac..73bc1d99e05 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2188,23 +2188,27 @@ by doing (clear-string STRING)."
   "Read a numeric value in the minibuffer, prompting with PROMPT.
 DEFAULT specifies a default value to return if the user just types RET.
 The value of DEFAULT is inserted into PROMPT."
-  (let ((n nil))
-    (when default
+  (let ((n nil)
+        (default1 (if (consp default) (car default) default)))
+    (when default1
       (setq prompt
             (if (string-match "\\(\\):[ \t]*\\'" prompt)
-                (replace-match (format " (default %s)" default) t t prompt 1)
+                (replace-match (format " (default %s)" default1) t t prompt 1)
               (replace-regexp-in-string "[ \t]*\\'"
-                                        (format " (default %s) " default)
+                                        (format " (default %s) " default1)
                                         prompt t t))))
     (while
         (progn
-          (let ((str (read-from-minibuffer prompt nil nil nil nil
-                                           (and default
-                                                (number-to-string default)))))
+          (let ((str (read-from-minibuffer
+                      prompt nil nil nil nil
+                      (when default
+                        (if (consp default)
+                            (mapcar 'number-to-string (delq nil default))
+                          (number-to-string default))))))
             (condition-case nil
                 (setq n (cond
-                         ((zerop (length str)) default)
-                         ((stringp str) (read str))))
+                         ((zerop (length str)) default1)
+                         ((stringp str) (string-to-number str))))
               (error nil)))
           (unless (numberp n)
             (message "Please enter a number.")
diff --git a/lisp/term/w32console.el b/lisp/term/w32console.el
index d52a4e68932..ceaa936e79b 100644
--- a/lisp/term/w32console.el
+++ b/lisp/term/w32console.el
@@ -52,6 +52,18 @@
   "Terminal initialization function for w32 console."
   ;; Share function key initialization with w32 gui frames
   (x-setup-function-keys (selected-frame))
+  ;; Set terminal and keyboard encodings to the current OEM codepage.
+  (let ((oem-code-page-coding
+         (intern (format "cp%d" (w32-get-console-codepage))))
+        (oem-code-page-output-coding
+         (intern (format "cp%d" (w32-get-console-output-codepage))))
+        oem-cs-p oem-o-cs-p)
+        (setq oem-cs-p (coding-system-p oem-code-page-coding))
+        (setq oem-o-cs-p (coding-system-p oem-code-page-output-coding))
+        (when oem-cs-p
+          (set-keyboard-coding-system oem-code-page-coding)
+          (set-terminal-coding-system
+           (if oem-o-cs-p oem-code-page-output-coding oem-code-page-coding))))
   (let* ((colors w32-tty-standard-colors)
          (color (car colors)))
     (tty-color-clear)
diff --git a/lisp/textmodes/reftex-vars.el b/lisp/textmodes/reftex-vars.el
index 4c875a35b3e..187c98af21f 100644
--- a/lisp/textmodes/reftex-vars.el
+++ b/lisp/textmodes/reftex-vars.el
@@ -122,7 +122,14 @@
       ;;("\\label{*}" nil nil nil nil)
       ))
 
-    )
+    (ctable     "The ctable package"
+     (("\\ctable[]{}{}{}" ?t "tab:" "\\ref{%s}" 1 ("table" "Tabelle"))))
+
+    (listings   "The listings package"
+      (("lstlisting" ?l "lst:" "~\\ref{%s}" nil (regexp "[Ll]isting"))))
+
+    (minted     "The minted package"
+      (("minted" ?l "lst:" "~\\ref{%s}" nil (regexp "[Ll]isting")))))
   "The default label environment descriptions.
 Lower-case symbols correspond to a style file of the same name in the LaTeX
 distribution.  Mixed-case symbols are convenience aliases.")
diff --git a/lisp/textmodes/reftex.el b/lisp/textmodes/reftex.el
index 8c349a2e20a..ae2f8fb8ea2 100644
--- a/lisp/textmodes/reftex.el
+++ b/lisp/textmodes/reftex.el
@@ -1284,7 +1284,15 @@ This enforces rescanning the buffer on next use."
 ;          (wbol "\\(\\`\\|[\n\r]\\)[ \t]*")
            (wbol "\\(^\\)[ \t]*")  ; Need to keep the empty group because
                                   ;;; because match number are hard coded
-           (label-re "\\\\label{\\([^}]*\\)}")
+           (label-re (concat "\\(?:"
+                             ;; Normal \label{...}
+                             "\\\\label{\\([^}]*\\)}"
+                             "\\|"
+                             ;; keyvals [..., label = {foo}, ...]
+                             ;; forms used by ctable, listings,
+                             ;; minted, ...
+                             "\\[[^]]*label[[:space:]]*=[[:space:]]*{?\\(?1:[^],}]+\\)}?[^[]*\\]"
+                             "\\)"))
            (include-re (concat wbol
                                "\\\\\\("
                                (mapconcat 'identity
@@ -1312,6 +1320,8 @@ This enforces rescanning the buffer on next use."
                     "\\)\\([[{][^]}]*[]}]\\)*[[{]\\(%s\\)[]}]"))
            (find-label-re-format
             (concat "\\("
+                    "label[[:space:]]*=[[:space:]]*"
+                    "\\|"
                     (mapconcat 'regexp-quote (append '("\\label")
                                                      macros-with-labels) "\\|")
                     "\\)\\([[{][^]}]*[]}]\\)*[[{]\\(%s\\)[]}]"))
diff --git a/lisp/textmodes/rst.el b/lisp/textmodes/rst.el
index 6e0562f4a4b..77dc7cc29bb 100644
--- a/lisp/textmodes/rst.el
+++ b/lisp/textmodes/rst.el
@@ -103,6 +103,8 @@
 
 ;;; Code:
 
+;; FIXME: Add proper ";;;###autoload" comments.
+
 ;; FIXME: When 24.1 is common place remove use of `lexical-let' and put "-*-
 ;;        lexical-binding: t -*-" in the first line.
 
@@ -123,7 +125,7 @@
 (defun rst-some (seq &optional pred)
   "Return non-nil if any element of SEQ yields non-nil when PRED is applied.
 Apply PRED to each element of list SEQ until the first non-nil
-result is yielded and return this result. PRED defaults to
+result is yielded and return this result.  PRED defaults to
 `identity'."
   (unless pred
     (setq pred 'identity))
@@ -171,7 +173,7 @@ and before TAIL-RE and DELIM-RE in VAR or DEFAULT for no match."
 ;; Use CVSHeader to really get information from CVS and not other version
 ;; control systems.
 (defconst rst-cvs-header
-  "$CVSHeader: sm/rst_el/rst.el,v 1.287 2012-06-16 09:41:47 stefan Exp $")
+  "$CVSHeader: sm/rst_el/rst.el,v 1.301 2012-07-30 19:29:46 stefan Exp $")
 (defconst rst-cvs-rev
   (rst-extract-version "\\$" "CVSHeader: \\S + " "[0-9]+\\(?:\\.[0-9]+\\)+"
                        " .*" rst-cvs-header "0.0")
@@ -185,22 +187,22 @@ and before TAIL-RE and DELIM-RE in VAR or DEFAULT for no match."
 ;; Use LastChanged... to really get information from SVN.
 (defconst rst-svn-rev
   (rst-extract-version "\\$" "LastChangedRevision: " "[0-9]+" " "
-                       "$LastChangedRevision: 7444 $")
+                       "$LastChangedRevision: 7490 $")
   "The SVN revision of this file.
 SVN revision is the upstream (docutils) revision.")
 (defconst rst-svn-timestamp
   (rst-extract-version "\\$" "LastChangedDate: " ".+?+" " "
-                       "$LastChangedDate: 2012-06-16 11:41:40 +0200 (Sat, 16 Jun 2012) $")
+                       "$LastChangedDate: 2012-07-30 21:29:33 +0200 (Mon, 30 Jul 2012) $")
   "The SVN time stamp of this file.")
 
 ;; Maintained by the release process.
 (defconst rst-official-version
   (rst-extract-version "%" "OfficialVersion: " "[0-9]+\\(?:\\.[0-9]+\\)+" " "
-                       "%OfficialVersion: 1.3.0 %")
+                       "%OfficialVersion: 1.3.1 %")
   "Official version of the package.")
 (defconst rst-official-cvs-rev
   (rst-extract-version "[%$]" "Revision: " "[0-9]+\\(?:\\.[0-9]+\\)+" " "
-                       "%Revision: 1.287 %")
+                       "%Revision: 1.301 %")
   "CVS revision of this file in the official version.")
 
 (defconst rst-version
@@ -217,7 +219,9 @@ in parentheses follows the development revision and the time stamp.")
     ("1.1.0" . "24.2")
     ("1.2.0" . "24.2")
     ("1.2.1" . "24.2")
-    ("1.3.0" . "24.2")))
+    ("1.3.0" . "24.2")
+    ("1.3.1" . "24.2")
+    ))
 
 (unless (assoc rst-official-version rst-package-emacs-version-alist)
   (error "Version %s not listed in `rst-package-emacs-version-alist'"
@@ -580,10 +584,13 @@ well but give an additional message."
     ;;
     ;; The adjustment function that adorns or rotates a section title.
     (rst-define-key map [?\C-c ?\C-=] 'rst-adjust [?\C-c ?\C-a t])
-    (rst-define-key map [?\C-=] 'rst-adjust) ; (Does not work on the Mac OSX.)
+    (rst-define-key map [?\C-=] 'rst-adjust) ; Does not work on the Mac OSX and
+                                             ; on consoles.
 
     ;; \C-c \C-a is the keymap for adornments.
     (rst-define-key map [?\C-c ?\C-a ?\C-h] 'describe-prefix-bindings)
+    ;; Another binding which works with all types of input.
+    (rst-define-key map [?\C-c ?\C-a ?\C-a] 'rst-adjust)
     ;; Display the hierarchy of adornments implied by the current document
     ;; contents.
     (rst-define-key map [?\C-c ?\C-a ?\C-d] 'rst-display-adornments-hierarchy)
@@ -3954,7 +3961,9 @@ An association list of the tool-set to a list of the (command to use,
 extension of produced filename, options to the tool (nil or a
 string)) to be used for converting the document."
   ;; FIXME: These are not options but symbols which may be referenced by
-  ;;        `rst-compile-*-toolset` below.
+  ;;        `rst-compile-*-toolset` below. The `:validate' keyword of
+  ;;        `defcustom' may help to define this properly in newer Emacs
+  ;;        versions (> 23.1).
   :type '(alist :options (html latex newlatex pseudoxml xml pdf s5)
                 :key-type symbol
                 :value-type (list :tag "Specification"
diff --git a/lisp/url/ChangeLog b/lisp/url/ChangeLog
index 0fc48907f40..ae224f4102f 100644
--- a/lisp/url/ChangeLog
+++ b/lisp/url/ChangeLog
@@ -1,3 +1,16 @@
+2012-07-28  David Engster  <deng@randomsample.de>
+
+        * url-dav.el (url-dav-supported-p): Added doc-string and remove
+        check for feature `xml' and function `xml-expand-namespace' which
+        never existed in Emacs proper.
+        (url-dav-process-response): Remove all indentation and newlines
+        from XML before parsing.  Change call to `xml-parse-region' to do
+        namespace expansion with simple qualified names (Bug#11916).
+        (url-dav-request): Add autoload.
+        (url-dav-directory-files): Properly deal with empty directories.
+        Unhex URL before generating relative URLs.
+        (url-dav-file-directory-p): Fix check for 'DAV:collection.
+
 2012-07-11  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * url.el, url-queue.el, url-parse.el, url-http.el, url-future.el:
diff --git a/lisp/url/url-dav.el b/lisp/url/url-dav.el
index 77e48b0e47d..4bb03369b9b 100644
--- a/lisp/url/url-dav.el
+++ b/lisp/url/url-dav.el
@@ -53,10 +53,10 @@
 
 ;;;###autoload
 (defun url-dav-supported-p (url)
-  (and (featurep 'xml)
-       (fboundp 'xml-expand-namespace)
-       (url-intersection url-dav-supported-protocols
-                         (plist-get (url-http-options url) 'dav))))
+  "Return WebDAV protocol version supported by URL.
+Returns nil if WebDAV is not supported."
+  (url-intersection url-dav-supported-protocols
+                    (plist-get (url-http-options url) 'dav)))
 
 (defun url-dav-node-text (node)
   "Return the text data from the XML node NODE."
@@ -385,7 +385,12 @@ XML document."
     (when buffer
       (unwind-protect
           (with-current-buffer buffer
+            ;; First remove all indentation and line endings
             (goto-char url-http-end-of-headers)
+            (indent-rigidly (point) (point-max) -1000)
+            (save-excursion
+              (while (re-search-forward "\r?\n" nil t)
+                (replace-match "")))
             (setq overall-status url-http-response-status)
 
             ;; XML documents can be transferred as either text/xml or
@@ -395,7 +400,7 @@ XML document."
                  url-http-content-type
                  (string-match "\\`\\(text\\|application\\)/xml"
                                url-http-content-type))
-                (setq tree (xml-parse-region (point) (point-max)))))
+                (setq tree (xml-parse-region (point) (point-max) nil nil 'symbol-qnames))))
         ;; Clean up after ourselves.
         (kill-buffer buffer)))
 
@@ -411,6 +416,7 @@ XML document."
         ;; nobody but us needs to know the difference.
         (list (cons url properties))))))
 
+;;;###autoload
 (defun url-dav-request (url method tag body
                                  &optional depth headers namespaces)
   "Perform WebDAV operation METHOD on URL.  Return the parsed responses.
@@ -768,8 +774,8 @@ files in the collection as well."
 (defun url-dav-directory-files (url &optional full match nosort files-only)
   "Return a list of names of files in URL.
 There are three optional arguments:
-If FULL is non-nil, return absolute file names.  Otherwise return names
- that are relative to the specified directory.
+If FULL is non-nil, return absolute URLs.  Otherwise return names
+ that are relative to the specified URL.
 If MATCH is non-nil, mention only file names that match the regexp MATCH.
 If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
  NOSORT is useful if you plan to sort the result yourself."
@@ -779,8 +785,9 @@ If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
         (files nil)
         (parsed-url (url-generic-parse-url url)))
 
-    (if (= (length properties) 1)
-        (signal 'file-error (list "Opening directory" "not a directory" url)))
+    (when (and (= (length properties) 1)
+               (not (url-dav-file-directory-p url)))
+      (signal 'file-error (list "Opening directory" "not a directory" url)))
 
     (while properties
       (setq child-props (pop properties)
@@ -794,7 +801,9 @@ If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
         ;; are not supposed to return fully-qualified names.
         (setq child-url (url-expand-file-name child-url parsed-url))
         (if (not full)
-            (setq child-url (substring child-url (length url))))
+            ;; Parts of the URL might be hex'ed.
+            (setq child-url (substring (url-unhex-string child-url)
+                                       (length url))))
 
         ;; We don't want '/' as the last character in filenames...
         (if (string-match "/$" child-url)
@@ -814,7 +823,8 @@ If NOSORT is non-nil, the list is not sorted--its order is unpredictable.
 (defun url-dav-file-directory-p (url)
   "Return t if URL names an existing DAV collection."
   (let ((properties (cdar (url-dav-get-properties url '(DAV:resourcetype)))))
-    (eq (plist-get properties 'DAV:resourcetype) 'DAV:collection)))
+    (when (member 'DAV:collection (plist-get properties 'DAV:resourcetype))
+      t)))
 
 (defun url-dav-make-directory (url &optional parents)
   "Create the directory DIR and any nonexistent parent dirs."
diff --git a/lisp/vc/vc.el b/lisp/vc/vc.el
index 0f3298d2686..2d95b14244f 100644
--- a/lisp/vc/vc.el
+++ b/lisp/vc/vc.el
@@ -1757,10 +1757,15 @@ saving the buffer."
       (call-interactively 'vc-version-diff)
     (when buffer-file-name (vc-buffer-sync not-urgent))
     (let ((backend (vc-deduce-backend))
+          (default-directory default-directory)
           rootdir working-revision)
-      (unless backend
-        (error "Buffer is not version controlled"))
-      (setq rootdir (vc-call-backend backend 'root default-directory))
+      (if backend
+          (setq rootdir (vc-call-backend backend 'root default-directory))
+        (setq rootdir (read-directory-name "Directory for VC root-diff: "))
+        (setq backend (vc-responsible-backend rootdir))
+        (if backend
+            (setq default-directory rootdir)
+          (error "Directory is not version controlled")))
       (setq working-revision (vc-working-revision rootdir))
       ;; VC diff for the root directory produces output that is
       ;; relative to it.  Bind default-directory to the root directory
@@ -2213,10 +2218,15 @@ When called interactively with a prefix argument, prompt for LIMIT."
     (t
      (list (when (> vc-log-show-limit 0) vc-log-show-limit)))))
   (let ((backend (vc-deduce-backend))
+        (default-directory default-directory)
         rootdir working-revision)
-    (unless backend
-      (error "Buffer is not version controlled"))
-    (setq rootdir (vc-call-backend backend 'root default-directory))
+    (if backend
+        (setq rootdir (vc-call-backend backend 'root default-directory))
+      (setq rootdir (read-directory-name "Directory for VC root-log: "))
+      (setq backend (vc-responsible-backend rootdir))
+      (if backend
+          (setq default-directory rootdir)
+        (error "Directory is not version controlled")))
     (setq working-revision (vc-working-revision rootdir))
     (vc-print-log-internal backend (list rootdir) working-revision nil limit)))
 
diff --git a/lisp/xml.el b/lisp/xml.el
index e2788e5e756..179fdd6b5cc 100644
--- a/lisp/xml.el
+++ b/lisp/xml.el
@@ -126,7 +126,10 @@ tag.  For example,
 
 would be represented by
 
-    '(\"\" . \"foo\")."
+    '(\"\" . \"foo\").
+
+If you'd just like a plain symbol instead, use 'symbol-qnames in
+the PARSE-NS argument."
 
   (car node))
 
@@ -313,7 +316,22 @@ only those characters, have whitespace syntax.")
   "Parse the well-formed XML file FILE.
 Return the top node with all its children.
 If PARSE-DTD is non-nil, the DTD is parsed rather than skipped.
-If PARSE-NS is non-nil, then QNAMES are expanded."
+
+If PARSE-NS is non-nil, then QNAMES are expanded.  By default,
+the variable `xml-default-ns' is the mapping from namespaces to
+URIs, and expanded names will be returned as a cons
+
+  (\"namespace:\" . \"foo\").
+
+If PARSE-NS is an alist, it will be used as the mapping from
+namespace to URIs instead.
+
+If it is the symbol 'symbol-qnames, expanded names will be
+returned as a plain symbol 'namespace:foo instead of a cons.
+
+Both features can be combined by providing a cons cell
+
+  (symbol-qnames . ALIST)."
   (with-temp-buffer
     (insert-file-contents file)
     (xml--parse-buffer parse-dtd parse-ns)))
@@ -329,7 +347,21 @@ If END is nil, it defaults to `point-max'.
 If BUFFER is nil, it defaults to the current buffer.
 If PARSE-DTD is non-nil, parse the DTD and return it as the first
 element of the list.
-If PARSE-NS is non-nil, expand QNAMES."
+If PARSE-NS is non-nil, then QNAMES are expanded.  By default,
+the variable `xml-default-ns' is the mapping from namespaces to
+URIs, and expanded names will be returned as a cons
+
+  (\"namespace:\" . \"foo\").
+
+If PARSE-NS is an alist, it will be used as the mapping from
+namespace to URIs instead.
+
+If it is the symbol 'symbol-qnames, expanded names will be
+returned as a plain symbol 'namespace:foo instead of a cons.
+
+Both features can be combined by providing a cons cell
+
+  (symbol-qnames . ALIST)."
   ;; Use fixed syntax table to ensure regexp char classes and syntax
   ;; specs DTRT.
   (unless buffer
@@ -386,26 +418,36 @@ is nil.
 
 During namespace-aware parsing, any name without a namespace is
 put into the namespace identified by DEFAULT.  nil is used to
-specify that the name shouldn't be given a namespace."
+specify that the name shouldn't be given a namespace.
+Expanded names will by default be returned as a cons.  If you
+would like to get plain symbols instead, provide a cons cell
+
+  (symbol-qnames . ALIST)
+
+in the XML-NS argument."
   (if (consp xml-ns)
-      (let* ((nsp (string-match ":" name))
+      (let* ((symbol-qnames (eq (car-safe xml-ns) 'symbol-qnames))
+             (nsp (string-match ":" name))
              (lname (if nsp (substring name (match-end 0)) name))
              (prefix (if nsp (substring name 0 (match-beginning 0)) default))
              (special (and (string-equal lname "xmlns") (not prefix)))
              ;; Setting default to nil will insure that there is not
              ;; matching cons in xml-ns.  In which case we
              (ns (or (cdr (assoc (if special "xmlns" prefix)
-                                 xml-ns))
+                                 (if symbol-qnames (cdr xml-ns) xml-ns)))
                      "")))
-        (cons ns (if special "" lname)))
+        (if (and symbol-qnames
+                 (not (string= prefix "xmlns")))
+            (intern (concat ns lname))
+          (cons ns (if special "" lname))))
     (intern name)))
 
 (defun xml-parse-tag (&optional parse-dtd parse-ns)
   "Parse the tag at point.
 If PARSE-DTD is non-nil, the DTD of the document, if any, is parsed and
 returned as the first element in the list.
-If PARSE-NS is non-nil, expand QNAMES; if the value of PARSE-NS
-is a list, use it as an alist mapping namespaces to URIs.
+If PARSE-NS is non-nil, expand QNAMES; for further details, see
+`xml-parse-region'.
 
 Return one of:
  - a list : the matching node
@@ -425,9 +467,16 @@ Return one of:
 
 (defun xml-parse-tag-1 (&optional parse-dtd parse-ns)
   "Like `xml-parse-tag', but possibly modify the buffer while working."
-  (let ((xml-validating-parser (or parse-dtd xml-validating-parser))
-        (xml-ns (cond ((consp parse-ns) parse-ns)
-                      (parse-ns xml-default-ns))))
+  (let* ((xml-validating-parser (or parse-dtd xml-validating-parser))
+         (xml-ns
+          (cond ((eq parse-ns 'symbol-qnames)
+                 (cons 'symbol-qnames xml-default-ns))
+                ((or (consp (car-safe parse-ns))
+                     (and (eq (car-safe parse-ns) 'symbol-qnames)
+                          (listp (cdr parse-ns))))
+                 parse-ns)
+                (parse-ns
+                 xml-default-ns))))
     (cond
      ;; Processing instructions, like <?xml version="1.0"?>.
      ((looking-at "<\\?")
@@ -475,7 +524,9 @@ Return one of:
                        (equal "http://www.w3.org/2000/xmlns/"
                               (caar attr)))
               (push (cons (cdar attr) (cdr attr))
-                    xml-ns))))
+                    (if (symbolp (car xml-ns))
+                        (cdr xml-ns)
+                      xml-ns)))))
         (setq children (list attrs (xml-maybe-do-ns node-name "" xml-ns)))
         (cond
          ;; is this an empty element ?