merge trunk

35 files changed, 707 insertions, 329 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index f9e7eac9123..a6f5a5fd525 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,159 @@
+2012-03-18  Chong Yidong  <cyd@gnu.org>
+
+        * faces.el (face-spec-reset-face): Don't call display-graphic-p if
+        it is not yet defined (for temacs).
+
+2012-03-18  Leo Liu  <sdl.web@gmail.com>
+
+        * net/rcirc.el (rcirc-cmd-quit): Allow quiting all servers with
+        prefix.
+
+2012-03-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * textmodes/ispell.el (ispell-skip-tib, ispell-keep-choices-win)
+        (ispell-choices-win-default-height, ispell-silently-savep)
+        (ispell-dictionary-alist, ispell-encoding8-command)
+        (ispell-check-version, ispell-aspell-find-dictionary)
+        (ispell-valid-dictionary-list, ispell-words-keyword)
+        (ispell-get-word, ispell-internal-change-dictionary)
+        (ispell-region, ispell-skip-region-list)
+        (ispell-begin-skip-region-regexp, ispell-ignore-fcc)
+        (ispell-process-line, ispell-minor-mode, ispell-minor-check)
+        (ispell-message-text-end, ispell-message)
+        (ispell-buffer-local-parsing): Doc fix.
+
+2012-03-13  Jambunathan K  <kjambunathan@gmail.com>
+
+        * htmlfontify.el: Add support for code block fontification for ODT
+        export (Bug #9914).
+        (hfy-optimisations): Define new option
+        `body-text-only'
+        (hfy-fontify-buffer): Honor above setting.
+        (hfy-begin-span, hfy-end-span): New routines factored out form
+        `hfy-fontify-buffer'.
+        (hfy-begin-span-handler, hfy-end-span-handler): New variables
+        that permit insertion of custom tags.
+        (hfy-fontify-buffer): Use above handlers.
+        (hfy-face-to-css-default): Same as the earlier `hfy-face-to-css'.
+        (hfy-face-to-css): Re-defined to be a variable.
+        (hfy-compile-stylesheet): Modified.  Allow stylesheet to be built
+        over multiple runs. This is made possible by having the caller let
+        bind a special variable `hfy-user-sheet-assoc'.
+        (htmlfontify-string): New defun.
+        (hfy-compile-face-map): Make sure that the last char in the
+        buffer is correctly fontified.
+        (hfy-face-resolve-face): Whitespace only change.
+
+2012-03-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * textmodes/ispell.el (ispell-get-decoded-string): Make the error
+        message more clear.
+
+2012-03-16  Leo Liu  <sdl.web@gmail.com>
+
+        * emacs-lisp/copyright.el (copyright-year-ranges): Fix typo.
+
+2012-03-16  Alan Mackenzie  <acm@muc.de>
+
+        Further optimise the handling of large macros.
+
+        * progmodes/cc-engine.el (c-crosses-statement-barrier-p): Use a
+        limit to a call of `c-literal-limits'.
+        (c-determine-+ve-limit): New function.
+        (c-at-macro-vsemi-p): Move `c-in-literal' to the bottom of an
+        `and'.
+        (c-guess-basic-syntax): In macros, restrict a search limit to
+        2000.
+        In CASE 5B, restrict a search limit to 500.
+        (c-just-after-func-arglist-p): Obviouly wrong `or' -> `and'.
+
+        * progmodes/cc-mode.el (c-neutralize-syntax-in-and-mark-CPP):
+        Restrict macro bounds to +-500 from after-change's BEG END.
+
+2012-03-16  Leo Liu  <sdl.web@gmail.com>
+
+        * font-lock.el (lisp-font-lock-keywords-2): Add letrec.
+
+2012-03-16  Aaron S. Hawley  <Aaron.S.Hawley@gmail.com>
+
+        * tar-mode.el (tar-mode): Fix saving by conditionally undoing
+        `special-mode' setting of `buffer-read-only'.  (Bug#11010)
+
+2012-03-16  Glenn Morris  <rgm@gnu.org>
+
+        * view.el (view-buffer, view-buffer-other-window)
+        (view-buffer-other-frame): Doc fixes re special mode-class.
+
+        * subr.el (eval-after-load): If named feature is provided not from
+        a file, run after-load forms.  (Bug#10946)
+
+        * calendar/calendar.el (calendar-insert-at-column):
+        Handle non-unit-width characters a bit better.  (Bug#10978)
+
+2012-03-15  Chong Yidong  <cyd@gnu.org>
+
+        * emacs-lisp/ring.el (ring-extend): New function.
+        (ring-insert+extend): Extend the ring correctly (Bug#11019).
+
+        * comint.el (comint-read-input-ring)
+        (comint-add-to-input-history): Grow comint-input-ring lazily.
+
+2012-03-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/perl-mode.el (perl-syntax-propertize-special-constructs):
+        Fix up parsing of multiline twoarg non-paired elements (bug#11014).
+
+        * imenu.el: Fix multiple inheritance breakage (bug#9199).
+        (imenu-add-to-menubar): Don't add a redundant index.
+        (imenu-update-menubar): Handle a dynamically composed keymap.
+
+2012-03-13  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * mail/sendmail.el (mail-encode-header):
+        Bind rfc2047-encode-encoded-words to nil.
+
+2012-03-13  Glenn Morris  <rgm@gnu.org>
+
+        * calendar/calendar.el (calendar-string-spread):
+        Handle non-unit-width characters a bit better.  (Bug#10978)
+
+2012-03-13  Leo Liu  <sdl.web@gmail.com>
+
+        * vc/vc-hg.el (vc-hg-working-revision): Rework to work with both
+        directory and file as argument (Bug#10822).
+
+2012-03-13  Kaushik Srenevasan  <ksrenevasan@gmail.com>  (tiny change)
+
+        * progmodes/gdb-mi.el (gdb-invalidate-disassembly):
+        For dynamically generated code, follow $PC.
+        (gdb-disassembly-handler-custom): Handle no function name case.
+
+2012-03-13  Tim Landscheidt  <tim@tim-landscheidt.de>  (tiny change)
+
+        * calendar/icalendar.el (icalendar-export-file, icalendar-import-file):
+        * emulation/ws-mode.el (ws-query-replace):
+        * sort.el (sort-regexp-fields):
+        Fix missing trailing whitespace in interactive prompts.  (Bug#11002)
+
+2012-03-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * dabbrev.el: Fix cycle completion order (bug#10963).
+        (dabbrev--last-obarray, dabbrev--last-completion-buffer): Remove.
+        (dabbrev-completion): Don't use an obarray; provide
+        a cycle-sort-function.
+
+2012-03-12  Leo Liu  <sdl.web@gmail.com>
+
+        * simple.el (kill-new): Use equal-including-properties for
+        comparison.
+        (kill-do-not-save-duplicates): Doc fix.
+
+2012-03-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * dabbrev.el: Fix cycle completion (bug#10963).
+        Use lexical binding and wrap to 80 columns.
+        (dabbrev-completion): Delay computing the list of completions.
+
 2012-03-12  Kenichi Handa  <handa@m17n.org>
 
         * international/quail.el (quail-insert-kbd-layout): Surround each
diff --git a/lisp/calendar/calendar.el b/lisp/calendar/calendar.el
index 0c351c6072f..d9ec27b4f88 100644
--- a/lisp/calendar/calendar.el
+++ b/lisp/calendar/calendar.el
@@ -1424,16 +1424,24 @@ Optional integers MON and YR are used instead of today's date."
   "Move to column INDENT, adding spaces as needed.
 Inserts STRING so that it ends at INDENT.  STRING is either a
 literal string, or a sexp to evaluate to return such.  Truncates
-STRING to length TRUNCATE, ensure a trailing space."
+STRING to length TRUNCATE, and ensures a trailing space."
   (if (not (ignore-errors (stringp (setq string (eval string)))))
       (calendar-move-to-column indent)
-    (if (> (length string) truncate)
-        (setq string (substring string 0 truncate)))
+    (if (> (string-width string) truncate)
+        (setq string (truncate-string-to-width string truncate)))
     (or (string-match " $" string)
-        (if (= (length string) truncate)
-            (aset string (1- truncate) ?\s)
-          (setq string (concat string " "))))
-    (calendar-move-to-column (- indent (length string)))
+        (setq string (concat (if (= (string-width string) truncate)
+                                 (substring string 0 -1)
+                               string)
+                             ;; Avoid inserting text properties unless
+                             ;; we have to (ie, non-unit-width chars).
+                             ;; This is by no means essential.
+                             (if (= (string-width string) (length string))
+                                 " "
+                               ;; Cribbed from buff-menu.el.
+                               (propertize
+                                " " 'display `(space :align-to ,indent))))))
+    (calendar-move-to-column (- indent (string-width string)))
     (insert string)))
 
 (defun calendar-generate-month (month year indent)
@@ -1756,8 +1764,8 @@ the STRINGS are just concatenated and the result truncated."
                           (if (< (length strings) 2)
                               (append (list "") strings (list ""))
                             strings)))
-         (n (- length (length (apply 'concat strings))))
-         (m (1- (length strings)))
+         (n (- length (string-width (apply 'concat strings))))
+         (m (* (1- (length strings)) (char-width char)))
          (s (car strings))
          (strings (cdr strings))
          (i 0))
@@ -1766,7 +1774,7 @@ the STRINGS are just concatenated and the result truncated."
                       (make-string (max 0 (/ (+ n i) m)) char)
                       string)
             i (1+ i)))
-    (substring s 0 length)))
+    (truncate-string-to-width s length)))
 
 (defun calendar-update-mode-line ()
   "Update the calendar mode line with the current date and date style."
diff --git a/lisp/calendar/icalendar.el b/lisp/calendar/icalendar.el
index 83bda94fefe..f1549ec20b1 100644
--- a/lisp/calendar/icalendar.el
+++ b/lisp/calendar/icalendar.el
@@ -915,7 +915,7 @@ would be \"pm\"."
   "Export diary file to iCalendar format.
 All diary entries in the file DIARY-FILENAME are converted to iCalendar
 format.  The result is appended to the file ICAL-FILENAME."
-  (interactive "FExport diary data from file:
+  (interactive "FExport diary data from file: \n\
 Finto iCalendar file: ")
   (save-current-buffer
     (set-buffer (find-file diary-filename))
@@ -1794,7 +1794,7 @@ Argument ICAL-FILENAME output iCalendar file.
 Argument DIARY-FILENAME input `diary-file'.
 Optional argument NON-MARKING determines whether events are created as
 non-marking or not."
-  (interactive "fImport iCalendar data from file:
+  (interactive "fImport iCalendar data from file: \n\
 Finto diary file:
 p")
   ;; clean up the diary file
diff --git a/lisp/cedet/ChangeLog b/lisp/cedet/ChangeLog
index ec7fdcecca0..f185c457ee2 100644
--- a/lisp/cedet/ChangeLog
+++ b/lisp/cedet/ChangeLog
@@ -1,3 +1,10 @@
+2012-03-12  David Engster  <deng@randomsample.de>
+
+        * semantic/db-find.el
+        (semanticdb-find-translate-path-brutish-default): If we don't yet
+        have a proper table for PATH, use `semanticdb-current-database'
+        instead (bug #10343).
+
 2012-03-11  David Engster  <deng@randomsample.de>
 
         * semantic/wisent/javascript.el (js-mode): Define `js-mode' as
diff --git a/lisp/cedet/semantic/db-find.el b/lisp/cedet/semantic/db-find.el
index ca6a8fbf5ca..15ef3b09238 100644
--- a/lisp/cedet/semantic/db-find.el
+++ b/lisp/cedet/semantic/db-find.el
@@ -325,8 +325,10 @@ Default action as described in `semanticdb-find-translate-path'."
          (cond ((null path) semanticdb-current-database)
                ((semanticdb-table-p path) (oref path parent-db))
                (t (let ((tt (semantic-something-to-tag-table path)))
-                    ;; @todo - What does this DO ??!?!
-                    (with-current-buffer (semantic-tag-buffer (car tt))
+                    (if tt
+                        ;; @todo - What does this DO ??!?!
+                        (with-current-buffer (semantic-tag-buffer (car tt))
+                          semanticdb-current-database)
                       semanticdb-current-database))))))
     (apply
      #'nconc
diff --git a/lisp/comint.el b/lisp/comint.el
index 4c2229f2f83..9306bf8dbb2 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -922,15 +922,18 @@ See also `comint-input-ignoredups' and `comint-write-input-ring'."
         (t
          (let* ((file comint-input-ring-file-name)
                 (count 0)
-                (size comint-input-ring-size)
-                (ring (make-ring size)))
+                ;; Some users set HISTSIZE or `comint-input-ring-size'
+                ;; to huge numbers.  Don't allocate a huge ring right
+                ;; away; there might not be that much history.
+                (ring-size (min 1500 comint-input-ring-size))
+                (ring (make-ring ring-size)))
            (with-temp-buffer
              (insert-file-contents file)
              ;; Save restriction in case file is already visited...
              ;; Watch for those date stamps in history files!
              (goto-char (point-max))
              (let (start end history)
-               (while (and (< count size)
+               (while (and (< count comint-input-ring-size)
                            (re-search-backward comint-input-ring-separator
                                                nil t)
                            (setq end (match-beginning 0)))
@@ -941,15 +944,18 @@ See also `comint-input-ignoredups' and `comint-write-input-ring'."
                          (point-min)))
                  (setq history (buffer-substring start end))
                  (goto-char start)
-                 (if (and (not (string-match comint-input-history-ignore
-                                             history))
-                          (or (null comint-input-ignoredups)
-                              (ring-empty-p ring)
-                              (not (string-equal (ring-ref ring 0)
-                                                 history))))
-                     (progn
-                       (ring-insert-at-beginning ring history)
-                       (setq count (1+ count)))))))
+                 (when (and (not (string-match comint-input-history-ignore
+                                               history))
+                            (or (null comint-input-ignoredups)
+                                (ring-empty-p ring)
+                                (not (string-equal (ring-ref ring 0)
+                                                   history))))
+                   (when (= count ring-size)
+                     (ring-extend ring (min (- comint-input-ring-size ring-size)
+                                            ring-size))
+                     (setq ring-size (ring-size ring)))
+                   (ring-insert-at-beginning ring history)
+                   (setq count (1+ count))))))
            (setq comint-input-ring ring
                  comint-input-ring-index nil)))))
 
@@ -1691,13 +1697,18 @@ Argument 0 is the command name."
 (defun comint-add-to-input-history (cmd)
   "Add CMD to the input history.
 Ignore duplicates if `comint-input-ignoredups' is non-nil."
-  (if (and (funcall comint-input-filter cmd)
-           (or (null comint-input-ignoredups)
-               (not (ring-p comint-input-ring))
-               (ring-empty-p comint-input-ring)
-               (not (string-equal (ring-ref comint-input-ring 0)
-                                  cmd))))
-      (ring-insert comint-input-ring cmd)))
+  (when (and (funcall comint-input-filter cmd)
+             (or (null comint-input-ignoredups)
+                 (not (ring-p comint-input-ring))
+                 (ring-empty-p comint-input-ring)
+                 (not (string-equal (ring-ref comint-input-ring 0) cmd))))
+    ;; If `comint-input-ring' is full, maybe grow it.
+    (let ((size (ring-size comint-input-ring)))
+      (and (= size (ring-length comint-input-ring))
+           (< size comint-input-ring-size)
+           (ring-extend comint-input-ring
+                        (min size (- comint-input-ring-size size)))))
+    (ring-insert comint-input-ring cmd)))
 
 (defun comint-send-input (&optional no-newline artificial)
   "Send input to process.
diff --git a/lisp/dabbrev.el b/lisp/dabbrev.el
index aad3c83c32b..c5b370bfa61 100644
--- a/lisp/dabbrev.el
+++ b/lisp/dabbrev.el
@@ -1,4 +1,4 @@
-;;; dabbrev.el --- dynamic abbreviation package
+;;; dabbrev.el --- dynamic abbreviation package  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1985-1986, 1992, 1994, 1996-1997, 2000-2012
 ;;   Free Software Foundation, Inc.
@@ -291,9 +291,6 @@ this list."
 ;; Internal variables
 ;;----------------------------------------------------------------
 
-;; Last obarray of completions in `dabbrev-completion'
-(defvar dabbrev--last-obarray nil)
-
 ;; Table of expansions seen so far
 (defvar dabbrev--last-table nil)
 
@@ -321,9 +318,6 @@ this list."
 ;; The buffer we found the expansion last time.
 (defvar dabbrev--last-buffer-found nil)
 
-;; The buffer we last did a completion in.
-(defvar dabbrev--last-completion-buffer nil)
-
 ;; If non-nil, a function to use when copying successive words.
 ;; It should be `upcase' or `downcase'.
 (defvar dabbrev--last-case-pattern nil)
@@ -387,49 +381,46 @@ then it searches *all* buffers."
          (abbrev (dabbrev--abbrev-at-point))
          (beg (progn (search-backward abbrev) (point)))
          (end (progn (search-forward abbrev) (point)))
-         (ignore-case-p (and (if (eq dabbrev-case-fold-search 'case-fold-search)
-                                 case-fold-search
-                               dabbrev-case-fold-search)
-                             (or (not dabbrev-upcase-means-case-search)
-                                 (string= abbrev (downcase abbrev)))))
-         (my-obarray dabbrev--last-obarray))
-    (save-excursion
-      ;;--------------------------------
-      ;; New abbreviation to expand.
-      ;;--------------------------------
-      (setq dabbrev--last-abbreviation abbrev)
-      ;; Find all expansion
-      (let ((completion-list
-             (dabbrev--find-all-expansions abbrev ignore-case-p))
-            (completion-ignore-case ignore-case-p))
-        ;; Make an obarray with all expansions
-        (setq my-obarray (make-vector (length completion-list) 0))
-        (or (> (length my-obarray) 0)
-            (error "No dynamic expansion for \"%s\" found%s"
-                   abbrev
-                   (if dabbrev--check-other-buffers "" " in this-buffer")))
-        (cond
-         ((or (not ignore-case-p)
-              (not dabbrev-case-replace))
-          (mapc (function (lambda (string)
-                            (intern string my-obarray)))
-                completion-list))
-         ((string= abbrev (upcase abbrev))
-          (mapc (function (lambda (string)
-                            (intern (upcase string) my-obarray)))
-                completion-list))
-         ((string= (substring abbrev 0 1)
-                   (upcase (substring abbrev 0 1)))
-          (mapc (function (lambda (string)
-                            (intern (capitalize string) my-obarray)))
-                completion-list))
-         (t
-          (mapc (function (lambda (string)
-                            (intern (downcase string) my-obarray)))
-                completion-list)))
-        (setq dabbrev--last-obarray my-obarray)
-        (setq dabbrev--last-completion-buffer (current-buffer))))
-    (completion-in-region beg end my-obarray)))
+         (ignore-case-p
+          (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+                   case-fold-search
+                 dabbrev-case-fold-search)
+               (or (not dabbrev-upcase-means-case-search)
+                   (string= abbrev (downcase abbrev)))))
+         (list 'uninitialized)
+         (table
+          (lambda (s p a)
+            (if (eq a 'metadata)
+                `(metadata (cycle-sort-function . ,#'identity)
+                           (category . dabbrev))
+              (when (eq list 'uninitialized)
+                (save-excursion
+                  ;;--------------------------------
+                  ;; New abbreviation to expand.
+                  ;;--------------------------------
+                  (setq dabbrev--last-abbreviation abbrev)
+                  ;; Find all expansion
+                  (let ((completion-list
+                         (dabbrev--find-all-expansions abbrev ignore-case-p))
+                        (completion-ignore-case ignore-case-p))
+                    (or (consp completion-list)
+                        (error "No dynamic expansion for \"%s\" found%s"
+                               abbrev
+                               (if dabbrev--check-other-buffers
+                                   "" " in this-buffer")))
+                    (setq list
+                          (cond
+                           ((not (and ignore-case-p dabbrev-case-replace))
+                            completion-list)
+                           ((string= abbrev (upcase abbrev))
+                            (mapcar #'upcase completion-list))
+                           ((string= (substring abbrev 0 1)
+                                     (upcase (substring abbrev 0 1)))
+                            (mapcar #'capitalize completion-list))
+                           (t
+                            (mapcar #'downcase completion-list)))))))
+              (complete-with-action a list s p)))))
+    (completion-in-region beg end table)))
 
 ;;;###autoload
 (defun dabbrev-expand (arg)
@@ -521,12 +512,13 @@ See also `dabbrev-abbrev-char-regexp' and \\[dabbrev-completion]."
       ;;--------------------------------
       (or expansion
           (setq expansion
-                (dabbrev--find-expansion abbrev direction
-                                         (and (if (eq dabbrev-case-fold-search 'case-fold-search)
-                                                  case-fold-search
-                                                dabbrev-case-fold-search)
-                                              (or (not dabbrev-upcase-means-case-search)
-                                                  (string= abbrev (downcase abbrev))))))))
+                (dabbrev--find-expansion
+                 abbrev direction
+                 (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+                          case-fold-search
+                        dabbrev-case-fold-search)
+                      (or (not dabbrev-upcase-means-case-search)
+                          (string= abbrev (downcase abbrev))))))))
     (cond
      ((not expansion)
       (dabbrev--reset-global-variables)
@@ -621,8 +613,6 @@ all skip characters."
 
 (defun dabbrev--reset-global-variables ()
   "Initialize all global variables."
-  ;; dabbrev--last-obarray and dabbrev--last-completion-buffer
-  ;; must not be reset here.
   (setq dabbrev--last-table nil
         dabbrev--last-abbreviation nil
         dabbrev--last-abbrev-location nil
@@ -667,13 +657,13 @@ of the expansion in `dabbrev--last-expansion-location'."
         (let ((case-fold-search ignore-case)
               (count n))
           (while (and (> count 0)
-                      (setq expansion (dabbrev--search abbrev
-                                                       reverse
-                                                       (and ignore-case
-                                                            (if (eq dabbrev-case-distinction 'case-replace)
-                                                                case-replace
-                                                              dabbrev-case-distinction))
-                                                       )))
+                      (setq expansion (dabbrev--search
+                                       abbrev reverse
+                                       (and ignore-case
+                                            (if (eq dabbrev-case-distinction
+                                                    'case-replace)
+                                                case-replace
+                                              dabbrev-case-distinction)))))
             (setq count (1- count))))
         (and expansion
              (setq dabbrev--last-expansion-location (point)))
@@ -829,14 +819,15 @@ EXPANSION is the expansion substring to be used this time.
 RECORD-CASE-PATTERN, if non-nil, means set `dabbrev--last-case-pattern'
 to record whether we upcased the expansion, downcased it, or did neither."
   ;;(undo-boundary)
-  (let ((use-case-replace (and (if (eq dabbrev-case-fold-search 'case-fold-search)
-                                   case-fold-search
-                                 dabbrev-case-fold-search)
-                               (or (not dabbrev-upcase-means-case-search)
-                                   (string= abbrev (downcase abbrev)))
-                               (if (eq dabbrev-case-replace 'case-replace)
-                                   case-replace
-                                 dabbrev-case-replace))))
+  (let ((use-case-replace
+         (and (if (eq dabbrev-case-fold-search 'case-fold-search)
+                  case-fold-search
+                dabbrev-case-fold-search)
+              (or (not dabbrev-upcase-means-case-search)
+                  (string= abbrev (downcase abbrev)))
+              (if (eq dabbrev-case-replace 'case-replace)
+                  case-replace
+                dabbrev-case-replace))))
 
     ;; If we upcased or downcased the original expansion,
     ;; do likewise for the subsequent words when we copy them.
@@ -862,12 +853,13 @@ to record whether we upcased the expansion, downcased it, or did neither."
     (let ((expansion-rest (substring expansion 1))
           (first-letter-position (string-match "[[:alpha:]]" abbrev)))
       (if (or (null first-letter-position)
-              (and (not (and (or (string= expansion-rest (downcase expansion-rest))
-                                 (string= expansion-rest (upcase expansion-rest)))
-                             (or (string= abbrev (downcase abbrev))
-                                 (and (string= abbrev (upcase abbrev))
-                                      (> (- (length abbrev) first-letter-position)
-                                         1)))))
+              (and (not
+                    (and (or (string= expansion-rest (downcase expansion-rest))
+                             (string= expansion-rest (upcase expansion-rest)))
+                         (or (string= abbrev (downcase abbrev))
+                             (and (string= abbrev (upcase abbrev))
+                                  (> (- (length abbrev) first-letter-position)
+                                     1)))))
                    (string= abbrev
                             (substring expansion 0 (length abbrev)))))
           (setq use-case-replace nil)))
@@ -951,9 +943,9 @@ Leaves point at the location of the start of the expansion."
       ;; Limited search.
       (save-restriction
         (and dabbrev-limit
-             (narrow-to-region dabbrev--last-expansion-location
-                               (+ (point)
-                                  (if reverse (- dabbrev-limit) dabbrev-limit))))
+             (narrow-to-region
+              dabbrev--last-expansion-location
+              (+ (point) (if reverse (- dabbrev-limit) dabbrev-limit))))
         ;;--------------------------------
         ;; Look for a distinct expansion, using dabbrev--last-table.
         ;;--------------------------------
diff --git a/lisp/emacs-lisp/copyright.el b/lisp/emacs-lisp/copyright.el
index a77998aa6d9..09b456b54ba 100644
--- a/lisp/emacs-lisp/copyright.el
+++ b/lisp/emacs-lisp/copyright.el
@@ -85,7 +85,7 @@ The second \\( \\) construct must match the years."
   "Non-nil if individual consecutive years should be replaced with a range.
 For example: 2005, 2006, 2007, 2008 might be replaced with 2005-2008.
 If you use ranges, you should add an explanatory note in a README file.
-The function `copyright-fix-year' respects this variable."
+The function `copyright-fix-years' respects this variable."
   :group 'copyright
   :type 'boolean
   :version "24.1")
diff --git a/lisp/emacs-lisp/ring.el b/lisp/emacs-lisp/ring.el
index 4b07de523c3..cee6a43df86 100644
--- a/lisp/emacs-lisp/ring.el
+++ b/lisp/emacs-lisp/ring.el
@@ -185,26 +185,31 @@ Raise error if ITEM is not in the RING."
     (unless curr-index (error "Item is not in the ring: `%s'" item))
     (ring-ref ring (ring-minus1 curr-index (ring-length ring)))))
 
+(defun ring-extend (ring x)
+  "Increase the size of RING by X."
+  (when (and (integerp x) (> x 0))
+    (let* ((hd       (car ring))
+           (length   (ring-length ring))
+           (size     (ring-size ring))
+           (old-vec  (cddr ring))
+           (new-vec  (make-vector (+ size x) nil)))
+      (setcdr ring (cons length new-vec))
+      ;; If the ring is wrapped, the existing elements must be written
+      ;; out in the right order.
+      (dotimes (j length)
+        (aset new-vec j (aref old-vec (mod (+ hd j) size))))
+      (setcar ring 0))))
+
 (defun ring-insert+extend (ring item &optional grow-p)
   "Like `ring-insert', but if GROW-P is non-nil, then enlarge ring.
 Insert onto ring RING the item ITEM, as the newest (last) item.
 If the ring is full, behavior depends on GROW-P:
   If GROW-P is non-nil, enlarge the ring to accommodate the new item.
   If GROW-P is nil, dump the oldest item to make room for the new."
-  (let* ((vec (cddr ring))
-         (veclen (length vec))
-         (hd (car ring))
-         (ringlen (ring-length ring)))
-    (prog1
-        (cond ((and grow-p (= ringlen veclen)) ; Full ring.  Enlarge it.
-               (setq veclen (1+ veclen))
-               (setcdr ring (cons (setq ringlen (1+ ringlen))
-                                  (setq vec (vconcat vec (vector item)))))
-               (setcar ring hd))
-              (t (aset vec (mod (+ hd ringlen) veclen) item)))
-      (if (= ringlen veclen)
-          (setcar ring (ring-plus1 hd veclen))
-        (setcar (cdr ring) (1+ ringlen))))))
+  (and grow-p
+       (= (ring-length ring) (ring-size ring))
+       (ring-extend ring 1))
+  (ring-insert ring item))
 
 (defun ring-remove+insert+extend (ring item &optional grow-p)
   "`ring-remove' ITEM from RING, then `ring-insert+extend' it.
diff --git a/lisp/emulation/ws-mode.el b/lisp/emulation/ws-mode.el
index aa8d647ec11..0c7be145751 100644
--- a/lisp/emulation/ws-mode.el
+++ b/lisp/emulation/ws-mode.el
@@ -716,7 +716,7 @@ This will only work for errors raised by WordStar mode functions."
 
 (defun ws-query-replace (from to)
   "In WordStar mode: Search string, remember string for repetition."
-  (interactive "sReplace:
+  (interactive "sReplace: \n\
 sWith: " )
   (setq ws-search-string from)
   (setq ws-search-direction t)
diff --git a/lisp/faces.el b/lisp/faces.el
index 0011e0357a1..34fad66ce27 100644
--- a/lisp/faces.el
+++ b/lisp/faces.el
@@ -1516,12 +1516,15 @@ If SPEC is nil, return nil."
   (apply 'set-face-attribute face frame
          (if (eq face 'default)
              ;; For the default face, avoid making any attribute
-             ;; unspecifed.  Instead, set attributes to default values
+             ;; unspecified.  Instead, set attributes to default values
              ;; (see also realize_default_face in xfaces.c).
              (append
               '(:underline nil :overline nil :strike-through nil
                 :box nil :inverse-video nil :stipple nil :inherit nil)
-              (unless (display-graphic-p frame)
+              ;; `display-graphic-p' is unavailable when running
+              ;; temacs, prior to loading frame.el.
+              (unless (and (fboundp 'display-graphic-p)
+                           (display-graphic-p frame))
                 '(:family "default" :foundry "default" :width normal
                   :height 1 :weight normal :slant normal
                   :foreground "unspecified-fg"
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 4222791705b..b65828ca1d7 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -2284,7 +2284,7 @@ in which C preprocessor directives are used. e.g. `asm-mode' and
      `(;; Control structures.  Emacs Lisp forms.
        (,(concat
           "(" (regexp-opt
-               '("cond" "if" "while" "while-no-input" "let" "let*"
+               '("cond" "if" "while" "while-no-input" "let" "let*" "letrec"
                  "prog" "progn" "progv" "prog1" "prog2" "prog*"
                  "inline" "lambda" "save-restriction" "save-excursion"
                  "save-selected-window" "save-window-excursion"
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 092f42cd2ed..d0d35407367 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,27 @@
+2012-03-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-sum.el (gnus-update-marks): Don't propagate marks unless
+        requested (bug#10961).
+
+        * shr.el (shr-table-widths): Divide the extra width more fairly over
+        the TDs (bug#10973).
+        (shr-render-td): Don't delete too much padding.
+        (shr-natural-width): Compute the natural width more correctly.
+        (shr-insert): Allow the natural width to be computed for tables again.
+        (shr-tag-table-1): Rework how the natural widths are computed by
+        rendering the table a third time.
+        (shr-natural-width): Removed.
+        (shr-buffer-width): New function.
+        (shr-expand-newlines): Use it.
+
+        * gnus-msg.el (gnus-bug): Don't delete the other windows.  We may be
+        using a `gnus-use-full-window' setup (bug#11013).
+
+2012-03-12  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnus-int.el (gnus-backend-trace): Flip default to nil before Emacs
+        24.1 release.
+
 2012-03-10  David Edmondson  <dme@dme.org>
 
         * mm-uu.el (mm-uu-forward-extract): Allow for blank lines between the
diff --git a/lisp/gnus/gnus-int.el b/lisp/gnus/gnus-int.el
index 8dc691ffe42..1190d79f778 100644
--- a/lisp/gnus/gnus-int.el
+++ b/lisp/gnus/gnus-int.el
@@ -247,7 +247,7 @@ If it is down, start it up (again)."
   (eq (nth 1 (assoc method gnus-opened-servers))
       'denied))
 
-(defvar gnus-backend-trace t)
+(defvar gnus-backend-trace nil)
 
 (defun gnus-open-server (gnus-command-method)
   "Open a connection to GNUS-COMMAND-METHOD."
diff --git a/lisp/gnus/gnus-msg.el b/lisp/gnus/gnus-msg.el
index 7c8d194f26b..500ace9e8ff 100644
--- a/lisp/gnus/gnus-msg.el
+++ b/lisp/gnus/gnus-msg.el
@@ -1453,7 +1453,6 @@ If YANK is non-nil, include the original article."
     (error "Gnus has been shut down"))
   (gnus-setup-message (if (message-mail-user-agent) 'message 'bug)
     (unless (message-mail-user-agent)
-      (delete-other-windows)
       (when gnus-bug-create-help-buffer
         (switch-to-buffer "*Gnus Help Bug*")
         (erase-buffer)
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 9770b8f9982..7f095e15496 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -6074,6 +6074,10 @@ If SELECT-ARTICLES, only select those articles from GROUP."
 
         (when (and (gnus-check-backend-function
                     'request-set-mark gnus-newsgroup-name)
+                   (or gnus-propagate-marks
+                       (gnus-method-option-p
+                        (gnus-find-method-for-group gnus-newsgroup-name)
+                        'server-marks))
                    (not (gnus-article-unpropagatable-p (cdr type))))
           (let* ((old (cdr (assq (cdr type) (gnus-info-marks info))))
                  ;; Don't do anything about marks for articles we
diff --git a/lisp/gnus/shr.el b/lisp/gnus/shr.el
index 41f12243971..53c0063de2e 100644
--- a/lisp/gnus/shr.el
+++ b/lisp/gnus/shr.el
@@ -341,7 +341,6 @@ the URL of the image to the kill buffer instead."
             (delete-char -1))
           (insert "\n")
           (unless found
-            (put-text-property (1- (point)) (point) 'shr-break t)
             ;; No space is needed at the beginning of a line.
             (when (eq (following-char) ? )
               (delete-char 1)))
@@ -711,7 +710,7 @@ ones, in case fg and bg are nil."
     (forward-line 1)
     (setq end (point))
     (narrow-to-region start end)
-    (let ((width (shr-natural-width))
+    (let ((width (shr-buffer-width))
           column)
       (goto-char (point-min))
       (while (not (eobp))
@@ -1048,7 +1047,10 @@ ones, in case fg and bg are nil."
          ;; be smaller (if there's little text) or bigger (if there's
          ;; unbreakable text).
          (sketch (shr-make-table cont suggested-widths))
-         (sketch-widths (shr-table-widths sketch suggested-widths)))
+         ;; Compute the "natural" width by setting each column to 500
+         ;; characters and see how wide they really render.
+         (natural (shr-make-table cont (make-vector (length columns) 500)))
+         (sketch-widths (shr-table-widths sketch natural suggested-widths)))
     ;; This probably won't work very well.
     (when (> (+ (loop for width across sketch-widths
                       summing (1+ width))
@@ -1186,31 +1188,35 @@ ones, in case fg and bg are nil."
             shr-table-corner))
   (insert "\n"))
 
-(defun shr-table-widths (table suggested-widths)
+(defun shr-table-widths (table natural-table suggested-widths)
   (let* ((length (length suggested-widths))
          (widths (make-vector length 0))
          (natural-widths (make-vector length 0)))
     (dolist (row table)
       (let ((i 0))
         (dolist (column row)
-          (aset widths i (max (aref widths i)
-                              (car column)))
-          (aset natural-widths i (max (aref natural-widths i)
-                                      (cadr column)))
+          (aset widths i (max (aref widths i) column))
+          (setq i (1+ i)))))
+    (dolist (row natural-table)
+      (let ((i 0))
+        (dolist (column row)
+          (aset natural-widths i (max (aref natural-widths i) column))
           (setq i (1+ i)))))
     (let ((extra (- (apply '+ (append suggested-widths nil))
                     (apply '+ (append widths nil))))
           (expanded-columns 0))
+      ;; We have extra, unused space, so divide this space amongst the
+      ;; columns.
       (when (> extra 0)
+        ;; If the natural width is wider than the rendered width, we
+        ;; want to allow the column to expand.
         (dotimes (i length)
-          ;; If the natural width is wider than the rendered width, we
-          ;; want to allow the column to expand.
           (when (> (aref natural-widths i) (aref widths i))
             (setq expanded-columns (1+ expanded-columns))))
         (dotimes (i length)
           (when (> (aref natural-widths i) (aref widths i))
             (aset widths i (min
-                            (1+ (aref natural-widths i))
+                            (aref natural-widths i)
                             (+ (/ extra expanded-columns)
                                (aref widths i))))))))
     widths))
@@ -1265,10 +1271,13 @@ ones, in case fg and bg are nil."
           (let ((shr-width width)
                 (shr-indentation 0))
             (shr-descend (cons 'td cont)))
+          ;; Delete padding at the bottom of the TDs.
           (delete-region
            (point)
-           (+ (point)
-              (skip-chars-backward " \t\n")))
+           (progn
+             (skip-chars-backward " \t\n")
+             (end-of-line)
+             (point)))
           (push (list (cons width cont) (buffer-string)
                       (shr-overlays-in-region (point-min) (point-max)))
                 shr-content-cache)))
@@ -1302,19 +1311,14 @@ ones, in case fg and bg are nil."
                   (split-string (buffer-string) "\n")
                   (shr-collect-overlays)
                   (car actual-colors))
-          (list max
-                (shr-natural-width)))))))
+          max)))))
 
-(defun shr-natural-width ()
+(defun shr-buffer-width ()
   (goto-char (point-min))
-  (let ((current 0)
-        (max 0))
+  (let ((max 0))
     (while (not (eobp))
       (end-of-line)
-      (setq current (+ current (current-column)))
-      (unless (get-text-property (point) 'shr-break)
-        (setq max (max max current)
-              current 0))
+      (setq max (max max (current-column)))
       (forward-line 1))
     max))
 
diff --git a/lisp/htmlfontify.el b/lisp/htmlfontify.el
index b94d4293fa7..fbf7a672ff6 100644
--- a/lisp/htmlfontify.el
+++ b/lisp/htmlfontify.el
@@ -450,6 +450,12 @@ and so on."
   keep-overlays      : More of a bell (or possibly whistle) than an
                        optimization - If on, preserve overlay highlighting
                        (cf ediff or goo-font-lock) as well as basic faces.\n
+  body-text-only     : Emit only body-text. In concrete terms,
+                       1. Suppress calls to `hfy-page-header'and
+                          `hfy-page-footer'
+                       2. Pretend that `div-wrapper' option above is
+                          turned off
+                       3. Don't enclose output in <pre> </pre> tags
   And the following are planned but not yet available:\n
   kill-context-leak  : Suppress hyperlinking between files highlighted by
                        different modes.\n
@@ -463,7 +469,8 @@ which can never slow you down, but may result in incomplete fontification."
                (const :tag "skip-refontification" skip-refontification)
                (const :tag "kill-context-leak"    kill-context-leak   )
                (const :tag "div-wrapper"          div-wrapper         )
-               (const :tag "keep-overlays"        keep-overlays       ))
+               (const :tag "keep-overlays"        keep-overlays       )
+               (const :tag "body-text-only"       body-text-only      ))
   :group 'htmlfontify
   :tag   "optimizations")
 
@@ -1044,7 +1051,7 @@ haven't encountered them yet.  Returns a `hfy-style-assoc'."
    ((facep fn)
     (hfy-face-attr-for-class fn hfy-display-class))
    ((and (symbolp fn)
-         (facep (symbol-value fn)))
+         (facep (symbol-value fn)))
     ;; Obsolete faces like `font-lock-reference-face' are defined as
     ;; aliases for another face.
     (hfy-face-attr-for-class (symbol-value fn) hfy-display-class))
@@ -1108,10 +1115,9 @@ See also `hfy-face-to-style-i', `hfy-flatten-style'."
 
 ;; construct an assoc of (stripped-name . "{ css-stuff-here }") pairs
 ;; from a face:
-(defun hfy-face-to-css (fn)
-  "Take FN, a font or `defface' specification (cf `face-attr-construct')
-and return a CSS style specification.\n
-See also `hfy-face-to-style'."
+(defun hfy-face-to-css-default (fn)
+  "Default handler for mapping faces to styles.
+See also `hfy-face-to-css'."
   ;;(message "hfy-face-to-css");;DBUG
   (let* ((css-list (hfy-face-to-style fn))
          (seen     nil)
@@ -1125,6 +1131,17 @@ See also `hfy-face-to-style'."
            css-list)))
     (cons (hfy-css-name fn) (format "{%s}" (apply 'concat css-text)))) )
 
+(defvar hfy-face-to-css 'hfy-face-to-css-default
+  "Handler for mapping faces  to styles.
+The signature of the handler is of the form \(lambda (FN) ...\).
+FN is a font or `defface' specification (cf
+`face-attr-construct').  The handler should return a cons cell of
+the form (STYLE-NAME . STYLE-SPEC).
+
+The default handler is `hfy-face-to-css-default'.
+
+See also `hfy-face-to-style'.")
+
 (defalias 'hfy-prop-invisible-p
   (if (fboundp 'invisible-p) #'invisible-p
     (lambda (prop)
@@ -1311,20 +1328,27 @@ The plists are returned in descending priority order."
 
 ;; construct an assoc of (face-name . (css-name . "{ css-style }")) elements:
 (defun hfy-compile-stylesheet ()
-  "Trawl the current buffer, construct and return a `hfy-sheet-assoc'."
+  "Trawl the current buffer, construct and return a `hfy-sheet-assoc'.
+If `hfy-user-sheet-assoc' is currently bound then use it to
+collect new styles discovered during this run.  Otherwise create
+a new assoc."
   ;;(message "hfy-compile-stylesheet");;DBUG
   (let ((pt (point-min))
         ;; Make the font stack stay:
         ;;(hfy-tmpfont-stack nil)
         (fn         nil)
-        (style      nil))
+        (style      (and (boundp 'hfy-user-sheet-assoc) hfy-user-sheet-assoc)))
     (save-excursion
       (goto-char pt)
       (while (< pt (point-max))
         (if (and (setq fn (hfy-face-at pt)) (not (assoc fn style)))
-            (push (cons fn (hfy-face-to-css fn)) style))
-        (setq pt (next-char-property-change pt))) )
-    (push (cons 'default (hfy-face-to-css 'default)) style)))
+            (push (cons fn (funcall hfy-face-to-css fn)) style))
+        (setq pt (next-char-property-change pt))))
+    (unless (assoc 'default style)
+      (push (cons 'default (funcall hfy-face-to-css 'default)) style))
+    (when (boundp 'hfy-user-sheet-assoc)
+      (setq hfy-user-sheet-assoc style))
+    style))
 
 (defun hfy-fontified-p ()
   "`font-lock' doesn't like to say it's been fontified when in batch
@@ -1425,7 +1449,7 @@ Returns a modified copy of FACE-MAP."
         (setq pt (next-char-property-change pt))
         (setq pt-narrow (+ offset pt)))
       (if (and map (not (eq 'end (cdar map))))
-          (push (cons (- (point-max) (point-min)) 'end) map)))
+          (push (cons (1+ (- (point-max) (point-min))) 'end) map)))
     (if (hfy-opt 'merge-adjacent-tags) (hfy-merge-adjacent-spans map) map)))
 
 (defun hfy-buffer ()
@@ -1547,6 +1571,61 @@ Do not record undo information during evaluation of BODY."
       (remove-text-properties (point-min) (point-max)
                               '(hfy-show-trailing-whitespace)))))
 
+(defun hfy-begin-span (style text-block text-id text-begins-block-p)
+  "Default handler to begin a span of text.
+Insert \"<span class=\"STYLE\" ...>\". See
+`hfy-begin-span-handler' for more information."
+  (when text-begins-block-p
+    (insert
+     (format "<span onclick=\"toggle_invis('%s');\">…</span>" text-block)))
+
+  (insert
+   (if text-block
+       (format "<span class=\"%s\" id=\"%s-%d\">" style text-block text-id)
+     (format "<span class=\"%s\">" style))))
+
+(defun hfy-end-span ()
+  "Default handler to end a span of text.
+Insert \"</span>\".  See `hfy-end-span-handler' for more
+information."
+  (insert "</span>"))
+
+(defvar hfy-begin-span-handler 'hfy-begin-span
+  "Handler to begin a span of text.
+The signature of the handler is \(lambda (STYLE TEXT-BLOCK
+TEXT-ID TEXT-BEGINS-BLOCK-P) ...\).  The handler must insert
+appropriate tags to begin a span of text.
+
+STYLE is the name of the style that begins at point.  It is
+derived from the face attributes as part of `hfy-face-to-css'
+callback.  The other arguments TEXT-BLOCK, TEXT-ID,
+TEXT-BEGINS-BLOCK-P are non-nil only if the buffer contains
+invisible text.
+
+TEXT-BLOCK is a string that identifies a single chunk of visible
+or invisible text of which the current position is a part.  For
+visible portions, it's value is \"nil\". For invisible portions,
+it's value is computed as part of `hfy-invisible-name'.
+
+TEXT-ID marks a unique position within a block.  It is set to
+value of `point' at the current buffer position.
+
+TEXT-BEGINS-BLOCK-P is a boolean and is non-nil if the current
+span also begins a invisible portion of text.
+
+An implementation can use TEXT-BLOCK, TEXT-ID,
+TEXT-BEGINS-BLOCK-P to implement fold/unfold-on-mouse-click like
+behaviour.
+
+The default handler is `hfy-begin-span'.")
+
+(defvar hfy-end-span-handler 'hfy-end-span
+  "Handler to end a span of text.
+The signature of the handler is \(lambda () ...\).  The handler
+must insert appropriate tags to end a span of text.
+
+The default handler is `hfy-end-span'.")
+
 (defun hfy-fontify-buffer (&optional srcdir file)
   "Implement the guts of `htmlfontify-buffer'.
 SRCDIR, if set, is the directory being htmlfontified.
@@ -1634,23 +1713,19 @@ FILE, if set, is the file name."
               (or (get-text-property pt 'hfy-linkp)
                   (get-text-property pt 'hfy-endl )))
         (if (eq 'end fn)
-            (insert "</span>")
+            (funcall hfy-end-span-handler)
           (if (not (and srcdir file))
               nil
             (when move-link
               (remove-text-properties (point) (1+ (point)) '(hfy-endl nil))
               (put-text-property pt (1+ pt) 'hfy-endl t) ))
           ;; if we have invisible blocks, we need to do some extra magic:
-          (if invis-ranges
-              (let ((iname (hfy-invisible-name pt invis-ranges))
-                    (fname (hfy-lookup         fn css-sheet   )))
-                (when (assq pt invis-ranges)
-                  (insert
-                   (format "<span onclick=\"toggle_invis('%s');\">" iname))
-                  (insert "…</span>"))
-                (insert
-                 (format "<span class=\"%s\" id=\"%s-%d\">" fname iname pt)))
-            (insert (format "<span class=\"%s\">" (hfy-lookup fn css-sheet))))
+          (funcall hfy-begin-span-handler
+                   (hfy-lookup fn css-sheet)
+                   (and invis-ranges
+                        (format "%s" (hfy-invisible-name pt invis-ranges)))
+                   (and invis-ranges pt)
+                   (and invis-ranges (assq pt invis-ranges)))
           (if (not move-link) nil
             ;;(message "removing prop2 @ %d" (point))
             (if (remove-text-properties (point) (1+ (point)) '(hfy-endl nil))
@@ -1698,23 +1773,39 @@ FILE, if set, is the file name."
     ;; so we have to do this after we use said properties:
     ;; (message "munging dangerous characters")
     (hfy-html-dekludge-buffer)
-    ;; insert the stylesheet at the top:
-    (goto-char (point-min))
-    ;;(message "inserting stylesheet")
-    (insert (hfy-sprintf-stylesheet css-sheet file))
-    (if (hfy-opt 'div-wrapper) (insert "<div class=\"default\">"))
-    (insert "\n<pre>")
-    (goto-char (point-max))
-    (insert "</pre>\n")
-    (if (hfy-opt 'div-wrapper) (insert "</div>"))
-    ;;(message "inserting footer")
-    (insert (funcall hfy-page-footer file))
+    (unless (hfy-opt 'body-text-only)
+      ;; insert the stylesheet at the top:
+      (goto-char (point-min))
+
+      ;;(message "inserting stylesheet")
+      (insert (hfy-sprintf-stylesheet css-sheet file))
+
+      (if (hfy-opt 'div-wrapper) (insert "<div class=\"default\">"))
+      (insert "\n<pre>")
+      (goto-char (point-max))
+      (insert "</pre>\n")
+      (if (hfy-opt 'div-wrapper) (insert "</div>"))
+      ;;(message "inserting footer")
+      (insert (funcall hfy-page-footer file)))
     ;; call any post html-generation hooks:
     (run-hooks 'hfy-post-html-hooks)
     ;; return the html buffer
     (set-buffer-modified-p nil)
     html-buffer))
 
+(defun htmlfontify-string (string)
+  "Take a STRING and return a fontified version of it.
+It is assumed that STRING has text properties that allow it to be
+fontified.  This is a simple convenience wrapper around
+`htmlfontify-buffer'."
+  (let* ((hfy-optimisations-1 (copy-sequence hfy-optimisations))
+         (hfy-optimisations (add-to-list 'hfy-optimisations-1
+                                         'skip-refontification)))
+    (with-temp-buffer
+      (insert string)
+      (htmlfontify-buffer)
+      (buffer-string))))
+
 (defun hfy-force-fontification ()
   "Try to force font-locking even when it is optimized away."
   (run-hooks 'hfy-init-kludge-hook)
diff --git a/lisp/imenu.el b/lisp/imenu.el
index 9a847f32e89..8363956355b 100644
--- a/lisp/imenu.el
+++ b/lisp/imenu.el
@@ -963,13 +963,14 @@ See the command `imenu' for more information."
           imenu-generic-expression
           (not (eq imenu-create-index-function
                    'imenu-default-create-index-function)))
-      (let ((newmap (make-sparse-keymap)))
-        (set-keymap-parent newmap (current-local-map))
-        (setq imenu--last-menubar-index-alist nil)
-        (define-key newmap [menu-bar index]
-          `(menu-item ,name ,(make-sparse-keymap "Imenu")))
-        (use-local-map newmap)
-        (add-hook 'menu-bar-update-hook 'imenu-update-menubar))
+      (unless (keymapp (lookup-key (current-local-map) [menu-bar index]))
+        (let ((newmap (make-sparse-keymap)))
+          (set-keymap-parent newmap (current-local-map))
+          (setq imenu--last-menubar-index-alist nil)
+          (define-key newmap [menu-bar index]
+            `(menu-item ,name ,(make-sparse-keymap "Imenu")))
+          (use-local-map newmap)
+          (add-hook 'menu-bar-update-hook 'imenu-update-menubar)))
     (error "The mode `%s' does not support Imenu"
            (format-mode-line mode-name))))
 
@@ -1008,6 +1009,9 @@ to `imenu-update-menubar'.")
                                                    (car (cdr menu))))
                                             'imenu--menubar-select))
           (setq old (lookup-key (current-local-map) [menu-bar index]))
+          ;; This should never happen, but in some odd cases, potentially,
+          ;; lookup-key may return a dynamically composed keymap.
+          (if (keymapp (cadr old)) (setq old (cadr old)))
           (setcdr old (cdr menu1)))))))
 
 (defun imenu--menubar-select (item)
diff --git a/lisp/mail/sendmail.el b/lisp/mail/sendmail.el
index f4dfcfcf647..4e2d827fc29 100644
--- a/lisp/mail/sendmail.el
+++ b/lisp/mail/sendmail.el
@@ -1085,9 +1085,10 @@ Return non-nil if and only if some part of the header is encoded."
                 (cons selected mm-coding-system-priorities)
               mm-coding-system-priorities))
            (tick (buffer-chars-modified-tick))
-           ;; rms: this proved necessary, but I don't recall why.
-           ;; Can anyone determine why, and state it here?
-           (rfc2047-encode-encoded-words t))
+           ;; Many mailers, including Gnus, passes a message of which
+           ;; the header is already encoded, so this is necessary to
+           ;; prevent it from being encoded again.
+           (rfc2047-encode-encoded-words nil))
       (rfc2047-encode-message-header)
       (= tick (buffer-chars-modified-tick)))))
 
diff --git a/lisp/net/mairix.el b/lisp/net/mairix.el
index 360b2286b7b..a8e969a18c5 100644
--- a/lisp/net/mairix.el
+++ b/lisp/net/mairix.el
@@ -659,7 +659,7 @@ Fill in VALUES if based on an article."
              " containing the word)\n"
              "    substring=   to match words containing the substring\n"
              "    substring=N  to match words containing the substring, allowing\n"
-             "                  up to N errors(mising/extra/different letters)\n"
+             "                  up to N errors(missing/extra/different letters)\n"
              "    ^substring=  to match the substring at the beginning of a word.\n"))
     (widget-insert
      "Whitespace will be converted to ',' (i.e. AND).  Use '/' for OR.\n\n")
diff --git a/lisp/net/rcirc.el b/lisp/net/rcirc.el
index 1c74e6190dc..d09b6aa831f 100644
--- a/lisp/net/rcirc.el
+++ b/lisp/net/rcirc.el
@@ -2165,13 +2165,17 @@ CHANNELS is a comma- or space-separated string of channel names."
   (let ((channel (if (> (length channel) 0) channel target)))
     (rcirc-send-string process (concat "PART " channel " :" rcirc-id-string))))
 
-(defun-rcirc-command quit (reason)
-  "Send a quit message to server with REASON."
-  (interactive "sQuit reason: ")
-  (rcirc-send-string process (concat "QUIT :"
-                                     (if (not (zerop (length reason)))
-                                         reason
-                                       rcirc-id-string))))
+(defun-rcirc-command quit (reason all)
+  "Send a quit message to server with REASON.
+When called with prefix, quit all servers."
+  (interactive "sQuit reason: \nP")
+  (dolist (p (if all
+                 (rcirc-process-list)
+               (list process)))
+    (rcirc-send-string p (concat "QUIT :"
+                                 (if (not (zerop (length reason)))
+                                     reason
+                                   rcirc-id-string)))))
 
 (defun-rcirc-command nick (nick)
   "Change nick to NICK."
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 3b33ac894f2..cf38001c123 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -236,7 +236,7 @@
 
 (defun c-invalidate-macro-cache (beg end)
   ;; Called from a before-change function.  If the change region is before or
-  ;; in the macro characterised by `c-macro-cache' etc., nullify it
+  ;; in the macro characterized by `c-macro-cache' etc., nullify it
   ;; appropriately.  BEG and END are the standard before-change-functions
   ;; parameters.  END isn't used.
   (cond
@@ -1246,7 +1246,7 @@ comment at the start of cc-engine.el for more info."
                        (c-at-vsemi-p))))
               (throw 'done vsemi-pos))
              ;; In a string/comment?
-             ((setq lit-range (c-literal-limits))
+             ((setq lit-range (c-literal-limits from))
               (goto-char (cdr lit-range)))
              ((eq (char-after) ?:)
               (forward-char)
@@ -2163,7 +2163,7 @@ comment at the start of cc-engine.el for more info."
 (make-variable-buffer-local 'c-state-semi-nonlit-pos-cache-limit)
 ;; An upper limit on valid entries in `c-state-semi-nonlit-pos-cache'.  This is
 ;; reduced by buffer changes, and increased by invocations of
-;; `c-state-literal-at'.  FIMXE!!!
+;; `c-state-literal-at'.  FIXME!!!
 
 (defsubst c-state-pp-to-literal (from to)
   ;; Do a parse-partial-sexp from FROM to TO, returning either
@@ -3250,8 +3250,7 @@ comment at the start of cc-engine.el for more info."
               (if scan-forward-p
                   (progn (narrow-to-region (point-min) here)
                          (c-append-to-state-cache good-pos))
-
-                (c-get-cache-scan-pos good-pos))))
+                good-pos)))
 
        (t ; (eq strategy 'IN-LIT)
         (setq c-state-cache nil
@@ -4563,6 +4562,38 @@ comment at the start of cc-engine.el for more info."
         (point-min))
        (t
         (c-determine-limit (- how-far-back count) base try-size))))))
+
+(defun c-determine-+ve-limit (how-far &optional start-pos)
+  ;; Return a buffer position about HOW-FAR non-literal characters forward
+  ;; from START-POS (default point), which must not be inside a literal.
+  (save-excursion
+    (let ((pos (or start-pos (point)))
+          (count how-far)
+          (s (parse-partial-sexp (point) (point)))) ; null state
+      (while (and (not (eobp))
+                  (> count 0))
+        ;; Scan over counted characters.
+        (setq s (parse-partial-sexp
+                 pos
+                 (min (+ pos count) (point-max))
+                 nil                    ; target-depth
+                 nil                    ; stop-before
+                 s                      ; state
+                 'syntax-table))        ; stop-comment
+        (setq count (- count (- (point) pos) 1)
+              pos (point))
+        ;; Scan over literal characters.
+        (if (nth 8 s)
+            (setq s (parse-partial-sexp
+                     pos
+                     (point-max)
+                     nil                ; target-depth
+                     nil                ; stop-before
+                     s                  ; state
+                     'syntax-table)     ; stop-comment
+                  pos (point))))
+      (point))))
+
 
 ;; `c-find-decl-spots' and accompanying stuff.
 
@@ -7670,8 +7701,8 @@ comment at the start of cc-engine.el for more info."
     (and
      (eq (c-beginning-of-statement-1 lim) 'same)
 
-     (not (or (c-major-mode-is 'objc-mode)
-              (c-forward-objc-directive)))
+     (not (and (c-major-mode-is 'objc-mode)
+               (c-forward-objc-directive)))
 
      (setq id-start
            (car-safe (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil)))
@@ -8635,7 +8666,6 @@ comment at the start of cc-engine.el for more info."
         (setq pos (point)))
       (and
        c-macro-with-semi-re
-       (not (c-in-literal))
        (eq (skip-chars-backward " \t") 0)
 
        ;; Check we've got nothing after this except comments and empty lines
@@ -8666,7 +8696,9 @@ comment at the start of cc-engine.el for more info."
              (c-backward-syntactic-ws)
              t))
        (c-simple-skip-symbol-backward)
-       (looking-at c-macro-with-semi-re)))))
+       (looking-at c-macro-with-semi-re)
+       (goto-char pos)
+       (not (c-in-literal))))))         ; The most expensive check last. 
 
 (defun c-macro-vsemi-status-unknown-p () t) ; See cc-defs.el.
 
@@ -9207,6 +9239,10 @@ comment at the start of cc-engine.el for more info."
                           containing-sexp nil)))
               (setq lim (1+ containing-sexp))))
         (setq lim (point-min)))
+      (when (c-beginning-of-macro)
+        (goto-char indent-point)
+        (let ((lim1 (c-determine-limit 2000)))
+          (setq lim (max lim lim1))))
 
       ;; If we're in a parenthesis list then ',' delimits the
       ;; "statements" rather than being an operator (with the
@@ -9571,7 +9607,8 @@ comment at the start of cc-engine.el for more info."
          ;; CASE 5B: After a function header but before the body (or
          ;; the ending semicolon if there's no body).
          ((save-excursion
-            (when (setq placeholder (c-just-after-func-arglist-p lim))
+            (when (setq placeholder (c-just-after-func-arglist-p
+                                     (max lim (c-determine-limit 500))))
               (setq tmp-pos (point))))
           (cond
 
@@ -9779,7 +9816,7 @@ comment at the start of cc-engine.el for more info."
            ;; top level construct.  Or, perhaps, an unrecognized construct.
            (t
             (while (and (setq placeholder (point))
-                        (eq (car (c-beginning-of-decl-1 containing-sexp))
+                        (eq (car (c-beginning-of-decl-1 containing-sexp)) ; Can't use `lim' here.
                             'same)
                         (save-excursion
                           (c-backward-syntactic-ws)
@@ -9882,7 +9919,7 @@ comment at the start of cc-engine.el for more info."
                               (eq (cdar c-state-cache) (point)))
                          ;; Speed up the backward search a bit.
                          (goto-char (caar c-state-cache)))
-                     (c-beginning-of-decl-1 containing-sexp)
+                     (c-beginning-of-decl-1 containing-sexp) ; Can't use `lim' here.
                      (setq placeholder (point))
                      (if (= start (point))
                          ;; The '}' is unbalanced.
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 985214db1dc..7c018feefbb 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -925,8 +925,8 @@ Note that the style variables are always made local to the buffer."
     ;; inside a string, comment, or macro.
     (setq new-bounds (c-extend-font-lock-region-for-macros
                       c-new-BEG c-new-END old-len))
-    (setq c-new-BEG (car new-bounds)
-          c-new-END (cdr new-bounds))
+    (setq c-new-BEG (max (car new-bounds) (c-determine-limit 500 begg))
+          c-new-END (min (cdr new-bounds) (c-determine-+ve-limit 500 endd)))
     ;; Clear all old relevant properties.
     (c-clear-char-property-with-value c-new-BEG c-new-END 'syntax-table '(1))
     (c-clear-char-property-with-value c-new-BEG c-new-END 'category 'c-cpp-delimiter)
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 8ea255e49dd..89450cd2276 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -3269,8 +3269,12 @@ DOC is an optional documentation string."
   (let* ((frame (gdb-current-buffer-frame))
          (file (bindat-get-field frame 'fullname))
          (line (bindat-get-field frame 'line)))
-    (when file
-      (format "-data-disassemble -f %s -l %s -n -1 -- 0" file line)))
+    (if file
+      (format "-data-disassemble -f %s -l %s -n -1 -- 0" file line)
+    ;; If we're unable to get a file name / line for $PC, simply
+    ;; follow $PC, disassembling the next 10 (x ~15 (on IA) ==
+    ;; 150 bytes) instructions.
+    "-data-disassemble -s $pc -e \"$pc + 150\" -- 0"))
   gdb-disassembly-handler
   ;; We update disassembly only after we have actual frame information
   ;; about all threads, so no there's `update' signal in this list
@@ -3329,8 +3333,12 @@ DOC is an optional documentation string."
       (gdb-table-add-row table
                          (list
                           (bindat-get-field instr 'address)
-                          (apply #'format "<%s+%s>:"
-                                 (gdb-get-many-fields instr 'func-name 'offset))
+                          (let
+                              ((func-name (bindat-get-field instr 'func-name))
+                               (offset (bindat-get-field instr 'offset)))
+                            (if func-name
+                                (format "<%s+%s>:" func-name offset)
+                              ""))
                           (bindat-get-field instr 'inst)))
       (when (string-equal (bindat-get-field instr 'address)
                           address)
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index e7afd0e0e67..de728da236d 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -388,7 +388,11 @@ The expansion is entirely correct because it uses the C preprocessor."
                       ;; In case of error, make sure we don't move backward.
                       (scan-error (goto-char startpos) nil))
                   (not (or (nth 8 (parse-partial-sexp
-                                   (point) limit nil nil state 'syntax-table))
+                                   ;; Since we don't know if point is within
+                                   ;; the first or the scond arg, we have to
+                                   ;; start from the beginning.
+                                   (if twoargs (1+ (nth 8 state)) (point))
+                                   limit nil nil state 'syntax-table))
                            ;; If we have a self-paired opener and a twoargs
                            ;; command, the form is s/../../ so we have to skip
                            ;; a second time.
diff --git a/lisp/simple.el b/lisp/simple.el
index f42ea3e7a50..936037f5caa 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -3069,7 +3069,8 @@ before the Emacs kill and one can still paste it using \\[yank] \\[yank-pop]."
   :version "23.2")
 
 (defcustom kill-do-not-save-duplicates nil
-  "Do not add a new string to `kill-ring' when it is the same as the last one."
+  "Do not add a new string to `kill-ring' if it duplicates the last one.
+The comparison is done using `equal-including-properties'."
   :type 'boolean
   :group 'killing
   :version "23.2")
@@ -3097,7 +3098,10 @@ argument should still be a \"useful\" string for such uses."
         (signal 'args-out-of-range
                 (list string "yank-handler specified for empty string"))))
   (unless (and kill-do-not-save-duplicates
-               (equal string (car kill-ring)))
+               ;; Due to text properties such as 'yank-handler that
+               ;; can alter the contents to yank, comparison using
+               ;; `equal' is unsafe.
+               (equal-including-properties string (car kill-ring)))
     (if (fboundp 'menu-bar-update-yank-menu)
         (menu-bar-update-yank-menu string (and replace (car kill-ring)))))
   (when save-interprogram-paste-before-kill
@@ -3108,10 +3112,10 @@ argument should still be a \"useful\" string for such uses."
                        (nreverse interprogram-paste)
                      (list interprogram-paste)))
           (unless (and kill-do-not-save-duplicates
-                       (equal s (car kill-ring)))
+                       (equal-including-properties s (car kill-ring)))
             (push s kill-ring))))))
   (unless (and kill-do-not-save-duplicates
-               (equal string (car kill-ring)))
+               (equal-including-properties string (car kill-ring)))
     (if (and replace kill-ring)
         (setcar kill-ring string)
       (push string kill-ring)
diff --git a/lisp/sort.el b/lisp/sort.el
index d38e475fd39..8cfe69f9458 100644
--- a/lisp/sort.el
+++ b/lisp/sort.el
@@ -423,7 +423,7 @@ For example: to sort lines in the region by the first word on each line
   ;; using negative prefix arg to mean "reverse" is now inconsistent with
   ;; other sort-.*fields functions but then again this was before, since it
   ;; didn't use the magnitude of the arg to specify anything.
-  (interactive "P\nsRegexp specifying records to sort:
+  (interactive "P\nsRegexp specifying records to sort: \n\
 sRegexp specifying key within record: \nr")
   (cond ((or (equal key-regexp "") (equal key-regexp "\\&"))
          (setq key-regexp 0))
diff --git a/lisp/subr.el b/lisp/subr.el
index e0b099dd16b..514827f9615 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1785,6 +1785,8 @@ this name matching.
 
 Alternatively, FILE can be a feature (i.e. a symbol), in which case FORM
 is evaluated at the end of any file that `provide's this feature.
+If the feature is provided when evaluating code not associated with a
+file, FORM is evaluated immediately after the provide statement.
 
 Usually FILE is just a library name like \"font-lock\" or a feature name
 like 'font-lock.
@@ -1814,14 +1816,16 @@ This function makes or adds to an entry on `after-load-alist'."
         ;; make sure that `form' is really run "after-load" in case the provide
         ;; call happens early.
         (setq form
-              `(when load-file-name
-                 (let ((fun (make-symbol "eval-after-load-helper")))
-                   (fset fun `(lambda (file)
-                                (if (not (equal file ',load-file-name))
-                                    nil
-                                  (remove-hook 'after-load-functions ',fun)
-                                  ,',form)))
-                   (add-hook 'after-load-functions fun)))))
+              `(if load-file-name
+                   (let ((fun (make-symbol "eval-after-load-helper")))
+                     (fset fun `(lambda (file)
+                                  (if (not (equal file ',load-file-name))
+                                      nil
+                                    (remove-hook 'after-load-functions ',fun)
+                                    ,',form)))
+                     (add-hook 'after-load-functions fun))
+                 ;; Not being provided from a file, run form right now.
+                 ,form)))
       ;; Add FORM to the element unless it's already there.
       (unless (member form (cdr elt))
         (nconc elt (purecopy (list form)))))))
diff --git a/lisp/tar-mode.el b/lisp/tar-mode.el
index 949ac4c0889..3eb2be15698 100644
--- a/lisp/tar-mode.el
+++ b/lisp/tar-mode.el
@@ -634,6 +634,9 @@ inside of a tar archive without extracting it and re-archiving it.
 
 See also: variables `tar-update-datestamp' and `tar-anal-blocksize'.
 \\{tar-mode-map}"
+  (and buffer-file-name
+       (file-writable-p buffer-file-name)
+       (setq buffer-read-only nil))    ; undo what `special-mode' did
   (make-local-variable 'tar-parse-info)
   (set (make-local-variable 'require-final-newline) nil) ; binary data, dude...
   (set (make-local-variable 'local-enable-local-variables) nil)
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index c1fcb6013b2..bbd433ec9fc 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -324,9 +324,9 @@ Uses `query-replace' (\\[query-replace]) for corrections."
 Skips any text between strings matching regular expressions
 `ispell-tib-ref-beginning' and `ispell-tib-ref-end'.
 
-TeX users beware:  Any field starting with [. will skip until a .] -- even
-your whole buffer -- unless you set `ispell-skip-tib' to nil.  That includes
-a [.5mm] type of number...."
+TeX users beware:  Any text between [. and .] will be skipped -- even if
+that's your whole buffer -- unless you set `ispell-skip-tib' to nil.
+That includes the [.5mm] type of number..."
   :type 'boolean
   :group 'ispell)
 
@@ -337,13 +337,13 @@ a [.5mm] type of number...."
   "Regexp matching the end of a Tib reference.")
 
 (defcustom ispell-keep-choices-win t
-  "*When non-nil, the `*Choices*' window remains for spelling session.
+  "*If non-nil, keep the `*Choices*' window for the entire spelling session.
 This minimizes redisplay thrashing."
   :type 'boolean
   :group 'ispell)
 
 (defcustom ispell-choices-win-default-height 2
-  "*The default size of the `*Choices*' window, including mode line.
+  "*The default size of the `*Choices*' window, including the mode line.
 Must be greater than 1."
   :type 'integer
   :group 'ispell)
@@ -493,7 +493,7 @@ default dictionary and LANG the two letter language code."
   :group 'ispell)
 
 (defcustom ispell-silently-savep nil
-  "*When non-nil, save the personal dictionary without confirmation."
+  "*When non-nil, save personal dictionary without asking for confirmation."
   :type 'boolean
   :group 'ispell)
 
@@ -714,7 +714,7 @@ Hint: regexp syntax requires the hyphen to be declared first here.
 
 CASECHARS, NOT-CASECHARS, and OTHERCHARS must be unibyte strings
 containing bytes of CHARACTER-SET.  In addition, if they contain
-a non-ASCII byte, the regular expression must be a single
+non-ASCII bytes, the regular expression must be a single
 `character set' construct that doesn't specify a character range
 for non-ASCII bytes.
 
@@ -734,27 +734,31 @@ but the dictionary can control the extended character mode.
 Both defaults can be overruled in a buffer-local fashion.  See
 `ispell-parsing-keyword' for details on this.
 
-CHARACTER-SET used for languages with multibyte characters.
+CHARACTER-SET used to encode text sent to the ispell subprocess
+when the language uses non-ASCII characters.
 
-Note that the CASECHARS and OTHERCHARS slots of the alist should
-contain the same character set as casechars and otherchars in the
-LANGUAGE.aff file \(e.g., english.aff\).")
+Note that with \"ispell\" as the speller, the CASECHARS and
+OTHERCHARS slots of the alist should contain the same character
+set as casechars and otherchars in the LANGUAGE.aff file \(e.g.,
+english.aff\).  apsell and hunspell don't have this limitation.")
 
 (defvar ispell-really-aspell nil)   ; Non-nil if we can use aspell extensions.
 (defvar ispell-really-hunspell nil) ; Non-nil if we can use hunspell extensions.
 (defvar ispell-encoding8-command nil
-  "Command line option prefix to select UTF-8 if supported, nil otherwise.
-If UTF-8 if supported by spellchecker and is selectable from the command line
-this variable will contain \"--encoding=\" for aspell and \"-i \" for hunspell,
-so UTF-8 or other mime charsets can be selected.  That will be set for hunspell
->=1.1.6 or aspell >= 0.60 in `ispell-check-version'.
-
-For aspell non-nil means to try to automatically find aspell dictionaries.
-Earlier aspell versions do not consistently support UTF-8.  Handling
+  "Command line option prefix to select encoding if supported, nil otherwise.
+If setting the encoding is supported by spellchecker and is selectable from
+the command line, this variable will contain \"--encoding=\" for aspell
+and \"-i \" for hunspell, so the appropriate mime charset can be selected.
+That will be set in `ispell-check-version' for hunspell >= 1.1.6 and
+aspell >= 0.60.
+
+For aspell, non-nil also means to try to automatically find its dictionaries.
+
+Earlier aspell versions do not consistently support charset encoding.  Handling
 this would require some extra guessing in `ispell-aspell-find-dictionary'.")
 
 (defvar ispell-aspell-supports-utf8 nil
-  "Non nil if aspell has consistent command line UTF-8 support.  Obsolete.
+  "Non-nil if aspell has consistent command line UTF-8 support.  Obsolete.
 ispell.el and flyspell.el will use for this purpose the more generic
 variable `ispell-encoding8-command' for both aspell and hunspell.  Is left
 here just for backwards compatibility.")
@@ -780,7 +784,7 @@ here just for backwards compatibility.")
 
 
 (defun ispell-check-version (&optional interactivep)
-  "Ensure that `ispell-program-name' is valid and the correct version.
+  "Ensure that `ispell-program-name' is valid and has the correct version.
 Returns version number if called interactively.
 Otherwise returns the library directory name, if that is defined."
   ;; This is a little wasteful as we actually launch ispell twice: once
@@ -983,8 +987,8 @@ Assumes that value contains no whitespace."
 
 (defun ispell-aspell-find-dictionary (dict-name)
   "For aspell dictionary DICT-NAME, return a list of parameters if an
-  associated data file is found or nil otherwise.  List format is
-  that of `ispell-dictionary-base-alist' elements."
+associated data file is found or nil otherwise.  List format is that
+of `ispell-dictionary-base-alist' elements."
   ;; Make sure `ispell-aspell-data-dir' is defined
   (or ispell-aspell-data-dir
       (setq ispell-aspell-data-dir
@@ -1117,7 +1121,7 @@ aspell is used along with Emacs).")
 
 (defun ispell-valid-dictionary-list ()
   "Return a list of valid dictionaries.
-The variable `ispell-library-directory' defines the library location."
+The variable `ispell-library-directory' defines their location."
   ;; Initialize variables and dictionaries alists for desired spellchecker.
   ;; Make sure ispell.el is loaded to avoid some autoload loops in XEmacs
   ;; (and may be others)
@@ -1307,7 +1311,8 @@ Protects against bogus binding of `enable-multibyte-characters' in XEmacs."
   (let* ((slot (or
                 (assoc ispell-current-dictionary ispell-local-dictionary-alist)
                 (assoc ispell-current-dictionary ispell-dictionary-alist)
-                (error "No match for the current dictionary")))
+                (error "No data for dictionary \"%s\", neither in `ispell-local-dictionary-alist' nor in `ispell-dictionary-alist'"
+                       ispell-current-dictionary)))
          (str (nth n slot)))
     (when (and (> (length str) 0)
                (not (multibyte-string-p str)))
@@ -1381,7 +1386,7 @@ Set to the MIME boundary locations when checking messages.")
 (defconst ispell-words-keyword "LocalWords: "
   "The keyword for local oddly-spelled words to accept.
 The keyword will be followed by any number of local word spellings.
-There can be multiple of these keywords in the file.")
+There can be multiple instances of this keyword in the file.")
 
 (defconst ispell-dictionary-keyword "Local IspellDict: "
   "The keyword for a local dictionary to use.
@@ -1786,7 +1791,8 @@ If optional argument FOLLOWING is non-nil or if `ispell-following-word'
 is non-nil when called interactively, then the following word
 \(rather than preceding\) is checked when the cursor is not over a word.
 Optional second argument contains otherchars that can be included in word
-many times.
+many times (see the doc string of `ispell-dictionary-alist' for details
+about otherchars).
 
 Word syntax is controlled by the definition of the chosen dictionary,
 which is in `ispell-local-dictionary-alist' or `ispell-dictionary-alist'."
@@ -2817,8 +2823,8 @@ By just answering RET you can find out what the current dictionary is."
 
 (defun ispell-internal-change-dictionary ()
   "Update the dictionary and the personal dictionary used by Ispell.
-This may kill the Ispell process; if so,
-a new one will be started when needed."
+This may kill the Ispell process; if so, a new one will be started
+when needed."
   (let ((dict (or ispell-local-dictionary ispell-dictionary))
         (pdict (or ispell-local-pdict ispell-personal-dictionary)))
     (unless (and (equal ispell-current-dictionary dict)
@@ -2836,8 +2842,8 @@ a new one will be started when needed."
 ;;;###autoload
 (defun ispell-region (reg-start reg-end &optional recheckp shift)
   "Interactively check a region for spelling errors.
-Return nil if spell session is quit,
- otherwise returns shift offset amount for last line processed."
+Return nil if spell session was terminated, otherwise returns shift offset
+amount for last line processed."
   (interactive "r")                     ; Don't flag errors on read-only bufs.
   (ispell-set-spellchecker-params)      ; Initialize variables and dicts alists
   (if (not recheckp)
@@ -2956,7 +2962,7 @@ Return nil if spell session is quit,
 (defun ispell-begin-skip-region-regexp ()
   "Return a regexp of the search keys for region skipping.
 Includes `ispell-skip-region-alist' plus tex, tib, html, and comment keys.
-Must call after `ispell-buffer-local-parsing' due to dependence on mode."
+Must be called after `ispell-buffer-local-parsing' due to dependence on mode."
   (mapconcat
    'identity
    (delq nil
@@ -3016,7 +3022,7 @@ Includes regions defined by `ispell-skip-region-alist', tex mode,
 `ispell-html-skip-alists', and `ispell-checking-message'.
 Manual checking must include comments and tib references.
 The list is of the form described by variable `ispell-skip-region-alist'.
-Must call after `ispell-buffer-local-parsing' due to dependence on mode."
+Must be called after `ispell-buffer-local-parsing' due to dependence on mode."
   (let ((skip-alist ispell-skip-region-alist))
     ;; only additional explicit region definition is tex.
     (if (eq ispell-parser 'tex)
@@ -3046,7 +3052,7 @@ Must call after `ispell-buffer-local-parsing' due to dependence on mode."
 
 (defun ispell-ignore-fcc (start end)
   "Delete the Fcc: message header when large attachments are included.
-Return value `nil' if file with large attachments are saved.
+Return value `nil' if file with large attachments is saved.
 This can be used to avoid multiple questions for multiple large attachments.
 Returns point to starting location afterwards."
   (let ((result t))
@@ -3153,7 +3159,7 @@ Returns a string with the line data."
                                       coding)))))
 
 (defun ispell-process-line (string shift)
-  "Send STRING, a line of text, to ispell and processes the result.
+  "Send STRING, a line of text, to ispell and process the result.
 This will modify the buffer for spelling errors.
 Requires variables ISPELL-START and ISPELL-END to be defined in its
 dynamic scope.
@@ -3468,7 +3474,7 @@ With a prefix argument ARG, enable Ispell minor mode if ARG is
 positive, and disable it otherwise.  If called from Lisp, enable
 the mode if ARG is omitted or nil.
 
-Ispell minor mode is a buffer-local mior mode.  When enabled,
+Ispell minor mode is a buffer-local minor mode.  When enabled,
 typing SPC or RET warns you if the previous word is incorrectly
 spelled.
 
@@ -3481,7 +3487,7 @@ RET, use `flyspell-mode'."
   nil " Spell" ispell-minor-keymap)
 
 (defun ispell-minor-check ()
-  "Check previous word then continue with the normal binding of this key.
+  "Check previous word, then continue with the normal binding of this key.
 Don't check previous word when character before point is a space or newline.
 Don't read buffer-local settings or word lists."
   (interactive "*")
@@ -3519,8 +3525,8 @@ Don't read buffer-local settings or word lists."
                ;; Matches commonly used "cut" boundaries
                "^\\(- \\)?[-=_]+\\s ?\\(cut here\\|Environment Follows\\)")
              "\\|")
-  "*End of text which will be checked in `ispell-message'.
-If it is a string, limit at first occurrence of that regular expression.
+  "*Text beyond which `ispell-message' will not spell-check.
+If it is a string, limit is the first occurrence of that regular expression.
 Otherwise, it must be a function which is called to get the limit.")
 (put 'ispell-message-text-end 'risky-local-variable t)
 
@@ -3625,7 +3631,7 @@ Don't check included messages.
 
 To abort spell checking of a message region and send the message anyway,
 use the `x' command.  (Any subsequent regions will be checked.)
-The `X' command aborts the message send so that you can edit the buffer.
+The `X' command aborts sending the message so that you can edit the buffer.
 
 To spell-check whenever a message is sent, include the appropriate lines
 in your .emacs file:
@@ -3788,7 +3794,7 @@ You can bind this to the key C-c i in GNUS or mail by adding to
 (defun ispell-buffer-local-parsing ()
   "Place Ispell into parsing mode for this buffer.
 Overrides the default parsing mode.
-Includes Latex/Nroff modes and extended character mode."
+Includes LaTeX/Nroff modes and extended character mode."
   ;; (ispell-init-process) must already be called.
   (ispell-send-string "!\n")            ; Put process in terse mode.
   ;; We assume all major modes with "tex-mode" in them should use latex parsing
@@ -3838,7 +3844,7 @@ Includes Latex/Nroff modes and extended character mode."
 
 (defun ispell-buffer-local-dict (&optional no-reload)
   "Initializes local dictionary and local personal dictionary.
-If optional NO-RELOAD is non-nil, do not make any dictionary reloading.
+If optional NO-RELOAD is non-nil, do not reload any dictionary.
 When a dictionary is defined in the buffer (see variable
 `ispell-dictionary-keyword'), it will override the local setting
 from \\[ispell-change-dictionary].
diff --git a/lisp/url/ChangeLog b/lisp/url/ChangeLog
index 960649bdbc9..ff6a6e6f805 100644
--- a/lisp/url/ChangeLog
+++ b/lisp/url/ChangeLog
@@ -1,3 +1,8 @@
+2012-03-14  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * url-queue.el (url-queue-kill-job): Make sure that the callback
+        is always called, even if we have a timeout.
+
 2012-03-11  Chong Yidong  <cyd@gnu.org>
 
         * url-http.el (url-http-end-of-document-sentinel): Handle
diff --git a/lisp/url/url-queue.el b/lisp/url/url-queue.el
index 6e4cedddaf3..46124717fed 100644
--- a/lisp/url/url-queue.el
+++ b/lisp/url/url-queue.el
@@ -156,9 +156,20 @@ The variable `url-queue-timeout' sets a timeout."
       (while (setq process (get-buffer-process (url-queue-buffer job)))
         (set-process-sentinel process 'ignore)
         (ignore-errors
-          (delete-process process))))
-    (ignore-errors
-      (kill-buffer (url-queue-buffer job)))))
+          (delete-process process)))))
+  ;; Call the callback with an error message to ensure that the caller
+  ;; is notified that the job has failed.
+  (with-current-buffer
+      (if (bufferp (url-queue-buffer job))
+          ;; Use the (partially filled) process buffer it it exists.
+          (url-queue-buffer job)
+        ;; If not, just create a new buffer, which will probably be
+        ;; killed again by the caller.
+        (generate-new-buffer " *temp*"))
+    (apply (url-queue-callback job)
+           (cons (list :error (list 'error 'url-queue-timeout
+                                    "Queue timeout exceeded"))
+                 (url-queue-cbargs job)))))
 
 (provide 'url-queue)
 
diff --git a/lisp/vc/vc-hg.el b/lisp/vc/vc-hg.el
index f3ba009b8c2..52e8051342d 100644
--- a/lisp/vc/vc-hg.el
+++ b/lisp/vc/vc-hg.el
@@ -226,45 +226,14 @@ highlighting the Log View buffer."
 
 (defun vc-hg-working-revision (file)
   "Hg-specific version of `vc-working-revision'."
-  (let*
-      ((status nil)
-       (default-directory (file-name-directory file))
-       ;; Avoid localization of messages so we can parse the output.
-       (avoid-local-env (append (list "TERM=dumb" "LANGUAGE=C")
-                                     process-environment))
-       (out
-        (with-output-to-string
-          (with-current-buffer
-              standard-output
-            (setq status
-                  (condition-case nil
-                      (let ((process-environment avoid-local-env))
-                        ;; Ignore all errors.
-                        (process-file
-                         vc-hg-program nil t nil
-                         "--config" "alias.parents=parents"
-                         "--config" "defaults.parents="
-                         "parents" "--template" "{rev}" (file-relative-name file)))
-                    ;; Some problem happened.  E.g. We can't find an `hg'
-                    ;; executable.
-                    (error nil)))))))
-    (if (eq 0 status)
-        out
-      ;; Check if the file is in the 'added state, the above hg
-      ;; command does not distinguish between 'added and 'unregistered.
-      (setq status
-            (condition-case nil
-                (let ((process-environment avoid-local-env))
-                  (process-file
-                   vc-hg-program nil nil nil
-                   ;; We use "log" here, if there's a faster command
-                   ;; that returns true for an 'added file and false
-                   ;; for an 'unregistered one, we could use that.
-                   "log" "-l1" (file-relative-name file)))
-              ;; Some problem happened.  E.g. We can't find an `hg'
-              ;; executable.
-              (error nil)))
-      (when (eq 0 status) "0"))))
+  (let ((default-directory (if (file-directory-p file)
+                               (file-name-as-directory file)
+                             (file-name-directory file))))
+    (ignore-errors
+      (with-output-to-string
+        (process-file vc-hg-program nil standard-output nil
+                      "log" "-l" "1" "--template" "{rev}"
+                      (file-relative-name file))))))
 
 ;;; History functions
 
diff --git a/lisp/view.el b/lisp/view.el
index 4a219971097..41cb9752288 100644
--- a/lisp/view.el
+++ b/lisp/view.el
@@ -309,7 +309,11 @@ this argument instead of explicitly setting `view-exit-action'.
 Do not set EXIT-ACTION to `kill-buffer' when BUFFER visits a
 file: Users may suspend viewing in order to modify the buffer.
 Exiting View mode will then discard the user's edits.  Setting
-EXIT-ACTION to `kill-buffer-if-not-modified' avoids this."
+EXIT-ACTION to `kill-buffer-if-not-modified' avoids this.
+
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings."
   (interactive "bView buffer: ")
   (switch-to-buffer buffer)
   (if (eq (get major-mode 'mode-class) 'special)
@@ -331,7 +335,11 @@ Optional argument NOT-RETURN is ignored.
 
 Optional argument EXIT-ACTION is either nil or a function with buffer as
 argument.  This function is called when finished viewing buffer.  Use
-this argument instead of explicitly setting `view-exit-action'."
+this argument instead of explicitly setting `view-exit-action'.
+
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings."
   (interactive "bIn other window view buffer:\nP")
   (let ((pop-up-windows t))
     (pop-to-buffer buffer t))
@@ -354,7 +362,11 @@ Optional argument NOT-RETURN is ignored.
 
 Optional argument EXIT-ACTION is either nil or a function with buffer as
 argument.  This function is called when finished viewing buffer.  Use
-this argument instead of explicitly setting `view-exit-action'."
+this argument instead of explicitly setting `view-exit-action'.
+
+This function does not enable View mode if the buffer's major-mode
+has a `special' mode-class, because such modes usually have their
+own View-like bindings."
   (interactive "bView buffer in other frame: \nP")
   (let ((pop-up-frames t))
     (pop-to-buffer buffer t))