conflict resolve

86 files changed, 1837 insertions, 1057 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 41e78c7885a..e86bc7f0a96 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,269 @@
+2013-03-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * desktop.el (desktop--v2s): Rename from desktop-internal-v2s.
+        Change return value to be a sexp.  Delay `get-buffer' to after
+        restoring the desktop (bug#13951).
+
+2013-03-26  Leo Liu  <sdl.web@gmail.com>
+
+        * register.el: Move semantic tag handling back to
+        cedet/semantic/senator.el.  (Bug#14052)
+
+2013-03-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eshell/em-prompt.el (eshell-emit-prompt): Make sure we can't insert
+        into the prompt either (bug#13963).
+
+2013-03-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * font-lock.el (lisp-font-lock-keywords-2): Don't highlight the "error"
+        part of "(error-foo)".
+
+2013-03-24  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (list-matching-lines-prefix-face): New defcustom.
+        (occur-1): Pass `list-matching-lines-prefix-face' to the function
+        `occur-engine' if `face-differs-from-default-p' returns t.
+        (occur-engine): Add `,' inside backquote construct to evaluate
+        `prefix-face'.  Propertize the prefix with the `prefix-face' face.
+        Pass `prefix-face' to the functions `occur-context-lines' and
+        `occur-engine-add-prefix'.
+        (occur-engine-add-prefix, occur-context-lines): Add optional arg
+        `prefix-face' and propertize the prefix with `prefix-face'.
+        (Bug#14017)
+
+2013-03-24  Leo Liu  <sdl.web@gmail.com>
+
+        * nxml/rng-valid.el (rng-validate-while-idle)
+        (rng-validate-quick-while-idle): Guard against deleted buffer.
+        (Bug#13999)
+
+        * emacs-lisp/edebug.el (edebug-mode): Make sure edebug-kill-buffer
+        is the last entry in kill-buffer-hook.
+
+        * files.el (kill-buffer-hook): Doc fix.
+
+2013-03-23  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * emacs-lisp/lisp-mode.el (emacs-lisp-docstring-fill-column):
+        Make it safe-local.
+
+        * vc/diff-mode.el (diff-mode-shared-map): Unbind "/" (Bug#14034).
+
+2013-03-23  Leo Liu  <sdl.web@gmail.com>
+
+        * nxml/nxml-util.el (nxml-with-unmodifying-text-property-changes):
+        Remove.
+
+        * nxml/rng-valid.el (rng-validate-mode)
+        (rng-after-change-function, rng-do-some-validation):
+        * nxml/rng-maint.el (rng-validate-buffer):
+        * nxml/nxml-rap.el (nxml-tokenize-forward, nxml-ensure-scan-up-to-date):
+        * nxml/nxml-outln.el (nxml-show-all, nxml-set-outline-state):
+        * nxml/nxml-mode.el (nxml-mode, nxml-degrade, nxml-after-change)
+        (nxml-extend-after-change-region): Use with-silent-modifications.
+
+        * nxml/rng-nxml.el (rng-set-state-after): Do not let-bind
+        timer-idle-list.
+
+        * nxml/rng-valid.el (rng-validate-while-idle-continue-p)
+        (rng-next-error-1, rng-previous-error-1): Do not let-bind
+        timer-idle-list.  (Bug#13999)
+
+2013-03-23  Juri Linkov  <juri@jurta.org>
+
+        * info.el (info-index-match): New face.
+        (Info-index, Info-apropos-matches): Add a nested subgroup to the
+        main pattern and add text properties with the new face to matches
+        in index entries relative to the beginning of the index entry.
+        (Bug#14015)
+
+2013-03-21  Eric Ludlam  <zappo@gnu.org>
+
+        * eieio/eieio-datadebug.el (data-debug/eieio-insert-slots):
+        Inhibit read only while inserting objects.
+
+2013-03-22  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * progmodes/cfengine.el: Update docs to mention
+        `cfengine-auto-mode'.  Use \_> and \_< instead of \> and \< for
+        symbol motion.  Remove "_" from the word syntax.
+
+2013-03-21  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * progmodes/cfengine.el (cfengine-common-syntax): Add "_" to word
+        syntax for both `cfengine2-mode' and `cfengine3-mode'.
+
+2013-03-20  Juri Linkov  <juri@jurta.org>
+
+        * info.el (Info-next-reference-or-link)
+        (Info-prev-reference-or-link): New functions.
+        (Info-next-reference, Info-prev-reference): Use them.
+        (Info-try-follow-nearest-node): Handle footnote navigation.
+        (Info-fontify-node): Fontify footnotes.  (Bug#13989)
+
+2013-03-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * subr.el (posn-point, posn-string): Fix it here instead (bug#13979).
+        * mouse.el (mouse-on-link-p): Undo scroll-bar fix.
+
+2013-03-20  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Suppress unnecessary non-ASCII chatter during build process.
+        * international/ja-dic-cnv.el (skkdic-collect-okuri-nasi)
+        (batch-skkdic-convert): Suppress most of the chatter.
+        It's not needed so much now that machines are faster,
+        and its non-ASCII component was confusing; see Dmitry Gutov in
+        <http://lists.gnu.org/archive/html/emacs-devel/2013-03/msg00508.html>.
+
+2013-03-20  Leo Liu  <sdl.web@gmail.com>
+
+        * ido.el (ido-chop): Fix bug#10994.
+
+2013-03-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * whitespace.el (whitespace-font-lock, whitespace-font-lock-mode):
+        Remove vars.
+        (whitespace-color-on, whitespace-color-off):
+        Use `font-lock-fontify-buffer' (Bug#13817).
+
+2013-03-19  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * mouse.el (mouse--down-1-maybe-follows-link): Fix follow-link
+        remapping in mode-line.
+        (mouse-on-link-p): Also check [mode-line follow-link] bindings.
+
+2013-03-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * whitespace.el (whitespace-color-on): Use `prepend' OVERRIDE
+        value for `whitespace-line' face (Bug#13875).
+        (whitespace-font-lock-keywords): Change description.
+        (whitespace-color-on): Don't save `font-lock-keywords' value, save
+        the constructed keywords instead.
+        (whitespace-color-off): Use `font-lock-remove-keywords' (Bug#13817).
+
+2013-03-19  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/compile.el (compilation-display-error): New command.
+        (compilation-mode-map, compilation-minor-mode-map): Bind it to
+        C-o.  (Bug#13992)
+
+2013-03-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * term/x-win.el (x-keysym-pair): Add a Fixme (Bug#13936).
+
+2013-03-18  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * mouse.el (mouse-on-link-p): Check for scroll bar (Bug#13979).
+
+2013-03-18  Michael Albinus  <michael.albinus@gmx.de>
+
+        * net/tramp-compat.el (tramp-compat-user-error): New defun.
+
+        * net/tramp-adb.el (tramp-adb-handle-shell-command):
+        * net/tramp-gvfs.el (top):
+        * net/tramp.el (tramp-find-method, tramp-dissect-file-name)
+        (tramp-handle-shell-command): Use it.
+        (tramp-dissect-file-name): Raise an error when hostname is a
+        method name, and neither method nor user is specified.
+
+        * net/trampver.el: Update release number.
+
+2013-03-18  Leo Liu  <sdl.web@gmail.com>
+
+        Make sure eldoc can be turned off properly.
+        * emacs-lisp/eldoc.el (eldoc-schedule-timer): Conditionalize on
+        eldoc-mode.
+        (eldoc-display-message-p): Revert last change.
+        (eldoc-display-message-no-interference-p)
+        (eldoc-print-current-symbol-info): Tweak.
+
+2013-03-18  Tassilo Horn  <tsdh@gnu.org>
+
+        * doc-view.el (doc-view-new-window-function): Check the new window
+        overlay's display property instead the char property of the
+        buffer's first char.  Use `with-selected-window' instead of
+        `save-window-excursion' with `select-window'.
+        (doc-view-document->bitmap): Check the current doc-view overlay's
+        display property instead the char property of the buffer's first char.
+
+2013-03-18  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Automate the build of ja-dic.el (Bug#13984).
+        * international/ja-dic-cnv.el (skkdic-convert): Remove the annotations
+        from the input, rather than assume that it's been done for us by the
+        SKK script unannotate.awk.  Switch ja-dic.el to UTF-8.  Don't put
+        the current date into a ja-dic.el comment, as that complicates
+        regression testing.
+
+2013-03-18  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * whitespace.el: Fix double evaluation.
+        (whitespace-space, whitespace-hspace, whitespace-tab)
+        (whitespace-newline, whitespace-trailing, whitespace-line)
+        (whitespace-space-before-tab, whitespace-indentation)
+        (whitespace-empty, whitespace-space-after-tab): Turn defcustoms into
+        obsolete defvars.
+        (whitespace-hspace-regexp): Fix regexp for emacs-unicode.
+        (whitespace-color-on): Use a single font-lock-add-keywords call.
+        Fix double-evaluation of face variables.
+
+2013-03-17  Michael Albinus  <michael.albinus@gmx.de>
+
+        * net/tramp-adb.el (tramp-adb-parse-device-names):
+        Use `start-process' instead of `call-process'.  Otherwise, the
+        function might be blocked under MS Windows.  (Bug#13299)
+
+2013-03-17  Leo Liu  <sdl.web@gmail.com>
+
+        Extend eldoc to display info in the mode-line.  (Bug#13978)
+        * emacs-lisp/eldoc.el (eldoc-post-insert-mode): New minor mode.
+        (eldoc-mode-line-string): New variable.
+        (eldoc-minibuffer-message): New function.
+        (eldoc-message-function): New variable.
+        (eldoc-message): Use it.
+        (eldoc-display-message-p)
+        (eldoc-display-message-no-interference-p):
+        Support eldoc-post-insert-mode.
+
+        * simple.el (eval-expression-minibuffer-setup-hook): New hook.
+        (eval-expression): Run it.
+
+2013-03-17  Roland Winkler  <winkler@gnu.org>
+
+        * emacs-lisp/crm.el (completing-read-multiple): Ignore empty
+        strings in the list of return values.
+
+2013-03-17  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * calc/calc-ext.el (math-read-number-fancy): Check for an explicit
+        radix before checking for HMS forms.
+
+2013-03-16  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/scheme.el: Add indentation and font-locking for λ.
+        (Bug#13975)
+
+2013-03-16  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/smie.el (smie-auto-fill): Don't inf-loop if there's no
+        token before point (bug#13942).
+
+2013-03-16  Leo Liu  <sdl.web@gmail.com>
+
+        * thingatpt.el (end-of-sexp): Fix bug#13952.  Use syntax-after.
+
+2013-03-16  Glenn Morris  <rgm@gnu.org>
+
+        * Version 24.3 released.
+
+2013-03-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * startup.el (command-line-normalize-file-name): Fix handling of
+        backslashes in DOS and Windows file names.  Reported by Xue Fuqiao
+        <xfq.free@gmail.com> in
+        http://lists.gnu.org/archive/html/help-gnu-emacs/2013-03/msg00245.html.
+
 2013-03-15  Michael Albinus  <michael.albinus@gmx.de>
 
         Sync with Tramp 2.2.7.
@@ -564,6 +830,11 @@
         Let-bind `isearch-other-end' to `start', `isearch-forward' to t
         and `isearch-error' to nil.
 
+2013-03-16  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el (python-info-current-defun):
+        Enhance match-data cluttering prevention.
+
 2013-02-22  Michael Albinus  <michael.albinus@gmx.de>
 
         * net/tramp.el (tramp-tramp-file-p): Fix docstring.
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 57de072fdc7..2cb5bf450d5 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -2945,50 +2945,6 @@ If X is not an error form, return 1."
       (and x sigma (math-scalarp x) (math-anglep sigma)
            (list 'sdev x sigma))))
 
-   ;; Hours (or degrees)
-   ((or (string-match "^\\([^#^]+\\)[@oOhH]\\(.*\\)$" s)
-        (string-match "^\\([^#^]+\\)[dD][eE]?[gG]?\\(.*\\)$" s))
-    (let* ((hours (math-match-substring s 1))
-           (minsec (math-match-substring s 2))
-           (hours (math-read-number hours))
-           (minsec (if (> (length minsec) 0) (math-read-number minsec) 0)))
-      (and hours minsec
-           (math-num-integerp hours)
-           (not (math-negp hours)) (not (math-negp minsec))
-           (cond ((math-num-integerp minsec)
-                  (and (Math-lessp minsec 60)
-                       (list 'hms hours minsec 0)))
-                 ((and (eq (car-safe minsec) 'hms)
-                       (math-zerop (nth 1 minsec)))
-                  (math-add (list 'hms hours 0 0) minsec))
-                 (t nil)))))
-
-   ;; Minutes
-   ((string-match "^\\([^'#^]+\\)[mM']\\(.*\\)$" s)
-    (let* ((minutes (math-match-substring s 1))
-           (seconds (math-match-substring s 2))
-           (minutes (math-read-number minutes))
-           (seconds (if (> (length seconds) 0) (math-read-number seconds) 0)))
-      (and minutes seconds
-           (math-num-integerp minutes)
-           (not (math-negp minutes)) (not (math-negp seconds))
-           (cond ((math-realp seconds)
-                  (and (Math-lessp minutes 60)
-                       (list 'hms 0 minutes seconds)))
-                 ((and (eq (car-safe seconds) 'hms)
-                       (math-zerop (nth 1 seconds))
-                       (math-zerop (nth 2 seconds)))
-                  (math-add (list 'hms 0 minutes 0) seconds))
-                 (t nil)))))
-
-   ;; Seconds
-   ((string-match "^\\([^\"#^]+\\)[sS\"]$" s)
-    (let ((seconds (math-read-number (math-match-substring s 1))))
-      (and seconds (math-realp seconds)
-           (not (math-negp seconds))
-           (Math-lessp seconds 60)
-           (list 'hms 0 0 seconds))))
-
    ;; Integer+fraction with explicit radix
    ((string-match "^\\([0-9]+\\)\\(#\\|\\^\\^\\)\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]*\\)[:/]\\([0-9a-zA-Z]\\)$" s)
     (let ((radix (string-to-number (math-match-substring s 1)))
@@ -3061,6 +3017,50 @@ If X is not an error form, return 1."
     (let ((digs (math-match-substring s 1)))
       (math-read-radix digs 16)))
 
+   ;; Hours (or degrees)
+   ((or (string-match "^\\([^#^]+\\)[@oOhH]\\(.*\\)$" s)
+        (string-match "^\\([^#^]+\\)[dD][eE]?[gG]?\\(.*\\)$" s))
+    (let* ((hours (math-match-substring s 1))
+           (minsec (math-match-substring s 2))
+           (hours (math-read-number hours))
+           (minsec (if (> (length minsec) 0) (math-read-number minsec) 0)))
+      (and hours minsec
+           (math-num-integerp hours)
+           (not (math-negp hours)) (not (math-negp minsec))
+           (cond ((math-num-integerp minsec)
+                  (and (Math-lessp minsec 60)
+                       (list 'hms hours minsec 0)))
+                 ((and (eq (car-safe minsec) 'hms)
+                       (math-zerop (nth 1 minsec)))
+                  (math-add (list 'hms hours 0 0) minsec))
+                 (t nil)))))
+
+   ;; Minutes
+   ((string-match "^\\([^'#^]+\\)[mM']\\(.*\\)$" s)
+    (let* ((minutes (math-match-substring s 1))
+           (seconds (math-match-substring s 2))
+           (minutes (math-read-number minutes))
+           (seconds (if (> (length seconds) 0) (math-read-number seconds) 0)))
+      (and minutes seconds
+           (math-num-integerp minutes)
+           (not (math-negp minutes)) (not (math-negp seconds))
+           (cond ((math-realp seconds)
+                  (and (Math-lessp minutes 60)
+                       (list 'hms 0 minutes seconds)))
+                 ((and (eq (car-safe seconds) 'hms)
+                       (math-zerop (nth 1 seconds))
+                       (math-zerop (nth 2 seconds)))
+                  (math-add (list 'hms 0 minutes 0) seconds))
+                 (t nil)))))
+
+   ;; Seconds
+   ((string-match "^\\([^\"#^]+\\)[sS\"]$" s)
+    (let ((seconds (math-read-number (math-match-substring s 1))))
+      (and seconds (math-realp seconds)
+           (not (math-negp seconds))
+           (Math-lessp seconds 60)
+           (list 'hms 0 0 seconds))))
+
    ;; Fraction using "/" instead of ":"
    ((string-match "^\\([0-9]+\\)/\\([0-9/]+\\)$" s)
     (math-read-number (concat (math-match-substring s 1) ":"
diff --git a/lisp/cedet/ChangeLog b/lisp/cedet/ChangeLog
index 2ccce8bb01d..8b914e8843e 100644
--- a/lisp/cedet/ChangeLog
+++ b/lisp/cedet/ChangeLog
@@ -1,3 +1,180 @@
+2013-03-26  Leo Liu  <sdl.web@gmail.com>
+
+        * semantic/senator.el (senator-copy-tag-to-register): Move
+        register handling logic from register.el.  (Bug#14052)
+
+2013-03-21  Eric Ludlam  <zappo@gnu.org>
+
+        * semantic.el (navigate-menu): Yank Tag :enable. Make sure
+        `senator-tag-ring' is bound.
+        (semantic-parse-region-default): Stop reversing the output of
+        parse-whole-stream.
+        (semantic-repeat-parse-whole-stream): Append returned tags
+        differently, so they come out in the right order.
+
+        * semantic/sb.el (semantic-sb-filter-tags-of-class): New option.
+        (semantic-sb-fetch-tag-table): Filter tags being bucketed to
+        exclude tags belonging to above filtered classes.
+
+        * semantic/find.el (semantic-filter-tags-by-class): New function.
+
+        * semantic/tag-ls.el (semantic-tag-similar-p-default): Add
+        short-circuit in case tag1 and 2 are identical.
+
+        * semantic/analyze/fcn.el
+        (semantic-analyze-dereference-metatype-stack): Use
+        `semantic-tag-similar-p' instead of 'eq' when comparing two tags
+        during metatype evaluation in case they are the same, but not the
+        same node. (Tweaked patch from Tomasz Gajewski) (Tiny change)
+
+        * semantic/db-find.el (semanticdb-partial-synchronize): Fix
+        require to semantic/db-typecache to be correct.
+        (semanticdb-find-tags-external-children-of-type): Make this a
+        brutish search by default.
+
+        * semantic/sort.el
+        (semantic-tag-external-member-children-default): When calling
+        `semanticdb-find-tags-external-children-of-type', pass in the
+        input tag as the place to start searching for externally defined
+        methods.
+
+        * semantic/db-file.el (semanticdb-default-save-directory): Doc
+        fix: Add ref to default value.
+
+        * semantic/complete.el (semantic-complete-post-command-hook): When
+        detecting if cursor is outside completion area, do so if cursor
+        moves before start of overlay, or the original starting location
+        of the overlay (i.e., if user deletes past beginning of the
+        overlay region).
+        (semantic-complete-inline-tag-engine): Initialize original start
+        of `semantic-complete-inline-overlay'.
+
+        * semantic/bovine/c.el (semantic-c-describe-environment): Update
+        some section titles.  Test semanticdb table before printing it.
+        (semantic-c-reset-preprocessor-symbol-map): Update
+        `semantic-lex-spp-macro-symbol-obarray' outside the loop over all
+        the files contributing to its value.
+        (semantic-c-describe-environment): If there is an EDE project but
+        no spp symbols from it, say so.
+
+        * srecode/args.el (srecode-semantic-handle-:project): New argument
+        handler. Provide variable values if not in an EDE project.
+
+        * srecode/srt-mode.el (srecode-template-mode): Fix typo on srecode
+        name.
+
+        * srecode/cpp.el (srecode-semantic-handle-:c): Replace all
+        characters in FILENAME_SYMBOL that aren't valid CPP symbol chars.
+
+        * srecode/map.el (srecode-map-validate-file-for-mode): Force
+        semantic to load if it is not active in the template being added
+        to the map.
+
+        * srecode/srt.el: Add local variables for setting the autoload
+        file name.
+        (srecode-semantic-handle-:srt): New autoload cookie
+
+        * ede.el (ede-apply-preprocessor-map): Apply map to
+        `semantic-lex-spp-project-macro-symbol-obarray' instead of the
+        system one. Add require for semantic.
+
+        * ede/proj-elisp.el (ede-update-version-in-source): In case a file
+        has both a version variable and a Version: comment, always use
+        `call-next-method'.
+
+        * ede/cpp-root.el (ede-set-project-variables): Deleted.
+        `ede-preprocessor-map' does the job this function was attempting
+        to do with :spp-table.
+        (ede-preprocessor-map): Update file tests to provide better
+        messages.  Do not try to get symbols from a file that is the file
+        in the current buffer.
+
+        * ede/base.el (ede-project-placeholder): Add more documentation to
+        :file slot.
+        (ede-load-cache): Use `insert-file-contents' instead of
+        `find-file-noselect' in order to avoid activating other tools.
+
+2013-03-21  David Engster  <deng@randomsample.de>
+
+        * semantic/bovine/c.el (semantic-get-local-variables): Also add a
+        new variable 'this' if we are in an inline member function.  For
+        detecting this, we check overlays at point if there is a class
+        spanning the current function.  Also, the variable 'this' has to
+        be a pointer.
+
+        * semantic/bovine/gcc.el (semantic-gcc-setup): Fail gracefully
+        when querying g++ for defines returns an error.
+
+        * srecode/srt-mode.el:
+        * srecode/compile.el:
+        * semantic/elp.el:
+        * semantic/db-el.el:
+        * semantic/complete.el:
+        * ede.el:
+        * cogre.el:
+        * srecode/table.el:
+        * srecode/mode.el:
+        * srecode/insert.el:
+        * srecode/compile.el:
+        * semantic/decorate/include.el:
+        * semantic/db.el:
+        * semantic/adebug.el:
+        * ede/auto.el:
+        * srecode/dictionary.el:
+        * semantic/ede-grammar.el:
+        * semantic/db.el:
+        * semantic/db-find.el:
+        * semantic/db-file.el:
+        * semantic/complete.el:
+        * semantic/bovine/c.el:
+        * semantic/analyze.el:
+        * ede/util.el:
+        * ede/proj.el:
+        * ede/proj-elisp.el:
+        * ede/pconf.el:
+        * ede/locate.el:
+        * ede.el: Adapt to EIEIO namespace cleanup: Rename `object-name'
+        to `eieio-object-name', `object-set-name-string' to
+        `eieio-object-set-name-string', `object-class' to
+        `eieio-object-class', `class-parent' to `eieio-class-parent',
+        `class-parents' to `eieio-class-parents', `class-children' to
+        `eieio-class-children', `object-name-string' to
+        `eieio-object-name-string', `object-class-fast' to
+        `eieio--object-class'. Also replace direct access with new
+        accessor functions.
+
+2013-03-21  Tomasz Gajewski <tomga@wp.pl> (tiny change)
+
+        * ede/cpp-root.el (ede-project-autoload, initialize-instance): Fix
+        EDE file symbol to match rename.  Fix ede-cpp-root symbol to
+        include -project in name.
+
+2013-03-21  Alex Ott <alexott@gmail.com>
+
+        * cedet-files.el (cedet-files-list-recursively): New.  Recursively
+        find files whose names are matching to given regex
+
+        * ede.el (ede-current-project): Rewrite to avoid imperative style.
+
+        * ede/files.el (ede-find-file): Simplify code.
+
+        * ede/base.el (ede-normalize-file/directory): Add function to
+        normalize :file or :directory slots if they are missing.
+
+        * ede/cpp-root.el (ede-cpp-root-project): Add compile-command
+        slot.
+        (project-compile-project): Compiles project using value specified
+        in :compule-command slot or in compile-command local variable.
+        Value of slot or local variable could be string or function that
+        receives project and should return string that will be invoked as
+        command.
+        (project-compile-target): Invokes compilation of whole project
+
+        * ede/files.el (ede-find-project-root): New function to
+        find root of project that contains specific file.
+        (ede-files-find-existing): New function which checks presence of
+        given directory in the list of registered projects.
+
 2013-03-04  Paul Eggert  <eggert@cs.ucla.edu>
 
         * semantic/wisent/wisent.el (wisent): Stick to ASCII in the ASCII art.
diff --git a/lisp/cedet/cedet-files.el b/lisp/cedet/cedet-files.el
index 36561090bd2..236040befb8 100644
--- a/lisp/cedet/cedet-files.el
+++ b/lisp/cedet/cedet-files.el
@@ -88,6 +88,24 @@ specific conversions during tests."
         (setq file (concat "//" (substring file 1)))))
     file))
 
+(defun cedet-files-list-recursively (dir re)
+  "Returns list of files in directory matching to given regex"
+  (when (file-accessible-directory-p dir)
+    (let ((files (directory-files dir t))
+          matched)
+      (dolist (file files matched)
+        (let ((fname (file-name-nondirectory file)))
+          (cond
+           ((or (string= fname ".")
+                (string= fname "..")) nil)
+           ((and (file-regular-p file)
+                 (string-match re fname))
+            (setq matched (cons file matched)))
+           ((file-directory-p file)
+            (let ((tfiles (cedet-files-list-recursively file re)))
+              (when tfiles (setq matched (append matched tfiles)))))))))))
+
+
 (provide 'cedet-files)
 
 ;;; cedet-files.el ends here
diff --git a/lisp/cedet/ede.el b/lisp/cedet/ede.el
index 3867f628b93..5fecd8b994f 100644
--- a/lisp/cedet/ede.el
+++ b/lisp/cedet/ede.el
@@ -330,14 +330,14 @@ Argument MENU-DEF is the menu definition to use."
    (easy-menu-create-menu
     "Project Forms"
     (let* ((obj (ede-current-project))
-           (class (if obj (object-class obj)))
+           (class (if obj (eieio-object-class obj)))
            (menu nil))
       (condition-case err
           (progn
             (while (and class (slot-exists-p class 'menu))
               ;;(message "Looking at class %S" class)
               (setq menu (append menu (oref class menu))
-                    class (class-parent class))
+                    class (eieio-class-parent class))
               (if (listp class) (setq class (car class))))
             (append
              '( [ "Add Target" ede-new-target (ede-current-project) ]
@@ -382,7 +382,7 @@ but can also be used interactively."
                             (oref proj configuration-default)))))
   (oset (ede-current-project) configuration-default newconfig)
   (message "%s will now build in %s mode."
-           (object-name (ede-current-project))
+           (eieio-object-name (ede-current-project))
            newconfig))
 
 (defun ede-customize-forms-menu (menu-def)
@@ -727,7 +727,7 @@ Optional argument NAME is the name to give this project."
                            'name
                            (let* ((l ede-project-class-files)
                                   (cp (ede-current-project))
-                                  (cs (when cp (object-class cp)))
+                                  (cs (when cp (eieio-object-class cp)))
                                   (r nil))
                              (while l
                                (if cs
@@ -779,7 +779,7 @@ Optional argument NAME is the name to give this project."
                                 :targets nil)))
          (inits (oref obj initializers)))
     ;; Force the name to match for new objects.
-    (object-set-name-string nobj (oref nobj :name))
+    (eieio-object-set-name-string nobj (oref nobj :name))
     ;; Handle init args.
     (while inits
       (eieio-oset nobj (car inits) (car (cdr inits)))
@@ -885,7 +885,7 @@ a string \"y\" or \"n\", which answers the y/n question done interactively."
   (when (not ede-object)
     (error "Can't add %s to target %s: Wrong file type"
            (file-name-nondirectory (buffer-file-name))
-           (object-name target)))
+           (eieio-object-name target)))
   (ede-apply-target-options))
 
 (defun ede-remove-file (&optional force)
@@ -979,12 +979,12 @@ Argument PROMPT is the prompt to use when querying the user for a target."
 (defmethod project-add-file ((ot ede-target) file)
   "Add the current buffer into project project target OT.
 Argument FILE is the file to add."
-  (error "add-file not supported by %s" (object-name ot)))
+  (error "add-file not supported by %s" (eieio-object-name ot)))
 
 (defmethod project-remove-file ((ot ede-target) fnnd)
   "Remove the current buffer from project target OT.
 Argument FNND is an argument."
-  (error "remove-file not supported by %s" (object-name ot)))
+  (error "remove-file not supported by %s" (eieio-object-name ot)))
 
 (defmethod project-edit-file-target ((ot ede-target))
   "Edit the target OT associated with this file."
@@ -992,45 +992,45 @@ Argument FNND is an argument."
 
 (defmethod project-new-target ((proj ede-project) &rest args)
   "Create a new target.  It is up to the project PROJ to get the name."
-  (error "new-target not supported by %s" (object-name proj)))
+  (error "new-target not supported by %s" (eieio-object-name proj)))
 
 (defmethod project-new-target-custom ((proj ede-project))
   "Create a new target.  It is up to the project PROJ to get the name."
-  (error "New-target-custom not supported by %s" (object-name proj)))
+  (error "New-target-custom not supported by %s" (eieio-object-name proj)))
 
 (defmethod project-delete-target ((ot ede-target))
   "Delete the current target OT from its parent project."
-  (error "add-file not supported by %s" (object-name ot)))
+  (error "add-file not supported by %s" (eieio-object-name ot)))
 
 (defmethod project-compile-project ((obj ede-project) &optional command)
   "Compile the entire current project OBJ.
 Argument COMMAND is the command to use when compiling."
-  (error "compile-project not supported by %s" (object-name obj)))
+  (error "compile-project not supported by %s" (eieio-object-name obj)))
 
 (defmethod project-compile-target ((obj ede-target) &optional command)
   "Compile the current target OBJ.
 Argument COMMAND is the command to use for compiling the target."
-  (error "compile-target not supported by %s" (object-name obj)))
+  (error "compile-target not supported by %s" (eieio-object-name obj)))
 
 (defmethod project-debug-target ((obj ede-target))
   "Run the current project target OBJ in a debugger."
-  (error "debug-target not supported by %s" (object-name obj)))
+  (error "debug-target not supported by %s" (eieio-object-name obj)))
 
 (defmethod project-run-target ((obj ede-target))
   "Run the current project target OBJ."
-  (error "run-target not supported by %s" (object-name obj)))
+  (error "run-target not supported by %s" (eieio-object-name obj)))
 
 (defmethod project-make-dist ((this ede-project))
   "Build a distribution for the project based on THIS project."
-  (error "Make-dist not supported by %s" (object-name this)))
+  (error "Make-dist not supported by %s" (eieio-object-name this)))
 
 (defmethod project-dist-files ((this ede-project))
   "Return a list of files that constitute a distribution of THIS project."
-  (error "Dist-files is not supported by %s" (object-name this)))
+  (error "Dist-files is not supported by %s" (eieio-object-name this)))
 
 (defmethod project-rescan ((this ede-project))
   "Rescan the EDE project THIS."
-  (error "Rescanning a project is not supported by %s" (object-name this)))
+  (error "Rescanning a project is not supported by %s" (eieio-object-name this)))
 
 (defun ede-ecb-project-paths ()
   "Return a list of all paths for all active EDE projects.
@@ -1157,18 +1157,15 @@ Optional argument OBJ is an object to find the parent of."
 (defun ede-current-project (&optional dir)
   "Return the current project file.
 If optional DIR is provided, get the project for DIR instead."
-  (let ((ans nil))
-    ;; If it matches the current directory, do we have a pre-existing project?
-    (when (and (or (not dir) (string= dir default-directory))
-               ede-object-project)
-      (setq ans ede-object-project)
-      )
+  ;; If it matches the current directory, do we have a pre-existing project?
+  (let ((proj (when (and (or (not dir) (string= dir default-directory))
+                        ede-object-project)
+                ede-object-project)))
     ;; No current project.
-    (when (not ans)
+    (if proj
+        proj
       (let* ((ldir (or dir default-directory)))
-        (setq ans (ede-directory-get-open-project ldir))))
-    ;; Return what we found.
-    ans))
+        (ede-directory-get-open-project ldir)))))
 
 (defun ede-buffer-object (&optional buffer projsym)
   "Return the target object for BUFFER.
@@ -1372,20 +1369,24 @@ and <root>/doc for doc sources."
 ;; C/C++
 (defun ede-apply-preprocessor-map ()
   "Apply preprocessor tables onto the current buffer."
+  ;; TODO - what if semantic-mode isn't enabled?
+  ;; what if we never want to load a C mode? Does this matter?
+  ;; Note: This require is needed for the case where EDE ends up
+  ;; in the hook order before Semantic based hooks.
+  (require 'semantic/lex-spp)
   (when (and ede-object
-             (boundp 'semantic-lex-spp-macro-symbol-obarray)
-             semantic-lex-spp-macro-symbol-obarray)
+             (boundp 'semantic-lex-spp-project-macro-symbol-obarray))
     (let* ((objs ede-object)
            (map (ede-preprocessor-map (if (consp objs)
                                           (car objs)
                                         objs))))
       (when map
         ;; We can't do a require for the below symbol.
-        (setq semantic-lex-spp-macro-symbol-obarray
+        (setq semantic-lex-spp-project-macro-symbol-obarray
               (semantic-lex-make-spp-table map)))
       (when (consp objs)
         (message "Choosing preprocessor syms for project %s"
-                 (object-name (car objs)))))))
+                 (eieio-object-name (car objs)))))))
 
 (defmethod ede-system-include-path ((this ede-project))
   "Get the system include path used by project THIS."
diff --git a/lisp/cedet/ede/auto.el b/lisp/cedet/ede/auto.el
index 22fce372e24..c0baf0fc8f8 100644
--- a/lisp/cedet/ede/auto.el
+++ b/lisp/cedet/ede/auto.el
@@ -199,8 +199,8 @@ added.  Possible values are:
             front of the list so more generic projects don't get priority."
   ;; First, can we identify PROJAUTO as already in the list?  If so, replace.
   (let ((projlist ede-project-class-files)
-        (projname (object-name-string projauto)))
-    (while (and projlist (not (string= (object-name-string (car projlist)) projname)))
+        (projname (eieio-object-name-string projauto)))
+    (while (and projlist (not (string= (eieio-object-name-string (car projlist)) projname)))
       (setq projlist (cdr projlist)))
 
     (if projlist
diff --git a/lisp/cedet/ede/base.el b/lisp/cedet/ede/base.el
index 1368ea348a0..5302ac3207a 100644
--- a/lisp/cedet/ede/base.el
+++ b/lisp/cedet/ede/base.el
@@ -135,7 +135,9 @@ other desired outcome.")
    (dirinode :documentation "The inode id for :directory.")
    (file :type string
          :initarg :file
-         :documentation "File name where this project is stored.")
+         :documentation "The File uniquely tagging this project instance.
+For some project types, this will be the file that stores the project configuration.
+In other projects types, this file is merely a unique identifier to this type of project.")
    (rootproject ; :initarg - no initarg, don't save this slot!
     :initform nil
     :type (or null ede-project-placeholder-child)
@@ -350,12 +352,12 @@ All specific project types must derive from this project."
 (defun ede-load-cache ()
   "Load the cache of EDE projects."
   (save-excursion
-    (let ((cachebuffer nil))
+    (let ((cachebuffer (get-buffer-create "*ede cache*")))
       (condition-case nil
-          (progn
-            (setq cachebuffer
-                  (find-file-noselect ede-project-placeholder-cache-file t))
-            (set-buffer cachebuffer)
+          (with-current-buffer cachebuffer
+            (erase-buffer)
+            (when (file-exists-p ede-project-placeholder-cache-file)
+              (insert-file-contents ede-project-placeholder-cache-file))
             (goto-char (point-min))
             (let ((c (read (current-buffer)))
                   (new nil)
@@ -610,6 +612,28 @@ instead of the current project."
               cp)))))
 
 
+;;; Utility functions
+;;
+
+(defun ede-normalize-file/directory (this project-file-name)
+  "Fills :directory or :file slots if they're missing in project THIS.
+The other slot will be used to calculate values.
+PROJECT-FILE-NAME is a name of project file (short name, like 'pom.xml', etc."
+  (when (and (or (not (slot-boundp this :file))
+                 (not (oref this :file)))
+             (slot-boundp this :directory)
+             (oref this :directory))
+    (oset this :file (expand-file-name project-file-name (oref this :directory))))
+  (when (and (or (not (slot-boundp this :directory))
+                 (not (oref this :directory)))
+             (slot-boundp this :file)
+             (oref this :file))
+    (oset this :directory (file-name-directory (oref this :file))))
+  )
+
+
+
+
 ;;; Hooks & Autoloads
 ;;
 ;;  These let us watch various activities, and respond appropriately.
diff --git a/lisp/cedet/ede/cpp-root.el b/lisp/cedet/ede/cpp-root.el
index d31ede723cc..cf2009ced30 100644
--- a/lisp/cedet/ede/cpp-root.el
+++ b/lisp/cedet/ede/cpp-root.el
@@ -242,11 +242,11 @@ ROOTPROJ is nil, since there is only one project."
 (ede-add-project-autoload
  (ede-project-autoload "cpp-root"
                        :name "CPP ROOT"
-                       :file 'ede-cpp-root
+                       :file 'ede/cpp-root
                        :proj-file 'ede-cpp-root-project-file-for-dir
                        :proj-root 'ede-cpp-root-project-root
                        :load-type 'ede-cpp-root-load
-                       :class-sym 'ede-cpp-root
+                       :class-sym 'ede-cpp-root-project
                        :new-p nil
                        :safe-p t)
  ;; When a user creates one of these, it should override any other project
@@ -272,10 +272,12 @@ ROOTPROJ is nil, since there is only one project."
 ;; level include paths, and PreProcessor macro tables.
 
 (defclass ede-cpp-root-target (ede-target)
-  ()
+  ((project :initform nil
+            :initarg :project))
   "EDE cpp-root project target.
 All directories need at least one target.")
 
+;;;###autoload
 (defclass ede-cpp-root-project (ede-project eieio-instance-tracker)
   ((tracking-symbol :initform 'ede-cpp-root-project-list)
    (include-path :initarg :include-path
@@ -339,6 +341,15 @@ The function symbol must take two arguments:
 It should return the fully qualified file name passed in from NAME.  If that file does not
 exist, it should return nil."
                )
+   (compile-command :initarg :compile-command
+                    :initform nil
+                    :type (or null string function)
+                    :documentation
+                    "Compilation command that will be used for this project.
+It could be string or function that will accept proj argument and should return string.
+The string will be passed to 'compuile' function that will be issued in root
+directory of project."
+                    )
    )
   "EDE cpp-root project class.
 Each directory needs a project file to control it.")
@@ -366,7 +377,7 @@ Each directory needs a project file to control it.")
     (when (or (not (file-exists-p f))
               (file-directory-p f))
       (delete-instance this)
-      (error ":file for ede-cpp-root must be a file"))
+      (error ":file for ede-cpp-root-project must be a file"))
     (oset this :file f)
     (oset this :directory (file-name-directory f))
     (ede-project-directory-remove-hash (file-name-directory f))
@@ -404,7 +415,8 @@ If one doesn't exist, create a new one for this directory."
                  :name (file-name-nondirectory
                         (directory-file-name dir))
                  :path dir
-                 :source nil))
+                 :source nil
+                 :project proj))
       (object-add-to-list proj :targets ans)
       )
     ans))
@@ -481,15 +493,6 @@ This is for project include paths and spp source files."
 
     filename))
 
-(defmethod ede-set-project-variables ((project ede-cpp-root-project) &optional buffer)
-  "Set variables local to PROJECT in BUFFER.
-Also set up the lexical preprocessor map."
-  (call-next-method)
-  (when (and (featurep 'semantic/bovine/c) (featurep 'semantic/lex-spp))
-    (setq semantic-lex-spp-project-macro-symbol-obarray
-          (semantic-lex-make-spp-table (oref project spp-table)))
-    ))
-
 (defmethod ede-system-include-path ((this ede-cpp-root-project))
   "Get the system include path used by project THIS."
   (oref this system-include-path))
@@ -506,11 +509,18 @@ Also set up the lexical preprocessor map."
               (table (when expfile
                        (semanticdb-file-table-object expfile)))
               )
-         (if (not table)
-             (message "Cannot find file %s in project." F)
+         (cond 
+          ((not (file-exists-p expfile))
+           (message "Cannot find file %s in project." F))
+          ((string= expfile (buffer-file-name))
+           ;; Don't include this file in it's own spp table.
+           )
+          ((not table)
+           (message "No db table available for %s." expfile))
+          (t
            (when (semanticdb-needs-refresh-p table)
              (semanticdb-refresh-table table))
-           (setq spp (append spp (oref table lexical-table))))))
+           (setq spp (append spp (oref table lexical-table)))))))
      (oref this spp-files))
     spp))
 
@@ -522,6 +532,29 @@ Also set up the lexical preprocessor map."
   "Get the pre-processor map for project THIS."
   (ede-preprocessor-map  (ede-target-parent this)))
 
+(defmethod project-compile-project ((proj ede-cpp-root-project) &optional command)
+  "Compile the entire current project PROJ.
+Argument COMMAND is the command to use when compiling."
+  ;; we need to be in the proj root dir for this to work
+  (let* ((cmd (oref proj :compile-command))
+         (ov (oref proj :local-variables))
+         (lcmd (when ov (cdr (assoc 'compile-command ov))))
+         (cmd-str (cond
+                   ((stringp cmd) cmd)
+                   ((functionp cmd) (funcall cmd proj))
+                   ((stringp lcmd) lcmd)
+                   ((functionp lcmd) (funcall lcmd proj)))))
+    (when cmd-str
+        (let ((default-directory (ede-project-root-directory proj)))
+        (compile cmd-str)))))
+
+(defmethod project-compile-target ((obj ede-cpp-root-target) &optional command)
+  "Compile the current target OBJ.
+Argument COMMAND is the command to use for compiling the target."
+  (when (oref obj :project)
+    (project-compile-project (oref obj :project) command)))
+
+
 ;;; Quick Hack
 (defun ede-create-lots-of-projects-under-dir (dir projfile &rest attributes)
   "Create a bunch of projects under directory DIR.
diff --git a/lisp/cedet/ede/emacs.el b/lisp/cedet/ede/emacs.el
index 925730c8121..f5a85f4a01b 100644
--- a/lisp/cedet/ede/emacs.el
+++ b/lisp/cedet/ede/emacs.el
@@ -59,7 +59,7 @@ DIR is the directory to search from."
   "Get the root directory for DIR."
   (when (not dir) (setq dir default-directory))
   (let ((case-fold-search t)
-        (proj (ede-emacs-file-existing dir)))
+        (proj (ede-files-find-existing dir ede-emacs-project-list)))
     (if proj
         (ede-up-directory (file-name-directory
                            (oref proj :file)))
@@ -134,7 +134,7 @@ m4_define(\\[SXEM4CS_BETA_VERSION\\], \\[\\([0-9]+\\)\\])")
 Return nil if there isn't one.
 Argument DIR is the directory it is created for.
 ROOTPROJ is nil, since there is only one project."
-  (or (ede-emacs-file-existing dir)
+  (or (ede-files-find-existing dir ede-emacs-project-list)
       ;; Doesn't already exist, so let's make one.
       (let* ((vertuple (ede-emacs-version dir))
              (proj (ede-emacs-project
diff --git a/lisp/cedet/ede/files.el b/lisp/cedet/ede/files.el
index 015f4fd9663..91433add7b0 100644
--- a/lisp/cedet/ede/files.el
+++ b/lisp/cedet/ede/files.el
@@ -50,12 +50,13 @@
 There is no completion at the prompt.  FILE is searched for within
 the current EDE project."
   (interactive "sFile: ")
-  (let ((fname (ede-expand-filename (ede-current-project) file))
+  (let* ((proj (ede-current-project))
+         (fname (ede-expand-filename proj file))
         )
     (unless fname
       (error "Could not find %s in %s"
              file
-             (ede-project-root-directory (ede-current-project))))
+             (ede-project-root-directory proj)))
     (find-file fname)))
 
 (defun ede-flush-project-hash ()
@@ -508,6 +509,26 @@ Argument DIR is the directory to trim upwards."
         nil
       fnd)))
 
+(defun ede-find-project-root (prj-file-name &optional dir)
+  "Tries to find directory with given project file"
+  (let ((prj-dir (locate-dominating-file (or dir default-directory)
+                                         prj-file-name)))
+    (when prj-dir
+      (expand-file-name prj-dir))))
+
+(defun ede-files-find-existing (dir prj-list)
+  "Find a project in the list of projects stored in given variable.
+DIR is the directory to search from."
+  (let ((projs prj-list)
+        (ans nil))
+    (while (and projs (not ans))
+      (let ((root (ede-project-root-directory (car projs))))
+        (when (string-match (concat "^" (regexp-quote root)) dir)
+          (setq ans (car projs))))
+      (setq projs (cdr projs)))
+    ans))
+
+
 (provide 'ede/files)
 
 ;; Local variables:
diff --git a/lisp/cedet/ede/locate.el b/lisp/cedet/ede/locate.el
index 072e2c2666a..3dbe3153680 100644
--- a/lisp/cedet/ede/locate.el
+++ b/lisp/cedet/ede/locate.el
@@ -163,7 +163,7 @@ that created this EDE locate object."
   "Create or update the database for the current project.
 You cannot create projects for the baseclass."
   (error "Cannot create/update a database of type %S"
-         (object-name loc)))
+         (eieio-object-name loc)))
 
 ;;; LOCATE
 ;;
diff --git a/lisp/cedet/ede/pconf.el b/lisp/cedet/ede/pconf.el
index 310014a0b64..a29e3720ea2 100644
--- a/lisp/cedet/ede/pconf.el
+++ b/lisp/cedet/ede/pconf.el
@@ -152,7 +152,7 @@ don't do it.  A value of nil means to just do it.")
 (defmethod ede-proj-configure-recreate ((this ede-proj-project))
   "Delete project THIS's configure script and start over."
   (if (not (ede-proj-configure-file this))
-      (error "Could not determine configure.ac for %S" (object-name this)))
+      (error "Could not determine configure.ac for %S" (eieio-object-name this)))
   (let ((b (get-file-buffer (ede-proj-configure-file this))))
     ;; Destroy all evidence of the old configure.ac
     (delete-file (ede-proj-configure-file this))
diff --git a/lisp/cedet/ede/proj-elisp.el b/lisp/cedet/ede/proj-elisp.el
index 8b426aa183f..d7720f25681 100644
--- a/lisp/cedet/ede/proj-elisp.el
+++ b/lisp/cedet/ede/proj-elisp.el
@@ -170,7 +170,7 @@ Bonus: Return a cons cell: (COMPILED . UPTODATE)."
                     (setq utd (1+ utd)))))))
 
             (oref obj source))
-    (message "All Emacs Lisp sources are up to date in %s" (object-name obj))
+    (message "All Emacs Lisp sources are up to date in %s" (eieio-object-name obj))
     (cons comp utd)))
 
 (defmethod ede-update-version-in-source ((this ede-proj-target-elisp) version)
@@ -194,7 +194,8 @@ is found, such as a `-version' variable, or the standard header."
                     (goto-char (match-beginning 1))
                     (insert version)))))
           (setq vs (cdr vs)))
-        (if (not match) (call-next-method)))))
+        ;; The next method will include comments such as "Version:"
+        (call-next-method))))
 
 
 ;;; Makefile generation functions
diff --git a/lisp/cedet/ede/proj.el b/lisp/cedet/ede/proj.el
index 2da2737d377..702e35f0b1f 100644
--- a/lisp/cedet/ede/proj.el
+++ b/lisp/cedet/ede/proj.el
@@ -512,11 +512,11 @@ Optional argument COMMAND is the s the alternate command to use."
 
 (defmethod project-debug-target ((obj ede-proj-target))
   "Run the current project target OBJ in a debugger."
-  (error "Debug-target not supported by %s" (object-name obj)))
+  (error "Debug-target not supported by %s" (eieio-object-name obj)))
 
 (defmethod project-run-target ((obj ede-proj-target))
   "Run the current project target OBJ."
-  (error "Run-target not supported by %s" (object-name obj)))
+  (error "Run-target not supported by %s" (eieio-object-name obj)))
 
 (defmethod ede-proj-makefile-target-name ((this ede-proj-target))
   "Return the name of the main target for THIS target."
diff --git a/lisp/cedet/ede/util.el b/lisp/cedet/ede/util.el
index 88a3e0a4512..71a79a1b706 100644
--- a/lisp/cedet/ede/util.el
+++ b/lisp/cedet/ede/util.el
@@ -49,7 +49,7 @@ Argument NEWVERSION is the version number to use in the current project."
 (defmethod project-update-version ((ot ede-project))
   "The :version of the project OT has been updated.
 Handle saving, or other detail."
-  (error "project-update-version not supported by %s" (object-name ot)))
+  (error "project-update-version not supported by %s" (eieio-object-name ot)))
 
 (defmethod ede-update-version-in-source ((this ede-project) version)
   "Change occurrences of a version string in sources.
diff --git a/lisp/cedet/semantic.el b/lisp/cedet/semantic.el
index edf2d0cb21a..3c93a8794b1 100644
--- a/lisp/cedet/semantic.el
+++ b/lisp/cedet/semantic.el
@@ -466,11 +466,10 @@ unterminated syntax."
     (widen)
     (when (or (< end start) (> end (point-max)))
       (error "Invalid parse region bounds %S, %S" start end))
-    (nreverse
-     (semantic-repeat-parse-whole-stream
+    (semantic-repeat-parse-whole-stream
       (or (cdr (assq start semantic-lex-block-streams))
           (semantic-lex start end depth))
-      nonterminal returnonerror))))
+      nonterminal returnonerror)))
 
 ;;; Parsing functions
 ;;
@@ -756,7 +755,7 @@ This function returns semantic tags without overlays."
                                   tag 'reparse-symbol nonterm))
                              tag)
                          (semantic--tag-expand tag))
-                    result (append tag result))
+                    result (append result tag))
             ;; No error in this case, a purposeful nil means don't
             ;; store anything.
             )
@@ -934,7 +933,8 @@ Throw away all the old tags, and recreate the tag database."
     '("--"))
   (define-key edit-menu [senator-yank-tag]
     '(menu-item "Yank Tag" senator-yank-tag
-                :enable (not (ring-empty-p senator-tag-ring))
+                :enable (and (boundp 'senator-tag-ring)
+                             (not (ring-empty-p senator-tag-ring)))
                 :help "Yank the head of the tag ring into the buffer"))
   (define-key edit-menu [senator-copy-tag-to-register]
     '(menu-item "Copy Tag To Register" senator-copy-tag-to-register
diff --git a/lisp/cedet/semantic/analyze.el b/lisp/cedet/semantic/analyze.el
index d1476111403..000193d4a55 100644
--- a/lisp/cedet/semantic/analyze.el
+++ b/lisp/cedet/semantic/analyze.el
@@ -800,7 +800,7 @@ CONTEXT's content is described in `semantic-analyze-current-context'."
   (semantic-analyze-pulse context)
   (with-output-to-temp-buffer "*Semantic Context Analysis*"
     (princ "Context Type: ")
-    (princ (object-name context))
+    (princ (eieio-object-name context))
     (princ "\n")
     (princ "Bounds: ")
     (princ (oref context bounds))
diff --git a/lisp/cedet/semantic/analyze/fcn.el b/lisp/cedet/semantic/analyze/fcn.el
index 6ee85b298a2..42bc482a1df 100644
--- a/lisp/cedet/semantic/analyze/fcn.el
+++ b/lisp/cedet/semantic/analyze/fcn.el
@@ -255,7 +255,7 @@ Optional argument TYPE-DECLARATION is how TYPE was found referenced."
         (nexttype (semantic-analyze-dereference-metatype type scope type-declaration))
         (idx 0))
     (catch 'metatype-recursion
-      (while (and nexttype (not (eq (car nexttype) lasttype)))
+      (while (and nexttype (not (semantic-tag-similar-p (car nexttype) lasttype)))
         (setq lasttype (car nexttype)
               lasttypedeclaration (cadr nexttype))
         (setq nexttype (semantic-analyze-dereference-metatype lasttype scope lasttypedeclaration))
diff --git a/lisp/cedet/semantic/bovine/c.el b/lisp/cedet/semantic/bovine/c.el
index 7aa93a0c942..2f8cf08af3e 100644
--- a/lisp/cedet/semantic/bovine/c.el
+++ b/lisp/cedet/semantic/bovine/c.el
@@ -155,15 +155,16 @@ part of the preprocessor map.")
                       ;; not be in a buffer.
                       (semanticdb-refresh-table table t)
                     (error (message "Error updating tables for %S"
-                                    (object-name table)))))
+                                    (eieio-object-name table)))))
                 (setq filemap (append filemap (oref table lexical-table)))
-                ;; Update symbol obarray
-                (setq-mode-local c-mode
-                                 semantic-lex-spp-macro-symbol-obarray
-                                 (semantic-lex-make-spp-table
-                                  (append semantic-lex-c-preprocessor-symbol-map-builtin
-                                          semantic-lex-c-preprocessor-symbol-map
-                                          filemap)))))))))))
+                )))))
+      ;; Update symbol obarray
+      (setq-mode-local c-mode
+                       semantic-lex-spp-macro-symbol-obarray
+                       (semantic-lex-make-spp-table
+                        (append semantic-lex-c-preprocessor-symbol-map-builtin
+                                semantic-lex-c-preprocessor-symbol-map
+                                filemap))))))
 
 ;; Make sure the preprocessor symbols are set up when mode-local kicks
 ;; in.
@@ -1946,15 +1947,17 @@ have to be wrapped in that namespace."
   "Do what `semantic-get-local-variables' does, plus add `this' if needed."
   (let* ((origvar (semantic-get-local-variables-default))
          (ct (semantic-current-tag))
-         (p (semantic-tag-function-parent ct)))
+         (p (when (semantic-tag-of-class-p ct 'function)
+              (or (semantic-tag-function-parent ct)
+                  (car-safe (semantic-find-tags-by-type
+                             "class" (semantic-find-tag-by-overlay)))))))
     ;; If we have a function parent, then that implies we can
-    (if (and p (semantic-tag-of-class-p ct 'function))
-        ;; Append a new tag THIS into our space.
-        (cons (semantic-tag-new-variable "this" p nil)
+    (if p
+        ;; Append a new tag THIS into our space.
+        (cons (semantic-tag-new-variable "this" p nil :pointer 1)
               origvar)
       ;; No parent, just return the usual
-      origvar)
-    ))
+      origvar)))
 
 (define-mode-local-override semantic-idle-summary-current-symbol-info
   c-mode ()
@@ -2151,14 +2154,18 @@ actually in their parent which is not accessible.")
           (princ "\n")))
 
       (princ "\n\nMacro Summary:\n")
+
       (when semantic-lex-c-preprocessor-symbol-file
-        (princ "\n  Your CPP table is primed from these files:\n")
+        (princ "\n  Your CPP table is primed from these system files:\n")
         (dolist (file semantic-lex-c-preprocessor-symbol-file)
           (princ "    ")
           (princ file)
           (princ "\n")
           (princ "    in table: ")
-          (princ (object-print (semanticdb-file-table-object file)))
+          (let ((fto (semanticdb-file-table-object file)))
+            (if fto
+                (princ (object-print fto))
+              (princ "No Table")))
           (princ "\n")
           ))
 
@@ -2173,7 +2180,7 @@ actually in their parent which is not accessible.")
           ))
 
       (when semantic-lex-c-preprocessor-symbol-map
-        (princ "\n  User symbol map:\n")
+        (princ "\n  User symbol map (primed from system files):\n")
         (dolist (S semantic-lex-c-preprocessor-symbol-map)
           (princ "    ")
           (princ (car S))
@@ -2183,25 +2190,27 @@ actually in their parent which is not accessible.")
           ))
 
       (when (and (boundp 'ede-object)
-                 ede-object
-                 (arrayp semantic-lex-spp-project-macro-symbol-obarray))
+                 ede-object)
         (princ "\n  Project symbol map:\n")
         (when (and (boundp 'ede-object) ede-object)
-          (princ "      Your project symbol map is derived from the EDE object:\n      ")
+          (princ "      Your project symbol map is also derived from the EDE object:\n      ")
           (princ (object-print ede-object)))
         (princ "\n\n")
-        (let ((macros nil))
-          (mapatoms
-           #'(lambda (symbol)
-               (setq macros (cons symbol macros)))
-           semantic-lex-spp-project-macro-symbol-obarray)
-          (dolist (S macros)
-            (princ "    ")
-            (princ (symbol-name S))
-            (princ " = ")
-            (princ (symbol-value S))
-            (princ "\n")
-            )))
+        (if (arrayp semantic-lex-spp-project-macro-symbol-obarray)
+            (let ((macros nil))
+              (mapatoms
+               #'(lambda (symbol)
+                   (setq macros (cons symbol macros)))
+               semantic-lex-spp-project-macro-symbol-obarray)
+              (dolist (S macros)
+                (princ "    ")
+                (princ (symbol-name S))
+                (princ " = ")
+                (princ (symbol-value S))
+                (princ "\n")
+                ))
+          ;; Else, not map
+          (princ "    No Symbols.\n")))
 
       (princ "\n\n  Use: M-x semantic-lex-spp-describe RET\n")
       (princ "\n  to see the complete macro table.\n")
diff --git a/lisp/cedet/semantic/bovine/gcc.el b/lisp/cedet/semantic/bovine/gcc.el
index 82876adb37e..7beb8ff3203 100644
--- a/lisp/cedet/semantic/bovine/gcc.el
+++ b/lisp/cedet/semantic/bovine/gcc.el
@@ -157,7 +157,11 @@ It should also include other symbols GCC was compiled with.")
                     ;; `cpp' command in `semantic-gcc-setup' doesn't work on
                     ;; Mac, try `gcc'.
                     (apply 'semantic-gcc-query "gcc" cpp-options))))
-         (defines (semantic-cpp-defs query))
+         (defines (if (stringp query)
+                      (semantic-cpp-defs query)
+                    (message (concat "Could not query gcc for defines. "
+                                     "Maybe g++ is not installed."))
+                    nil))
          (ver (cdr (assoc 'version fields)))
          (host (or (cdr (assoc 'target fields))
                    (cdr (assoc '--target fields))
diff --git a/lisp/cedet/semantic/complete.el b/lisp/cedet/semantic/complete.el
index 194e0ee5f66..1c2ddf45c9d 100644
--- a/lisp/cedet/semantic/complete.el
+++ b/lisp/cedet/semantic/complete.el
@@ -678,7 +678,8 @@ a reasonable distance."
             ;;(message "Inline Hook installed, but overlay deleted.")
             (semantic-complete-inline-exit))
         ;; Exit if commands caused us to exit the area of interest
-        (let ((s (semantic-overlay-start semantic-complete-inline-overlay))
+        (let ((os (semantic-overlay-get semantic-complete-inline-overlay 'semantic-original-start))
+              (s (semantic-overlay-start semantic-complete-inline-overlay))
               (e (semantic-overlay-end semantic-complete-inline-overlay))
               (b (semantic-overlay-buffer semantic-complete-inline-overlay))
               (txt nil)
@@ -686,8 +687,10 @@ a reasonable distance."
           (cond
            ;; EXIT when we are no longer in a good place.
            ((or (not (eq b (current-buffer)))
-                (<= (point) s)
-                (> (point) e))
+                (< (point) s)
+                (< (point) os)
+                (> (point) e)
+                )
             ;;(message "Exit: %S %S %S" s e (point))
             (semantic-complete-inline-exit)
             )
@@ -710,7 +713,6 @@ a reasonable distance."
            (t
             ;; Else, show completions now
             (semantic-complete-inline-force-display)
-
             ))))
     ;; If something goes terribly wrong, clean up after ourselves.
     (error (semantic-complete-inline-exit))))
@@ -761,6 +763,10 @@ END is at the end of the current symbol being completed."
   (semantic-overlay-put semantic-complete-inline-overlay
                         'window-config-start
                         (current-window-configuration))
+  ;; Save the original start.  We need to exit completion if START
+  ;; moves.
+  (semantic-overlay-put semantic-complete-inline-overlay
+                        'semantic-original-start start)
   ;; Install our command hooks
   (add-hook 'pre-command-hook 'semantic-complete-pre-command-hook)
   (add-hook 'post-command-hook 'semantic-complete-post-command-hook)
@@ -1171,7 +1177,7 @@ These collectors track themselves on a per-buffer basis."
   (let ((old nil)
         (bl semantic-collector-per-buffer-list))
     (while (and bl (null old))
-      (if (eq (object-class (car bl)) this)
+      (if (eq (eieio-object-class (car bl)) this)
           (setq old (car bl))))
     (unless old
       (let ((new (call-next-method)))
@@ -1510,7 +1516,7 @@ one in the source buffer."
           (insert (semantic-format-tag-summarize tag nil t) "\n\n")
           (when table
             (insert "From table: \n")
-            (insert (object-name table) "\n\n"))
+            (insert (eieio-object-name table) "\n\n"))
           (when buf
             (insert "In buffer: \n\n")
             (insert (format "%S" buf)))
diff --git a/lisp/cedet/semantic/db-el.el b/lisp/cedet/semantic/db-el.el
index 260f964c191..1b0f3292ad3 100644
--- a/lisp/cedet/semantic/db-el.el
+++ b/lisp/cedet/semantic/db-el.el
@@ -216,9 +216,8 @@ TOKTYPE is a hint to the type of tag desired."
             (symbol-name sym)
             "class"
             (semantic-elisp-desymbolify
-             (aref (class-v semanticdb-project-database)
-                   class-public-a)) ;; slots
-            (semantic-elisp-desymbolify (class-parents sym)) ;; parents
+             (eieio--class-public-a (class-v semanticdb-project-database))) ;; slots
+            (semantic-elisp-desymbolify (eieio-class-parents sym)) ;; parents
             ))
           ((not toktype)
            ;; Figure it out on our own.
diff --git a/lisp/cedet/semantic/db-file.el b/lisp/cedet/semantic/db-file.el
index 269ff264126..2ef4fba1288 100644
--- a/lisp/cedet/semantic/db-file.el
+++ b/lisp/cedet/semantic/db-file.el
@@ -44,6 +44,8 @@
 (defcustom semanticdb-default-save-directory
   (locate-user-emacs-file "semanticdb" ".semanticdb")
   "Directory name where semantic cache files are stored.
+By default, it is either ~/.emacs.d/semanticdb, or ~/.semanticdb depending
+on which exists.
 If this value is nil, files are saved in the current directory.  If the value
 is a valid directory, then it overrides `semanticdb-default-file-name' and
 stores caches in a coded file name in this directory."
@@ -316,7 +318,7 @@ Argument OBJ is the object to write."
          (data-debug-new-buffer (concat "*SEMANTICDB ERROR*"))
          (data-debug-insert-thing obj "*" "")
          (setq semanticdb-data-debug-on-write-error nil))
-       (message "Error Writing Table: %s" (object-name obj))
+       (message "Error Writing Table: %s" (eieio-object-name obj))
        (error "%S" (car (cdr tableerror)))))
 
     ;; Clear the dirty bit.
diff --git a/lisp/cedet/semantic/db-find.el b/lisp/cedet/semantic/db-find.el
index 77fd10fc7aa..2e4ca319a9d 100644
--- a/lisp/cedet/semantic/db-find.el
+++ b/lisp/cedet/semantic/db-find.el
@@ -244,7 +244,7 @@ This class will cache data derived during various searches.")
            (let ((tab-idx (semanticdb-get-table-index tab)))
              ;; Not a full reset?
              (when (oref tab-idx type-cache)
-               (require 'db-typecache)
+               (require 'semantic/db-typecache)
                (semanticdb-typecache-notify-reset
                 (oref tab-idx type-cache)))
              )))
@@ -919,7 +919,7 @@ but should be good enough for debugging assertions."
   (if (< (length result) 2)
       (concat "#<FIND RESULT "
               (mapconcat (lambda (a)
-                           (concat "(" (object-name (car a) ) " . "
+                           (concat "(" (eieio-object-name (car a) ) " . "
                                    "#<TAG LIST " (number-to-string (length (cdr a))) ">)"))
                          result
                          " ")
@@ -1285,7 +1285,7 @@ associated with that tag should be loaded into a buffer."
   (semanticdb-find-tags-collector
    (lambda (table tags)
      (semanticdb-find-tags-external-children-of-type-method table type tags))
-   path find-file-match))
+   path find-file-match t))
 
 (defun semanticdb-find-tags-subclasses-of-type
   (type &optional path find-file-match)
diff --git a/lisp/cedet/semantic/db.el b/lisp/cedet/semantic/db.el
index a6088231c61..e8784c4f85c 100644
--- a/lisp/cedet/semantic/db.el
+++ b/lisp/cedet/semantic/db.el
@@ -190,7 +190,7 @@ If one doesn't exist, create it."
       (oref obj index)
     (let ((idx nil))
       (setq idx (funcall semanticdb-default-find-index-class
-                         (concat (object-name obj) " index")
+                         (concat (eieio-object-name obj) " index")
                          ;; Fill in the defaults
                          :table obj
                          ))
@@ -469,7 +469,7 @@ other than :table."
   (let ((cache (oref table cache))
         (obj nil))
     (while (and (not obj) cache)
-      (if (eq (object-class-fast (car cache)) desired-class)
+      (if (eq (eieio--object-class (car cache)) desired-class)
           (setq obj (car cache)))
       (setq cache (cdr cache)))
     (if obj
@@ -520,7 +520,7 @@ other than :table."
   (let ((cache (oref db cache))
         (obj nil))
     (while (and (not obj) cache)
-      (if (eq (object-class-fast (car cache)) desired-class)
+      (if (eq (eieio--object-class (car cache)) desired-class)
           (setq obj (car cache)))
       (setq cache (cdr cache)))
     (if obj
diff --git a/lisp/cedet/semantic/decorate/include.el b/lisp/cedet/semantic/decorate/include.el
index 3a08db2b0d0..0451ad44fe8 100644
--- a/lisp/cedet/semantic/decorate/include.el
+++ b/lisp/cedet/semantic/decorate/include.el
@@ -797,7 +797,7 @@ Argument EVENT describes the event that caused this function to be called."
           (dolist (p path)
             (if (slot-boundp p 'tags)
                 (princ (format "\n  %s :\t%d tags, %d are includes. %s"
-                               (object-name-string p)
+                               (eieio-object-name-string p)
                                (length (oref p tags))
                                (length (semantic-find-tags-by-class
                                         'include p))
@@ -810,7 +810,7 @@ Argument EVENT describes the event that caused this function to be called."
                                  "  Needs to be parsed.")
                                 (t ""))))
               (princ (format "\n  %s :\tUnparsed"
-                             (object-name-string p))))
+                             (eieio-object-name-string p))))
             )))
       )))
 
diff --git a/lisp/cedet/semantic/ede-grammar.el b/lisp/cedet/semantic/ede-grammar.el
index 094832a8258..cb2a1faaac0 100644
--- a/lisp/cedet/semantic/ede-grammar.el
+++ b/lisp/cedet/semantic/ede-grammar.el
@@ -162,7 +162,7 @@ Lays claim to all -by.el, and -wy.el files."
                         (setq comp (1+ comp))
                       (setq utd (1+ utd))))))))
           (oref obj source))
-    (message "All Semantic Grammar sources are up to date in %s" (object-name obj))
+    (message "All Semantic Grammar sources are up to date in %s" (eieio-object-name obj))
     (cons comp utd)))
 
 ;;; Makefile generation functions
diff --git a/lisp/cedet/semantic/find.el b/lisp/cedet/semantic/find.el
index aa42a77725e..f660c69ec3d 100644
--- a/lisp/cedet/semantic/find.el
+++ b/lisp/cedet/semantic/find.el
@@ -313,6 +313,15 @@ TABLE is a tag table.  See `semantic-something-to-tag-table'."
     (eq ,class (semantic-tag-class (car tags)))
     ,table))
 
+(defmacro semantic-filter-tags-by-class (class &optional table)
+  "Find all tags of class not in the list CLASS in TABLE.
+CLASS is a list of symbols representing the class of the token,
+such as 'variable, of 'function..
+TABLE is a tag table.  See `semantic-something-to-tag-table'."
+  `(semantic--find-tags-by-macro
+    (not (memq (semantic-tag-class (car tags)) ,class))
+    ,table))
+
 (defmacro semantic-find-tags-by-type (type &optional table)
   "Find all tags of with a type TYPE in TABLE.
 TYPE is a string or tag representing a data type as defined in the
diff --git a/lisp/cedet/semantic/grammar.el b/lisp/cedet/semantic/grammar.el
index ba4570e692b..9cb0f60b80a 100644
--- a/lisp/cedet/semantic/grammar.el
+++ b/lisp/cedet/semantic/grammar.el
@@ -51,6 +51,9 @@
 (declare-function semantic-grammar-wy--install-parser
                   "semantic/gram-wy-fallback")
 
+(declare-function semantic-grammar-wy--install-parser
+                  "semantic/gram-wy-fallback")
+
 
 ;;;;
 ;;;; Set up lexer
diff --git a/lisp/cedet/semantic/sb.el b/lisp/cedet/semantic/sb.el
index e2d143b529e..32117da1af5 100644
--- a/lisp/cedet/semantic/sb.el
+++ b/lisp/cedet/semantic/sb.el
@@ -43,6 +43,11 @@ This will replace the named bucket that would have usually occurred here."
   :group 'speedbar
   :type 'integer)
 
+(defvar semantic-sb-filter-tags-of-class '(code)
+  "Tags classes to not display in speedbar.
+Make this buffer local for modes that have different types of tags
+that should be ignored.")
+
 (defcustom semantic-sb-button-format-tag-function 'semantic-format-tag-abbreviate
   "*Function called to create the text for a but from a token."
   :group 'speedbar
@@ -405,7 +410,12 @@ Returns the tag list, or t for an error."
               (setq out (semantic-adopt-external-members out))
               ;; Dump all the tokens into buckets.
               (semantic-sb-with-tag-buffer (car out)
-                (semantic-bucketize out)))
+                (semantic-bucketize out nil
+                                    (lambda (tagsin)
+                                      ;; Remove all boring tags.
+                                      (semantic-filter-tags-by-class
+                                       semantic-sb-filter-tags-of-class
+                                       tagsin)))))
           (error t))
       t)))
 
diff --git a/lisp/cedet/semantic/senator.el b/lisp/cedet/semantic/senator.el
index a79e70a7f61..157223ff192 100644
--- a/lisp/cedet/semantic/senator.el
+++ b/lisp/cedet/semantic/senator.el
@@ -727,7 +727,13 @@ kill ring."
   (semantic-fetch-tags)
   (let ((ft (semantic-obtain-foreign-tag)))
     (when ft
-      (set-register register ft)
+      (set-register
+       register (registerv-make
+                 ft
+                 :insert-func #'semantic-insert-foreign-tag
+                 :jump-func (lambda (v)
+                              (switch-to-buffer (semantic-tag-buffer v))
+                              (goto-char (semantic-tag-start v)))))
       (if kill-flag
           (kill-region (semantic-tag-start ft)
                        (semantic-tag-end ft))))))
diff --git a/lisp/cedet/semantic/sort.el b/lisp/cedet/semantic/sort.el
index 6b58689524c..b32e11290ac 100644
--- a/lisp/cedet/semantic/sort.el
+++ b/lisp/cedet/semantic/sort.el
@@ -522,7 +522,7 @@ See `semantic-tag-external-member-children' for details."
            (semanticdb-minor-mode-p)
            (require 'semantic/db-find))
       (let ((m (semanticdb-find-tags-external-children-of-type
-                (semantic-tag-name tag))))
+                (semantic-tag-name tag) tag)))
         (if m (apply #'append (mapcar #'cdr m))))
     (semantic--find-tags-by-function
      `(lambda (tok)
diff --git a/lisp/cedet/semantic/tag-ls.el b/lisp/cedet/semantic/tag-ls.el
index 7e5913334ea..53da7b65661 100644
--- a/lisp/cedet/semantic/tag-ls.el
+++ b/lisp/cedet/semantic/tag-ls.el
@@ -146,36 +146,42 @@ are the same.
 IGNORABLE-ATTRIBUTES are tag attributes that can be ignored.
 
 See `semantic-tag-similar-p' for details."
-  (let* ((ignore (append ignorable-attributes semantic-tag-similar-ignorable-attributes))
-         (A1 (and (semantic--tag-similar-names-p tag1 tag2 (memq :name ignore))
-                  (semantic--tag-similar-types-p tag1 tag2)
-                  (semantic-tag-of-class-p tag1 (semantic-tag-class tag2))))
-         (attr1 (semantic-tag-attributes tag1))
-         (attr2 (semantic-tag-attributes tag2))
-         (A2 t)
-         (A3 t)
-         )
-    ;; Test if there are non-ignorable attributes in A2 which are not present in A1
-    (while (and A2 attr2)
-      (let ((a (car attr2)))
-        (unless (or (eq a :type) (memq a ignore))
-          (setq A2 (semantic-tag-get-attribute tag1 a)))
-        (setq attr2 (cdr (cdr attr2)))))
-    (while (and A2 attr1 A3)
-      (let ((a (car attr1)))
-
-        (cond ((or (eq a :type) ;; already tested above.
-                   (memq a ignore)) ;; Ignore them...
-               nil)
-
-              (t
-               (setq A3
-                     (semantic--tag-attribute-similar-p
-                      a (car (cdr attr1)) (semantic-tag-get-attribute tag2 a)
-                      ignorable-attributes)))
-              ))
-      (setq attr1 (cdr (cdr attr1))))
-    (and A1 A2 A3)))
+  (or
+   ;; Tags are similar if they have the exact same lisp object
+   ;; Added for performance when testing a relatively common case in some uses
+   ;; of this code.
+   (eq tag1 tag2)
+   ;; More complex similarness test.
+   (let* ((ignore (append ignorable-attributes semantic-tag-similar-ignorable-attributes))
+          (A1 (and (semantic--tag-similar-names-p tag1 tag2 (memq :name ignore))
+                   (semantic--tag-similar-types-p tag1 tag2)
+                   (semantic-tag-of-class-p tag1 (semantic-tag-class tag2))))
+          (attr1 (semantic-tag-attributes tag1))
+          (attr2 (semantic-tag-attributes tag2))
+          (A2 t)
+          (A3 t)
+          )
+     ;; Test if there are non-ignorable attributes in A2 which are not present in A1
+     (while (and A2 attr2)
+       (let ((a (car attr2)))
+         (unless (or (eq a :type) (memq a ignore))
+           (setq A2 (semantic-tag-get-attribute tag1 a)))
+         (setq attr2 (cdr (cdr attr2)))))
+     (while (and A2 attr1 A3)
+       (let ((a (car attr1)))
+
+         (cond ((or (eq a :type)        ;; already tested above.
+                    (memq a ignore))    ;; Ignore them...
+                nil)
+
+               (t
+                (setq A3
+                      (semantic--tag-attribute-similar-p
+                       a (car (cdr attr1)) (semantic-tag-get-attribute tag2 a)
+                       ignorable-attributes)))
+               ))
+       (setq attr1 (cdr (cdr attr1))))
+     (and A1 A2 A3))))
 
 ;;; FULL NAMES
 ;;
diff --git a/lisp/cedet/srecode/args.el b/lisp/cedet/srecode/args.el
index b91f96f611d..d6798f7523d 100644
--- a/lisp/cedet/srecode/args.el
+++ b/lisp/cedet/srecode/args.el
@@ -157,6 +157,30 @@ do not contain any text from preceding or following text."
         (srecode-dictionary-show-section dict "RCS")
       )))
 
+;;; :project ARGUMENT HANDLING
+;;
+;; When the :project argument is required, fill the dictionary with
+;; information that the current project (from EDE) might know
+(defun srecode-semantic-handle-:project (dict)
+  "Add macros into the dictionary DICT based on the current ede project."
+  (let* ((bfn (buffer-file-name))
+         (dir (file-name-directory bfn)))
+    (if (ede-toplevel)
+        (let* ((projecttop (ede-toplevel-project default-directory))
+               (relfname (file-relative-name bfn projecttop))
+               (reldir (file-relative-name dir projecttop))
+               )
+          (srecode-dictionary-set-value dict "PROJECT_FILENAME" relfname)
+          (srecode-dictionary-set-value dict "PROJECT_DIRECTORY" reldir)
+          (srecode-dictionary-set-value dict "PROJECT_NAME" (ede-name (ede-toplevel)))
+          (srecode-dictionary-set-value dict "PROJECT_VERSION" (oref (ede-toplevel) :version))
+          )
+      ;; If there is no EDE project, then put in some base values.
+      (srecode-dictionary-set-value dict "PROJECT_FILENAME" bfn)
+      (srecode-dictionary-set-value dict "PROJECT_DIRECTORY" dir)
+      (srecode-dictionary-set-value dict "PROJECT_NAME" "N/A")
+      (srecode-dictionary-set-value dict "PROJECT_VERSION" "1.0"))))
+
 ;;; :system ARGUMENT HANDLING
 ;;
 ;; When a :system argument is required, fill the dictionary with
diff --git a/lisp/cedet/srecode/compile.el b/lisp/cedet/srecode/compile.el
index 170b99c1fd2..0d68036c433 100644
--- a/lisp/cedet/srecode/compile.el
+++ b/lisp/cedet/srecode/compile.el
@@ -510,12 +510,12 @@ to the inserter constructor."
   ;;(message "Compile: %s %S" name props)
   (if (not key)
       (apply 'srecode-template-inserter-variable name props)
-    (let ((classes (class-children srecode-template-inserter))
+    (let ((classes (eieio-class-children srecode-template-inserter))
           (new nil))
       ;; Loop over the various subclasses and
       ;; create the correct inserter.
       (while (and (not new) classes)
-        (setq classes (append classes (class-children (car classes))))
+        (setq classes (append classes (eieio-class-children (car classes))))
         ;; Do we have a match?
         (when (and (not (class-abstract-p (car classes)))
                    (equal (oref (car classes) key) key))
@@ -594,7 +594,7 @@ A list of defined variables VARS provides a variable table."
 (defmethod srecode-dump ((tmp srecode-template))
   "Dump the contents of the SRecode template tmp."
   (princ "== Template \"")
-  (princ (object-name-string tmp))
+  (princ (eieio-object-name-string tmp))
   (princ "\" in context ")
   (princ (oref tmp context))
   (princ "\n")
@@ -640,12 +640,12 @@ Argument INDENT specifies the indentation level for the list."
 (defmethod srecode-dump ((ins srecode-template-inserter) indent)
   "Dump the state of the SRecode template inserter INS."
   (princ "INS: \"")
-  (princ (object-name-string ins))
+  (princ (eieio-object-name-string ins))
   (when (oref ins :secondname)
     (princ "\" : \"")
     (princ (oref ins :secondname)))
   (princ "\" type \"")
-  (let* ((oc (symbol-name (object-class ins)))
+  (let* ((oc (symbol-name (eieio-object-class ins)))
          (junk (string-match "srecode-template-inserter-" oc))
          (on (if junk
                  (substring oc (match-end 0))
diff --git a/lisp/cedet/srecode/cpp.el b/lisp/cedet/srecode/cpp.el
index 94b394a1631..fd500b6d9a3 100644
--- a/lisp/cedet/srecode/cpp.el
+++ b/lisp/cedet/srecode/cpp.el
@@ -70,8 +70,7 @@ HEADER - Shown section if in a header file."
       (srecode-dictionary-show-section dict "NOTHEADER"))
 
     ;; Strip out bad characters
-    (while (string-match "\\.\\| " fsym)
-      (setq fsym (replace-match "_" t t fsym)))
+    (setq fsym (replace-regexp-in-string "[^a-zA-Z0-9_]" "_" fsym))
     (srecode-dictionary-set-value dict "FILENAME_SYMBOL" fsym)
     )
   )
diff --git a/lisp/cedet/srecode/dictionary.el b/lisp/cedet/srecode/dictionary.el
index bac05666726..bbc791f09d8 100644
--- a/lisp/cedet/srecode/dictionary.el
+++ b/lisp/cedet/srecode/dictionary.el
@@ -175,7 +175,7 @@ associated with a buffer or parent."
        ((srecode-dictionary-child-p buffer-or-parent)
         (setq parent buffer-or-parent
               buffer (oref buffer-or-parent buffer)
-              origin (concat (object-name buffer-or-parent) " in "
+              origin (concat (eieio-object-name buffer-or-parent) " in "
                              (if buffer (buffer-name buffer)
                                "no buffer")))
         (when buffer
@@ -454,12 +454,12 @@ If you subclass `srecode-dictionary-compound-value' then this
 method could return nil, but if it does that, it must insert
 the value itself using `princ', or by detecting if the current
 standard out is a buffer, and using `insert'."
-  (object-name cp))
+  (eieio-object-name cp))
 
 (defmethod srecode-dump ((cp srecode-dictionary-compound-value)
                          &optional indent)
   "Display information about this compound value."
-  (princ (object-name cp))
+  (princ (eieio-object-name cp))
   )
 
 (defmethod srecode-compound-toString ((cp srecode-dictionary-compound-variable)
@@ -654,7 +654,7 @@ STATE is the current compiler state."
                                        4)))
                       (while entry
                         (princ " --> SUBDICTIONARY ")
-                        (princ (object-name dict))
+                        (princ (eieio-object-name dict))
                         (princ "\n")
                         (srecode-dump (car entry) newindent)
                         (setq entry (cdr entry))
diff --git a/lisp/cedet/srecode/insert.el b/lisp/cedet/srecode/insert.el
index 466efae3b9c..0d647bb56c5 100644
--- a/lisp/cedet/srecode/insert.el
+++ b/lisp/cedet/srecode/insert.el
@@ -809,7 +809,7 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
     (srecode-insert-report-error
      dict
      "Only section dictionaries allowed for `%s'"
-     (object-name-string sti)))
+     (eieio-object-name-string sti)))
 
   ;; Output the code from the sub-template.
   (srecode-insert-method (slot-value sti slot) dict))
@@ -866,7 +866,7 @@ Return the remains of INPUT."
   (let* ((out (srecode-compile-split-code tag input STATE
                                           (oref ins :object-name))))
     (oset ins template (srecode-template
-                        (object-name-string ins)
+                        (eieio-object-name-string ins)
                         :context nil
                         :args nil
                         :code (cdr out)))
diff --git a/lisp/cedet/srecode/java.el b/lisp/cedet/srecode/java.el
index db4d2deee28..29a8465c45c 100644
--- a/lisp/cedet/srecode/java.el
+++ b/lisp/cedet/srecode/java.el
@@ -42,9 +42,24 @@ FILENAME_AS_CLASS - file converted to a Java class name."
          )
     (while (string-match "\\.\\| " fpak)
       (setq fpak (replace-match "_" t t fpak)))
-    (if (string-match "src/" dir)
-        (setq dir (substring dir (match-end 0)))
-      (setq dir (file-name-nondirectory (directory-file-name dir))))
+    ;; We can extract package from:
+    ;; 1) a java EDE project source paths,
+    (cond ((ede-current-project)
+           (let* ((proj (ede-current-project))
+                  (pths (ede-source-paths proj 'java-mode))
+                  (pth)
+                  (res))
+             (while (and (not res)
+                         (setq pth (expand-file-name (car pths))))
+               (when (string-match pth dir)
+                 (setq res (substring dir (match-end 0))))
+               (setq pths (cdr pths)))
+             (setq dir res)))
+          ;; 2) a simple heuristic
+          ((string-match "src/" dir)
+           (setq dir (substring dir (match-end 0))))
+          ;; 3) outer directory as a fallback
+          (t (setq dir (file-name-nondirectory (directory-file-name dir)))))
     (setq dir (directory-file-name dir))
     (while (string-match "/" dir)
       (setq dir (replace-match "." t t dir)))
diff --git a/lisp/cedet/srecode/map.el b/lisp/cedet/srecode/map.el
index cbe602f3299..1dd9ba4cf47 100644
--- a/lisp/cedet/srecode/map.el
+++ b/lisp/cedet/srecode/map.el
@@ -363,6 +363,9 @@ Return non-nil if the map changed."
           (let ((semantic-init-hook nil))
             (semantic-new-buffer-fcn))
           )
+        ;; Force semantic to be enabled in this buffer.
+        (unless (semantic-active-p)
+          (semantic-new-buffer-fcn))
 
         (semantic-fetch-tags)
         (let* ((mode-tag
diff --git a/lisp/cedet/srecode/mode.el b/lisp/cedet/srecode/mode.el
index 8c4a53ec891..e8e1c78198e 100644
--- a/lisp/cedet/srecode/mode.el
+++ b/lisp/cedet/srecode/mode.el
@@ -225,7 +225,7 @@ MENU-DEF is the menu to bind this into."
                    (ctxtcons (assoc ctxt alltabs))
                    (bind (if (slot-boundp temp 'binding)
                              (oref temp binding)))
-                   (name (object-name-string temp)))
+                   (name (eieio-object-name-string temp)))
 
               (when (not ctxtcons)
                 (if (string= context ctxt)
diff --git a/lisp/cedet/srecode/srt-mode.el b/lisp/cedet/srecode/srt-mode.el
index 455895c003d..2f43dc3872b 100644
--- a/lisp/cedet/srecode/srt-mode.el
+++ b/lisp/cedet/srecode/srt-mode.el
@@ -187,7 +187,7 @@ we can tell font lock about them.")
   "Keymap used in srecode mode.")
 
 ;;;###autoload
-(define-derived-mode srecode-template-mode fundamental-mode "SRecorder"
+(define-derived-mode srecode-template-mode fundamental-mode "SRecode"
   "Major-mode for writing SRecode macros."
   (set (make-local-variable 'comment-start) ";;")
   (set (make-local-variable 'comment-end) "")
@@ -232,7 +232,7 @@ we can tell font lock about them.")
   "Provide help for working with macros in a template."
   (interactive)
   (let* ((root 'srecode-template-inserter)
-         (chl (aref (class-v root) class-children))
+         (chl (eieio--class-children (class-v root)))
          (ess (srecode-template-get-escape-start))
          (ees (srecode-template-get-escape-end))
          )
@@ -248,7 +248,7 @@ we can tell font lock about them.")
                (showexample t)
                )
           (setq chl (cdr chl))
-          (setq chl (append (aref (class-v C) class-children) chl))
+          (setq chl (append (eieio--class-children (class-v C)) chl))
 
           (catch 'skip
             (when (eq C 'srecode-template-inserter-section-end)
diff --git a/lisp/cedet/srecode/srt.el b/lisp/cedet/srecode/srt.el
index 3875246cb37..1fad31dafd6 100644
--- a/lisp/cedet/srecode/srt.el
+++ b/lisp/cedet/srecode/srt.el
@@ -69,6 +69,7 @@ DEFAULT is the default if RET is hit."
                    nil initial (or hist 'srecode-read-major-mode-history))
   )
 
+;;;###autoload
 (defun srecode-semantic-handle-:srt (dict)
   "Add macros into the dictionary DICT based on the current SRT file.
 Adds the following:
@@ -104,4 +105,9 @@ MODE - The mode of this buffer.  If not declared yet, guess."
 
 (provide 'srecode/srt)
 
+;; Local variables:
+;; generated-autoload-file: "loaddefs.el"
+;; generated-autoload-load-name: "srecode/srt"
+;; End:
+
 ;;; srecode/srt.el ends here
diff --git a/lisp/cedet/srecode/table.el b/lisp/cedet/srecode/table.el
index 802740ba063..26163bd1e51 100644
--- a/lisp/cedet/srecode/table.el
+++ b/lisp/cedet/srecode/table.el
@@ -251,7 +251,7 @@ Use PREDICATE is the same as for the `sort' function."
 (defmethod srecode-dump ((tab srecode-template-table))
   "Dump the contents of the SRecode template table TAB."
   (princ "Template Table for ")
-  (princ (object-name-string tab))
+  (princ (eieio-object-name-string tab))
   (princ "\nPriority: ")
   (prin1 (oref tab :priority))
   (when (oref tab :application)
diff --git a/lisp/desktop.el b/lisp/desktop.el
index 1151bd434bc..9c95f597fff 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -697,83 +697,69 @@ is nil, ask the user where to save the desktop."
      ll)))
 
 ;; ----------------------------------------------------------------------------
-(defun desktop-internal-v2s (value)
-  "Convert VALUE to a pair (QUOTE . TXT); (eval (read TXT)) gives VALUE.
-TXT is a string that when read and evaluated yields VALUE.
+(defun desktop--v2s (value)
+  "Convert VALUE to a pair (QUOTE . SEXP); (eval SEXP) gives VALUE.
+SEXP is an sexp that when evaluated yields VALUE.
 QUOTE may be `may' (value may be quoted),
 `must' (value must be quoted), or nil (value must not be quoted)."
   (cond
     ((or (numberp value) (null value) (eq t value) (keywordp value))
-     (cons 'may (prin1-to-string value)))
+     (cons 'may value))
     ((stringp value)
      (let ((copy (copy-sequence value)))
        (set-text-properties 0 (length copy) nil copy)
-       ;; Get rid of text properties because we cannot read them
-       (cons 'may (prin1-to-string copy))))
+       ;; Get rid of text properties because we cannot read them.
+       (cons 'may copy)))
     ((symbolp value)
-     (cons 'must (prin1-to-string value)))
+     (cons 'must value))
     ((vectorp value)
-     (let* ((special nil)
-            (pass1 (mapcar
-                    (lambda (el)
-                      (let ((res (desktop-internal-v2s el)))
-                        (if (null (car res))
-                            (setq special t))
-                        res))
-                    value)))
+     (let* ((pass1 (mapcar #'desktop--v2s value))
+            (special (assq nil pass1)))
        (if special
-           (cons nil (concat "(vector "
-                             (mapconcat (lambda (el)
-                                          (if (eq (car el) 'must)
-                                              (concat "'" (cdr el))
-                                            (cdr el)))
-                                        pass1
-                                        " ")
-                             ")"))
-         (cons 'may (concat "[" (mapconcat 'cdr pass1 " ") "]")))))
+           (cons nil `(vector
+                       ,@(mapcar (lambda (el)
+                                   (if (eq (car el) 'must)
+                                       `',(cdr el) (cdr el)))
+                                 pass1)))
+         (cons 'may `[,@(mapcar #'cdr pass1)]))))
     ((consp value)
      (let ((p value)
            newlist
            use-list*
            anynil)
        (while (consp p)
-         (let ((q.txt (desktop-internal-v2s (car p))))
-           (or anynil (setq anynil (null (car q.txt))))
-           (setq newlist (cons q.txt newlist)))
+         (let ((q.sexp (desktop--v2s (car p))))
+           (push q.sexp newlist))
          (setq p (cdr p)))
-       (if p
-           (let ((last (desktop-internal-v2s p)))
-             (or anynil (setq anynil (null (car last))))
-             (or anynil
-                 (setq newlist (cons '(must . ".") newlist)))
-             (setq use-list* t)
-             (setq newlist (cons last newlist))))
-       (setq newlist (nreverse newlist))
-       (if anynil
+       (when p
+         (let ((last (desktop--v2s p)))
+           (setq use-list* t)
+           (push last newlist)))
+       (if (assq nil newlist)
            (cons nil
-                 (concat (if use-list* "(desktop-list* "  "(list ")
-                         (mapconcat (lambda (el)
-                                      (if (eq (car el) 'must)
-                                          (concat "'" (cdr el))
-                                        (cdr el)))
-                                    newlist
-                                    " ")
-                         ")"))
+                 `(,(if use-list* 'desktop-list* 'list)
+                   ,@(mapcar (lambda (el)
+                               (if (eq (car el) 'must)
+                                   `',(cdr el) (cdr el)))
+                             (nreverse newlist))))
          (cons 'must
-               (concat "(" (mapconcat 'cdr newlist " ") ")")))))
+               `(,@(mapcar #'cdr
+                           (nreverse (if use-list* (cdr newlist) newlist)))
+                 ,@(if use-list* (cdar newlist)))))))
     ((subrp value)
-     (cons nil (concat "(symbol-function '"
-                       (substring (prin1-to-string value) 7 -1)
-                       ")")))
+     (cons nil `(symbol-function
+                 ',(intern-soft (substring (prin1-to-string value) 7 -1)))))
     ((markerp value)
-     (let ((pos (prin1-to-string (marker-position value)))
-           (buf (prin1-to-string (buffer-name (marker-buffer value)))))
-       (cons nil (concat "(let ((mk (make-marker)))"
-                         " (add-hook 'desktop-delay-hook"
-                         " (list 'lambda '() (list 'set-marker mk "
-                         pos " (get-buffer " buf ")))) mk)"))))
-    (t                                   ; save as text
-     (cons 'may "\"Unprintable entity\""))))
+     (let ((pos (marker-position value))
+           (buf (buffer-name (marker-buffer value))))
+       (cons nil
+             `(let ((mk (make-marker)))
+                (add-hook 'desktop-delay-hook
+                          `(lambda ()
+                             (set-marker ,mk ,,pos (get-buffer ,,buf))))
+                mk))))
+    (t                                  ; Save as text.
+     (cons 'may "Unprintable entity"))))
 
 ;; ----------------------------------------------------------------------------
 (defun desktop-value-to-string (value)
@@ -781,9 +767,11 @@ QUOTE may be `may' (value may be quoted),
 Not all types of values are supported."
   (let* ((print-escape-newlines t)
          (float-output-format nil)
-         (quote.txt (desktop-internal-v2s value))
-         (quote (car quote.txt))
-         (txt (cdr quote.txt)))
+         (quote.sexp (desktop--v2s value))
+         (quote (car quote.sexp))
+         (txt
+          (let ((print-quoted t))
+            (prin1-to-string (cdr quote.sexp)))))
     (if (eq quote 'must)
         (concat "'" txt)
       txt)))
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index ee77f397746..6217f5d0a3f 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -326,7 +326,7 @@ of the page moves to the previous page."
       (delete-overlay ol))
     (image-mode-window-put 'overlay ol winprops)
     (when (windowp (car winprops))
-      (if (stringp (get-char-property (point-min) 'display))
+      (if (stringp (overlay-get ol 'display))
           ;; We're not already displaying an image, so this is the
           ;; initial window showing the document.
           (run-with-timer nil nil
@@ -338,12 +338,11 @@ of the page moves to the previous page."
                               (with-selected-window (car winprops)
                                 (doc-view-goto-page 1)))))
         ;; We've split the window showing the document.  All we need
-        ;; to do is selecting the new window to make the image appear
-        ;; there, too.
+        ;; to do is selecting the new window to cause a redisplay to
+        ;; make the image appear there, too.
         (run-with-timer nil nil
                         (lambda ()
-                          (save-window-excursion
-                            (select-window (car winprops)))))))))
+                          (with-selected-window (car winprops))))))))
 
 (defvar doc-view-current-files nil
   "Only used internally.")
@@ -1026,7 +1025,7 @@ Start by converting PAGES, and then the rest."
            ;; not sufficient.
            (dolist (win (get-buffer-window-list (current-buffer) nil 'visible))
              (with-selected-window win
-               (when (stringp (get-char-property (point-min) 'display))
+               (when (stringp (overlay-get (doc-view-current-overlay) 'display))
                  (doc-view-goto-page (doc-view-current-page)))))
            ;; Convert the rest of the pages.
            (doc-view-pdf/ps->png pdf png)))))))
diff --git a/lisp/emacs-lisp/crm.el b/lisp/emacs-lisp/crm.el
index f88cb0ef9bb..e1e1847dd59 100644
--- a/lisp/emacs-lisp/crm.el
+++ b/lisp/emacs-lisp/crm.el
@@ -287,7 +287,8 @@ INHERIT-INPUT-METHOD."
                        prompt initial-input map
                        nil hist def inherit-input-method)))
           (and def (string-equal input "") (setq input def))
-          (split-string input crm-separator)))
+          ;; Ignore empty strings in the list of return values.
+          (split-string input crm-separator t)))
     (remove-hook 'choose-completion-string-functions
                  'crm--choose-completion-string)))
 
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 4cbd02a6e0d..41b02da82fe 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -3875,7 +3875,10 @@ Options:
   ;; If the user kills the buffer in which edebug is currently active,
   ;; exit to top level, because the edebug command loop can't usefully
   ;; continue running in such a case.
-  (add-hook 'kill-buffer-hook 'edebug-kill-buffer nil t)
+  ;;
+  ;; Append `edebug-kill-buffer' to the hook to avoid interfering with
+  ;; other entries that are ungarded against deleted buffer.
+  (add-hook 'kill-buffer-hook 'edebug-kill-buffer t t)
   (use-local-map edebug-mode-map))
 
 (defun edebug-kill-buffer ()
diff --git a/lisp/emacs-lisp/eieio-datadebug.el b/lisp/emacs-lisp/eieio-datadebug.el
index 7daa24257a1..d3ae8b191e1 100644
--- a/lisp/emacs-lisp/eieio-datadebug.el
+++ b/lisp/emacs-lisp/eieio-datadebug.el
@@ -80,38 +80,39 @@ PREBUTTONTEXT is some text between PREFIX and the object button."
 ;; Each object should have an opportunity to show stuff about itself.
 
 (defmethod data-debug/eieio-insert-slots ((obj eieio-default-superclass)
-                                                prefix)
+                                          prefix)
   "Insert the slots of OBJ into the current DDEBUG buffer."
-  (data-debug-insert-thing (eieio-object-name-string obj)
-                                prefix
-                                "Name: ")
-  (let* ((cl (eieio-object-class obj))
-         (cv (class-v cl)))
-    (data-debug-insert-thing (class-constructor cl)
-                                  prefix
-                                  "Class: ")
-    ;; Loop over all the public slots
-    (let ((publa (eieio--class-public-a cv))
-          )
-      (while publa
-        (if (slot-boundp obj (car publa))
-            (let* ((i (class-slot-initarg cl (car publa)))
-                   (v (eieio-oref obj (car publa))))
-              (data-debug-insert-thing
-               v prefix (concat
-                         (if i (symbol-name i)
-                           (symbol-name (car publa)))
-                         " ")))
-          ;; Unbound case
-          (let ((i (class-slot-initarg cl (car publa))))
-            (data-debug-insert-custom
-             "#unbound" prefix
-             (concat (if i (symbol-name i)
-                       (symbol-name (car publa)))
-                     " ")
-             'font-lock-keyword-face))
-          )
-        (setq publa (cdr publa))))))
+  (let ((inhibit-read-only t))
+    (data-debug-insert-thing (eieio-object-name-string obj)
+                             prefix
+                             "Name: ")
+    (let* ((cl (eieio-object-class obj))
+           (cv (class-v cl)))
+      (data-debug-insert-thing (class-constructor cl)
+                               prefix
+                               "Class: ")
+      ;; Loop over all the public slots
+      (let ((publa (eieio--class-public-a cv))
+            )
+        (while publa
+          (if (slot-boundp obj (car publa))
+              (let* ((i (class-slot-initarg cl (car publa)))
+                     (v (eieio-oref obj (car publa))))
+                (data-debug-insert-thing
+                 v prefix (concat
+                           (if i (symbol-name i)
+                             (symbol-name (car publa)))
+                           " ")))
+            ;; Unbound case
+            (let ((i (class-slot-initarg cl (car publa))))
+              (data-debug-insert-custom
+               "#unbound" prefix
+               (concat (if i (symbol-name i)
+                         (symbol-name (car publa)))
+                       " ")
+               'font-lock-keyword-face))
+            )
+          (setq publa (cdr publa)))))))
 
 ;;; Augment the Data debug thing display list.
 (data-debug-add-specialized-thing (lambda (thing) (object-p thing))
diff --git a/lisp/emacs-lisp/eldoc.el b/lisp/emacs-lisp/eldoc.el
index 5a6b486dcd0..4efbdcb22cb 100644
--- a/lisp/emacs-lisp/eldoc.el
+++ b/lisp/emacs-lisp/eldoc.el
@@ -146,6 +146,10 @@ directly.  Instead, use `eldoc-add-command' and `eldoc-remove-command'.")
   "Idle time delay currently in use by timer.
 This is used to determine if `eldoc-idle-delay' is changed by the user.")
 
+(defvar eldoc-message-function 'eldoc-minibuffer-message
+  "The function used by `eldoc-message' to display messages.
+It should receive the same arguments as `message'.")
+
 
 ;;;###autoload
 (define-minor-mode eldoc-mode
@@ -170,6 +174,20 @@ expression point is on."
    (remove-hook 'pre-command-hook 'eldoc-pre-command-refresh-echo-area)))
 
 ;;;###autoload
+(define-minor-mode eldoc-post-insert-mode nil
+  :group 'eldoc :lighter (:eval (if eldoc-mode ""
+                                  (concat eldoc-minor-mode-string "|i")))
+  (setq eldoc-last-message nil)
+  (let ((prn-info (lambda ()
+                    (unless eldoc-mode
+                      (eldoc-print-current-symbol-info)))))
+    (if eldoc-post-insert-mode
+        (add-hook 'post-self-insert-hook prn-info nil t)
+      (remove-hook 'post-self-insert-hook prn-info t))))
+
+(add-hook 'eval-expression-minibuffer-setup-hook 'eldoc-post-insert-mode)
+
+;;;###autoload
 (defun turn-on-eldoc-mode ()
   "Unequivocally turn on ElDoc mode (see command `eldoc-mode')."
   (interactive)
@@ -180,14 +198,46 @@ expression point is on."
   (or (and eldoc-timer
            (memq eldoc-timer timer-idle-list))
       (setq eldoc-timer
-            (run-with-idle-timer eldoc-idle-delay t
-                                 'eldoc-print-current-symbol-info)))
+            (run-with-idle-timer
+             eldoc-idle-delay t
+             (lambda () (and eldoc-mode (eldoc-print-current-symbol-info))))))
 
   ;; If user has changed the idle delay, update the timer.
   (cond ((not (= eldoc-idle-delay eldoc-current-idle-delay))
          (setq eldoc-current-idle-delay eldoc-idle-delay)
          (timer-set-idle-time eldoc-timer eldoc-idle-delay t))))
 
+(defvar eldoc-mode-line-string nil)
+(put 'eldoc-mode-line-string 'risky-local-variable t)
+
+(defun eldoc-minibuffer-message (format-string &rest args)
+  "Display messages in the mode-line when in the minibuffer.
+Otherwise work like `message'."
+  (if (minibufferp)
+      (progn
+        (with-current-buffer
+            (window-buffer
+             (or (window-in-direction 'above (minibuffer-window))
+                 (minibuffer-selected-window)
+                 (get-largest-window)))
+          (unless (and (listp mode-line-format)
+                       (assq 'eldoc-mode-line-string mode-line-format))
+            (setq mode-line-format
+                  (list "" '(eldoc-mode-line-string
+                             (" " eldoc-mode-line-string " "))
+                        mode-line-format))))
+        (add-hook 'minibuffer-exit-hook
+                  (lambda () (setq eldoc-mode-line-string nil))
+                  nil t)
+        (cond
+         ((null format-string)
+          (setq eldoc-mode-line-string nil))
+         ((stringp format-string)
+          (setq eldoc-mode-line-string
+                (apply 'format format-string args))))
+        (force-mode-line-update))
+    (apply 'message format-string args)))
+
 (defun eldoc-message (&rest args)
   (let ((omessage eldoc-last-message))
     (setq eldoc-last-message
@@ -203,8 +253,9 @@ expression point is on."
     ;; they are Legion.
     ;; Emacs way of preventing log messages.
     (let ((message-log-max nil))
-      (cond (eldoc-last-message (message "%s" eldoc-last-message))
-            (omessage (message nil)))))
+      (cond (eldoc-last-message
+             (funcall eldoc-message-function "%s" eldoc-last-message))
+            (omessage (funcall eldoc-message-function nil)))))
   eldoc-last-message)
 
 ;; This function goes on pre-command-hook for XEmacs or when using idle
@@ -236,11 +287,7 @@ expression point is on."
 (defun eldoc-display-message-no-interference-p ()
   (and eldoc-mode
        (not executing-kbd-macro)
-       (not (and (boundp 'edebug-active) edebug-active))
-       ;; Having this mode operate in an active minibuffer/echo area causes
-       ;; interference with what's going on there.
-       (not cursor-in-echo-area)
-       (not (eq (selected-window) (minibuffer-window)))))
+       (not (and (boundp 'edebug-active) edebug-active))))
 
 
 ;;;###autoload
@@ -262,7 +309,7 @@ Emacs Lisp mode) that support ElDoc.")
 
 (defun eldoc-print-current-symbol-info ()
   (condition-case err
-      (and (eldoc-display-message-p)
+      (and (or (eldoc-display-message-p) eldoc-post-insert-mode)
            (if eldoc-documentation-function
                (eldoc-message (funcall eldoc-documentation-function))
              (let* ((current-symbol (eldoc-current-symbol))
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 4ebaa0a49d5..b528dd11316 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -1436,6 +1436,8 @@ Any non-integer value means do not use a different value of
   :type '(choice (integer)
                  (const :tag "Use the current `fill-column'" t))
   :group 'lisp)
+(put 'emacs-lisp-docstring-fill-column 'safe-local-variable
+     (lambda (x) (or (eq x t) (integerp x))))
 
 (defun lisp-fill-paragraph (&optional justify)
   "Like \\[fill-paragraph], but handle Emacs Lisp comments and docstrings.
diff --git a/lisp/emacs-lisp/smie.el b/lisp/emacs-lisp/smie.el
index eb3fa8f3b09..18cc0e811ce 100644
--- a/lisp/emacs-lisp/smie.el
+++ b/lisp/emacs-lisp/smie.el
@@ -1631,31 +1631,34 @@ to which that point should be aligned, if we were to reindent it.")
 (defun smie-auto-fill ()
   (let ((fc (current-fill-column)))
     (while (and fc (> (current-column) fc))
-      (cond
-       ((not (or (nth 8 (save-excursion
-                          (syntax-ppss (line-beginning-position))))
-                 (nth 8 (syntax-ppss))))
-        (save-excursion
-          (beginning-of-line)
-          (smie-indent-forward-token)
-          (let ((bsf (point))
-                (gain 0)
-                curcol)
-            (while (<= (setq curcol (current-column)) fc)
-              ;; FIXME?  `smie-indent-calculate' can (and often will)
-              ;; return a result that actually depends on the presence/absence
-              ;; of a newline, so the gain computed here may not be accurate,
-              ;; but in practice it seems to works well enough.
-              (let* ((newcol (smie-indent-calculate))
-                     (newgain (- curcol newcol)))
-                (when (> newgain gain)
-                  (setq gain newgain)
-                  (setq bsf (point))))
-              (smie-indent-forward-token))
-            (when (> gain 0)
-              (goto-char bsf)
-              (newline-and-indent)))))
-       (t (do-auto-fill))))))
+      (or (unless (or (nth 8 (save-excursion
+                               (syntax-ppss (line-beginning-position))))
+                      (nth 8 (syntax-ppss)))
+            (save-excursion
+              (let ((end (point))
+                    (bsf (progn (beginning-of-line)
+                                (smie-indent-forward-token)
+                                (point)))
+                    (gain 0)
+                    curcol)
+                (while (and (<= (point) end)
+                            (<= (setq curcol (current-column)) fc))
+                  ;; FIXME?  `smie-indent-calculate' can (and often will)
+                  ;; return a result that actually depends on the
+                  ;; presence/absence of a newline, so the gain computed here
+                  ;; may not be accurate, but in practice it seems to works
+                  ;; well enough.
+                  (let* ((newcol (smie-indent-calculate))
+                         (newgain (- curcol newcol)))
+                    (when (> newgain gain)
+                      (setq gain newgain)
+                      (setq bsf (point))))
+                  (smie-indent-forward-token))
+                (when (> gain 0)
+                  (goto-char bsf)
+                  (newline-and-indent)
+                  'done))))
+          (do-auto-fill)))))
 
 
 (defun smie-setup (grammar rules-function &rest keywords)
diff --git a/lisp/eshell/em-prompt.el b/lisp/eshell/em-prompt.el
index c1c4d4730f9..c5429c59bd6 100644
--- a/lisp/eshell/em-prompt.el
+++ b/lisp/eshell/em-prompt.el
@@ -122,6 +122,7 @@ arriving, or after."
            (add-text-properties 0 (length prompt)
                                 '(read-only t
                                   face eshell-prompt
+                                  front-sticky (face read-only)
                                   rear-nonsticky (face read-only))
                                 prompt))
       (eshell-interactive-print prompt)))
diff --git a/lisp/files.el b/lisp/files.el
index 9da9ac6fd53..06958622d14 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -1516,7 +1516,10 @@ expand wildcards (if any) and replace the file with multiple files."
 (defvar kill-buffer-hook nil
   "Hook run when a buffer is killed.
 The buffer being killed is current while the hook is running.
-See `kill-buffer'.")
+See `kill-buffer'.
+
+Note: Be careful with let-binding this hook considering it is
+frequently used for cleanup.")
 
 (defun find-alternate-file (filename &optional wildcards)
   "Find file FILENAME, select its buffer, kill previous buffer.
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 9436012ee59..f9b75243494 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -2323,12 +2323,12 @@ in which C preprocessor directives are used. e.g. `asm-mode' and
           "\\_>")
           . 1)
        ;; Exit/Feature symbols as constants.
-       (,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\>"
+       (,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\_>"
                  "[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?")
         (1 font-lock-keyword-face)
         (2 font-lock-constant-face nil t))
        ;; Erroneous structures.
-       ("(\\(abort\\|assert\\|warn\\|check-type\\|cerror\\|error\\|signal\\)\\>" 1 font-lock-warning-face)
+       ("(\\(abort\\|assert\\|warn\\|check-type\\|cerror\\|error\\|signal\\)\\_>" 1 font-lock-warning-face)
        ;; Words inside \\[] tend to be for `substitute-command-keys'.
        ("\\\\\\\\\\[\\(\\(?:\\sw\\|\\s_\\)+\\)\\]"
         (1 font-lock-constant-face prepend))
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 870164023d5..9fffc4f1a45 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,15 @@
+2013-03-26  Andrew Cohen  <cohen@bu.edu>
+
+        * nnir.el: Major rewrite. Cleaner separation between searches and group
+        management. Marks are now shown in nnir summary buffers. Rudimentary
+        support for real (i.e. not ephemeral) nnir groups.
+        (gnus-summary-make-nnir-group): New function for initiating searches
+        from a summary buffer.
+
+2013-03-18  Sam Steingold  <sds@gnu.org>
+
+        * message.el (message-bury): Minor cleanup.
+
 2013-03-06  Katsumi Yamaoka  <yamaoka@jpl.org>
 
         * nndir.el (nndir-request-list): Remove 2nd argument passed to
diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index a6638097b47..2b2a0a94413 100644
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -4097,11 +4097,9 @@ Instead, just auto-save the buffer and then bury it."
 
 (defun message-bury (buffer)
   "Bury this mail BUFFER."
-  (if message-return-action
-      (progn
-        (bury-buffer buffer)
-        (apply (car message-return-action) (cdr message-return-action)))
-    (with-current-buffer buffer (bury-buffer))))
+  (bury-buffer buffer)
+  (when message-return-action
+    (apply (car message-return-action) (cdr message-return-action))))
 
 (defun message-send (&optional arg)
   "Send the message in the current buffer.
diff --git a/lisp/gnus/nnir.el b/lisp/gnus/nnir.el
index cf5a813c5a8..cabd08b0653 100644
--- a/lisp/gnus/nnir.el
+++ b/lisp/gnus/nnir.el
@@ -29,10 +29,6 @@
 
 ;;; Commentary:
 
-;; TODO: Documentation in the Gnus manual
-
-;; Where in the existing gnus manual would this fit best?
-
 ;; What does it do?  Well, it allows you to search your mail using
 ;; some search engine (imap, namazu, swish-e, gmane and others -- see
 ;; later) by typing `G G' in the Group buffer.  You will then get a
@@ -136,17 +132,26 @@
 ;; other backend.
 
 ;; The interface between the two layers consists of the single
-;; function `nnir-run-query', which just selects the appropriate
-;; function for the search engine one is using.  The input to
-;; `nnir-run-query' is a string, representing the query as input by
-;; the user.  The output of `nnir-run-query' is supposed to be a
-;; vector, each element of which should in turn be a three-element
-;; vector.  The first element should be full group name of the article,
-;; the second element should be the article number, and the third
-;; element should be the Retrieval Status Value (RSV) as returned from
-;; the search engine.  An RSV is the score assigned to the document by
-;; the search engine.  For Boolean search engines, the
-;; RSV is always 1000 (or 1 or 100, or whatever you like).
+;; function `nnir-run-query', which dispatches the search to the
+;; proper search function.  The argument of `nnir-run-query' is an
+;; alist with two keys: 'nnir-query-spec and 'nnir-group-spec. The
+;; value for 'nnir-query-spec is an alist. The only required key/value
+;; pair is (query . "query") specifying the search string to pass to
+;; the query engine. Individual engines may have other elements. The
+;; value of 'nnir-group-spec is a list with the specification of the
+;; groups/servers to search.  The format of the 'nnir-group-spec is
+;; (("server1" ("group11" "group12")) ("server2" ("group21"
+;; "group22"))). If any of the group lists is absent then all groups
+;; on that server are searched.
+
+;; The output of `nnir-run-query' is supposed to be a vector, each
+;; element of which should in turn be a three-element vector.  The
+;; first element should be full group name of the article, the second
+;; element should be the article number, and the third element should
+;; be the Retrieval Status Value (RSV) as returned from the search
+;; engine.  An RSV is the score assigned to the document by the search
+;; engine.  For Boolean search engines, the RSV is always 1000 (or 1
+;; or 100, or whatever you like).
 
 ;; The sorting order of the articles in the summary buffer created by
 ;; nnir is based on the order of the articles in the above mentioned
@@ -179,26 +184,21 @@
 
 ;;; Internal Variables:
 
-(defvar nnir-current-query nil
-  "Internal: stores current query (= group name).")
-
-(defvar nnir-current-server nil
-  "Internal: stores current server (does it ever change?).")
+(defvar nnir-memo-query nil
+  "Internal: stores current query.")
 
-(defvar nnir-current-group-marked nil
-  "Internal: stores current list of process-marked groups.")
+(defvar nnir-memo-server nil
+  "Internal: stores current server.")
 
 (defvar nnir-artlist nil
   "Internal: stores search result.")
 
-(defvar nnir-tmp-buffer " *nnir*"
-  "Internal: temporary buffer.")
-
 (defvar nnir-search-history ()
   "Internal: the history for querying search options in nnir")
 
-(defvar nnir-extra-parms nil
-  "Internal: stores request for extra search parms")
+(defconst nnir-tmp-buffer " *nnir*"
+  "Internal: temporary buffer.")
+
 
 ;; Imap variables
 
@@ -290,14 +290,14 @@ is `(valuefunc member)'."
   (autoload 'nnimap-command "nnimap")
   (autoload 'nnimap-possibly-change-group "nnimap")
   (autoload 'nnimap-make-thread-query "nnimap")
-  (autoload 'gnus-registry-action "gnus-registry"))
+  (autoload 'gnus-registry-action "gnus-registry")
+  (autoload 'gnus-registry-get-id-key "gnus-registry")
+  (autoload 'gnus-group-topic-name "gnus-topic"))
+
 
 (nnoo-declare nnir)
 (nnoo-define-basics nnir)
 
-(defvoo nnir-address nil
-  "The address of the nnir server.")
-
 (gnus-declare-backend "nnir" 'mail 'virtual)
 
 
@@ -344,7 +344,7 @@ result, `gnus-retrieve-headers' will be called instead."
 (defcustom nnir-imap-default-search-key "whole message"
   "*The default IMAP search key for an nnir search. Must be one of
   the keys in `nnir-imap-search-arguments'. To use raw imap queries
-  by default set this to \"Imap\"."
+  by default set this to \"imap\"."
   :version "24.1"
   :type `(choice ,@(mapcar (lambda (elem) (list 'const (car elem)))
                            nnir-imap-search-arguments))
@@ -546,17 +546,17 @@ that it is for notmuch, not Namazu."
                ,nnir-imap-default-search-key      ; default
                )))
     (gmane   nnir-run-gmane
-             ((author . "Gmane Author: ")))
+             ((gmane-author . "Gmane Author: ")))
     (swish++ nnir-run-swish++
-             ((group . "Swish++ Group spec: ")))
+             ((swish++-group . "Swish++ Group spec: ")))
     (swish-e nnir-run-swish-e
-             ((group . "Swish-e Group spec: ")))
+             ((swish-e-group . "Swish-e Group spec: ")))
     (namazu  nnir-run-namazu
              ())
     (notmuch nnir-run-notmuch
              ())
     (hyrex   nnir-run-hyrex
-             ((group . "Hyrex Group spec: ")))
+             ((hyrex-group . "Hyrex Group spec: ")))
     (find-grep nnir-run-find-grep
                ((grep-options . "Grep options: "))))
   "Alist of supported search engines.
@@ -576,69 +576,113 @@ needs the variables `nnir-namazu-program',
 
 Add an entry here when adding a new search engine.")
 
-(defcustom nnir-method-default-engines
-  '((nnimap . imap)
-    (nntp . gmane))
+(defcustom nnir-method-default-engines  '((nnimap . imap) (nttp . gmane))
   "*Alist of default search engines keyed by server method."
   :version "24.1"
+  :group 'nnir
   :type `(repeat (cons (choice (const nnimap) (const nttp) (const nnspool)
                                (const nneething) (const nndir) (const nnmbox)
                                (const nnml) (const nnmh) (const nndraft)
                                (const nnfolder) (const nnmaildir))
                        (choice
                         ,@(mapcar (lambda (elem) (list 'const (car elem)))
-                                  nnir-engines))))
-  :group 'nnir)
+                                  nnir-engines)))))
 
 ;; Gnus glue.
 
-(defun gnus-group-make-nnir-group (nnir-extra-parms &optional parms)
-  "Create an nnir group.  Asks for query."
+(defun gnus-group-make-nnir-group (nnir-extra-parms &optional specs)
+  "Create an nnir group.  Prompt for a search query and determine
+the groups to search as follows: if called from the *Server*
+buffer search all groups belonging to the server on the current
+line; if called from the *Group* buffer search any marked groups,
+or the group on the current line, or all the groups under the
+current topic. Calling with a prefix-arg prompts for additional
+search-engine specific constraints. A non-nil `specs' arg must be
+an alist with `nnir-query-spec' and `nnir-group-spec' keys, and
+skips all prompting."
   (interactive "P")
-  (setq nnir-current-query nil
-        nnir-current-server nil
-        nnir-current-group-marked nil
-        nnir-artlist nil)
-  (let* ((query (unless parms (read-string "Query: " nil 'nnir-search-history)))
-         (parms (or parms (list (cons 'query query))))
-         (srv (or (cdr (assq 'server parms)) (gnus-server-server-name) "nnir")))
-   (add-to-list 'parms (cons 'unique-id (message-unique-id)) t)
+  (let* ((group-spec
+          (or (cdr (assoc 'nnir-group-spec specs))
+            (if (gnus-server-server-name)
+                (list (list (gnus-server-server-name)))
+              (nnir-categorize
+               (or gnus-group-marked
+                   (if (gnus-group-group-name)
+                       (list (gnus-group-group-name))
+                     (cdr (assoc (gnus-group-topic-name) gnus-topic-alist))))
+               gnus-group-server))))
+         (query-spec
+          (or (cdr (assoc 'nnir-query-spec specs))
+            (apply
+             'append
+             (list (cons 'query
+                         (read-string "Query: " nil 'nnir-search-history)))
+             (when nnir-extra-parms
+               (mapcar
+                (lambda (x)
+                  (nnir-read-parms (nnir-server-to-search-engine (car x))))
+                group-spec))))))
     (gnus-group-read-ephemeral-group
-     (concat "nnir:" (prin1-to-string parms)) (list 'nnir srv) t
-     (cons (current-buffer) gnus-current-window-configuration)
-     nil)))
+     (concat "nnir-" (message-unique-id))
+     (list 'nnir "nnir")
+     nil
+;     (cons (current-buffer) gnus-current-window-configuration)
+     nil
+     nil nil
+     (list
+      (cons 'nnir-specs (list (cons 'nnir-query-spec query-spec)
+                              (cons 'nnir-group-spec group-spec)))
+      (cons 'nnir-artlist nil)))))
+
+(defun gnus-summary-make-nnir-group (nnir-extra-parms)
+  "Search a group from the summary buffer."
+  (interactive "P")
+  (gnus-warp-to-article)
+  (let ((spec
+         (list
+          (cons 'nnir-group-spec
+                (list (list
+                       (gnus-group-server gnus-newsgroup-name)
+                       (list gnus-newsgroup-name)))))))
+    (gnus-group-make-nnir-group nnir-extra-parms spec)))
 
 
 ;; Gnus backend interface functions.
 
 (deffoo nnir-open-server (server &optional definitions)
   ;; Just set the server variables appropriately.
-  (add-hook 'gnus-summary-mode-hook 'nnir-mode)
-  (nnoo-change-server 'nnir server definitions))
-
-(deffoo nnir-request-group (group &optional server fast info)
-  "GROUP is the query string."
-  (nnir-possibly-change-server server)
-  ;; Check for cache and return that if appropriate.
-  (if (and (equal group nnir-current-query)
-           (equal gnus-group-marked nnir-current-group-marked)
-           (or (null server)
-               (equal server nnir-current-server)))
-      nnir-artlist
-    ;; Cache miss.
-    (setq nnir-artlist (nnir-run-query group)))
-  (with-current-buffer nntp-server-buffer
-    (setq nnir-current-query group)
-    (when server (setq nnir-current-server server))
-    (setq nnir-current-group-marked gnus-group-marked)
-    (if (zerop (length nnir-artlist))
-        (nnheader-report 'nnir "Search produced empty results.")
-      ;; Remember data for cache.
-      (nnheader-insert "211 %d %d %d %s\n"
-                       (nnir-artlist-length nnir-artlist) ; total #
-                       1              ; first #
-                       (nnir-artlist-length nnir-artlist) ; last #
-                       group))))      ; group name
+  (let ((backend (car (gnus-server-to-method server))))
+    (if backend
+        (nnoo-change-server backend server definitions)
+      (add-hook 'gnus-summary-mode-hook 'nnir-mode)
+      (nnoo-change-server 'nnir server definitions))))
+
+(deffoo nnir-request-group (group &optional server dont-check info)
+  (nnir-possibly-change-group group server)
+  (let ((pgroup (if (gnus-group-prefixed-p group)
+                    group
+                  (gnus-group-prefixed-name  group '(nnir "nnir"))))
+        length)
+    ;; Check for cached search result or run the query and cache the
+    ;; result.
+    (unless (and nnir-artlist dont-check)
+      (gnus-group-set-parameter
+       pgroup 'nnir-artlist
+       (setq nnir-artlist
+             (nnir-run-query
+              (gnus-group-get-parameter pgroup 'nnir-specs t))))
+      (nnir-request-update-info pgroup (gnus-get-info pgroup)))
+    (with-current-buffer nntp-server-buffer
+      (if (zerop (setq length (nnir-artlist-length nnir-artlist)))
+          (progn
+            (nnir-close-group group)
+            (nnheader-report 'nnir "Search produced empty results."))
+        (nnheader-insert "211 %d %d %d %s\n"
+                         length    ; total #
+                         1         ; first #
+                         length    ; last #
+                         group)))) ; group name
+  nnir-artlist)
 
 (deffoo nnir-retrieve-headers (articles &optional group server fetch-old)
   (with-current-buffer nntp-server-buffer
@@ -654,13 +698,7 @@ Add an entry here when adding a new search engine.")
                (server (gnus-group-server artgroup))
                (gnus-override-method (gnus-server-to-method server))
                parsefunc)
-          ;; (or (numberp art)
-          ;;     (nnheader-report
-          ;;      'nnir
-          ;;      "nnir-retrieve-headers doesn't grok message ids: %s"
-          ;;      art))
-          (nnir-possibly-change-server server)
-          ;; is this needed?
+          ;; (nnir-possibly-change-group nil server)
           (erase-buffer)
           (case (setq gnus-headers-retrieved-by
                       (or
@@ -694,6 +732,7 @@ Add an entry here when adding a new search engine.")
       'nov)))
 
 (deffoo nnir-request-article (article &optional group server to-buffer)
+  (nnir-possibly-change-group group server)
   (if (and (stringp article)
            (not (eq 'nnimap (car (gnus-server-to-method server)))))
       (nnheader-report
@@ -702,35 +741,35 @@ Add an entry here when adding a new search engine.")
        server)
     (save-excursion
       (let ((article article)
-            query)
-        (when (stringp article)
-          (setq gnus-override-method (gnus-server-to-method server))
-          (setq query
-                (list
-                 (cons 'query (format "HEADER Message-ID %s" article))
-                 (cons 'unique-id article)
-                 (cons 'criteria "")
-                 (cons 'shortcut t)))
-          (unless (and (equal query nnir-current-query)
-                       (equal server nnir-current-server))
-            (setq nnir-artlist (nnir-run-imap query server))
-            (setq nnir-current-query query)
-            (setq nnir-current-server server))
-          (setq article 1))
-        (unless (zerop (length nnir-artlist))
-          (let ((artfullgroup (nnir-article-group article))
-                (artno (nnir-article-number article)))
-            (message "Requesting article %d from group %s"
-                     artno artfullgroup)
-            (if to-buffer
-                (with-current-buffer to-buffer
-                  (let ((gnus-article-decode-hook nil))
-                    (gnus-request-article-this-buffer artno artfullgroup)))
-              (gnus-request-article artno artfullgroup))
-            (cons artfullgroup artno)))))))
+            query)
+        (when (stringp article)
+          (setq gnus-override-method (gnus-server-to-method server))
+          (setq query
+                (list
+                 (cons 'query (format "HEADER Message-ID %s" article))
+                 (cons 'criteria "")
+                 (cons 'shortcut t)))
+          (unless (and nnir-artlist (equal query nnir-memo-query)
+                       (equal server nnir-memo-server))
+            (setq nnir-artlist (nnir-run-imap query server)
+                  nnir-memo-query query
+                  nnir-memo-server server))
+          (setq article 1))
+        (unless (zerop (nnir-artlist-length nnir-artlist))
+          (let ((artfullgroup (nnir-article-group article))
+                (artno (nnir-article-number article)))
+            (message "Requesting article %d from group %s"
+                     artno artfullgroup)
+            (if to-buffer
+                (with-current-buffer to-buffer
+                  (let ((gnus-article-decode-hook nil))
+                    (gnus-request-article-this-buffer artno artfullgroup)))
+              (gnus-request-article artno artfullgroup))
+            (cons artfullgroup artno)))))))
 
 (deffoo nnir-request-move-article (article group server accept-form
                                            &optional last internal-move-group)
+  (nnir-possibly-change-group group server)
   (let* ((artfullgroup (nnir-article-group article))
          (artno (nnir-article-number article))
          (to-newsgroup (nth 1 accept-form))
@@ -751,6 +790,7 @@ Add an entry here when adding a new search engine.")
           (gnus-group-real-name to-newsgroup)))))
 
 (deffoo nnir-request-expire-articles (articles group &optional server force)
+  (nnir-possibly-change-group group server)
   (if force
     (let ((articles-by-group (nnir-categorize
                               articles nnir-article-group nnir-article-ids))
@@ -772,20 +812,79 @@ Add an entry here when adding a new search engine.")
     articles))
 
 (deffoo nnir-warp-to-article ()
+  (nnir-possibly-change-group gnus-newsgroup-name)
   (let* ((cur (if (> (gnus-summary-article-number) 0)
                   (gnus-summary-article-number)
-                (error "This is not a real article")))
+                (error "Can't warp to a pseudo-article")))
          (backend-article-group (nnir-article-group cur))
          (backend-article-number (nnir-article-number cur))
          (quit-config (gnus-ephemeral-group-p gnus-newsgroup-name)))
-    ;; first exit from the nnir summary buffer.
-    (gnus-summary-exit)
+
+    ;; what should we do here? we could leave all the buffers around
+    ;; and assume that we have to exit from them one by one. or we can
+    ;; try to clean up directly
+
+    ;;first exit from the nnir summary buffer.
+;    (gnus-summary-exit)
     ;; and if the nnir summary buffer in turn came from another
     ;; summary buffer we have to clean that summary up too.
-    (when (eq (cdr quit-config) 'summary)
-      (gnus-summary-exit))
+ ;   (when (not (eq (cdr quit-config) 'group))
+;      (gnus-summary-exit))
     (gnus-summary-read-group-1 backend-article-group t t  nil
-                               nil (list backend-article-number))))
+                               nil (list backend-article-number))))
+
+
+(deffoo nnir-request-update-info (group info &optional server)
+  (let ((articles-by-group
+         (nnir-categorize
+          (number-sequence 1 (nnir-artlist-length nnir-artlist))
+          nnir-article-group nnir-article-ids)))
+    (gnus-set-active group
+                     (cons 1 (nnir-artlist-length nnir-artlist)))
+    (while (not (null articles-by-group))
+      (let* ((group-articles (pop articles-by-group))
+             (articleids (reverse (cadr group-articles)))
+             (group-info (gnus-get-info (car group-articles)))
+             (marks (gnus-info-marks group-info))
+             (read (gnus-info-read group-info)))
+        (gnus-info-set-read
+         info
+         (gnus-add-to-range
+          (gnus-info-read info)
+          (remove nil  (mapcar (lambda (art)
+                                 (let ((num (cdr art)))
+                                   (when (gnus-member-of-range num read)
+                                     (car art)))) articleids))))
+        (mapc (lambda (mark)
+                (let ((type (car mark))
+                      (range (cdr mark)))
+                  (gnus-add-marked-articles
+                   group
+                   type
+                   (remove nil
+                           (mapcar
+                            (lambda (art)
+                              (let ((num (cdr art)))
+                                (when (gnus-member-of-range num range)
+                                  (car art))))
+                            articleids))))) marks)))))
+
+
+(deffoo nnir-close-group (group &optional server)
+  (let ((pgroup (if (gnus-group-prefixed-p group)
+                    group
+                  (gnus-group-prefixed-name  group '(nnir "nnir")))))
+    (when (and nnir-artlist (not (gnus-ephemeral-group-p pgroup)))
+      (gnus-group-set-parameter  pgroup 'nnir-artlist nnir-artlist))
+    (setq nnir-artlist nil)
+    (when (gnus-ephemeral-group-p pgroup)
+      (gnus-kill-ephemeral-group pgroup)
+      (setq gnus-ephemeral-servers
+            (delq (assq 'nnir gnus-ephemeral-servers)
+                  gnus-ephemeral-servers)))))
+;; (gnus-opened-servers-remove
+;;  (car (assoc  '(nnir "nnir-ephemeral" (nnir-address "nnir"))
+;;              gnus-opened-servers))))
 
 (nnoo-define-skeleton nnir)
 
@@ -813,7 +912,7 @@ ready to be added to the list of search results."
     ;; remove trailing slash and, for nnmaildir, cur/new/tmp
     (setq dirnam
           (substring dirnam 0
-                     (if (string-match "^nnmaildir:" (gnus-group-server server))
+                     (if (string-match "\\`nnmaildir:" (gnus-group-server server))
                          -5 -1)))
 
     ;; Set group to dirnam without any leading dots or slashes,
@@ -823,7 +922,7 @@ ready to be added to the list of search results."
                  "[/\\]" "." t)))
 
     (vector (gnus-group-full-name group server)
-            (if (string-match "^nnmaildir:" (gnus-group-server server))
+            (if (string-match "\\`nnmaildir:" (gnus-group-server server))
                 (nnmaildir-base-name-to-article-number
                  (substring article 0 (string-match ":" article))
                  group nil)
@@ -850,35 +949,36 @@ details on the language and supported extensions."
       (apply
        'vconcat
        (catch 'found
-         (mapcar
-          (lambda (group)
-            (let (artlist)
-              (condition-case ()
-                  (when (nnimap-possibly-change-group
-                         (gnus-group-short-name group) server)
-                    (with-current-buffer (nnimap-buffer)
-                      (message "Searching %s..." group)
-                      (let ((arts 0)
-                            (result (nnimap-command "UID SEARCH %s"
-                                                    (if (string= criteria "")
-                                                        qstring
-                                                      (nnir-imap-make-query
-                                                       criteria qstring)))))
-                        (mapc
-                         (lambda (artnum)
-                           (let ((artn (string-to-number artnum)))
-                             (when (> artn 0)
-                               (push (vector group artn 100)
-                                     artlist)
-                               (when (assq 'shortcut query)
-                                 (throw 'found (list artlist)))
-                               (setq arts (1+ arts)))))
-                         (and (car result) (cdr (assoc "SEARCH" (cdr result)))))
-                        (message "Searching %s... %d matches" group arts)))
-                    (message "Searching %s...done" group))
-                (quit nil))
-              (nreverse artlist)))
-          groups))))))
+         (mapcar
+          (lambda (group)
+            (let (artlist)
+              (condition-case ()
+                  (when (nnimap-possibly-change-group
+                         (gnus-group-short-name group) server)
+                    (with-current-buffer (nnimap-buffer)
+                      (message "Searching %s..." group)
+                      (let ((arts 0)
+                            (result (nnimap-command "UID SEARCH %s"
+                                                    (if (string= criteria "")
+                                                        qstring
+                                                      (nnir-imap-make-query
+                                                       criteria qstring)))))
+                        (mapc
+                         (lambda (artnum)
+                           (let ((artn (string-to-number artnum)))
+                             (when (> artn 0)
+                               (push (vector group artn 100)
+                                     artlist)
+                               (when (assq 'shortcut query)
+                                 (throw 'found (list artlist)))
+                               (setq arts (1+ arts)))))
+                         (and (car result)
+                              (cdr (assoc "SEARCH" (cdr result)))))
+                        (message "Searching %s... %d matches" group arts)))
+                    (message "Searching %s...done" group))
+                (quit nil))
+              (nreverse artlist)))
+          groups))))))
 
 (defun nnir-imap-make-query (criteria qstring)
   "Parse the query string and criteria into an appropriate IMAP search
@@ -1073,14 +1173,14 @@ Windows NT 4.0."
 
   (save-excursion
     (let ( (qstring (cdr (assq 'query query)))
-           (groupspec (cdr (assq 'group query)))
+           (groupspec (cdr (assq 'swish++-group query)))
            (prefix (nnir-read-server-parm 'nnir-swish++-remove-prefix server))
            artlist
            ;; nnml-use-compressed-files might be any string, but probably this
            ;; is sufficient.  Note that we can't only use the value of
            ;; nnml-use-compressed-files because old articles might have been
            ;; saved with a different value.
-           (article-pattern (if (string-match "^nnmaildir:"
+           (article-pattern (if (string-match "\\`nnmaildir:"
                                               (gnus-group-server server))
                                 ":[0-9]+"
                               "^[0-9]+\\(\\.[a-z0-9]+\\)?$"))
@@ -1247,7 +1347,7 @@ Tested with swish-e-2.0.1 on Windows NT 4.0."
 (defun nnir-run-hyrex (query server &optional group)
   (save-excursion
     (let ((artlist nil)
-          (groupspec (cdr (assq 'group query)))
+          (groupspec (cdr (assq 'hyrex-group query)))
           (qstring (cdr (assq 'query query)))
           (prefix (nnir-read-server-parm 'nnir-hyrex-remove-prefix server))
           score artno dirnam)
@@ -1323,7 +1423,7 @@ Tested with Namazu 2.0.6 on a GNU/Linux system."
   ;; (when group
   ;;   (error "The Namazu backend cannot search specific groups"))
   (save-excursion
-    (let ((article-pattern (if (string-match "^nnmaildir:"
+    (let ((article-pattern (if (string-match "\\`nnmaildir:"
                                              (gnus-group-server server))
                                ":[0-9]+"
                              "^[0-9]+$"))
@@ -1394,10 +1494,10 @@ actually)."
 
   (save-excursion
     (let ( (qstring (cdr (assq 'query query)))
-           (groupspec (cdr (assq 'group query)))
+           (groupspec (cdr (assq 'notmuch-group query)))
            (prefix (nnir-read-server-parm 'nnir-notmuch-remove-prefix server))
            artlist
-           (article-pattern (if (string-match "^nnmaildir:"
+           (article-pattern (if (string-match "\\`nnmaildir:"
                                               (gnus-group-server server))
                                ":[0-9]+"
                              "^[0-9]+$"))
@@ -1467,24 +1567,23 @@ actually)."
          (directory (cadr (assoc sym (cddr method))))
          (regexp (cdr (assoc 'query query)))
          (grep-options (cdr (assoc 'grep-options query)))
-         (grouplist (or grouplist (nnir-get-active server)))
-         artlist)
+         (grouplist (or grouplist (nnir-get-active server))))
     (unless directory
       (error "No directory found in method specification of server %s"
              server))
     (apply
      'vconcat
      (mapcar (lambda (x)
-               (let ((group x))
+               (let ((group x)
+                     artlist)
                  (message "Searching %s using find-grep..."
                           (or group server))
                  (save-window-excursion
                    (set-buffer (get-buffer-create nnir-tmp-buffer))
-                   (erase-buffer)
                    (if (> gnus-verbose 6)
                        (pop-to-buffer (current-buffer)))
                    (cd directory) ; Using relative paths simplifies
-                                  ; postprocessing.
+                                        ; postprocessing.
                    (let ((group
                           (if (not group)
                               "."
@@ -1507,7 +1606,8 @@ actually)."
                      (save-excursion
                        (apply
                         'call-process "find" nil t
-                        "find" group "-type" "f" "-name" "[0-9]*" "-exec"
+                        "find" group "-maxdepth" "1" "-type" "f"
+                        "-name" "[0-9]*" "-exec"
                         "grep"
                         `("-l" ,@(and grep-options
                                       (split-string grep-options "\\s-" t))
@@ -1557,8 +1657,8 @@ actually)."
                              (error "Can't search non-gmane groups: %s" x)))
                            groups " "))
              (authorspec
-              (if (assq 'author query)
-                  (format "author:%s" (cdr (assq 'author query))) ""))
+              (if (assq 'gmane-author query)
+                  (format "author:%s" (cdr (assq 'gmane-author query))) ""))
              (search (format "%s %s %s"
                              qstring groupspec authorspec))
              (gnus-inhibit-demon t)
@@ -1594,11 +1694,10 @@ actually)."
 
 ;;; Util Code:
 
-(defun nnir-read-parms (query nnir-search-engine)
+(defun nnir-read-parms (nnir-search-engine)
   "Reads additional search parameters according to `nnir-engines'."
   (let ((parmspec (caddr (assoc nnir-search-engine nnir-engines))))
-    (append query
-           (mapcar 'nnir-read-parm parmspec))))
+    (mapcar 'nnir-read-parm parmspec)))
 
 (defun nnir-read-parm (parmspec)
   "Reads a single search parameter.
@@ -1612,46 +1711,23 @@ actually)."
           (cons sym (format (cdr mapping) result)))
       (cons sym (read-string prompt)))))
 
-(autoload 'gnus-group-topic-name "gnus-topic")
-
-(defun nnir-run-query (query)
-  "Invoke appropriate search engine function (see `nnir-engines').
-  If some groups were process-marked, run the query for each of the groups
-  and concat the results."
-  (let ((q (car (read-from-string query)))
-        (groups (if (not (string= "nnir" nnir-address))
-                    (list (list nnir-address))
-                  (nnir-categorize
-                   (or gnus-group-marked
-                       (if (gnus-group-group-name)
-                           (list (gnus-group-group-name))
-                         (cdr (assoc (gnus-group-topic-name)
-                                     gnus-topic-alist))))
-                   gnus-group-server))))
-    (apply 'vconcat
-           (mapcar
-            (lambda (x)
-              (let* ((server (car x))
-                     (nnir-search-engine
-                      (or (nnir-read-server-parm 'nnir-search-engine
-                                                 server t)
-                          (cdr (assoc (car
-                                       (gnus-server-to-method server))
-                                      nnir-method-default-engines))))
-                     search-func)
-                (setq search-func (cadr (assoc nnir-search-engine
-                                               nnir-engines)))
-                (if search-func
-                    (funcall
-                     search-func
-                     (if nnir-extra-parms
-                         (or (and (eq nnir-search-engine 'imap)
-                                  (assq 'criteria q) q)
-                             (setq q (nnir-read-parms q nnir-search-engine)))
-                       q)
-                     server (cadr x))
-                  nil)))
-            groups))))
+(defun nnir-run-query (specs)
+  "Invoke appropriate search engine function (see `nnir-engines')."
+  (apply 'vconcat
+         (mapcar
+          (lambda (x)
+            (let* ((server (car x))
+                   (search-engine (nnir-server-to-search-engine server))
+                   (search-func (cadr (assoc search-engine nnir-engines))))
+              (and search-func
+                   (funcall search-func (cdr (assq 'nnir-query-spec specs))
+                            server (cadr x)))))
+          (cdr (assq 'nnir-group-spec specs)))))
+
+(defun nnir-server-to-search-engine (server)
+  (or (nnir-read-server-parm 'nnir-search-engine server t)
+      (cdr (assoc (car (gnus-server-to-method server))
+                  nnir-method-default-engines))))
 
 (defun nnir-read-server-parm (key server &optional not-global)
   "Returns the parameter value corresponding to `key' for
@@ -1663,36 +1739,43 @@ environment unless `not-global' is non-nil."
           ((and (not not-global) (boundp key)) (symbol-value key))
           (t nil))))
 
+(defun nnir-possibly-change-group (group &optional server)
+  (or (not server) (nnir-server-opened server) (nnir-open-server server))
+  (when (and group (string-match "\\`nnir" group))
+    (setq nnir-artlist (gnus-group-get-parameter
+                        (gnus-group-prefixed-name
+                         (gnus-group-short-name group) '(nnir "nnir"))
+                        'nnir-artlist t))))
 
-(defun nnir-possibly-change-server (server)
-  (unless (and server (nnir-server-opened server))
-    (nnir-open-server server)))
-
+(defun nnir-server-opened (&optional server)
+  (let ((backend (car (gnus-server-to-method server))))
+    (nnoo-current-server-p (or backend 'nnir) server)))
 
 (defun nnir-search-thread (header)
-  "Make an nnir group based on the thread containing the article header"
-  (let ((parm (list
-               (cons 'query
-                     (nnimap-make-thread-query header))
-               (cons 'criteria "")
-               (cons 'server (gnus-method-to-server
-                              (gnus-find-method-for-group
-                               gnus-newsgroup-name))))))
-    (gnus-group-make-nnir-group nil parm)
+  "Make an nnir group based on the thread containing the article
+header. The current server will be searched. If the registry is
+installed, the server that the registry reports the current
+article came from is also searched."
+  (let* ((query
+          (list (cons 'query (nnimap-make-thread-query header))
+                (cons 'criteria "")))
+         (server
+          (list (list (gnus-method-to-server
+           (gnus-find-method-for-group gnus-newsgroup-name)))))
+         (registry-group (and
+                          (gnus-bound-and-true-p 'gnus-registry-enabled)
+                          (car (gnus-registry-get-id-key
+                                (mail-header-id header) 'group))))
+         (registry-server
+          (and registry-group
+               (gnus-method-to-server
+                (gnus-find-method-for-group registry-group)))))
+    (when registry-server (add-to-list 'server (list registry-server)))
+    (gnus-group-make-nnir-group nil (list
+                                     (cons 'nnir-query-spec query)
+                                     (cons 'nnir-group-spec server)))
     (gnus-summary-goto-subject (gnus-id-to-article (mail-header-id header)))))
 
-;; unused?
-(defun nnir-artlist-groups (artlist)
-  "Returns a list of all groups in the given ARTLIST."
-  (let ((res nil)
-        (with-dups nil))
-    ;; from each artitem, extract group component
-    (setq with-dups (mapcar 'nnir-artitem-group artlist))
-    ;; remove duplicates from above
-    (mapc (function (lambda (x) (add-to-list 'res x)))
-            with-dups)
-    res))
-
 (defun nnir-get-active (srv)
   (let ((method (gnus-server-to-method srv))
         groups)
@@ -1758,6 +1841,46 @@ environment unless `not-global' is non-nil."
 
 
 
+(deffoo nnir-request-create-group (group &optional server args)
+  (message "Creating nnir group %s" group)
+  (let ((group (gnus-group-prefixed-name  group '(nnir "nnir")))
+        (query-spec
+          (list (cons 'query
+                      (read-string "Query: " nil 'nnir-search-history))))
+         (group-spec (list (list (read-string "Server: " nil nil)))))
+    (gnus-group-set-parameter
+     group 'nnir-specs
+     (list (cons 'nnir-query-spec query-spec)
+           (cons 'nnir-group-spec group-spec)))
+    (gnus-group-set-parameter
+     group 'nnir-artlist
+     (setq nnir-artlist
+           (nnir-run-query
+            (list (cons 'nnir-query-spec query-spec)
+                  (cons 'nnir-group-spec group-spec)))))
+    (nnir-request-update-info group (gnus-get-info group)))
+  t)
+
+(deffoo nnir-request-delete-group (group &optional force server)
+  t)
+
+(deffoo nnir-request-list (&optional server)
+  t)
+
+(deffoo nnir-request-scan (group method)
+  (if group
+      (let ((pgroup (if (gnus-group-prefixed-p group)
+                        group
+                      (gnus-group-prefixed-name  group '(nnir "nnir")))))
+        (gnus-group-set-parameter
+         pgroup 'nnir-artlist
+         (setq nnir-artlist
+               (nnir-run-query
+                (gnus-group-get-parameter pgroup 'nnir-specs t))))
+        (nnir-request-update-info pgroup (gnus-get-info pgroup)))
+    t))
+
+
 ;; The end.
 (provide 'nnir)
 
diff --git a/lisp/ido.el b/lisp/ido.el
index 589f44175eb..7ace1811daa 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -3150,13 +3150,15 @@ for first matching file."
     (exit-minibuffer)))
 
 (defun ido-chop (items elem)
-  "Remove all elements before ELEM and put them at the end of ITEMS."
+  "Remove all elements before ELEM and put them at the end of ITEMS.
+Use `eq' for comparison."
   (let ((ret nil)
         (next nil)
         (sofar nil))
     (while (not ret)
       (setq next (car items))
-      (if (equal next elem)
+      ;; Use `eq' to avoid bug http://debbugs.gnu.org/10994
+      (if (eq next elem)
           (setq ret (append items (nreverse sofar)))
         ;; else
         (progn
diff --git a/lisp/info.el b/lisp/info.el
index 3792857d47a..4679b51b999 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -158,6 +158,12 @@ A header-line does not scroll with the rest of the buffer."
   "Face for Info nodes in a node header."
   :group 'info)
 
+(defface info-index-match
+  '((t :inherit match))
+  "Face used to highlight matches in an index entry."
+  :group 'info
+  :version "24.4")
+
 ;; This is a defcustom largely so that we can get the benefit
 ;; of custom-initialize-delay.  Perhaps it would work to make it a
 ;; defvar and explicitly give it a standard-value property, and
@@ -3057,6 +3063,38 @@ See `Info-scroll-down'."
         (select-window (posn-window (event-start e))))
     (Info-scroll-down)))
 
+(defun Info-next-reference-or-link (pat prop)
+  "Move point to the next pattern-based cross-reference or property-based link.
+The next cross-reference is searched using the regexp PAT, and the next link
+is searched using the text property PROP.  Move point to the closest found position
+of either a cross-reference found by `re-search-forward' or a link found by
+`next-single-char-property-change'.  Return the new position of point, or nil."
+  (let ((pxref (save-excursion (re-search-forward pat nil t)))
+        (plink (next-single-char-property-change (point) prop)))
+    (when (and (< plink (point-max)) (not (get-char-property plink prop)))
+      (setq plink (next-single-char-property-change plink prop)))
+    (if (< plink (point-max))
+        (if (and pxref (<= pxref plink))
+            (goto-char (or (match-beginning 1) (match-beginning 0)))
+          (goto-char plink))
+      (if pxref (goto-char (or (match-beginning 1) (match-beginning 0)))))))
+
+(defun Info-prev-reference-or-link (pat prop)
+  "Move point to the previous pattern-based cross-reference or property-based link.
+The previous cross-reference is searched using the regexp PAT, and the previous link
+is searched using the text property PROP.  Move point to the closest found position
+of either a cross-reference found by `re-search-backward' or a link found by
+`previous-single-char-property-change'.  Return the new position of point, or nil."
+  (let ((pxref (save-excursion (re-search-backward pat nil t)))
+        (plink (previous-single-char-property-change (point) prop)))
+    (when (and (> plink (point-min)) (not (get-char-property plink prop)))
+      (setq plink (previous-single-char-property-change plink prop)))
+    (if (> plink (point-min))
+        (if (and pxref (>= pxref plink))
+            (goto-char (or (match-beginning 1) (match-beginning 0)))
+          (goto-char plink))
+      (if pxref (goto-char (or (match-beginning 1) (match-beginning 0)))))))
+
 (defun Info-next-reference (&optional recur count)
   "Move cursor to the next cross-reference or menu item in the node.
 If COUNT is non-nil (interactively with a prefix arg), jump over
@@ -3071,14 +3109,13 @@ COUNT cross-references."
             (old-pt (point))
             (case-fold-search t))
         (or (eobp) (forward-char 1))
-        (or (re-search-forward pat nil t)
+        (or (Info-next-reference-or-link pat 'link)
             (progn
               (goto-char (point-min))
-              (or (re-search-forward pat nil t)
+              (or (Info-next-reference-or-link pat 'link)
                   (progn
                     (goto-char old-pt)
                     (user-error "No cross references in this node")))))
-        (goto-char (or (match-beginning 1) (match-beginning 0)))
         (if (looking-at "\\* Menu:")
             (if recur
                 (user-error "No cross references in this node")
@@ -3099,14 +3136,13 @@ COUNT cross-references."
       (let ((pat "\\*note[ \n\t]+\\([^:]+\\):\\|^\\* .*:\\|[hf]t?tps?://")
             (old-pt (point))
             (case-fold-search t))
-        (or (re-search-backward pat nil t)
+        (or (Info-prev-reference-or-link pat 'link)
             (progn
               (goto-char (point-max))
-              (or (re-search-backward pat nil t)
+              (or (Info-prev-reference-or-link pat 'link)
                   (progn
                     (goto-char old-pt)
                     (user-error "No cross references in this node")))))
-        (goto-char (or (match-beginning 1) (match-beginning 0)))
         (if (looking-at "\\* Menu:")
             (if recur
                 (user-error "No cross references in this node")
@@ -3246,7 +3282,7 @@ Give an empty topic name to go to the Index node itself."
            (= (aref topic 0) ?:))
       (setq topic (substring topic 1)))
   (let ((orignode Info-current-node)
-        (pattern (format "\n\\* +\\([^\n]*%s[^\n]*\\):[ \t]+\\([^\n]*\\)\\.\\(?:[ \t\n]*(line +\\([0-9]+\\))\\)?"
+        (pattern (format "\n\\* +\\([^\n]*\\(%s\\)[^\n]*\\):[ \t]+\\([^\n]*\\)\\.\\(?:[ \t\n]*(line +\\([0-9]+\\))\\)?"
                          (regexp-quote topic)))
         node (nodes (Info-index-nodes))
         (ohist-list Info-history-list)
@@ -3265,12 +3301,14 @@ Give an empty topic name to go to the Index node itself."
               (progn
                 (goto-char (point-min))
                 (while (re-search-forward pattern nil t)
-                  (push (list (match-string-no-properties 1)
-                              (match-string-no-properties 2)
-                              Info-current-node
-                              (string-to-number (concat "0"
-                                                        (match-string 3))))
-                        matches))
+                  (let ((entry (match-string-no-properties 1))
+                        (nodename (match-string-no-properties 3))
+                        (line (string-to-number (concat "0" (match-string 4)))))
+                    (add-text-properties
+                     (- (match-beginning 2) (match-beginning 1))
+                     (- (match-end 2) (match-beginning 1))
+                     '(face info-index-match) entry)
+                    (push (list entry nodename Info-current-node line) matches)))
                 (setq nodes (cdr nodes) node (car nodes)))
             (Info-goto-node node))
           (or matches
@@ -3496,7 +3534,7 @@ MATCHES is a list of index matches found by `Info-apropos-matches'.")
 Return a list of matches where each element is in the format
 \((FILENAME INDEXTEXT NODENAME LINENUMBER))."
   (unless (string= string "")
-    (let ((pattern (format "\n\\* +\\([^\n]*%s[^\n]*\\):[ \t]+\\([^\n]+\\)\\.\\(?:[ \t\n]*(line +\\([0-9]+\\))\\)?"
+    (let ((pattern (format "\n\\* +\\([^\n]*\\(%s\\)[^\n]*\\):[ \t]+\\([^\n]+\\)\\.\\(?:[ \t\n]*(line +\\([0-9]+\\))\\)?"
                            (regexp-quote string)))
           (ohist Info-history)
           (ohist-list Info-history-list)
@@ -3529,12 +3567,15 @@ Return a list of matches where each element is in the format
                         (progn
                           (goto-char (point-min))
                           (while (re-search-forward pattern nil t)
-                            (setq matches
-                                  (cons (list manual
-                                              (match-string-no-properties 1)
-                                              (match-string-no-properties 2)
-                                              (match-string-no-properties 3))
-                                        matches)))
+                            (let ((entry (match-string-no-properties 1))
+                                  (nodename (match-string-no-properties 3))
+                                  (line (match-string-no-properties 4)))
+                              (add-text-properties
+                               (- (match-beginning 2) (match-beginning 1))
+                               (- (match-end 2) (match-beginning 1))
+                               '(face info-index-match) entry)
+                              (setq matches (cons (list manual entry nodename line)
+                                                  matches))))
                           (setq nodes (cdr nodes) node (car nodes)))
                       (Info-goto-node node))))
             (error
@@ -3840,7 +3881,25 @@ If FORK is non-nil, it is passed to `Info-goto-node'."
      ((setq node (Info-get-token (point) "File: " "File: \\([^,\n\t]*\\)"))
       (Info-goto-node "Top" fork))
      ((setq node (Info-get-token (point) "Prev: " "Prev: \\([^,\n\t]*\\)"))
-      (Info-goto-node node fork)))
+      (Info-goto-node node fork))
+     ;; footnote
+     ((setq node (Info-get-token (point) "(" "\\(([0-9]+)\\)"))
+      (let ((old-point (point)) new-point)
+        (save-excursion
+          (goto-char (point-min))
+          (when (re-search-forward "^[ \t]*-+ Footnotes -+$" nil t)
+            (setq new-point (if (< old-point (point))
+                                ;; Go to footnote reference
+                                (and (search-forward node nil t)
+                                     ;; Put point at beginning of link
+                                     (match-beginning 0))
+                              ;; Go to footnote definition
+                              (search-backward node nil t)))))
+        (if new-point
+            (progn
+              (goto-char new-point)
+              (setq node t))
+          (setq node nil)))))
     node))
 
 (defun Info-mouse-follow-link (click)
@@ -4896,6 +4955,21 @@ first line or header line, and for breadcrumb links.")
                                  mouse-face highlight
                                  help-echo "mouse-2: go to this URL"))))
 
+      ;; Fontify footnotes
+      (goto-char (point-min))
+      (when (and not-fontified-p (re-search-forward "^[ \t]*-+ Footnotes -+$" nil t))
+        (let ((limit (point)))
+          (goto-char (point-min))
+          (while (re-search-forward "\\(([0-9]+)\\)" nil t)
+            (add-text-properties (match-beginning 0) (match-end 0)
+                                 `(font-lock-face info-xref
+                                   link t
+                                   mouse-face highlight
+                                   help-echo
+                                   ,(if (< (point) limit)
+                                        "mouse-2: go to footnote definition"
+                                      "mouse-2: go to footnote reference"))))))
+
       ;; Hide empty lines at the end of the node.
       (goto-char (point-max))
       (skip-chars-backward "\n")
diff --git a/lisp/international/ja-dic-cnv.el b/lisp/international/ja-dic-cnv.el
index c0fcf19d841..41a31004194 100644
--- a/lisp/international/ja-dic-cnv.el
+++ b/lisp/international/ja-dic-cnv.el
@@ -279,9 +279,9 @@
                 skkdic-okuri-nasi-entries-count
                 (1+ skkdic-okuri-nasi-entries-count))
           (setq ratio (floor (/ (* (point) 100.0) (point-max))))
-          (if (/= ratio prev-ratio)
+          (if (/= (/ prev-ratio 10) (/ ratio 10))
               (progn
-                (message "collected %2d%% %s ..." ratio kana)
+                (message "collected %2d%% ..." ratio)
                 (setq prev-ratio ratio)))
           (while candidates
             (let ((entry (lookup-nested-alist (car candidates)
@@ -304,12 +304,12 @@
       (while l
         (let ((kana (car (car l)))
               (candidates (cdr (car l))))
-          (setq ratio (/ (* count 1000) skkdic-okuri-nasi-entries-count)
+          (setq ratio (/ (* count 100) skkdic-okuri-nasi-entries-count)
                 count (1+ count))
-          (if (/= prev-ratio (/ ratio 10))
+          (if (/= (/ prev-ratio 10) (/ ratio 10))
               (progn
-                (message "processed %2d%% %s ..." (/ ratio 10) kana)
-                (setq prev-ratio (/ ratio 10))))
+                (message "processed %2d%% ..." ratio)
+                (setq prev-ratio ratio)))
           (if (setq candidates
                     (skkdic-reduced-candidates skkbuf kana candidates))
               (progn
@@ -330,16 +330,21 @@ The name of generated file is specified by the variable `ja-dic-filename'."
   (interactive "FSKK dictionary file: ")
   (message "Reading file \"%s\" ..." filename)
   (let* ((coding-system-for-read 'euc-japan)
-         (skkbuf(find-file-noselect (expand-file-name filename)))
+         (skkbuf (get-buffer-create " *skkdic-unannotated*"))
          (buf (get-buffer-create "*skkdic-work*")))
+    ;; Set skkbuf to an unannotated copy of the dictionary.
+    (with-current-buffer skkbuf
+      (insert-file-contents (expand-file-name filename))
+      (re-search-forward "^[^;]")
+      (while (re-search-forward ";[^\n/]*/" nil t)
+        (replace-match "/")))
     ;; Setup and generate the header part of working buffer.
     (with-current-buffer buf
       (erase-buffer)
       (buffer-disable-undo)
       (insert ";;; ja-dic.el --- dictionary for Japanese input method"
-              " -*-coding: euc-japan; -*-\n"
+              " -*-coding: utf-8; -*-\n"
               ";;\tGenerated by the command `skkdic-convert'\n"
-              ";;\tDate: " (current-time-string) "\n"
               ";;\tOriginal SKK dictionary file: "
               (file-relative-name (expand-file-name filename) dirname)
               "\n\n"
@@ -348,7 +353,6 @@ The name of generated file is specified by the variable `ja-dic-filename'."
               ";; Do byte-compile this file again after any modification.\n\n"
               ";;; Start of the header of the original SKK dictionary.\n\n")
       (set-buffer skkbuf)
-      (widen)
       (goto-char 1)
       (let (pos)
         (search-forward ";; okuri-ari")
@@ -399,7 +403,7 @@ The name of generated file is specified by the variable `ja-dic-filename'."
       ;; Save the working buffer.
       (set-buffer buf)
       (set-visited-file-name (expand-file-name ja-dic-filename dirname) t)
-      (set-buffer-file-coding-system 'euc-japan)
+      (set-buffer-file-coding-system 'utf-8)
       (save-buffer 0))
     (kill-buffer skkbuf)
     (switch-to-buffer buf)))
@@ -429,12 +433,7 @@ To get complete usage, invoke:
             (setq targetdir (expand-file-name (car command-line-args-left)))
             (setq command-line-args-left (cdr command-line-args-left))))
       (setq filename (expand-file-name (car command-line-args-left)))
-      (message "Converting %s to %s ..." filename ja-dic-filename)
-      (message "It takes around 10 minutes even on Sun SS20.")
-      (skkdic-convert filename targetdir)
-      (message "Do byte-compile the created file by:")
-      (message "  %% emacs -batch -f batch-byte-compile %s" ja-dic-filename)
-      ))
+      (skkdic-convert filename targetdir)))
   (kill-emacs 0))
 
 
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 51601bca8df..0367cad87b8 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -128,7 +128,11 @@ Expects to be bound to `down-mouse-1' in `key-translation-map'."
                 (put newup 'event-kind (get (car event) 'event-kind))
                 (put newdown 'event-kind (get (car this-event) 'event-kind))
                 (push (cons newup (cdr event)) unread-command-events)
-                (vector (cons newdown (cdr this-event))))
+                ;; Modify the event in place, so read-key-sequence doesn't
+                ;; generate a second fake prefix key (see fake_prefixed_keys in
+                ;; src/keyboard.c).
+                (setcar this-event newdown)
+                (vector this-event))
             (push event unread-command-events)
             nil))))))
 
@@ -759,6 +763,9 @@ at the same position."
                   mouse-1-click-in-non-selected-windows
                   (eq (selected-window) (posn-window pos)))
               (or (mouse-posn-property pos 'follow-link)
+                  (let ((area (posn-area pos)))
+                    (when area
+                      (key-binding (vector area 'follow-link) nil t pos)))
                   (key-binding [follow-link] nil t pos)))))
     (cond
      ((eq action 'mouse-face)
diff --git a/lisp/net/tramp-adb.el b/lisp/net/tramp-adb.el
index 2d683a4d3d2..a71df54db58 100644
--- a/lisp/net/tramp-adb.el
+++ b/lisp/net/tramp-adb.el
@@ -155,12 +155,18 @@ pass to the OPERATION."
   "Return a list of (nil host) tuples allowed to access."
   (with-timeout (10)
     (with-temp-buffer
-      (when (zerop (call-process tramp-adb-program nil t nil "devices"))
-        (let (result)
-          (goto-char (point-min))
-          (while (search-forward-regexp "^\\(\\S-+\\)[[:space:]]+device$" nil t)
-            (add-to-list 'result (list nil (match-string 1))))
-          result)))))
+      ;; `call-process' does not react on timer under MS Windows.
+      ;; That's why we use `start-process'.
+      (let ((p (start-process
+                tramp-adb-program (current-buffer) tramp-adb-program "devices"))
+            result)
+        (tramp-compat-set-process-query-on-exit-flag p nil)
+        (while (eq 'run (process-status p))
+          (sleep-for 0.1))
+        (goto-char (point-min))
+        (while (search-forward-regexp "^\\(\\S-+\\)[[:space:]]+device$" nil t)
+          (add-to-list 'result (list nil (match-string 1))))
+        result))))
 
 (defun tramp-adb-handle-expand-file-name (name &optional dir)
   "Like `expand-file-name' for Tramp files."
@@ -850,7 +856,7 @@ PRESERVE-UID-GID and PRESERVE-EXTENDED-ATTRIBUTES are completely ignored."
     (when p
       (if (yes-or-no-p "A command is running.  Kill it? ")
           (ignore-errors (kill-process p))
-        (error "Shell command in progress")))
+        (tramp-compat-user-error "Shell command in progress")))
 
     (if current-buffer-p
         (progn
diff --git a/lisp/net/tramp-compat.el b/lisp/net/tramp-compat.el
index d4639817b18..ed61fbcfa76 100644
--- a/lisp/net/tramp-compat.el
+++ b/lisp/net/tramp-compat.el
@@ -533,6 +533,11 @@ EOL-TYPE can be one of `dos', `unix', or `mac'."
                         "`dos', `unix', or `mac'")))))
         (t (error "Can't change EOL conversion -- is MULE missing?"))))
 
+;; `user-error' has been added to Emacs 24.3.
+(defun tramp-compat-user-error (format &rest args)
+  "Signal a pilot error."
+  (apply (if (fboundp 'user-error) 'user-error 'error) format args))
+
 (add-hook 'tramp-unload-hook
           (lambda ()
             (unload-feature 'tramp-compat 'force)))
diff --git a/lisp/net/tramp-gvfs.el b/lisp/net/tramp-gvfs.el
index e3850653263..6f066f56a2b 100644
--- a/lisp/net/tramp-gvfs.el
+++ b/lisp/net/tramp-gvfs.el
@@ -153,7 +153,7 @@
 (unless (and (tramp-compat-funcall 'dbus-get-unique-name :session)
              (or (tramp-compat-process-running-p "gvfs-fuse-daemon")
                  (tramp-compat-process-running-p "gvfsd-fuse")))
-  (error "Package `tramp-gvfs' not supported"))
+  (tramp-compat-user-error "Package `tramp-gvfs' not supported"))
 
 (defconst tramp-gvfs-path-mounttracker "/org/gtk/vfs/mounttracker"
   "The object path of the GVFS daemon.")
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index dc3dffd857b..86f7f338b27 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -1203,7 +1203,7 @@ their replacement."
                   result (substring result 0 -1))
           (unless (y-or-n-p (format "Method %s is obsolete, use %s? "
                                     result (substring result 0 -1)))
-            (error 'file-error "Method \"%s\" not supported" result)))
+            (tramp-compat-user-error "Method \"%s\" not supported" result)))
         (add-to-list 'tramp-warned-obsolete-methods result))
       ;; This works with the current set of `tramp-obsolete-methods'.
       ;; Must be improved, if their are more sophisticated replacements.
@@ -1249,7 +1249,7 @@ non-nil, the file name parts are not expanded to their default
 values."
   (save-match-data
     (let ((match (string-match (nth 0 tramp-file-name-structure) name)))
-      (unless match (error "Not a Tramp file name: %s" name))
+      (unless match (tramp-compat-user-error "Not a Tramp file name: %s" name))
       (let ((method    (match-string (nth 1 tramp-file-name-structure) name))
             (user      (match-string (nth 2 tramp-file-name-structure) name))
             (host      (match-string (nth 3 tramp-file-name-structure) name))
@@ -1259,7 +1259,12 @@ values."
           (when (string-match tramp-prefix-ipv6-regexp host)
             (setq host (replace-match "" nil t host)))
           (when (string-match tramp-postfix-ipv6-regexp host)
-            (setq host (replace-match "" nil t host))))
+            (setq host (replace-match "" nil t host)))
+          (when (and (equal tramp-syntax 'ftp) (null method) (null user)
+                     (member host (mapcar 'car tramp-methods))
+                     (not (tramp-completion-mode-p)))
+            (tramp-compat-user-error
+             "Host name must not match method `%s'" host)))
         (if nodefault
             (vector method user host localname hop)
           (vector
@@ -3179,7 +3184,7 @@ User is always nil."
     (when p
       (if (yes-or-no-p "A command is running.  Kill it? ")
           (ignore-errors (kill-process p))
-        (error "Shell command in progress")))
+        (tramp-compat-user-error "Shell command in progress")))
 
     (if current-buffer-p
         (progn
diff --git a/lisp/net/trampver.el b/lisp/net/trampver.el
index 64053c202b7..0e54cd60d98 100644
--- a/lisp/net/trampver.el
+++ b/lisp/net/trampver.el
@@ -31,7 +31,7 @@
 ;; should be changed only there.
 
 ;;;###tramp-autoload
-(defconst tramp-version "2.2.7"
+(defconst tramp-version "2.2.8-pre"
   "This version of Tramp.")
 
 ;;;###tramp-autoload
@@ -44,7 +44,7 @@
                       (= emacs-major-version 21)
                       (>= emacs-minor-version 4)))
              "ok"
-           (format "Tramp 2.2.7 is not fit for %s"
+           (format "Tramp 2.2.8-pre is not fit for %s"
                    (when (string-match "^.*$" (emacs-version))
                      (match-string 0 (emacs-version)))))))
   (unless (string-match "\\`ok\\'" x) (error "%s" x)))
diff --git a/lisp/nxml/nxml-mode.el b/lisp/nxml/nxml-mode.el
index 2ee73235dd0..44271a689cf 100644
--- a/lisp/nxml/nxml-mode.el
+++ b/lisp/nxml/nxml-mode.el
@@ -540,7 +540,7 @@ Many aspects this mode can be customized using
       (widen)
       (nxml-clear-dependent-regions (point-min) (point-max))
       (setq nxml-scan-end (copy-marker (point-min) nil))
-      (nxml-with-unmodifying-text-property-changes
+      (with-silent-modifications
         (nxml-clear-inside (point-min) (point-max))
         (nxml-with-invisible-motion
           (nxml-scan-prolog)))))
@@ -601,7 +601,7 @@ Many aspects this mode can be customized using
   (save-excursion
     (save-restriction
       (widen)
-      (nxml-with-unmodifying-text-property-changes
+      (with-silent-modifications
         (nxml-clear-inside (point-min) (point-max))))))
 
 ;;; Change management
@@ -625,7 +625,7 @@ Many aspects this mode can be customized using
             (widen)
             (save-match-data
               (nxml-with-invisible-motion
-                (nxml-with-unmodifying-text-property-changes
+                (with-silent-modifications
                   (nxml-after-change1
                    start end pre-change-length)))))))))
 
@@ -910,7 +910,7 @@ Called with `font-lock-beg' and `font-lock-end' dynamically bound."
                        (widen)
                        (save-match-data
                          (nxml-with-invisible-motion
-                           (nxml-with-unmodifying-text-property-changes
+                           (with-silent-modifications
                              (nxml-extend-after-change-region1
                               start end pre-change-length)))))))))
       (if (consp region) region))))
diff --git a/lisp/nxml/nxml-outln.el b/lisp/nxml/nxml-outln.el
index e30aee3de53..dab22f7559f 100644
--- a/lisp/nxml/nxml-outln.el
+++ b/lisp/nxml/nxml-outln.el
@@ -149,7 +149,7 @@ See the variable `nxml-section-element-name-regexp' for more details."
 (defun nxml-show-all ()
   "Show all elements in the buffer normally."
   (interactive)
-  (nxml-with-unmodifying-text-property-changes
+  (with-silent-modifications
     (remove-text-properties (point-min)
                             (point-max)
                             '(nxml-outline-state nil)))
@@ -370,7 +370,7 @@ customize which elements are recognized as sections and headings."
   (get-text-property pos 'nxml-outline-state))
 
 (defun nxml-set-outline-state (pos state)
-  (nxml-with-unmodifying-text-property-changes
+  (with-silent-modifications
     (if state
         (put-text-property pos (1+ pos) 'nxml-outline-state state)
       (remove-text-properties pos (1+ pos) '(nxml-outline-state nil)))))
diff --git a/lisp/nxml/nxml-rap.el b/lisp/nxml/nxml-rap.el
index bc87044cde6..5bc4d74456b 100644
--- a/lisp/nxml/nxml-rap.el
+++ b/lisp/nxml/nxml-rap.el
@@ -293,7 +293,7 @@ Sets variables like `nxml-token-after'."
       (cond ((memq xmltok-type '(comment
                                  cdata-section
                                  processing-instruction))
-             (nxml-with-unmodifying-text-property-changes
+             (with-silent-modifications
                (nxml-set-inside (1+ xmltok-start) (point) xmltok-type)))
             (xmltok-dependent-regions
              (nxml-mark-parse-dependent-regions)))
@@ -338,7 +338,7 @@ Leave point unmoved if it is not inside anything special."
                                '(comment
                                  processing-instruction
                                  cdata-section))
-                     (nxml-with-unmodifying-text-property-changes
+                     (with-silent-modifications
                        (nxml-set-inside (1+ xmltok-start)
                                         (point)
                                         xmltok-type)))
diff --git a/lisp/nxml/nxml-util.el b/lisp/nxml/nxml-util.el
index b2d9cdde183..6ba6d21f7ed 100644
--- a/lisp/nxml/nxml-util.el
+++ b/lisp/nxml/nxml-util.el
@@ -78,27 +78,6 @@ This is the inverse of `nxml-make-namespace'."
             (nxml-degrade ,context ,error-symbol))))
     `(progn ,@body)))
 
-(defmacro nxml-with-unmodifying-text-property-changes (&rest body)
-  "Evaluate BODY without any text property changes modifying the buffer.
-Any text properties changes happen as usual but the changes are not treated as
-modifications to the buffer."
-  (let ((modified (make-symbol "modified")))
-    `(let ((,modified (buffer-modified-p))
-           (inhibit-read-only t)
-           (inhibit-modification-hooks t)
-           (buffer-undo-list t)
-           (deactivate-mark nil)
-           ;; Apparently these avoid file locking problems.
-           (buffer-file-name nil)
-           (buffer-file-truename nil))
-       (unwind-protect
-           (progn ,@body)
-         (unless ,modified
-           (restore-buffer-modified-p nil))))))
-
-(put 'nxml-with-unmodifying-text-property-changes 'lisp-indent-function 0)
-(def-edebug-spec nxml-with-unmodifying-text-property-changes t)
-
 (defmacro nxml-with-invisible-motion (&rest body)
   "Evaluate body without calling any point motion hooks."
   `(let ((inhibit-point-motion-hooks t))
diff --git a/lisp/nxml/rng-maint.el b/lisp/nxml/rng-maint.el
index 74192f213dc..ff73e3718ec 100644
--- a/lisp/nxml/rng-maint.el
+++ b/lisp/nxml/rng-maint.el
@@ -259,7 +259,7 @@
 (defun rng-validate-buffer ()
   (save-restriction
     (widen)
-    (nxml-with-unmodifying-text-property-changes
+    (with-silent-modifications
       (rng-clear-cached-state (point-min) (point-max)))
     ;; 1+ to clear empty overlays at (point-max)
     (rng-clear-overlays (point-min) (1+ (point-max))))
diff --git a/lisp/nxml/rng-nxml.el b/lisp/nxml/rng-nxml.el
index cfb8e33cccb..bc070136adb 100644
--- a/lisp/nxml/rng-nxml.el
+++ b/lisp/nxml/rng-nxml.el
@@ -380,9 +380,7 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
                 (< rng-validate-up-to-date-end pos))
       ;; Display percentage validated.
       (force-mode-line-update)
-      ;; Force redisplay but don't allow idle timers to run.
-      (let ((timer-idle-list nil))
-        (sit-for 0)))
+      (sit-for 0))
     (message "Parsing...done"))
   (save-excursion
     (save-restriction
diff --git a/lisp/nxml/rng-valid.el b/lisp/nxml/rng-valid.el
index a87ab2532ce..e1140980813 100644
--- a/lisp/nxml/rng-valid.el
+++ b/lisp/nxml/rng-valid.el
@@ -244,7 +244,7 @@ to use for finding the schema."
           (> (prefix-numeric-value arg) 0)))
   (save-restriction
     (widen)
-    (nxml-with-unmodifying-text-property-changes
+    (with-silent-modifications
       (rng-clear-cached-state (point-min) (point-max)))
     ;; 1+ to clear empty overlays at (point-max)
     (rng-clear-overlays (point-min) (1+ (point-max)))
@@ -305,7 +305,7 @@ The schema is set like `rng-auto-set-schema'."
 
 (defun rng-after-change-function (start end pre-change-len)
   (setq rng-message-overlay-inhibit-point nil)
-  (nxml-with-unmodifying-text-property-changes
+  (with-silent-modifications
     (rng-clear-cached-state start end))
   ;; rng-validate-up-to-date-end holds the position before the change
   ;; Adjust it to reflect the change.
@@ -414,26 +414,17 @@ The schema is set like `rng-auto-set-schema'."
 (defvar rng-validate-display-modified-p nil)
 
 (defun rng-validate-while-idle-continue-p ()
-  ;; input-pending-p and sit-for run timers that are
-  ;; ripe.  Binding timer-idle-list to nil prevents
-  ;; this.  If we don't do this, then any ripe timers
-  ;; will get run, and we won't get any chance to
-  ;; validate until Emacs becomes idle again or until
-  ;; the other lower priority timers finish (which
-  ;; can take a very long time in the case of
-  ;; jit-lock).
-  (let ((timer-idle-list nil))
-    (and (not (input-pending-p))
-         ;; Fake rng-validate-up-to-date-end so that the mode line
-         ;; shows progress.  Also use this to save point.
-         (let ((rng-validate-up-to-date-end (point)))
-           (goto-char rng-validate-display-point)
-           (when (not rng-validate-display-modified-p)
-             (restore-buffer-modified-p nil))
-           (force-mode-line-update)
-           (let ((continue (sit-for 0)))
-             (goto-char rng-validate-up-to-date-end)
-             continue)))))
+  (and (not (input-pending-p))
+       ;; Fake rng-validate-up-to-date-end so that the mode line
+       ;; shows progress.  Also use this to save point.
+       (let ((rng-validate-up-to-date-end (point)))
+         (goto-char rng-validate-display-point)
+         (when (not rng-validate-display-modified-p)
+           (restore-buffer-modified-p nil))
+         (force-mode-line-update)
+         (let ((continue (sit-for 0)))
+           (goto-char rng-validate-up-to-date-end)
+           continue))))
 
 ;; Calling rng-do-some-validation once with a continue-p function, as
 ;; opposed to calling it repeatedly, helps on initial validation of a
@@ -442,24 +433,26 @@ The schema is set like `rng-auto-set-schema'."
 ;; validation process down.
 
 (defun rng-validate-while-idle (buffer)
-  (with-current-buffer buffer
-    (if rng-validate-mode
-        (if (let ((rng-validate-display-point (point))
-                  (rng-validate-display-modified-p (buffer-modified-p)))
-              (rng-do-some-validation 'rng-validate-while-idle-continue-p))
-            (force-mode-line-update)
-          (rng-validate-done))
-      ;; must have done kill-all-local-variables
-      (rng-kill-timers))))
+  (when (buffer-live-p buffer)          ; bug#13999
+    (with-current-buffer buffer
+      (if rng-validate-mode
+          (if (let ((rng-validate-display-point (point))
+                    (rng-validate-display-modified-p (buffer-modified-p)))
+                (rng-do-some-validation 'rng-validate-while-idle-continue-p))
+              (force-mode-line-update)
+            (rng-validate-done))
+        ;; must have done kill-all-local-variables
+        (rng-kill-timers)))))
 
 (defun rng-validate-quick-while-idle (buffer)
-  (with-current-buffer buffer
-    (if rng-validate-mode
-        (if (rng-do-some-validation)
-            (force-mode-line-update)
-          (rng-validate-done))
-      ;; must have done kill-all-local-variables
-      (rng-kill-timers))))
+  (when (buffer-live-p buffer)          ; bug#13999
+    (with-current-buffer buffer
+      (if rng-validate-mode
+          (if (rng-do-some-validation)
+              (force-mode-line-update)
+            (rng-validate-done))
+        ;; must have done kill-all-local-variables
+        (rng-kill-timers)))))
 
 (defun rng-validate-done ()
   (when (or (not (current-message))
@@ -478,7 +471,7 @@ The schema is set like `rng-auto-set-schema'."
         (condition-case-unless-debug err
             (and (rng-validate-prepare)
                  (let ((rng-dt-namespace-context-getter '(nxml-ns-get-context)))
-                   (nxml-with-unmodifying-text-property-changes
+                   (with-silent-modifications
                      (rng-do-some-validation-1 continue-p-function))))
           ;; errors signaled from a function run by an idle timer
           ;; are ignored; if we don't catch them, validation
@@ -880,9 +873,7 @@ means goto the first error."
                             (< rng-validate-up-to-date-end (point-max)))
                    ;; Display percentage validated.
                    (force-mode-line-update)
-                   ;; Force redisplay but don't allow idle timers to run.
-                   (let ((timer-idle-list nil))
-                     (sit-for 0))
+                   (sit-for 0)
                    (setq pos
                          (max pos (1- rng-validate-up-to-date-end)))
                    t)))))
@@ -905,9 +896,7 @@ means goto the first error."
       (while (and (rng-do-some-validation)
                   (< rng-validate-up-to-date-end (min pos (point-max))))
         (force-mode-line-update)
-        ;; Force redisplay but don't allow idle timers to run.
-        (let ((timer-idle-list nil))
-          (sit-for 0)))
+        (sit-for 0))
       (while (and (> arg 0)
                   (setq err (rng-find-previous-error-overlay pos)))
         (setq pos (overlay-start err))
diff --git a/lisp/progmodes/cfengine.el b/lisp/progmodes/cfengine.el
index 74b81b0cd01..11eb0eeaf49 100644
--- a/lisp/progmodes/cfengine.el
+++ b/lisp/progmodes/cfengine.el
@@ -30,11 +30,13 @@
 ;; The CFEngine 3.x support doesn't have Imenu support but patches are
 ;; welcome.
 
+;; By default, CFEngine 3.x syntax is used.
+
 ;; You can set it up so either `cfengine2-mode' (2.x and earlier) or
 ;; `cfengine3-mode' (3.x) will be picked, depending on the buffer
 ;; contents:
 
-;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine-mode))
+;; (add-to-list 'auto-mode-alist '("\\.cf\\'" . cfengine-auto-mode))
 
 ;; OR you can choose to always use a specific version, if you prefer
 ;; it:
@@ -181,7 +183,7 @@ This includes those for cfservd as well as cfagent.")
     ("$(\\([[:alnum:]_]+\\))" 1 font-lock-variable-name-face)
     ("${\\([[:alnum:]_]+\\)}" 1 font-lock-variable-name-face)
     ;; Variable definitions.
-    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
+    ("\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
     ;; File, acl &c in group:   { token ... }
     ("{[ \t]*\\([^ \t\n]+\\)" 1 font-lock-constant-face)))
 
@@ -189,9 +191,9 @@ This includes those for cfservd as well as cfagent.")
   `(
     ;; Defuns.  This happens early so they don't get caught by looser
     ;; patterns.
-    (,(concat "\\<" cfengine3-defuns-regex "\\>"
-              "[ \t]+\\<\\([[:alnum:]_.:]+\\)\\>"
-              "[ \t]+\\<\\([[:alnum:]_.:]+\\)"
+    (,(concat "\\_<" cfengine3-defuns-regex "\\_>"
+              "[ \t]+\\_<\\([[:alnum:]_.:]+\\)\\_>"
+              "[ \t]+\\_<\\([[:alnum:]_.:]+\\)"
               ;; Optional parentheses with variable names inside.
               "\\(?:(\\([^)]*\\))\\)?")
      (1 font-lock-builtin-face)
@@ -212,10 +214,10 @@ This includes those for cfservd as well as cfagent.")
     ("[@$]{\\([[:alnum:]_.:]+\\)}" 1 font-lock-variable-name-face)
 
     ;; Variable definitions.
-    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
+    ("\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
 
     ;; Variable types.
-    (,(concat "\\<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\>")
+    (,(concat "\\_<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\_>")
      1 font-lock-type-face)))
 
 (defvar cfengine2-imenu-expression
@@ -223,9 +225,9 @@ This includes those for cfservd as well as cfagent.")
                               (regexp-opt cfengine2-actions t))
                   ":[^:]")
          1)
-    ("Variables/classes" "\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1)
-    ("Variables/classes" "\\<define=\\([[:alnum:]_]+\\)" 1)
-    ("Variables/classes" "\\<DefineClass\\>[ \t]+\\([[:alnum:]_]+\\)" 1))
+    ("Variables/classes" "\\_<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1)
+    ("Variables/classes" "\\_<define=\\([[:alnum:]_]+\\)" 1)
+    ("Variables/classes" "\\_<DefineClass\\>[ \t]+\\([[:alnum:]_]+\\)" 1))
   "`imenu-generic-expression' for CFEngine mode.")
 
 (defun cfengine2-outline-level ()
@@ -338,7 +340,7 @@ Intended as the value of `indent-line-function'."
 Treats body/bundle blocks as defuns."
   (unless (<= (current-column) (current-indentation))
     (end-of-line))
-  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\_>") nil t)
       (beginning-of-line)
     (goto-char (point-min)))
   t)
@@ -347,7 +349,7 @@ Treats body/bundle blocks as defuns."
   "`end-of-defun' function for Cfengine 3 mode.
 Treats body/bundle blocks as defuns."
   (end-of-line)
-  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\_>") nil t)
       (beginning-of-line)
     (goto-char (point-max)))
   t)
@@ -366,7 +368,7 @@ Intended as the value of `indent-line-function'."
 
       (cond
        ;; Body/bundle blocks start at 0.
-       ((looking-at (concat cfengine3-defuns-regex "\\>"))
+       ((looking-at (concat cfengine3-defuns-regex "\\_>"))
         (indent-line-to 0))
        ;; Categories are indented one step.
        ((looking-at (concat cfengine3-category-regex "[ \t]*\\(#.*\\)*$"))
@@ -583,7 +585,7 @@ on the buffer contents"
     (save-restriction
       (goto-char (point-min))
       (while (not (or (eobp) v3))
-        (setq v3 (looking-at (concat cfengine3-defuns-regex "\\>")))
+        (setq v3 (looking-at (concat cfengine3-defuns-regex "\\_>")))
         (forward-line)))
     (if v3 (cfengine3-mode) (cfengine2-mode))))
 
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 9e9e2f0b090..98a89bb2363 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -1814,6 +1814,7 @@ Returns the compilation buffer created."
     (define-key map [follow-link] 'mouse-face)
     (define-key map "\C-c\C-c" 'compile-goto-error)
     (define-key map "\C-m" 'compile-goto-error)
+    (define-key map "\C-o" 'compilation-display-error)
     (define-key map "\C-c\C-k" 'kill-compilation)
     (define-key map "\M-n" 'compilation-next-error)
     (define-key map "\M-p" 'compilation-previous-error)
@@ -1858,6 +1859,7 @@ Returns the compilation buffer created."
     (define-key map [follow-link] 'mouse-face)
     (define-key map "\C-c\C-c" 'compile-goto-error)
     (define-key map "\C-m" 'compile-goto-error)
+    (define-key map "\C-o" 'compilation-display-error)
     (define-key map "\C-c\C-k" 'kill-compilation)
     (define-key map "\M-n" 'compilation-next-error)
     (define-key map "\M-p" 'compilation-previous-error)
@@ -2299,6 +2301,12 @@ Prefix arg N says how many files to move backwards (or forwards, if negative)."
   (interactive "p")
   (compilation-next-file (- n)))
 
+(defun compilation-display-error ()
+  "Display the source for current error in another window."
+  (interactive)
+  (setq compilation-current-error (point))
+  (next-error-no-select 0))
+
 (defun kill-compilation ()
   "Kill the process made by the \\[compile] or \\[grep] commands."
   (interactive)
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index aae5526ea82..fab20102097 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -310,7 +310,7 @@ See `run-hooks'."
         "(" (regexp-opt
              '("begin" "call-with-current-continuation" "call/cc"
                "call-with-input-file" "call-with-output-file" "case" "cond"
-               "do" "else" "for-each" "if" "lambda"
+               "do" "else" "for-each" "if" "lambda" "λ"
                "let" "let*" "let-syntax" "letrec" "letrec-syntax"
                ;; SRFI 11 usage comes up often enough.
                "let-values" "let*-values"
@@ -410,6 +410,7 @@ that variable's value is a string."
 (put 'make 'scheme-indent-function 1)
 (put 'style 'scheme-indent-function 1)
 (put 'root 'scheme-indent-function 1)
+(put 'λ 'scheme-indent-function 1)
 
 (defvar dsssl-font-lock-keywords
   (eval-when-compile
diff --git a/lisp/register.el b/lisp/register.el
index ae2f7cf3e2a..4876c614642 100644
--- a/lisp/register.el
+++ b/lisp/register.el
@@ -31,10 +31,6 @@
 
 (eval-when-compile (require 'cl-lib))
 
-(declare-function semantic-insert-foreign-tag "semantic/tag" (foreign-tag))
-(declare-function semantic-tag-buffer "semantic/tag" (tag))
-(declare-function semantic-tag-start "semantic/tag" (tag))
-
 ;;; Code:
 
 (cl-defstruct
@@ -174,11 +170,6 @@ delete any existing frames that the frame configuration doesn't mention.
           (error "Register access aborted"))
       (find-file (nth 1 val))
       (goto-char (nth 2 val)))
-     ((and (fboundp 'semantic-foreign-tag-p)
-           semantic-mode
-           (semantic-foreign-tag-p val))
-      (switch-to-buffer (semantic-tag-buffer val))
-      (goto-char (semantic-tag-start val)))
      (t
       (error "Register doesn't contain a buffer position or configuration")))))
 
@@ -349,10 +340,6 @@ Interactively, second arg is non-nil if prefix arg is supplied."
       (princ val (current-buffer)))
      ((and (markerp val) (marker-position val))
       (princ (marker-position val) (current-buffer)))
-     ((and (fboundp 'semantic-foreign-tag-p)
-           semantic-mode
-           (semantic-foreign-tag-p val))
-      (semantic-insert-foreign-tag val))
      (t
       (error "Register does not contain text"))))
   (if (not arg) (exchange-point-and-mark)))
diff --git a/lisp/replace.el b/lisp/replace.el
index 17eea19edd8..1bebff448fa 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -1125,6 +1125,14 @@ If the value is nil, don't highlight the buffer names specially."
   :type 'face
   :group 'matching)
 
+(defcustom list-matching-lines-prefix-face 'shadow
+  "Face used by \\[list-matching-lines] to show the prefix column.
+If the face doesn't differ from the default face,
+don't highlight the prefix with line numbers specially."
+  :type 'face
+  :group 'matching
+  :version "24.4")
+
 (defcustom occur-excluded-properties
   '(read-only invisible intangible field mouse-face help-echo local-map keymap
     yank-handler follow-link)
@@ -1334,7 +1342,9 @@ See also `multi-occur'."
                       (isearch-no-upper-case-p regexp t)
                     case-fold-search)
                   list-matching-lines-buffer-name-face
-                  nil list-matching-lines-face
+                  (if (face-differs-from-default-p list-matching-lines-prefix-face)
+                      list-matching-lines-prefix-face)
+                  list-matching-lines-face
                   (not (eq occur-excluded-properties t))))))
           (let* ((bufcount (length active-bufs))
                  (diff (- (length bufs) bufcount)))
@@ -1423,7 +1433,7 @@ See also `multi-occur'."
                             (apply #'propertize (format "%7d:" lines)
                                    (append
                                     (when prefix-face
-                                      `(font-lock-face prefix-face))
+                                      `(font-lock-face ,prefix-face))
                                     `(occur-prefix t mouse-face (highlight)
                                       ;; Allow insertion of text at
                                       ;; the end of the prefix (for
@@ -1447,7 +1457,9 @@ See also `multi-occur'."
                              ;; of multi-line matches.
                              (replace-regexp-in-string
                               "\n"
-                              "\n       :"
+                              (if prefix-face
+                                  (propertize "\n       :" 'font-lock-face prefix-face)
+                                "\n       :")
                               match-str)
                              ;; Add marker at eol, but no mouse props.
                              (propertize "\n" 'occur-target marker)))
@@ -1458,7 +1470,8 @@ See also `multi-occur'."
                               ;; The complex multi-line display style.
                               (setq ret (occur-context-lines
                                          out-line nlines keep-props begpt endpt
-                                         lines prev-lines prev-after-lines))
+                                         lines prev-lines prev-after-lines
+                                         prefix-face))
                               ;; Set first elem of the returned list to `data',
                               ;; and the second elem to `prev-after-lines'.
                               (setq prev-after-lines (nth 1 ret))
@@ -1482,7 +1495,7 @@ See also `multi-occur'."
                 (when prev-after-lines
                   (with-current-buffer out-buf
                     (insert (apply #'concat (occur-engine-add-prefix
-                                             prev-after-lines)))))))
+                                             prev-after-lines prefix-face)))))))
             (when (not (zerop matches)) ;; is the count zero?
               (setq globalcount (+ globalcount matches))
               (with-current-buffer out-buf
@@ -1537,10 +1550,13 @@ See also `multi-occur'."
         str)
     (buffer-substring-no-properties beg end)))
 
-(defun occur-engine-add-prefix (lines)
+(defun occur-engine-add-prefix (lines &optional prefix-face)
   (mapcar
    #'(lambda (line)
-       (concat "       :" line "\n"))
+       (concat (if prefix-face
+                   (propertize "       :" 'font-lock-face prefix-face)
+                 "       :")
+               line "\n"))
    lines))
 
 (defun occur-accumulate-lines (count &optional keep-props pt)
@@ -1569,7 +1585,8 @@ See also `multi-occur'."
 ;; Generate a list of lines, add prefixes to all but OUT-LINE,
 ;; then concatenate them all together.
 (defun occur-context-lines (out-line nlines keep-props begpt endpt
-                                     lines prev-lines prev-after-lines)
+                                     lines prev-lines prev-after-lines
+                                     &optional prefix-face)
   ;; Find after- and before-context lines of the current match.
   (let ((before-lines
          (nreverse (cdr (occur-accumulate-lines
@@ -1609,10 +1626,13 @@ See also `multi-occur'."
      ;; Return a list where the first element is the output line.
      (apply #'concat
             (append
-             (and prev-after-lines
-                  (occur-engine-add-prefix prev-after-lines))
-             (and separator (list separator))
-             (occur-engine-add-prefix before-lines)
+             (if prev-after-lines
+                 (occur-engine-add-prefix prev-after-lines prefix-face))
+             (if separator
+                 (list (if prefix-face
+                           (propertize separator 'font-lock-face prefix-face)
+                         separator)))
+             (occur-engine-add-prefix before-lines prefix-face)
              (list out-line)))
      ;; And the second element is the list of context after-lines.
      (if (> nlines 0) after-lines))))
diff --git a/lisp/simple.el b/lisp/simple.el
index 3ef700a6058..9baa1b7c884 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -1291,6 +1291,9 @@ display the result of expression evaluation."
             (format " (#o%o, #x%x, %s)" value value char-string)
           (format " (#o%o, #x%x)" value value)))))
 
+(defvar eval-expression-minibuffer-setup-hook nil
+  "Hook run by `eval-expression' when entering the minibuffer.")
+
 ;; We define this, rather than making `eval' interactive,
 ;; for the sake of completion of names like eval-region, eval-buffer.
 (defun eval-expression (exp &optional insert-value)
@@ -1308,9 +1311,11 @@ If `eval-expression-debug-on-error' is non-nil, which is the default,
 this command arranges for all errors to enter the debugger."
   (interactive
    (list (let ((minibuffer-completing-symbol t))
-           (read-from-minibuffer "Eval: "
-                                 nil read-expression-map t
-                                 'read-expression-history))
+           (minibuffer-with-setup-hook
+               (lambda () (run-hooks 'eval-expression-minibuffer-setup-hook))
+             (read-from-minibuffer "Eval: "
+                                   nil read-expression-map t
+                                   'read-expression-history)))
          current-prefix-arg))
 
   (if (null eval-expression-debug-on-error)
diff --git a/lisp/startup.el b/lisp/startup.el
index ad31a7a2a45..db84a5b11b2 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -2399,13 +2399,17 @@ A fancy display is used on graphic displays, normal otherwise."
     ;; Use arg 1 so that we don't collapse // at the start of the file name.
     ;; That is significant on some systems.
     ;; However, /// at the beginning is supposed to mean just /, not //.
-    (if (string-match "^///+" file)
+    (if (string-match
+         (if (memq system-type '(ms-dos windows-nt))
+             "^\\([\\/][\\/][\\/]\\)+"
+           "^///+")
+         file)
         (setq file (replace-match "/" t t file)))
-    (and (memq system-type '(ms-dos windows-nt))
-         (string-match "^[A-Za-z]:\\(\\\\[\\\\/]\\)" file) ; C:\/ or C:\\
-         (setq file (replace-match "/" t t file 1)))
-    (while (string-match "//+" file 1)
-      (setq file (replace-match "/" t t file)))
+    (if (memq system-type '(ms-dos windows-nt))
+        (while (string-match "\\([\\/][\\/]\\)+" file 1)
+          (setq file (replace-match "/" t t file)))
+      (while (string-match "//+" file 1)
+        (setq file (replace-match "/" t t file))))
     file))
 
 ;;; startup.el ends here
diff --git a/lisp/subr.el b/lisp/subr.el
index 9a7b94208fe..4eb46ec2b01 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1044,14 +1044,17 @@ and `event-end' functions."
                 (nth 1 position))))
     (and (symbolp area) area)))
 
-(defsubst posn-point (position)
+(defun posn-point (position)
   "Return the buffer location in POSITION.
 POSITION should be a list of the form returned by the `event-start'
-and `event-end' functions."
+and `event-end' functions.
+Returns nil if POSITION does not correspond to any buffer location (e.g.
+a click on a scroll bar)."
   (or (nth 5 position)
-      (if (consp (nth 1 position))
-          (car (nth 1 position))
-        (nth 1 position))))
+      (let ((pt (nth 1 position)))
+        (or (car-safe pt)
+            ;; Apparently this can also be `vertical-scroll-bar' (bug#13979).
+            (if (integerp pt) pt)))))
 
 (defun posn-set-point (position)
   "Move point to POSITION.
@@ -1124,12 +1127,14 @@ POSITION should be a list of the form returned by the `event-start'
 and `event-end' functions."
   (nth 3 position))
 
-(defsubst posn-string (position)
+(defun posn-string (position)
   "Return the string object of POSITION.
 Value is a cons (STRING . STRING-POS), or nil if not a string.
 POSITION should be a list of the form returned by the `event-start'
 and `event-end' functions."
-  (nth 4 position))
+  (let ((x (nth 4 position)))
+    ;; Apparently this can also be `handle' or `below-handle' (bug#13979).
+    (when (consp x) x)))
 
 (defsubst posn-image (position)
   "Return the image object of POSITION.
diff --git a/lisp/term/x-win.el b/lisp/term/x-win.el
index 63ef2b402b0..84d6ddbf46c 100644
--- a/lisp/term/x-win.el
+++ b/lisp/term/x-win.el
@@ -427,7 +427,9 @@ as returned by `x-server-vendor'."
         (#x3fe . ?,D~(B)
         ;; Kana: Fixme: needs conversion to Japanese charset -- seems
         ;; to require jisx0213, for which the Unicode translation
-        ;; isn't clear.
+        ;; isn't clear.  Using Emacs to convert this to Unicode and back changes
+        ;; this from "(J~(B" (i.e., bytes "ESC ( J ~ ESC ( B") to "$(G"#(B" (i.e., bytes
+        ;; "ESC $ ( G " # ESC ( B").
         (#x47e . ?(J~(B)
         (#x4a1 . ?$A!#(B)
         (#x4a2 . ?\$A!8(B)
@@ -1127,6 +1129,9 @@ as returned by `x-server-vendor'."
         (#x20a8 . ?$,1tH(B)
         (#x20aa . ?$,1tJ(B)
         (#x20ab . ?$,1tK(B)
+        ;; Kana: Fixme: needs checking.  Using Emacs to convert this to Unicode
+        ;; and back changes this from ",b$(B" (i.e., bytes "ESC , b $ ESC ( B") to
+        ;; ",F$(B" (i.e., bytes "ESC , F $ ESC ( B").
         (#x20ac . ?,b$(B)))
   (puthash (car pair) (cdr pair) x-keysym-table))
 
diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el
index 9526cb76e74..259cd772b12 100644
--- a/lisp/thingatpt.el
+++ b/lisp/thingatpt.el
@@ -182,7 +182,7 @@ The bounds of THING are determined by `bounds-of-thing-at-point'."
 (defun end-of-sexp ()
   "Move point to the end of the current sexp.
 \[This is an internal function.]"
-  (let ((char-syntax (char-syntax (char-after))))
+  (let ((char-syntax (syntax-after (point))))
     (if (or (eq char-syntax ?\))
             (and (eq char-syntax ?\") (in-string-p)))
         (forward-char 1)
diff --git a/lisp/vc/diff-mode.el b/lisp/vc/diff-mode.el
index d9224b29c2e..e945d6ef160 100644
--- a/lisp/vc/diff-mode.el
+++ b/lisp/vc/diff-mode.el
@@ -124,7 +124,6 @@ when editing big diffs)."
     ("A" . diff-ediff-patch)
     ("r" . diff-restrict-view)
     ("R" . diff-reverse-direction)
-    ("/" . diff-undo)
     ([remap undo] . diff-undo))
   "Basic keymap for `diff-mode', bound to various prefix keys."
   :inherit special-mode-map)
diff --git a/lisp/whitespace.el b/lisp/whitespace.el
index 975b89f2fc2..c32155f5430 100644
--- a/lisp/whitespace.el
+++ b/lisp/whitespace.el
@@ -554,13 +554,10 @@ See also `whitespace-display-mappings' for documentation."
                          (const :tag "(Mark) NEWLINEs" newline-mark)))
   :group 'whitespace)
 
-
-(defcustom whitespace-space 'whitespace-space
+(defvar whitespace-space 'whitespace-space
   "Symbol face used to visualize SPACE.
-
-Used when `whitespace-style' includes the value `spaces'."
-  :type 'face
-  :group 'whitespace)
+Used when `whitespace-style' includes the value `spaces'.")
+(make-obsolete-variable 'whitespace-space "use the face instead" "24.4")
 
 
 (defface whitespace-space
@@ -573,13 +570,10 @@ Used when `whitespace-style' includes the value `spaces'."
   :group 'whitespace)
 
 
-(defcustom whitespace-hspace 'whitespace-hspace
+(defvar whitespace-hspace 'whitespace-hspace
   "Symbol face used to visualize HARD SPACE.
-
-Used when `whitespace-style' includes the value `spaces'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `spaces'.")
+(make-obsolete-variable 'whitespace-hspace "use the face instead" "24.4")
 
 (defface whitespace-hspace              ; 'nobreak-space
   '((((class color) (background dark))
@@ -591,13 +585,10 @@ Used when `whitespace-style' includes the value `spaces'."
   :group 'whitespace)
 
 
-(defcustom whitespace-tab 'whitespace-tab
+(defvar whitespace-tab 'whitespace-tab
   "Symbol face used to visualize TAB.
-
-Used when `whitespace-style' includes the value `tabs'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `tabs'.")
+(make-obsolete-variable 'whitespace-tab "use the face instead" "24.4")
 
 (defface whitespace-tab
   '((((class color) (background dark))
@@ -609,16 +600,12 @@ Used when `whitespace-style' includes the value `tabs'."
   :group 'whitespace)
 
 
-(defcustom whitespace-newline 'whitespace-newline
+(defvar whitespace-newline 'whitespace-newline
   "Symbol face used to visualize NEWLINE char mapping.
-
 See `whitespace-display-mappings'.
-
 Used when `whitespace-style' includes the values `newline-mark'
-and `newline'."
-  :type 'face
-  :group 'whitespace)
-
+and `newline'.")
+(make-obsolete-variable 'whitespace-newline "use the face instead" "24.4")
 
 (defface whitespace-newline
   '((default :weight normal)
@@ -634,13 +621,10 @@ See `whitespace-display-mappings'."
   :group 'whitespace)
 
 
-(defcustom whitespace-trailing 'whitespace-trailing
+(defvar whitespace-trailing 'whitespace-trailing
   "Symbol face used to visualize trailing blanks.
-
-Used when `whitespace-style' includes the value `trailing'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `trailing'.")
+(make-obsolete-variable 'whitespace-trailing "use the face instead" "24.4")
 
 (defface whitespace-trailing            ; 'trailing-whitespace
   '((default :weight bold)
@@ -650,15 +634,11 @@ Used when `whitespace-style' includes the value `trailing'."
   :group 'whitespace)
 
 
-(defcustom whitespace-line 'whitespace-line
+(defvar whitespace-line 'whitespace-line
   "Symbol face used to visualize \"long\" lines.
-
 See `whitespace-line-column'.
-
-Used when `whitespace-style' includes the value `line'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `line'.")
+(make-obsolete-variable 'whitespace-line "use the face instead" "24.4")
 
 (defface whitespace-line
   '((((class mono)) :inverse-video t :weight bold :underline t)
@@ -669,13 +649,11 @@ See `whitespace-line-column'."
   :group 'whitespace)
 
 
-(defcustom whitespace-space-before-tab 'whitespace-space-before-tab
+(defvar whitespace-space-before-tab 'whitespace-space-before-tab
   "Symbol face used to visualize SPACEs before TAB.
-
-Used when `whitespace-style' includes the value `space-before-tab'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `space-before-tab'.")
+(make-obsolete-variable 'whitespace-space-before-tab
+                        "use the face instead" "24.4")
 
 (defface whitespace-space-before-tab
   '((((class mono)) :inverse-video t :weight bold :underline t)
@@ -684,13 +662,10 @@ Used when `whitespace-style' includes the value `space-before-tab'."
   :group 'whitespace)
 
 
-(defcustom whitespace-indentation 'whitespace-indentation
+(defvar whitespace-indentation 'whitespace-indentation
   "Symbol face used to visualize 8 or more SPACEs at beginning of line.
-
-Used when `whitespace-style' includes the value `indentation'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `indentation'.")
+(make-obsolete-variable 'whitespace-indentation "use the face instead" "24.4")
 
 (defface whitespace-indentation
   '((((class mono)) :inverse-video t :weight bold :underline t)
@@ -699,13 +674,10 @@ Used when `whitespace-style' includes the value `indentation'."
   :group 'whitespace)
 
 
-(defcustom whitespace-empty 'whitespace-empty
+(defvar whitespace-empty 'whitespace-empty
   "Symbol face used to visualize empty lines at beginning and/or end of buffer.
-
-Used when `whitespace-style' includes the value `empty'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `empty'.")
+(make-obsolete-variable 'whitespace-empty "use the face instead" "24.4")
 
 (defface whitespace-empty
   '((((class mono)) :inverse-video t :weight bold :underline t)
@@ -714,13 +686,11 @@ Used when `whitespace-style' includes the value `empty'."
   :group 'whitespace)
 
 
-(defcustom whitespace-space-after-tab 'whitespace-space-after-tab
+(defvar whitespace-space-after-tab 'whitespace-space-after-tab
   "Symbol face used to visualize 8 or more SPACEs after TAB.
-
-Used when `whitespace-style' includes the value `space-after-tab'."
-  :type 'face
-  :group 'whitespace)
-
+Used when `whitespace-style' includes the value `space-after-tab'.")
+(make-obsolete-variable 'whitespace-space-after-tab
+                        "use the face instead" "24.4")
 
 (defface whitespace-space-after-tab
   '((((class mono)) :inverse-video t :weight bold :underline t)
@@ -730,15 +700,9 @@ Used when `whitespace-style' includes the value `space-after-tab'."
 
 
 (defcustom whitespace-hspace-regexp
-  "\\(\\(\xA0\\|\x8A0\\|\x920\\|\xE20\\|\xF20\\)+\\)"
+  "\\(\u00A0+\\)"
   "Specify HARD SPACE characters regexp.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \"\\xA0\"   \"\\x8A0\"   \"\\x920\"   \"\\xE20\"   \"\\xF20\"
-
-that should be considered HARD SPACE.
-
 Here are some examples:
 
    \"\\\\(^\\xA0+\\\\)\"                \
@@ -806,7 +770,7 @@ Used when `whitespace-style' includes `tabs'."
   "\\([\t \u00A0]+\\)$"
   "Specify trailing characters regexp.
 
-If you're using `mule' package, there may be other characters besides:
+There may be other characters besides:
 
    \" \"  \"\\t\"  \"\\u00A0\"
 
@@ -823,13 +787,6 @@ Used when `whitespace-style' includes `trailing'."
 (defcustom whitespace-space-before-tab-regexp "\\( +\\)\\(\t+\\)"
   "Specify SPACEs before TAB regexp.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \" \"  \"\\t\"  \"\\xA0\"  \"\\x8A0\"  \"\\x920\"  \"\\xE20\"  \
-\"\\xF20\"
-
-that should be considered blank.
-
 Used when `whitespace-style' includes `space-before-tab',
 `space-before-tab::tab' or  `space-before-tab::space'."
   :type '(regexp :tag "SPACEs Before TAB")
@@ -844,13 +801,6 @@ Used when `whitespace-style' includes `space-before-tab',
 It is a cons where the cons car is used for SPACEs visualization
 and the cons cdr is used for TABs visualization.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \" \"  \"\\t\"  \"\\xA0\"  \"\\x8A0\"  \"\\x920\"  \"\\xE20\"  \
-\"\\xF20\"
-
-that should be considered blank.
-
 Used when `whitespace-style' includes `indentation',
 `indentation::tab' or  `indentation::space'."
   :type '(cons (regexp :tag "Indentation SPACEs")
@@ -861,13 +811,6 @@ Used when `whitespace-style' includes `indentation',
 (defcustom whitespace-empty-at-bob-regexp "^\\(\\([ \t]*\n\\)+\\)"
   "Specify regexp for empty lines at beginning of buffer.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \" \"  \"\\t\"  \"\\xA0\"  \"\\x8A0\"  \"\\x920\"  \"\\xE20\"  \
-\"\\xF20\"
-
-that should be considered blank.
-
 Used when `whitespace-style' includes `empty'."
   :type '(regexp :tag "Empty Lines At Beginning Of Buffer")
   :group 'whitespace)
@@ -876,13 +819,6 @@ Used when `whitespace-style' includes `empty'."
 (defcustom whitespace-empty-at-eob-regexp "^\\([ \t\n]+\\)"
   "Specify regexp for empty lines at end of buffer.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \" \"  \"\\t\"  \"\\xA0\"  \"\\x8A0\"  \"\\x920\"  \"\\xE20\"  \
-\"\\xF20\"
-
-that should be considered blank.
-
 Used when `whitespace-style' includes `empty'."
   :type '(regexp :tag "Empty Lines At End Of Buffer")
   :group 'whitespace)
@@ -896,13 +832,6 @@ Used when `whitespace-style' includes `empty'."
 It is a cons where the cons car is used for SPACEs visualization
 and the cons cdr is used for TABs visualization.
 
-If you're using `mule' package, there may be other characters besides:
-
-   \" \"  \"\\t\"  \"\\xA0\"  \"\\x8A0\"  \"\\x920\"  \"\\xE20\"  \
-\"\\xF20\"
-
-that should be considered blank.
-
 Used when `whitespace-style' includes `space-after-tab',
 `space-after-tab::tab' or `space-after-tab::space'."
   :type '(regexp :tag "SPACEs After TAB")
@@ -1932,14 +1861,8 @@ cleaning up these problems."
 ;;;; Internal functions
 
 
-(defvar whitespace-font-lock-mode nil
-  "Used to remember whether a buffer had font lock mode on or not.")
-
-(defvar whitespace-font-lock nil
-  "Used to remember whether a buffer initially had font lock on or not.")
-
 (defvar whitespace-font-lock-keywords nil
-  "Used to save locally `font-lock-keywords' value.")
+  "Used to save the value `whitespace-color-on' adds to `font-lock-keywords'.")
 
 
 (defconst whitespace-help-text
@@ -2177,8 +2100,6 @@ resultant list will be returned."
   ;; prepare local hooks
   (add-hook 'write-file-functions 'whitespace-write-file-hook nil t)
   ;; create whitespace local buffer environment
-  (set (make-local-variable 'whitespace-font-lock-mode) nil)
-  (set (make-local-variable 'whitespace-font-lock) nil)
   (set (make-local-variable 'whitespace-font-lock-keywords) nil)
   (set (make-local-variable 'whitespace-display-table) nil)
   (set (make-local-variable 'whitespace-display-table-was-local) nil)
@@ -2228,10 +2149,6 @@ resultant list will be returned."
 (defun whitespace-color-on ()
   "Turn on color visualization."
   (when (whitespace-style-face-p)
-    (unless whitespace-font-lock
-      (setq whitespace-font-lock t
-            whitespace-font-lock-keywords
-            (copy-sequence font-lock-keywords)))
     ;; save current point and refontify when necessary
     (set (make-local-variable 'whitespace-point)
          (point))
@@ -2245,163 +2162,98 @@ resultant list will be returned."
          nil)
     (add-hook 'post-command-hook #'whitespace-post-command-hook nil t)
     (add-hook 'before-change-functions #'whitespace-buffer-changed nil t)
-    ;; turn off font lock
-    (set (make-local-variable 'whitespace-font-lock-mode)
-         font-lock-mode)
-    (font-lock-mode 0)
-    ;; add whitespace-mode color into font lock
-    (when (memq 'spaces whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs
-        (list whitespace-space-regexp  1 whitespace-space  t)
-        ;; Show HARD SPACEs
-        (list whitespace-hspace-regexp 1 whitespace-hspace t))
-       t))
-    (when (memq 'tabs whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show TABs
-        (list whitespace-tab-regexp 1 whitespace-tab t))
-       t))
-    (when (memq 'trailing whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show trailing blanks
-        (list #'whitespace-trailing-regexp 1 whitespace-trailing t))
-       t))
-    (when (or (memq 'lines      whitespace-active-style)
-              (memq 'lines-tail whitespace-active-style))
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show "long" lines
-        (list
-         (let ((line-column (or whitespace-line-column fill-column)))
-           (format
-            "^\\([^\t\n]\\{%s\\}\\|[^\t\n]\\{0,%s\\}\t\\)\\{%d\\}%s\\(.+\\)$"
-            whitespace-tab-width
-            (1- whitespace-tab-width)
-            (/ line-column whitespace-tab-width)
-            (let ((rem (% line-column whitespace-tab-width)))
-              (if (zerop rem)
-                  ""
-                (format ".\\{%d\\}" rem)))))
-         (if (memq 'lines whitespace-active-style)
-             0                          ; whole line
-           2)                           ; line tail
-         whitespace-line t))
-       t))
-    (cond
-     ((memq 'space-before-tab whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs before TAB (indent-tabs-mode)
-        (list whitespace-space-before-tab-regexp
-              (if whitespace-indent-tabs-mode 1 2)
-              whitespace-space-before-tab t))
-       t))
-     ((memq 'space-before-tab::tab whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs before TAB (SPACEs)
-        (list whitespace-space-before-tab-regexp
-              1 whitespace-space-before-tab t))
-       t))
-     ((memq 'space-before-tab::space whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs before TAB (TABs)
-        (list whitespace-space-before-tab-regexp
-              2 whitespace-space-before-tab t))
-       t)))
-    (cond
-     ((memq 'indentation whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show indentation SPACEs (indent-tabs-mode)
-        (list (whitespace-indentation-regexp)
-              1 whitespace-indentation t))
-       t))
-     ((memq 'indentation::tab whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show indentation SPACEs (SPACEs)
-        (list (whitespace-indentation-regexp 'tab)
-              1 whitespace-indentation t))
-       t))
-     ((memq 'indentation::space whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show indentation SPACEs (TABs)
-        (list (whitespace-indentation-regexp 'space)
-              1 whitespace-indentation t))
-       t)))
-    (when (memq 'empty whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show empty lines at beginning of buffer
-        (list #'whitespace-empty-at-bob-regexp
-              1 whitespace-empty t))
-       t)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show empty lines at end of buffer
-        (list #'whitespace-empty-at-eob-regexp
-              1 whitespace-empty t))
-       t))
-    (cond
-     ((memq 'space-after-tab whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs after TAB (indent-tabs-mode)
-        (list (whitespace-space-after-tab-regexp)
-              1 whitespace-space-after-tab t))
-       t))
-     ((memq 'space-after-tab::tab whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs after TAB (SPACEs)
-        (list (whitespace-space-after-tab-regexp 'tab)
-              1 whitespace-space-after-tab t))
-       t))
-     ((memq 'space-after-tab::space whitespace-active-style)
-      (font-lock-add-keywords
-       nil
-       (list
-        ;; Show SPACEs after TAB (TABs)
-        (list (whitespace-space-after-tab-regexp 'space)
-              1 whitespace-space-after-tab t))
-       t)))
-    ;; now turn on font lock and highlight blanks
-    (font-lock-mode 1)))
+    ;; Add whitespace-mode color into font lock.
+    (setq
+     whitespace-font-lock-keywords
+     `(
+       ,@(when (memq 'spaces whitespace-active-style)
+           ;; Show SPACEs.
+           `((,whitespace-space-regexp 1 whitespace-space t)
+             ;; Show HARD SPACEs.
+             (,whitespace-hspace-regexp 1 whitespace-hspace t)))
+       ,@(when (memq 'tabs whitespace-active-style)
+           ;; Show TABs.
+           `((,whitespace-tab-regexp 1 whitespace-tab t)))
+       ,@(when (memq 'trailing whitespace-active-style)
+           ;; Show trailing blanks.
+           `((,#'whitespace-trailing-regexp 1 whitespace-trailing t)))
+       ,@(when (or (memq 'lines      whitespace-active-style)
+                   (memq 'lines-tail whitespace-active-style))
+           ;; Show "long" lines.
+           `((,(let ((line-column (or whitespace-line-column fill-column)))
+                 (format
+                  "^\\([^\t\n]\\{%s\\}\\|[^\t\n]\\{0,%s\\}\t\\)\\{%d\\}%s\\(.+\\)$"
+                  whitespace-tab-width
+                  (1- whitespace-tab-width)
+                  (/ line-column whitespace-tab-width)
+                  (let ((rem (% line-column whitespace-tab-width)))
+                    (if (zerop rem)
+                        ""
+                      (format ".\\{%d\\}" rem)))))
+              ,(if (memq 'lines whitespace-active-style)
+                   0                    ; whole line
+                 2)                     ; line tail
+              whitespace-line prepend)))
+       ,@(when (or (memq 'space-before-tab whitespace-active-style)
+                   (memq 'space-before-tab::tab whitespace-active-style)
+                   (memq 'space-before-tab::space whitespace-active-style))
+           `((,whitespace-space-before-tab-regexp
+              ,(cond
+                ((memq 'space-before-tab whitespace-active-style)
+                 ;; Show SPACEs before TAB (indent-tabs-mode).
+                 (if whitespace-indent-tabs-mode 1 2))
+                ((memq 'space-before-tab::tab whitespace-active-style)
+                 1)
+                ((memq 'space-before-tab::space whitespace-active-style)
+                 2))
+              whitespace-space-before-tab t)))
+       ,@(when (or (memq 'indentation whitespace-active-style)
+                   (memq 'indentation::tab whitespace-active-style)
+                   (memq 'indentation::space whitespace-active-style))
+           `((,(cond
+                ((memq 'indentation whitespace-active-style)
+                 ;; Show indentation SPACEs (indent-tabs-mode).
+                 (whitespace-indentation-regexp))
+                ((memq 'indentation::tab whitespace-active-style)
+                 ;; Show indentation SPACEs (SPACEs).
+                 (whitespace-indentation-regexp 'tab))
+                ((memq 'indentation::space whitespace-active-style)
+                 ;; Show indentation SPACEs (TABs).
+                 (whitespace-indentation-regexp 'space)))
+              1 whitespace-indentation t)))
+       ,@(when (memq 'empty whitespace-active-style)
+           ;; Show empty lines at beginning of buffer.
+           `((,#'whitespace-empty-at-bob-regexp
+              1 whitespace-empty t)
+             ;; Show empty lines at end of buffer.
+             (,#'whitespace-empty-at-eob-regexp
+              1 whitespace-empty t)))
+       ,@(when (or (memq 'space-after-tab whitespace-active-style)
+                   (memq 'space-after-tab::tab whitespace-active-style)
+                   (memq 'space-after-tab::space whitespace-active-style))
+           `((,(cond
+                ((memq 'space-after-tab whitespace-active-style)
+                 ;; Show SPACEs after TAB (indent-tabs-mode).
+                 (whitespace-space-after-tab-regexp))
+                ((memq 'space-after-tab::tab whitespace-active-style)
+                 ;; Show SPACEs after TAB (SPACEs).
+                 (whitespace-space-after-tab-regexp 'tab))
+                ((memq 'space-after-tab::space whitespace-active-style)
+                 ;; Show SPACEs after TAB (TABs).
+                 (whitespace-space-after-tab-regexp 'space)))
+              1 whitespace-space-after-tab t)))))
+    (font-lock-add-keywords nil whitespace-font-lock-keywords t)
+    (font-lock-fontify-buffer)))
 
 
 (defun whitespace-color-off ()
   "Turn off color visualization."
   ;; turn off font lock
   (when (whitespace-style-face-p)
-    (font-lock-mode 0)
     (remove-hook 'post-command-hook #'whitespace-post-command-hook t)
     (remove-hook 'before-change-functions #'whitespace-buffer-changed t)
-    (when whitespace-font-lock
-      (setq whitespace-font-lock nil
-            font-lock-keywords   whitespace-font-lock-keywords))
-    ;; restore original font lock state
-    (font-lock-mode whitespace-font-lock-mode)))
+    (font-lock-remove-keywords nil whitespace-font-lock-keywords)
+    (font-lock-fontify-buffer)))
 
 
 (defun whitespace-trailing-regexp (limit)