Merge branch 'trunk' into xwidget

Conflicts:
	src/Makefile.in
	src/keyboard.c
	src/termhooks.h

111 files changed, 6493 insertions, 4484 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 3fa1ffe40a7..ae429db7a7a 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,657 @@
+2013-06-12  Glenn Morris  <rgm@gnu.org>
+
+        * ido.el (ido-delete-ignored-files): Remove.
+        (ido-wide-find-dirs-or-files, ido-make-file-list-1):
+        Go back to calling ido-ignore-item-p directly.
+
+2013-06-12  Eyal Lotem  <eyal.lotem@gmail.com>  (tiny change)
+
+        * ido.el (ido-wide-find-dirs-or-files): Respect ido-case-fold.
+
+        * ido.el (ido-delete-ignored-files): New function,
+        split from ido-make-file-list-1.
+        (ido-wide-find-dirs-or-files): Maybe ignore files.  (Bug#13003)
+        (ido-make-file-list-1): Use ido-delete-ignored-files.
+
+2013-06-12  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (inferior-octave-startup)
+        (inferior-octave-completion-table)
+        (inferior-octave-track-window-width-change)
+        (octave-eldoc-function-signatures, octave-help)
+        (octave-find-definition): Use single quoted strings.
+        (inferior-octave-startup-args): Change default value.
+        (inferior-octave-startup): Do not hard code "-i" and
+        "--no-line-editing".
+        (inferior-octave-resync-dirs): Add optional arg NOERROR.
+        (inferior-octave-directory-tracker): Use it.
+        (octave-goto-function-definition): Robustify.
+        (octave-help): Support highlighting operators in 'See also'.
+        (octave-find-definition): Find subfunctions only in Octave mode.
+
+2013-06-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * help-fns.el (help-fns--compiler-macro): If the handler function is
+        named, then put a link to it.
+        * help-mode.el (help-function-cmacro): Adjust regexp for cl-lib names.
+        * emacs-lisp/cl-macs.el (cl--compiler-macro-typep): New function.
+        (cl-typep): Use it.
+        (cl-eval-when): Simplify debug spec.
+        (cl-define-compiler-macro): Use eval-and-compile.  Give a name to the
+        compiler-macro function instead of setting `compiler-macro-file'.
+
+2013-06-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+            Daniel Hackney  <dan@haxney.org>
+
+        First part of Daniel Hackney's patch to package.el.
+        * emacs-lisp/package.el: Use defstruct.
+        (package-desc): New, main struct.
+        (package--bi-desc, package--ac-desc): New structs, used to describe the
+        format in external files.
+        (package-desc-vers): Replace with package-desc-version accessor.
+        (package-desc-doc): Replace with package-desc-summary accessor.
+        (package-activate-1): Remove `package' arg since the pkg-vec now
+        includes the name.
+        (define-package): Use package-desc-from-define.
+        (package-unpack-single): Change file-name arg to be a symbol.
+        (package--add-to-archive-contents): Use package-desc-create and new
+        accessor functions to package--ac-desc.
+        (package-buffer-info, package-tar-file-info): Return a package-desc.
+        (package-install-from-buffer): Remove `type' argument.  Change pkg-info
+        arg to be a package-desc.
+        (package-install-file): Adjust accordingly.  Use \' to match EOS.
+        (package--from-builtin): New function.
+        (describe-package-1, package-menu--generate): Use it.
+        (package--make-autoloads-and-compile): Change name arg to be a symbol.
+        (package-generate-autoloads): Idem and return the name of the file.
+        * emacs-lisp/package-x.el (package-upload-buffer-internal):
+        Change pkg-info arg to be a package-desc.
+        Use package-make-ac-desc.
+        (package-upload-file): Use \' to match EOS.
+        * finder.el (finder-compile-keywords): Use package-make-builtin.
+
+2013-06-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * vc/vc.el (vc-deduce-fileset): Change error message.
+        (vc-read-backend): New function.
+        (vc-next-action): Use it.
+
+        * subr.el (function-arity): Remove (mistakenly added) (bug#14590).
+
+        * progmodes/prolog.el (prolog-make-keywords-regexp): Remove.
+        (prolog-font-lock-keywords): Use regexp-opt instead.
+        Don't manually highlight strings.
+        (prolog-mode-variables): Simplify comment-start-skip.
+        (prolog-consult-compile): Use display-buffer.  Remove unused old-filter.
+
+        * emacs-lisp/generic.el (generic--normalise-comments)
+        (generic-set-comment-syntax, generic-set-comment-vars): New functions.
+        (generic-mode-set-comments): Use them.
+        (generic-bracket-support): Use setq-local.
+        (generic-make-keywords-list): Declare obsolete.
+
+2013-06-11  Glenn Morris  <rgm@gnu.org>
+
+        * emacs-lisp/lisp-mode.el (lisp-mode-variables):
+        Prettify after setting font-lock-defaults.  (Bug#14574)
+
+2013-06-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * replace.el (query-replace, occur-read-regexp-defaults-function)
+        (replace-search):
+        * subr.el (declare-function, number-sequence, local-set-key)
+        (substitute-key-definition, locate-user-emacs-file)
+        (with-silent-modifications, split-string, eval-after-load):
+        Fix typos, remove unneeded backslashes and reflow some docstrings.
+
+2013-06-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * international/mule-conf.el (file-coding-system-alist): Use utf-8 as
+        default for Elisp files.
+
+2013-06-11  Glenn Morris  <rgm@gnu.org>
+
+        * vc/log-view.el (log-view-mode-map): Inherit from special-mode-map,
+        although define-derived-mode was doing this anyway.  (Bug#14583)
+
+2013-06-10  Juanma Barranquero  <lekktu@gmail.com>
+
+        * allout.el (allout-encryption-plaintext-sanitization-regexps):
+        Fix make-variable-buffer-local call to refer to the correct variable.
+
+2013-06-10  Aidan Gauland  <aidalgol@amuri.net>
+
+        * eshell/em-term.el (eshell-visual-commands)
+        (eshell-visual-subcommands, eshell-visual-options):
+        Add summary line to docstrings.  Add cross-references.
+
+2013-06-10  Glenn Morris  <rgm@gnu.org>
+
+        * epa.el (epa-read-file-name): New function.  (Bug#14510)
+        (epa-decrypt-file): Make plain-file optional.  Use epa-read-file-name.
+
+2013-06-09  Aidan Gauland  <aidalgol@amuri.net>
+
+        * eshell/em-term.el (eshell-visual-command-p): Fix bug that caused
+        output redirection to be ignored with visual commands.
+
+2013-06-09  Aidan Gauland  <aidalgol@amuri.net>
+
+        * eshell/em-term.el (eshell-visual-command-p): New function.
+        (eshell-term-initialize): Move long lambda to separate function
+        eshell-visual-command-p.
+        * eshell/em-dirs.el (eshell-dirs-initialise):
+        * eshell/em-script.el (eshell-script-initialize):
+        Add missing #' to lambda.
+
+2013-06-08  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (octave-add-log-current-defun): New function.
+        (octave-mode): Set add-log-current-defun-function.
+        (octave-goto-function-definition): Do not move point if not found.
+        (octave-find-definition): Enhance to try subfunctions first.
+
+2013-06-08  Glenn Morris  <rgm@gnu.org>
+
+        * emacs-lisp/bytecomp.el (byte-compile-char-before)
+        (byte-compile-backward-char, byte-compile-backward-word):
+        Improve previous change, to handle non-explicit nil.
+
+2013-06-07  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/smie.el: Improve show-paren-mode behavior.
+        (smie--opener/closer-at-point): New function.
+        (smie--matching-block-data): Use it.  Don't match from right after an
+        opener or right before a closer.  Obey smie-blink-matching-inners.
+        Don't signal a mismatch for repeated inners like "switch..case..case".
+
+2013-06-07  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (octave-mode): Set comment-use-global-state
+        to t.  (Bug#14303)
+        (octave-function-header-regexp): Fix.  (Bug#14570)
+        (octave-help-mode-finish-hook, octave-help-mode-finish):
+        Remove.  Just use temp-buffer-show-hook.
+
+        * newcomment.el (comment-search-backward): Revert last change.
+        (Bug#14434)
+
+        * emacs-lisp/smie.el (smie--matching-block-data): Minor simplification.
+
+2013-06-07  Eli Zaretskii  <eliz@gnu.org>
+
+        * Makefile.in (TAGS TAGS-LISP): Pass the (long) list of *.el files
+        through xargs, to avoid failure due to MS-Windows limitations on
+        command-line length.
+
+2013-06-06  Glenn Morris  <rgm@gnu.org>
+
+        * font-lock.el (lisp-font-lock-keywords-2):
+        Treat user-error like error.
+
+        * emacs-lisp/bytecomp.el (byte-compile-char-before)
+        (byte-compile-backward-char, byte-compile-backward-word):
+        Handle explicit nil arguments.  (Bug#14565)
+
+2013-06-05  Alan Mackenzie  <acm@muc.de>
+
+        * isearch.el (isearch-allow-prefix): New user option.
+        (isearch-other-meta-char): Don't exit isearch when a prefix
+        argument is typed whilst `isearch-allow-prefix' is non-nil.
+        (Bug#9706)
+
+2013-06-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * autorevert.el (auto-revert-notify-handler): Use memq.
+        Hide assertion failure.
+
+        * skeleton.el: Use cl-lib.
+        (skeleton-further-elements): Use defvar-local.
+        (skeleton-insert): Use cl-progv.
+
+2013-06-05  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * progmodes/prog-mode.el (prog-prettify-symbols)
+        (prog-prettify-install): Update docstrings.
+
+2013-06-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * simple.el: Move all the prog-mode code to prog-mode.el.
+        * progmodes/prog-mode.el: New file.
+        * loadup.el: Add prog-mode.el.
+
+2013-06-05  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * simple.el (prog-prettify-symbols): Add version.
+        (prog-prettify-install): Add convenience function to prettify symbols.
+
+        * progmodes/perl-mode.el (perl--augmented-font-lock-keywords)
+        (perl--augmented-font-lock-keywords-1)
+        (perl--augmented-font-lock-keywords-2, perl-mode): Remove unneeded
+        variables and use it.
+
+        * progmodes/cfengine.el (cfengine3--augmented-font-lock-keywords)
+        (cfengine3-mode): Remove unneeded variable and use it.
+
+        * emacs-lisp/lisp-mode.el (lisp--augmented-font-lock-keywords)
+        (lisp--augmented-font-lock-keywords-1)
+        (lisp--augmented-font-lock-keywords-2, lisp-mode-variables):
+        Remove unneeded variables and use it.
+
+2013-06-05  João Távora  <joaotavora@gmail.com>
+
+        * net/tls.el (open-tls-stream): Remove unneeded buffer contents up
+        to point when opening the connection.  (Bug#14380)
+
+2013-06-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * subr.el (load-history-regexp, load-history-filename-element)
+        (eval-after-load, after-load-functions, do-after-load-evaluation)
+        (eval-next-after-load, display-delayed-warnings)
+        (collapse-delayed-warnings, delayed-warnings-hook): Move after the
+        definition of save-match-data.
+        (overriding-local-map): Remove accidental obsolescence declaration.
+
+        * emacs-lisp/edebug.el (edebug-result): Move before first use.
+
+2013-06-05  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        Generalize symbol prettify support to prog-mode and implement it
+        for perl-mode, cfengine3-mode, and emacs-lisp-mode.
+        * simple.el (prog-prettify-symbols-alist, prog-prettify-symbols)
+        (prog--prettify-font-lock-compose-symbol)
+        (prog-prettify-font-lock-symbols-keywords): New variables and
+        functions to support symbol prettification.
+        * emacs-lisp/lisp-mode.el (lisp--augmented-font-lock-keywords)
+        (lisp--augmented-font-lock-keywords-1)
+        (lisp--augmented-font-lock-keywords-2, lisp-mode-variables)
+        (lisp--prettify-symbols-alist): Implement prettify of lambda.
+        * progmodes/cfengine.el (cfengine3--augmented-font-lock-keywords)
+        (cfengine3--prettify-symbols-alist, cfengine3-mode):
+        Implement prettify of -> => :: strings.
+        * progmodes/perl-mode.el (perl-prettify-symbols)
+        (perl--font-lock-compose-symbol)
+        (perl--font-lock-symbols-keywords): Move to prog-mode.
+        (perl--prettify-symbols-alist): Prettify -> => :: strings.
+        (perl-font-lock-keywords-1)
+        (perl-font-lock-keywords-2): Remove explicit prettify support.
+        (perl--augmented-font-lock-keywords)
+        (perl--augmented-font-lock-keywords-1)
+        (perl--augmented-font-lock-keywords-2, perl-mode):
+        Implement prettify support.
+
+2013-06-05  Leo Liu  <sdl.web@gmail.com>
+
+        Re-implement smie matching block highlight using
+        show-paren-data-function.  (Bug#14395)
+        * emacs-lisp/smie.el (smie-matching-block-highlight)
+        (smie--highlight-matching-block-overlay)
+        (smie--highlight-matching-block-lastpos)
+        (smie-highlight-matching-block)
+        (smie-highlight-matching-block-mode): Remove.
+        (smie--matching-block-data-cache): New variable.
+        (smie--matching-block-data): New function.
+        (smie-setup): Use smie--matching-block-data for
+        show-paren-data-function.
+
+        * progmodes/octave.el (octave-mode-menu): Fix.
+        (octave-find-definition): Skip garbage lines.
+
+2013-06-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Fix compilation error with simultaneous dynamic+lexical scoping.
+        Add warning when a defvar appears after the first let-binding.
+        * emacs-lisp/bytecomp.el (byte-compile-lexical-variables): New var.
+        (byte-compile-close-variables): Initialize it.
+        (byte-compile--declare-var): New function.
+        (byte-compile-file-form-defvar)
+        (byte-compile-file-form-define-abbrev-table)
+        (byte-compile-file-form-custom-declare-variable): Use it.
+        (byte-compile-make-lambda-lexenv): Change the argument.  Simplify.
+        (byte-compile-lambda): Share call to byte-compile-arglist-vars.
+        (byte-compile-bind): Handle dynamic bindings that shadow
+        lexical bindings.
+        (byte-compile-unbind): Make arg non-optional.
+        (byte-compile-let): Simplify.
+        * emacs-lisp/cconv.el (byte-compile-lexical-variables): Declare var.
+        (cconv--analyse-function, cconv-analyse-form): Populate it.
+        Protect byte-compile-bound-variables to limit the scope of defvars.
+        (cconv-analyse-form): Add missing rule for (defvar <foo>).
+        Remove unneeded rule for `declare'.
+
+        * emacs-lisp/cl-macs.el (cl--compiler-macro-adjoin): Use macroexp-let2
+        so as to avoid depending on cl-adjoin at run-time.
+        * emacs-lisp/cl-lib.el (cl-pushnew): Use backquotes.
+
+        * emacs-lisp/macroexp.el (macroexp--compiling-p): New function.
+        (macroexp--warn-and-return): Use it.
+
+2013-06-05  Leo Liu  <sdl.web@gmail.com>
+
+        * eshell/esh-mode.el (eshell-mode): Fix key bindings.
+
+2013-06-04  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/compile.el (compile-goto-error): Add optional arg NOMSG.
+        (compilation-auto-jump): Suppress the "Mark set" message to give
+        way to exit message.
+
+2013-06-04  Alan Mackenzie  <acm@muc.de>
+
+        Remove faulty optimisation from indentation calculation.
+        * progmodes/cc-engine.el (c-guess-basic-syntax): Don't calculate
+        search limit based on 2000 characters back from indent-point.
+
+2013-06-03  Tassilo Horn  <tsdh@gnu.org>
+
+        * eshell/em-term.el (cl-lib): Require `cl-lib'.
+
+2013-06-03  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/lisp.el: Use lexical-binding.
+        (lisp--local-variables-1, lisp--local-variables): New functions.
+        (lisp--local-variables-completion-table): New var.
+        (lisp-completion-at-point): Use it complete let-bound vars.
+
+        * emacs-lisp/lisp-mode.el (eval-sexp-add-defvars): Expand macros
+        eagerly (bug#14422).
+
+2013-06-03  Michael Albinus  <michael.albinus@gmx.de>
+
+        * autorevert.el (auto-revert-notify-enabled)
+        (auto-revert-notify-rm-watch, auto-revert-notify-add-watch)
+        (auto-revert-notify-event-p, auto-revert-notify-event-file-name)
+        (auto-revert-notify-handler): Handle also gfilenotify.
+
+        * subr.el (file-notify-handle-event): New defun.  Replacing ...
+        (inotify-event-p, inotify-handle-event, w32notify-handle-event):
+        Remove.
+
+2013-06-03  Juri Linkov  <juri@jurta.org>
+
+        * bindings.el (search-map): Bind `highlight-symbol-at-point' to
+        `M-s h .'.  (Bug#14427)
+
+        * hi-lock.el (highlight-symbol-at-point): New alias for the new
+        command `hi-lock-face-symbol-at-point'.
+        (hi-lock-face-symbol-at-point): New command.
+        (hi-lock-map): Bind `highlight-symbol-at-point' to `C-x w .'.
+        (hi-lock-menu): Add `highlight-symbol-at-point'.
+        (hi-lock-mode): Doc fix.
+
+        * isearch.el (isearch-forward-symbol-at-point): New command.
+        (search-map): Bind `isearch-forward-symbol-at-point' to `M-s .'.
+        (isearch-highlight-regexp): Add a regexp which matches
+        words/symbols for word/symbol mode.
+
+        * subr.el (find-tag-default-bounds): New function with the body
+        mostly moved from `find-tag-default'.
+        (find-tag-default): Move most code to `find-tag-default-bounds',
+        call it and apply `buffer-substring-no-properties' afterwards.
+
+2013-06-03  Tassilo Horn  <tsdh@gnu.org>
+
+        * eshell/em-term.el (eshell-term-initialize):
+        Use `cl-intersection' rather than `intersection'.
+
+2013-06-02  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * vc/log-view.el: Doc fix.
+        (log-view-mode-map): Copy keymap from `special-mode-map'.
+
+2013-06-02  Eric Ludlam  <zappo@gnu.org>
+
+        * emacs-lisp/eieio.el (eieio--defalias, eieio-hook)
+        (eieio-error-unsupported-class-tags, eieio-skip-typecheck)
+        (eieio-optimize-primary-methods-flag, eieio-initializing-object)
+        (eieio-unbound, eieio-default-superclass)
+        (eieio--define-field-accessors, method-static, method-before)
+        (method-primary, method-after, method-num-lists)
+        (method-generic-before, method-generic-primary)
+        (method-generic-after, method-num-slots)
+        (eieio-specialized-key-to-generic-key)
+        (eieio--check-type, class-v, class-p)
+        (eieio-class-name, define-obsolete-function-alias)
+        (eieio-class-parents-fast, eieio-class-children-fast)
+        (same-class-fast-p, class-constructor, generic-p)
+        (generic-primary-only-p, generic-primary-only-one-p)
+        (class-option-assoc, class-option, eieio-object-p)
+        (class-abstract-p, class-method-invocation-order)
+        (eieio-defclass-autoload-map, eieio-defclass-autoload)
+        (eieio-class-un-autoload, eieio-defclass)
+        (eieio-eval-default-p, eieio-perform-slot-validation-for-default)
+        (eieio-add-new-slot, eieio-copy-parents-into-subclass)
+        (eieio--defgeneric-init-form, eieio-defgeneric-form)
+        (eieio-defgeneric-reset-generic-form)
+        (eieio-defgeneric-form-primary-only)
+        (eieio-defgeneric-reset-generic-form-primary-only)
+        (eieio-defgeneric-form-primary-only-one)
+        (eieio-defgeneric-reset-generic-form-primary-only-one)
+        (eieio-unbind-method-implementations)
+        (eieio--defmethod, eieio--typep)
+        (eieio-perform-slot-validation, eieio-validate-slot-value)
+        (eieio-validate-class-slot-value, eieio-barf-if-slot-unbound)
+        (eieio-oref, eieio-oref-default, eieio-default-eval-maybe)
+        (eieio-oset, eieio-oset-default, eieio-slot-originating-class-p)
+        (eieio-slot-name-index, eieio-class-slot-name-index)
+        (eieio-set-defaults, eieio-initarg-to-attribute)
+        (eieio-attribute-to-initarg, eieio-c3-candidate)
+        (eieio-c3-merge-lists, eieio-class-precedence-c3)
+        (eieio-class-precedence-dfs, eieio-class-precedence-bfs)
+        (eieio-class-precedence-list, eieio-generic-call-methodname)
+        (eieio-generic-call-arglst, eieio-generic-call-key)
+        (eieio-generic-call-next-method-list)
+        (eieio-pre-method-execution-functions, eieio-generic-call)
+        (eieio-generic-call-primary-only, eieiomt-method-list)
+        (eieiomt-optimizing-obarray, eieiomt-install)
+        (eieiomt-add, eieiomt-next, eieiomt-sym-optimize)
+        (eieio-generic-form, eieio-defmethod, make-obsolete)
+        (eieio-defgeneric, make-obsolete): Move to eieio-core.el
+        (defclass): Remove `eval-and-compile' from macro.
+        (call-next-method, shared-initialize): Instead of using
+        `scoped-class' variable, use new eieio--scoped-class, and
+        eieio--with-scoped-class.
+        (initialize-instance): Rename local variable 'scoped-class' to
+        'this-class' to remove ambiguitity from old global.
+
+        * emacs-lisp/eieio-core.el: New file.  Derived from key parts of
+        eieio.el.
+        (eieio--scoped-class-stack): New variable
+        (eieio--scoped-class): New fcn
+        (eieio--with-scoped-class): New scoping macro.
+        (eieio-defclass): Use pushnew instead of add-to-list.
+        (eieio-defgeneric-form-primary-only-one, eieio-oset-default)
+        (eieio-slot-name-index, eieio-set-defaults, eieio-generic-call)
+        (eieio-generic-call-primary-only, eieiomt-add): Instead of using
+        `scoped-class' variable, use new eieio--scoped-class, and
+        eieio--with-scoped-class.
+
+        * emacs-lisp/eieio-base.el (cl-lib): Require during compile.
+
+2013-06-02  Tassilo Horn  <tsdh@gnu.org>
+
+        * eshell/esh-ext.el (eshell-external-command): Pass args to
+        `eshell-find-interpreter'.
+        (eshell-find-interpreter): Add new second parameter ARGS.
+
+        * eshell/em-script.el (eshell-script-initialize): Add second arg
+        to the function added as MATCH to `eshell-interpreter-alist'.
+
+        * eshell/em-dirs.el (eshell-dirs-initialize): Add second arg to
+        the function added as MATCH to `eshell-interpreter-alist'.
+
+        * eshell/em-term.el (eshell-visual-subcommands): New defcustom.
+        (eshell-visual-options): New defcustom.
+        (eshell-escape-control-x): Adapt docstring.
+        (eshell-term-initialize): Test `eshell-visual-subcommands' and
+        `eshell-visual-options' in addition to `eshell-visual-commands'.
+        (eshell-exec-visual): Pass args to `eshell-find-interpreter'.
+
+2013-06-01  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * progmodes/python.el (python-indent-block-enders): Add break,
+        continue and raise keywords.
+
+2013-06-01  Glenn Morris  <rgm@gnu.org>
+
+        * pcmpl-gnu.el (pcomplete/tar): Check obsolete variable is bound.
+
+        Plain (f)boundp silences compilation warnings since Emacs 22.1.
+        * progmodes/cc-cmds.el (delete-forward-p):
+        * progmodes/cc-defs.el (buffer-syntactic-context-depth):
+        * progmodes/cc-engine.el (buffer-syntactic-context):
+        * progmodes/cc-fonts.el (face-property-instance):
+        * progmodes/cc-mode.el (set-keymap-parents):
+        * progmodes/cc-vars.el (get-char-table): No need for cc-bytecomp-defun.
+        * progmodes/cc-defs.el (c-set-region-active, c-beginning-of-defun-1)
+        * progmodes/cc-mode.el (c-make-inherited-keymap): Use plain fboundp.
+        * progmodes/cc-defs.el (zmacs-region-stays, zmacs-regions)
+        (lookup-syntax-properties): Remove unecessary cc-bytecomp-defvar.
+
+        * progmodes/cc-vars.el (other): Emacs has this widget since
+        at least 21.1, so don't (re)define it.
+
+        * eshell/em-cmpl.el (eshell-cmpl-initialize):
+        Replace the obsolete alias pcomplete-arg-quote-list.
+
+2013-06-01  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (octave-mode-syntax-table): Give `.'
+        punctuation syntax.
+        (inferior-octave-minimal-columns)
+        (inferior-octave-last-column-width): New variables.
+        (inferior-octave-track-window-width-change): New function.
+        (inferior-octave-mode): Adjust column width so that Octave output,
+        for example from 'ls', can fit into the window nicely.
+
+2013-05-31  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-syntax-expansion-allowed-p):
+        Highlight expansions inside regexp literals.
+
+2013-05-31  Glenn Morris  <rgm@gnu.org>
+
+        * obsolete/sym-comp.el (symbol-complete):
+        Replace obsolete completion-annotate-function.
+
+        * progmodes/cc-vars.el (c-make-macro-with-semi-re): Silence compiler.
+
+2013-05-31  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/ruby-mode.el (ruby-syntax-expansion-allowed-p):
+        New function, checks if point is inside a literal that allows
+        expression expansion.
+        (ruby-syntax-propertize-expansion): Use it.
+        (ruby-syntax-propertize-function): Bind `case-fold-search' to nil
+        around the body.
+
+2013-05-30  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (isearch-mode-map): Bind `isearch-toggle-invisible'
+        to "\M-si".
+        (isearch-invisible): New variable.
+        (isearch-forward): Doc fix.
+        (isearch-mode): Set `isearch-invisible'
+        to the value of `search-invisible'.
+        (isearch-toggle-case-fold): Doc fix.
+        (isearch-toggle-invisible): New command.
+        (isearch-query-replace): Let-bind `search-invisible'
+        to the value of `isearch-invisible'.
+        (isearch-search): Use `isearch-invisible' instead of
+        `search-invisible'.  Let-bind `search-invisible'
+        to the value of `isearch-invisible'.  (Bug#11378)
+
+2013-05-30  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (perform-replace): Avoid `isearch-range-invisible'
+        call when `query-flag' is nil and `search-invisible' is non-nil.
+        (Bug#11746)
+
+2013-05-30  Glenn Morris  <rgm@gnu.org>
+
+        * progmodes/gdb-mi.el (gdb-wait-for-pending): Fix typo.
+
+        * progmodes/cc-bytecomp.el (cc-bytecomp-noruntime-functions): New.
+        (cc-require): Suppress spurious "noruntime" warnings.
+        (cc-require-when-compile): Use fboundp, for sake of compiler.
+
+        * progmodes/cc-mode.el: Move load of cc-vars before that of
+        cc-langs (which in turn loads cc-vars), to quieten compiler.
+
+2013-05-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * paren.el: Simplify the code.
+        (show-paren-mode): Always start the timer.
+        (show-paren--idle-timer): Rename from show-paren-idle-timer.
+        (show-paren--overlay, show-paren--overlay-1): Rename from
+        show-paren-overlay and show-paren-overlay-1, and initialize to an
+        overlay rather than to nil.
+        (show-paren-function): Misc cleanup and simplifications.
+
+2013-05-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * paren.el (show-paren-data-function): New hook.
+        (show-paren--default): New function, extracted from show-paren-function.
+        (show-paren-function): Use show-paren-data-function.
+
+2013-05-30  Glenn Morris  <rgm@gnu.org>
+
+        * ielm.el (ielm-map, ielm-complete-symbol):
+        Use completion-at-point rather than obsolete functions.
+        (inferior-emacs-lisp-mode): Doc fix.
+        Set completion-at-point-functions, rather than
+        comint-dynamic-complete-functions.
+
+        * eshell/em-cmpl.el (eshell-complete-lisp-symbol): New function.
+        (eshell-cmpl-initialize, eshell-complete-parse-arguments):
+        Replace obsolete lisp-complete-symbol with eshell-complete-lisp-symbol.
+
+        * image.el (image-animated-p): Tweak definition.
+
+        * net/rlogin.el (rlogin-program, rlogin-explicit-args): Default to ssh.
+        (rlogin-process-connection-type): Tweak default.  Add set-after.
+        (rlogin-host): Doc fix.
+        (rlogin): Tweak prompt.
+        (rlogin-tab-or-complete): Use completion-at-point rather than alias.
+
+        * net/net-utils.el (nslookup-mode-map, ftp-mode-map):
+        * progmodes/tcl.el (inferior-tcl-mode-map):
+        Use completion-at-point rather than obsolete alias.
+
+        * emacs-lisp/eieio.el (eieio-eval-default-p): Move before use.
+
+        * minibuffer.el (read-file-name-completion-ignore-case):
+        Move before completion--in-region, for eager macro expansion.
+
+2013-05-29  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (occur-engine): Rename `globalcount' to `global-lines'
+        for total count of matching lines.  Add `global-matches' for total
+        count of matches.  Rename `matches' to `lines' for count of
+        matching lines.  Add `matches' for count of matches.
+        Rename `lines' to `curr-line' for line count.  Rename `prev-lines'
+        to `prev-line' for line number of prev match endpt.
+        Increment `matches' for every match.  Print the number of
+        matching lines in the header.
+        (occur-context-lines): Rename `lines' to `curr-line'.
+        Rename `prev-lines' to `prev-line'.  (Bug#14017)
+
+2013-05-29  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (perform-replace): Add `skip-read-only-count',
+        `skip-filtered-count', `skip-invisible-count' let-bound to 0.
+        Increment them for corresponding conditions and report the number
+        of skipped occurrences in the final message.  (Bug#11746)
+        (query-replace, query-replace-regexp, query-replace-regexp-eval)
+        (replace-string, replace-regexp): Doc fix.
+
+2013-05-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/trace.el (trace--read-args): Provide a default.
+
+        * emacs-lisp/lisp-mode.el (lisp-mode-shared-map): Inherit from
+        prog-mode-map (bug#14504).
+
 2013-05-29  Leo Liu  <sdl.web@gmail.com>
 
         * progmodes/octave.el (octave-indent-comment): Tweak regexps.
@@ -24,12 +678,11 @@
 2013-05-28  Alan Mackenzie  <acm@muc.de>
 
         Handle "capitalised keywords" correctly.
-        * progmodes/cc-mode.el (c-after-change): bind case-fold-search to
-        nil.
+        * progmodes/cc-mode.el (c-after-change): Bind case-fold-search to nil.
 
 2013-05-28  Aidan Gauland  <aidalgol@amuri.net>
 
-        * eshell/em-unix.el: Added -r option to cp
+        * eshell/em-unix.el: Add -r option to cp.
 
 2013-05-28  Glenn Morris  <rgm@gnu.org>
 
@@ -1540,7 +2193,7 @@
 
         * emacs-lisp/syntax.el (syntax-propertize-multiline):
         Use `syntax-multiline' text property consistently instead of
-        `font-lock-multiline'. (bug#14237).
+        `font-lock-multiline'.  (Bug#14237)
 
 2013-04-26  Glenn Morris  <rgm@gnu.org>
 
@@ -1728,9 +2381,9 @@
 
 2013-04-21  Xue Fuqiao  <xfq.free@gmail.com>
 
-        * comint.el: (comint-dynamic-complete-functions, comint-mode-map):
+        * comint.el (comint-dynamic-complete-functions, comint-mode-map):
         `comint-dynamic-complete' is obsolete since 24.1, replaced by
-        `completion-at-point'. (Bug#13774)
+        `completion-at-point'.  (Bug#13774)
 
         * startup.el (normal-no-mouse-startup-screen): Bug fix, the
         default key binding for `describe-distribution' has been moved to
@@ -1759,7 +2412,8 @@
 
         * comint.el (comint-redirect-original-filter-function): Remove.
         (comint-redirect-cleanup, comint-redirect-send-command-to-process):
-        * vc/vc-cvs.el (vc-cvs-annotate-process-filter,vc-cvs-annotate-command):
+        * vc/vc-cvs.el (vc-cvs-annotate-process-filter)
+        (vc-cvs-annotate-command):
         * progmodes/octave-inf.el (inferior-octave-send-list-and-digest):
         * progmodes/prolog.el (prolog-consult-compile):
         * progmodes/gdb-mi.el (gdb, gdb--check-interpreter):
@@ -2200,9 +2854,8 @@
 
 2013-04-03  Alan Mackenzie  <acm@muc.de>
 
-        Handle `parse-partial-sexp' landing inside a comment opener
-        (Bug#13244). Also adapt to the new values of element 7 of a parse
-        state.
+        Handle `parse-partial-sexp' landing inside a comment opener (Bug#13244).
+        Also adapt to the new values of element 7 of a parse state.
 
         * progmodes/cc-engine.el (c-state-pp-to-literal): New optional
         parameter `not-in-delimiter'.  Handle being inside comment opener.
@@ -2838,7 +3491,7 @@
 2013-03-08  Jambunathan K  <kjambunathan@gmail.com>
 
         * hi-lock.el (hi-lock-read-regexp-defaults-function): New var.
-        (hi-lock-read-regexp-defaults):  New defun.
+        (hi-lock-read-regexp-defaults): New defun.
         (hi-lock-line-face-buffer, hi-lock-face-buffer)
         (hi-lock-face-phrase-buffer): Propagate above change.
         Update docstring (bug#13892).
@@ -2894,7 +3547,7 @@
 
         Correct the position of point in some line-up functions.
         * progmodes/cc-align.el (c-lineup-whitesmith-in-block)
-        (c-lineup-assignments, c-lineup-gcc-asm-reg ): take position of
+        (c-lineup-assignments, c-lineup-gcc-asm-reg ): Take position of
         point at column 0 rather than at a random place in the line.
 
 2013-03-05  Michael Albinus  <michael.albinus@gmx.de>
@@ -4429,7 +5082,7 @@
 2013-01-12  Eli Zaretskii  <eliz@gnu.org>
 
         * autorevert.el (auto-revert-notify-handler): Fix filtering of
-        file notification by ACTION. For filtering by file name, compare
+        file notification by ACTION.  For filtering by file name, compare
         only the non-directory part of the file name.
 
 2013-01-12  Stefan Monnier  <monnier@iro.umontreal.ca>
@@ -4512,7 +5165,7 @@
 2013-01-11  Julien Danjou  <julien@danjou.info>
 
         * color.el (color-rgb-to-hsv): Fix conversion computing in case min and
-        max are almost equal. Also return the correct value for V which is
+        max are almost equal.  Also return the correct value for V which is
         already between 0 and 1.
 
 2013-01-11  Dmitry Antipov  <dmantipov@yandex.ru>
@@ -4966,7 +5619,7 @@
 2012-12-31  Jürgen Hötzel  <juergen@archlinux.org>
 
         * net/tramp-adb.el (tramp-adb-maybe-open-connection): Handle errors
-        (No device connected, invalid device name). (Bug #13299)
+        (No device connected, invalid device name).  (Bug #13299)
 
 2012-12-31  Martin Rudalics  <rudalics@gmx.at>
 
@@ -5351,7 +6004,7 @@
 
 2012-12-14  Paul Eggert  <eggert@cs.ucla.edu>
 
-        Fix permissions bugs with setgid directories etc. (Bug#13125)
+        Fix permissions bugs with setgid directories etc.  (Bug#13125)
         * files.el (backup-buffer): Don't rely on 9th output of
         file-attributes, as it's now a placeholder.  Instead, use the new
         optional arg of file-ownership-preserved-p.
@@ -5809,7 +6462,7 @@
         * textmodes/ispell.el (ispell-init-process)
         (ispell-start-process, ispell-internal-change-dictionary):
         Make sure personal dictionary name is expanded after initial
-        `default-directory' value. Use expanded strings for
+        `default-directory' value.  Use expanded strings for
         keep/restart checks and for value (Bug#13019).
 
 2012-12-03  Jay Belanger  <jay.p.belanger@gmail.com>
@@ -6491,7 +7144,7 @@
 
         * play/gamegrid.el (gamegrid-add-score-with-update-game-score-1):
         Don't signal an error with a score that is too low to add to the
-        list of top scores. (Bug#12779)
+        list of top scores.  (Bug#12779)
 
 2012-11-17  Chong Yidong  <cyd@gnu.org>
 
@@ -6560,7 +7213,7 @@
 
         * window.el (record-window-buffer)
         (display-buffer-record-window): When copying the markers to
-        window-point preserve window-point-insertion-type. (Bug#12588)
+        window-point preserve window-point-insertion-type.  (Bug#12588)
 
 2012-11-16  Glenn Morris  <rgm@gnu.org>
 
@@ -6648,8 +7301,8 @@
         (ad-advice-definition): Redefine as functions.
         (ad-advice-classes): Move before first use.
         (ad-make-origname, ad-set-orig-definition, ad-clear-orig-definition)
-        (ad-make-mapped-call, ad-make-advised-docstring,ad-make-plain-docstring)
-        (ad--defalias-fset): Remove functions.
+        (ad-make-mapped-call, ad-make-advised-docstring)
+        (ad-make-plain-docstring, ad--defalias-fset): Remove functions.
         (ad-make-advicefunname, ad-clear-advicefunname-definition): New funs.
         (ad-get-orig-definition): Rewrite.
         (ad-make-advised-definition-docstring): Change base docstring.
@@ -6901,7 +7554,7 @@
 
 2012-11-09  Vincent Belaïche  <vincentb1@users.sourceforge.net>
 
-        * ses.el: symbol to coordinate mapping is made by symbol property
+        * ses.el: Symbol to coordinate mapping is made by symbol property
         `ses-cell'.  This means that the same mapping is done for all SES
         sheets.  That is good enough for cells with standard A1 names, but
         not for named cell.  So a hash map is added for the latter.
@@ -6997,7 +7650,7 @@
         buffer and calls `ispell-buffer' with debugging enabled.
 
         * textmodes/ispell.el (ispell-region): Do not prefix sent string by
-        comment in autoconf mode. (Bug#12768)
+        comment in autoconf mode.  (Bug#12768)
 
 2012-11-06  Dmitry Antipov  <dmantipov@yandex.ru>
 
@@ -8142,13 +8795,13 @@
 
         * textmodes/reftex-cite.el (reftex-create-bibtex-file): Make sure
         that entries with whitespace at various places are found.
-        Doc fix. Include entries that are cross-referenced from cited entries.
+        Doc fix.  Include entries that are cross-referenced from cited entries.
         Include @String definitions in the resulting bib file.  Add header
         and footer defined in `reftex-create-bibtex-header' and
         `reftex-create-bibtex-footer'.
         (reftex-do-citation): Make it possible again to insert
         non-existent entries.  Save match data when asking for optional
-        arguments. Return all keys, not just the first one.
+        arguments.  Return all keys, not just the first one.
         (reftex-all-used-citation-keys): Fix regexp to correctly extract
         all citations in the same line.
         (reftex-parse-bibtex-entry): Accept additional optional argument
@@ -8208,7 +8861,7 @@
 
         * textmodes/reftex-sel.el
         (reftex-select-cycle-ref-style-internal): Adapt to new structure
-        of `reftex-ref-style-alist'. Remove code for testing macro type.
+        of `reftex-ref-style-alist'.  Remove code for testing macro type.
         (reftex-select-toggle-varioref)
         (reftex-select-toggle-fancyref): Remove.
         (reftex-select-cycle-ref-style-internal)
@@ -8750,7 +9403,7 @@
 
         * textmodes/bibtex.el (bibtex-autokey-transcriptions):
         Transcribe also LaTeX hyphenation.
-        (bibtex-reformat): Bug fix. Do not quote twice the elements of
+        (bibtex-reformat): Bug fix.  Do not quote twice the elements of
         bibtex-reformat-previous-options.
 
 2012-09-23  Roland Winkler  <winkler@gnu.org>
@@ -10836,7 +11489,7 @@
         * progmodes/python.el (python-shell-send-setup-max-wait): Delete var.
         (python-shell-make-comint): accept-process-output at startup.
         (run-python-internal): Set inferior-python-mode-hook to nil.
-        (python-shell-internal-get-or-create-process): call sit-for.
+        (python-shell-internal-get-or-create-process): Call sit-for.
         (python-preoutput-result): Add obsolete alias.
         (python-shell-internal-send-string): Use it.
         (python-shell-send-setup-code): Remove call to
@@ -11028,7 +11681,7 @@
 2012-07-27  Fabián Ezequiel Gallina  <fgallina@cuca>
 
         Consistent completion in inferior python with emacs -nw.
-        * progmodes/python.el (inferior-python-mode): replace "<tab>"
+        * progmodes/python.el (inferior-python-mode): Replace "<tab>"
         binding in inferior-python-mode-map with "\t".
         (python-shell-completion-complete-at-point)
         (python-completion-complete-at-point): Remove interactive spec.
@@ -11777,7 +12430,7 @@
         (xml-name-start-char-re, xml-name-char-re, xml-name-re)
         (xml-names-re, xml-nmtoken-re, xml-nmtokens-re, xml-char-ref-re)
         (xml-entity-ref, xml-pe-reference-re)
-        (xml-reference-re,xml-att-value-re, xml-tokenized-type-re)
+        (xml-reference-re, xml-att-value-re, xml-tokenized-type-re)
         (xml-notation-type-re, xml-enumeration-re, xml-enumerated-type-re)
         (xml-att-type-re, xml-default-decl-re, xml-att-def-re)
         (xml-entity-value-re): Use syntax references in regexps where
@@ -18592,8 +19245,8 @@
 
         * progmodes/verilog-mode.el (verilog-read-defines): Fix reading
         parameters with embedded comments.  Reported by Ray Stevens.
-        (verilog-calc-1, verilog-fork-wait-re) (verilog-forward-sexp,
-        verilog-wait-fork-re): Fix indentation of "wait fork", bug407.
+        (verilog-calc-1, verilog-fork-wait-re, verilog-forward-sexp)
+        (verilog-wait-fork-re): Fix indentation of "wait fork", bug407.
         Reported by Tim Holt.
         (verilog-auto): Fix AUTOing a upper module then AUTOing module
         instantiated by upper module causing wrong expansion until AUTOed a
@@ -20162,7 +20815,7 @@
 
 2011-10-07  Chong Yidong  <cyd@stupidchicken.com>
 
-        * bindings.el ([M-left],[M-right]): Bind to left-word and
+        * bindings.el ([M-left], [M-right]): Bind to left-word and
         right-word respectively.
 
 2011-10-07  Glenn Morris  <rgm@gnu.org>
@@ -25484,15 +26137,15 @@
 2011-05-10  Jim Meyering  <meyering@redhat.com>
 
         Fix doubled-word typos.
-        * international/quail.el (quail-insert-kbd-layout): and and -> and
-        * kermit.el: and and -> and
-        * net/ldap.el (ldap-search-internal): to to -> to
+        * international/quail.el (quail-insert-kbd-layout): and and -> and.
+        * kermit.el: and and -> and.
+        * net/ldap.el (ldap-search-internal): to to -> to.
         * progmodes/vhdl-mode.el (vhdl-offsets-alist): Likewise.
-        * progmodes/js.el (js-mode): and and -> and
-        * textmodes/artist.el (artist-move-to-xy): at at -> at
-        (artist-draw-region-trim-line-endings): if if -> if
+        * progmodes/js.el (js-mode): and and -> and.
+        * textmodes/artist.el (artist-move-to-xy): at at -> at.
+        (artist-draw-region-trim-line-endings): if if -> if.
         And Safetyc -> Safety.
-        * textmodes/reftex-dcr.el (reftex-view-crossref): at at -> at a
+        * textmodes/reftex-dcr.el (reftex-view-crossref): at at -> at a.
 
 2011-05-10  Glenn Morris  <rgm@gnu.org>
             Stefan Monnier  <monnier@iro.umontreal.ca>
diff --git a/lisp/ChangeLog.2 b/lisp/ChangeLog.2
index 3832f342d6f..fddc98a612d 100644
--- a/lisp/ChangeLog.2
+++ b/lisp/ChangeLog.2
@@ -777,7 +777,7 @@
 
 1987-12-21  Richard Stallman  (rms@frosted-flakes)
 
-        * window.el (split-widow-{vertically,horizontally}):
+        * window.el (split-window-{vertically,horizontally}):
         Make the arg optional.
 
 1987-12-09  Richard Stallman  (rms@frosted-flakes)
@@ -1392,7 +1392,7 @@
         * shell.el: Minor doc fixes.
 
         * rmail.el (rmail-get-new-mail):
-        Handle errors competently. (Don't attempt to
+        Handle errors competently.  (Don't attempt to
         handle them, rather than botching the job)
 
         * rmail.el (rmail-insert-inbox-text):
@@ -3032,7 +3032,7 @@
 
         Rename "kill" -> "delete" for both function-names and documentation.
 
-        Define C-d as Buffer-menu-delete-backwards. (also in ebuff-menu)
+        Define C-d as Buffer-menu-delete-backwards (also in ebuff-menu).
 
         Save space: Merge buffer-menu-{execute,do-saves,do-kills}.
 
diff --git a/lisp/Makefile.in b/lisp/Makefile.in
index 4884213daeb..61449b66c9b 100644
--- a/lisp/Makefile.in
+++ b/lisp/Makefile.in
@@ -209,8 +209,9 @@ update-authors:
         $(emacs) -l authors -f batch-update-authors $(top_srcdir)/etc/AUTHORS $(top_srcdir)
 
 TAGS TAGS-LISP: $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptagsfiles4)
-        els=`echo $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptagsfiles4) | sed -e "s,$(lisp)/[^ ]*loaddefs[^ ]*,," -e "s,$(lisp)/ldefs-boot[^ ]*,,"`; \
-        ${ETAGS} -o $@ $$els
+        rm -f $@; touch $@; \
+         echo $(lisptagsfiles1) $(lisptagsfiles2) $(lisptagsfiles3) $(lisptagsfiles4) | sed -e "s,$(lisp)/[^ ]*loaddefs[^ ]*,," -e "s,$(lisp)/ldefs-boot[^ ]*,," | \
+        xargs $(XARGS_LIMIT) ${ETAGS} -a -o $@
 
 # The src/Makefile.in has its own set of dependencies and when they decide
 # that one Lisp file needs to be re-compiled, we had better recompile it as
diff --git a/lisp/allout.el b/lisp/allout.el
index 5a9b03b7a0e..1e4134b3ccf 100644
--- a/lisp/allout.el
+++ b/lisp/allout.el
@@ -1561,7 +1561,7 @@ Each value can be a regexp or a list with a regexp followed by a
 substitution string.  If it's just a regexp, all its matches are removed
 before the text is encrypted.  If it's a regexp and a substitution, the
 substitution is used against the regexp matches, a la `replace-match'.")
-(make-variable-buffer-local 'allout-encryption-text-removal-regexps)
+(make-variable-buffer-local 'allout-encryption-plaintext-sanitization-regexps)
 ;;;_   = allout-encryption-ciphertext-rejection-regexps
 (defvar allout-encryption-ciphertext-rejection-regexps nil
   "Variable for regexps matching plaintext to remove before encryption.
diff --git a/lisp/autorevert.el b/lisp/autorevert.el
index a2ce6017b21..4a6d4cb4cc0 100644
--- a/lisp/autorevert.el
+++ b/lisp/autorevert.el
@@ -271,7 +271,7 @@ This variable becomes buffer local when set in any fashion.")
   :version "24.4")
 
 (defconst auto-revert-notify-enabled
-  (or (featurep 'inotify) (featurep 'w32notify))
+  (or (featurep 'gfilenotify) (featurep 'inotify) (featurep 'w32notify))
   "Non-nil when Emacs has been compiled with file notification support.")
 
 (defcustom auto-revert-use-notify auto-revert-notify-enabled
@@ -502,9 +502,12 @@ will use an up-to-date value of `auto-revert-interval'"
              (puthash key value auto-revert-notify-watch-descriptor-hash-list)
            (remhash key auto-revert-notify-watch-descriptor-hash-list)
            (ignore-errors
-             (funcall (if (fboundp 'inotify-rm-watch)
-                          'inotify-rm-watch 'w32notify-rm-watch)
-                      auto-revert-notify-watch-descriptor)))))
+             (funcall
+              (cond
+               ((fboundp 'gfile-rm-watch) 'gfile-rm-watch)
+               ((fboundp 'inotify-rm-watch) 'inotify-rm-watch)
+               ((fboundp 'w32notify-rm-watch) 'w32notify-rm-watch))
+              auto-revert-notify-watch-descriptor)))))
      auto-revert-notify-watch-descriptor-hash-list)
     (remove-hook 'kill-buffer-hook 'auto-revert-notify-rm-watch))
   (setq auto-revert-notify-watch-descriptor nil
@@ -519,12 +522,18 @@ will use an up-to-date value of `auto-revert-interval'"
 
   (when (and buffer-file-name auto-revert-use-notify
              (not auto-revert-notify-watch-descriptor))
-    (let ((func (if (fboundp 'inotify-add-watch)
-                    'inotify-add-watch 'w32notify-add-watch))
-          ;; `attrib' is needed for file modification time.
-          (aspect (if (fboundp 'inotify-add-watch)
-                      '(attrib create modify moved-to) '(size last-write-time)))
-          (file (if (fboundp 'inotify-add-watch)
+    (let ((func
+           (cond
+            ((fboundp 'gfile-add-watch) 'gfile-add-watch)
+            ((fboundp 'inotify-add-watch) 'inotify-add-watch)
+            ((fboundp 'w32notify-add-watch) 'w32notify-add-watch)))
+          (aspect
+           (cond
+            ((fboundp 'gfile-add-watch) '(watch-mounts))
+            ;; `attrib' is needed for file modification time.
+            ((fboundp 'inotify-add-watch) '(attrib create modify moved-to))
+            ((fboundp 'w32notify-add-watch) '(size last-write-time))))
+          (file (if (or (fboundp 'gfile-add-watch) (fboundp 'inotify-add-watch))
                     (directory-file-name (expand-file-name default-directory))
                   (buffer-file-name))))
       (setq auto-revert-notify-watch-descriptor
@@ -545,10 +554,13 @@ will use an up-to-date value of `auto-revert-interval'"
 
 (defun auto-revert-notify-event-p (event)
   "Check that event is a file notification event."
-  (cond ((featurep 'inotify)
-         (and (listp event) (= (length event) 4)))
-        ((featurep 'w32notify)
-         (and (listp event) (= (length event) 3) (stringp (nth 2 event))))))
+  (and (listp event)
+       (cond ((featurep 'gfilenotify)
+              (and (>= (length event) 3) (stringp (nth 2 event))))
+             ((featurep 'inotify)
+              (= (length event) 4))
+             ((featurep 'w32notify)
+              (and (= (length event) 3) (stringp (nth 2 event)))))))
 
 (defun auto-revert-notify-event-descriptor (event)
   "Return watch descriptor of file notification event, or nil."
@@ -561,11 +573,12 @@ will use an up-to-date value of `auto-revert-interval'"
 (defun auto-revert-notify-event-file-name (event)
   "Return file name of file notification event, or nil."
   (and (auto-revert-notify-event-p event)
-       (cond ((featurep 'inotify) (nth 3 event))
+       (cond ((featurep 'gfilenotify) (nth 2 event))
+             ((featurep 'inotify) (nth 3 event))
              ((featurep 'w32notify) (nth 2 event)))))
 
 (defun auto-revert-notify-handler (event)
-  "Handle an event returned from file notification."
+  "Handle an EVENT returned from file notification."
   (when (auto-revert-notify-event-p event)
     (let* ((descriptor (auto-revert-notify-event-descriptor event))
            (action (auto-revert-notify-event-action event))
@@ -576,12 +589,20 @@ will use an up-to-date value of `auto-revert-interval'"
         ;; Check, that event is meant for us.
         ;; TODO: Filter events which stop watching, like `move' or `removed'.
         (cl-assert descriptor)
-        (when (featurep 'inotify)
+        (cond
+         ((featurep 'gfilenotify)
+          (cl-assert (memq action '(attribute-changed changed created deleted
+                                    ;; FIXME: I keep getting this action, so I
+                                    ;; added it here, but I have no idea what
+                                    ;; I'm doing.  --Stef
+                                    changes-done-hint))
+                     t))
+         ((featurep 'inotify)
           (cl-assert (or (memq 'attrib action)
                          (memq 'create action)
                          (memq 'modify action)
                          (memq 'moved-to action))))
-        (when (featurep 'w32notify) (cl-assert (eq 'modified action)))
+         ((featurep 'w32notify) (cl-assert (eq 'modified action))))
         ;; Since we watch a directory, a file name must be returned.
         (cl-assert (stringp file))
         (dolist (buffer buffers)
diff --git a/lisp/bindings.el b/lisp/bindings.el
index fe0eabb77af..2013c079820 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -894,6 +894,7 @@ if `inhibit-field-text-motion' is non-nil."
 (define-key search-map "hr" 'highlight-regexp)
 (define-key search-map "hp" 'highlight-phrase)
 (define-key search-map "hl" 'highlight-lines-matching-regexp)
+(define-key search-map "h." 'highlight-symbol-at-point)
 (define-key search-map "hu" 'unhighlight-regexp)
 (define-key search-map "hf" 'hi-lock-find-patterns)
 (define-key search-map "hw" 'hi-lock-write-interactive-patterns)
diff --git a/lisp/cedet/ChangeLog b/lisp/cedet/ChangeLog
index 25f966362ce..98548a919d5 100644
--- a/lisp/cedet/ChangeLog
+++ b/lisp/cedet/ChangeLog
@@ -1,3 +1,96 @@
+2013-06-02  Eric Ludlam <zappo@gnu.org>
+
+        * semantic/edit.el (semantic-change-function): Use
+        `save-match-data' around running hooks.
+
+        * semantic/decorate/mode.el
+        (semantic-decorate-style-predicate-default)
+        (semantic-decorate-style-highlighter-default): New.
+        (semantic-decoration-mode): Do not require
+        `semantic/decorate/include' anymore.
+        (semantic-toggle-decoration-style): Error if an unknown decoration
+        style is toggled.
+        (define-semantic-decoration-style): Add new :load option.  When
+        :load is specified, add autoload tokens for the definition
+        functions so that code is loaded when the mode is used.
+        (semantic-decoration-on-includes): New autoload definition for
+        highlighting includes.
+
+        * semantic/bovine/c.el (semantic-lex-c-ifdef): Allow some misc
+        characters to appear after the tested variable.
+
+        * semantic/ede-grammar.el (project-compile-target): Calculate full
+        src name via ede-expand-filename instead of the crutch of the
+        current buffer.  Enables this target to compile in batch mode.
+
+        * semantic/idle.el
+        (semantic-idle-symbol-maybe-highlight): Wrap highlighting of
+        remote symbol with `save-excursion'.
+        (semantic-idle-scheduler-work-parse-neighboring-files): Instead of
+        using directory-files on each found mode pattern, collect all the
+        patterns for the current mode, and then for each file, see if it
+        matches any of them.  If it does, parse the file.  (Patch
+        inspiration from Tomasz Gajewski.)
+
+        * semantic/ctxt.el (semantic-ctxt-end-of-symbol): New.
+        (semantic-ctxt-current-symbol-default): New.
+
+        * semantic/bovine/el.el (semantic-default-elisp-setup): Add
+        autoload cookie.  Explain existence.
+        (footer): Add local variable for loaddefs.
+
+        * semantic/db.el (semanticdb-file-table-object): Add new filter,
+        only checking for regular files too.
+
+        * semantic/wisent/python.el
+        (semantic-format-tag-abbreviate): New override.  Cuts back on size
+        of code tags.
+
+        * srecode/compile.el (srecode-compile-templates): Fix warning
+        punctuation.  Remove status messages to clean up testing output
+
+        * ede/base.el (ede-project-placeholder-cache-file): Update doc to
+        mention 'nil' value.
+        (ede-save-cache): Disable cache save if file is nil.
+
+        * ede.el (ede-initialize-state-current-buffer): Flush deleted
+        projects.
+        (global-ede-mode): Always append our find-file-hook to the end.
+        (ede-flush-deleted-projects): New command.
+
+        * ede/cpp-root.el (ede-preprocessor-map): Protect against init
+        problems.
+
+        * ede/proj.el (ede-proj-target): Added a new "custom" option for
+        custom symbols representing a compiler or linker instead of
+        restricting things to only the predefined compilers and linkers.
+
+2013-06-02  David Engster <dengste@eml.cc>
+
+        * semantic.el (semantic-mode-map): To avoid showing showing
+        Development menu twice, only disable menu item if menu-bar is
+        actually enabled, otherwise the popup 'global menu' might display
+        a disabled Development menu.
+
+        * srecode/srt-wy.el: Regenerate.
+
+2013-06-02  Pete Beardmore  <elbeardmorez@msn.com>
+
+        * semantic/complete.el
+        (semantic-displayor-show-request): Fix which slot in obj is set to
+        the max tags.
+
+2013-06-01  Glenn Morris  <rgm@gnu.org>
+
+        * semantic/grammar.el (semantic-grammar-complete):
+        Replace the obsolete function lisp-complete-symbol.
+
+        * semantic/analyze/fcn.el (semantic-tag-similar-p): Autoload.
+
+        * srecode/args.el, srecode/java.el: Require ede.
+
+        * semantic/lex.el (semantic-lex-make-type-table): Fix transposed args.
+
 2013-05-24  Glenn Morris  <rgm@gnu.org>
 
         * semantic/bovine/grammar.el (bovine-make-parsers):
diff --git a/lisp/cedet/ede.el b/lisp/cedet/ede.el
index 5fecd8b994f..3483d541122 100644
--- a/lisp/cedet/ede.el
+++ b/lisp/cedet/ede.el
@@ -494,6 +494,11 @@ provided `global-ede-mode' is enabled."
 (defun ede-initialize-state-current-buffer ()
   "Initialize the current buffer's state for EDE.
 Sets buffer local variables for EDE."
+  ;; due to inode recycling, make sure we don't
+  ;; we flush projects deleted off the system.
+  (ede-flush-deleted-projects)
+
+  ;; Init the buffer.
   (let* ((ROOT nil)
          (proj (ede-directory-get-open-project default-directory
                                                'ROOT))
@@ -569,7 +574,9 @@ an EDE controlled project."
         (add-hook 'semanticdb-project-predicate-functions 'ede-directory-project-p)
         (add-hook 'semanticdb-project-root-functions 'ede-toplevel-project-or-nil)
         (add-hook 'ecb-source-path-functions 'ede-ecb-project-paths)
-        (add-hook 'find-file-hook 'ede-turn-on-hook)
+        ;; Append our hook to the end.  This allows mode-local to finish
+        ;; it's stuff before we start doing misc file loads, etc.
+        (add-hook 'find-file-hook 'ede-turn-on-hook t)
         (add-hook 'dired-mode-hook 'ede-turn-on-hook)
         (add-hook 'kill-emacs-hook 'ede-save-cache)
         (ede-load-cache)
@@ -1057,6 +1064,18 @@ On success, return the added project."
   (add-to-list 'ede-projects proj)
   proj)
 
+(defun ede-flush-deleted-projects ()
+  "Scan the projects list for projects which no longer exist.
+Flush the dead projects from the project cache."
+  (interactive)
+  (let ((dead nil))
+    (dolist (P ede-projects)
+      (when (not (file-exists-p (oref P :file)))
+        (add-to-list 'dead P)))
+    (dolist (D dead)
+      (setq ede-projects (remove D ede-projects)))
+    ))
+
 (defun ede-load-project-file (dir &optional rootreturn)
   "Project file independent way to read a project in from DIR.
 Optional ROOTRETURN will return the root project for DIR."
diff --git a/lisp/cedet/ede/base.el b/lisp/cedet/ede/base.el
index 5302ac3207a..a94ce8f1868 100644
--- a/lisp/cedet/ede/base.el
+++ b/lisp/cedet/ede/base.el
@@ -306,7 +306,8 @@ All specific project types must derive from this project."
 ;;
 (defcustom ede-project-placeholder-cache-file
   (locate-user-emacs-file "ede-projects.el" ".projects.ede")
-  "File containing the list of projects EDE has viewed."
+  "File containing the list of projects EDE has viewed.
+If set to nil, then the cache is not saved."
   :group 'ede
   :type 'file)
 
@@ -316,38 +317,39 @@ All specific project types must derive from this project."
 (defun ede-save-cache ()
   "Save a cache of EDE objects that Emacs has seen before."
   (interactive)
-  (let ((p ede-projects)
-        (c ede-project-cache-files)
-        (recentf-exclude '( (lambda (f) t) ))
-        )
-    (condition-case nil
-        (progn
-          (set-buffer (find-file-noselect ede-project-placeholder-cache-file t))
-          (erase-buffer)
-          (insert ";; EDE project cache file.
-;; This contains a list of projects you have visited.\n(")
-          (while p
-            (when (and (car p) (ede-project-p p))
-              (let ((f (oref (car p) file)))
-                (when (file-exists-p f)
-                  (insert "\n  \"" f "\""))))
-            (setq p (cdr p)))
-          (while c
-            (insert "\n \"" (car c) "\"")
-            (setq c (cdr c)))
-          (insert "\n)\n")
-          (condition-case nil
-              (save-buffer 0)
-            (error
-             (message "File %s could not be saved."
-                      ede-project-placeholder-cache-file)))
-          (kill-buffer (current-buffer))
+  (when ede-project-placeholder-cache-file
+    (let ((p ede-projects)
+          (c ede-project-cache-files)
+          (recentf-exclude '( (lambda (f) t) ))
           )
-      (error
-       (message "File %s could not be read."
-                ede-project-placeholder-cache-file))
-
-      )))
+      (condition-case nil
+          (progn
+            (set-buffer (find-file-noselect ede-project-placeholder-cache-file t))
+            (erase-buffer)
+            (insert ";; EDE project cache file.
+;; This contains a list of projects you have visited.\n(")
+            (while p
+              (when (and (car p) (ede-project-p p))
+                (let ((f (oref (car p) file)))
+                  (when (file-exists-p f)
+                    (insert "\n  \"" f "\""))))
+              (setq p (cdr p)))
+            (while c
+              (insert "\n \"" (car c) "\"")
+              (setq c (cdr c)))
+            (insert "\n)\n")
+            (condition-case nil
+                (save-buffer 0)
+              (error
+               (message "File %s could not be saved."
+                        ede-project-placeholder-cache-file)))
+            (kill-buffer (current-buffer))
+            )
+        (error
+         (message "File %s could not be read."
+                  ede-project-placeholder-cache-file))
+
+        ))))
 
 (defun ede-load-cache ()
   "Load the cache of EDE projects."
diff --git a/lisp/cedet/ede/cpp-root.el b/lisp/cedet/ede/cpp-root.el
index 47ba16ade7f..719289765a3 100644
--- a/lisp/cedet/ede/cpp-root.el
+++ b/lisp/cedet/ede/cpp-root.el
@@ -507,7 +507,10 @@ This is for project include paths and spp source files."
      (lambda (F)
        (let* ((expfile (ede-expand-filename root F))
               (table (when expfile
-                       (semanticdb-file-table-object expfile)))
+                       ;; Disable EDE init on preprocessor file load
+                       ;; otherwise we recurse, cause errs, etc.
+                       (let ((ede-constructing t))
+                         (semanticdb-file-table-object expfile))))
               )
          (cond
           ((not (file-exists-p expfile))
diff --git a/lisp/cedet/ede/proj.el b/lisp/cedet/ede/proj.el
index 702e35f0b1f..99a5978b005 100644
--- a/lisp/cedet/ede/proj.el
+++ b/lisp/cedet/ede/proj.el
@@ -104,6 +104,7 @@ distributed, and each should have a corresponding rule to build it.")
              :initform nil
              :type (or null symbol)
              :custom (choice (const :tag "None" nil)
+                             (symbol :tag "Custom Compiler Symbol")
                              :slotofchoices availablecompilers)
              :label "Compiler for building sources"
              :group make
@@ -116,6 +117,7 @@ of these compiler resources, and global customization thereof.")
              :initform nil
              :type (or null symbol)
              :custom (choice (const :tag "None" nil)
+                             (symbol :tag "Custom Linker Symbol")
                              :slotofchoices availablelinkers)
              :label "Linker for combining intermediate object files."
              :group make
diff --git a/lisp/cedet/semantic.el b/lisp/cedet/semantic.el
index 3c93a8794b1..909902a71fe 100644
--- a/lisp/cedet/semantic.el
+++ b/lisp/cedet/semantic.el
@@ -899,7 +899,8 @@ Throw away all the old tags, and recreate the tag database."
     ;; and Semantic are both enabled.  Is there a better way?
     (define-key map [menu-bar cedet-menu]
       (list 'menu-item "Development" cedet-menu-map
-            :enable (quote (not (bound-and-true-p global-ede-mode)))))
+            :enable (quote (not (and menu-bar-mode
+                                     (bound-and-true-p global-ede-mode))))))
     ;; (define-key km "-"    'senator-fold-tag)
     ;; (define-key km "+"    'senator-unfold-tag)
     map))
diff --git a/lisp/cedet/semantic/analyze/fcn.el b/lisp/cedet/semantic/analyze/fcn.el
index 42bc482a1df..4300c89c9df 100644
--- a/lisp/cedet/semantic/analyze/fcn.el
+++ b/lisp/cedet/semantic/analyze/fcn.el
@@ -245,6 +245,8 @@ used by the analyzer debugger."
           (semantic-scope-set-typecache scope nil)
           )))))
 
+(autoload 'semantic-tag-similar-p "semantic/tag-ls")
+
 (defun semantic-analyze-dereference-metatype-stack (type scope &optional type-declaration)
   "Dereference metatypes repeatedly until we hit a real TYPE.
 Uses `semantic-analyze-dereference-metatype'.
diff --git a/lisp/cedet/semantic/bovine/c.el b/lisp/cedet/semantic/bovine/c.el
index 2f8cf08af3e..3c991ea8555 100644
--- a/lisp/cedet/semantic/bovine/c.el
+++ b/lisp/cedet/semantic/bovine/c.el
@@ -529,7 +529,7 @@ code to parse."
 (define-lex-regex-analyzer semantic-lex-c-ifdef
   "Code blocks wrapped up in #ifdef.
 Uses known macro tables in SPP to determine what block to skip."
-  "^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)$"
+  "^\\s-*#\\s-*\\(ifndef\\|ifdef\\)\\s-+\\(\\(\\sw\\|\\s_\\)+\\)\\([ \t\C-m].*\\)?$"
   (semantic-c-do-lex-ifdef))
 
 (defun semantic-c-do-lex-ifdef ()
diff --git a/lisp/cedet/semantic/bovine/el.el b/lisp/cedet/semantic/bovine/el.el
index a8ddbe106f7..07e0e08bbaf 100644
--- a/lisp/cedet/semantic/bovine/el.el
+++ b/lisp/cedet/semantic/bovine/el.el
@@ -940,8 +940,11 @@ ELisp variables can be pretty long, so track this one too.")
 (define-child-mode lisp-mode emacs-lisp-mode
   "Make `lisp-mode' inherit mode local behavior from `emacs-lisp-mode'.")
 
+;;;###autoload
 (defun semantic-default-elisp-setup ()
   "Setup hook function for Emacs Lisp files and Semantic."
+  ;; This is here mostly to get this file loaded when a .el file is
+  ;; loaded into Emacs.
   )
 
 (add-hook 'emacs-lisp-mode-hook 'semantic-default-elisp-setup)
@@ -960,6 +963,12 @@ ELisp variables can be pretty long, so track this one too.")
   '(require 'semantic/db-el)
   )
 
+
 (provide 'semantic/bovine/el)
 
+;; Local variables:
+;; generated-autoload-file: "../loaddefs.el"
+;; generated-autoload-load-name: "semantic/bovine/el"
+;; End:
+
 ;;; semantic/bovine/el.el ends here
diff --git a/lisp/cedet/semantic/complete.el b/lisp/cedet/semantic/complete.el
index 6c2b97a677a..b42e24fb9c0 100644
--- a/lisp/cedet/semantic/complete.el
+++ b/lisp/cedet/semantic/complete.el
@@ -1667,7 +1667,7 @@ Display mechanism using tooltip for a list of possible completions.")
           (setq msg "...")))
        ((eq mode 'verbose)
         ;; Always show extended match set.
-        (oset obj max-tags semantic-displayor-tooltip-max-tags)
+        (oset obj max-tags-initial semantic-displayor-tooltip-max-tags)
         (setq max-tags semantic-displayor-tooltip-max-tags)))
       (unless msg
         (oset obj shown t)
diff --git a/lisp/cedet/semantic/ctxt.el b/lisp/cedet/semantic/ctxt.el
index 2c0b428c195..629bbdee561 100644
--- a/lisp/cedet/semantic/ctxt.el
+++ b/lisp/cedet/semantic/ctxt.el
@@ -357,6 +357,87 @@ beginning and end of a command."
             (def-edebug-spec semantic-with-buffer-narrowed-to-command
               (def-body))))
 
+(define-overloadable-function semantic-ctxt-end-of-symbol (&optional point)
+  "Move point to the end of the current symbol under POINT.
+This skips forward over symbols in a complex reference.
+For example, in the C statement:
+  this.that().entry;
+
+If the cursor is on 'this', will move point to the ; after entry.")
+
+(defun semantic-ctxt-end-of-symbol-default (&optional point)
+  "Move point to the end of the current symbol under POINT.
+This will move past type/field names when applicable.
+Depends on `semantic-type-relation-separator-character', and will
+work on C like languages."
+  (if point (goto-char point))
+  (let* ((fieldsep1 (mapconcat (lambda (a) (regexp-quote a))
+                               semantic-type-relation-separator-character
+                               "\\|"))
+         ;; NOTE: The [ \n] expression below should used \\s-, but that
+         ;; doesn't work in C since \n means end-of-comment, and isn't
+         ;; really whitespace.
+         (fieldsep (concat "[ \t\n\r]*\\(" fieldsep1 "\\)[ \t\n\r]*\\(\\w\\|\\s_\\)"))
+         (case-fold-search semantic-case-fold)
+         (continuesearch t)
+         (end nil)
+         )
+      (with-syntax-table semantic-lex-syntax-table
+        (cond ((looking-at "\\w\\|\\s_")
+               ;; In the middle of a symbol, move to the end.
+               (forward-sexp 1))
+              ((looking-at fieldsep1)
+               ;; We are in a fine spot.. do nothing.
+               nil
+               )
+              ((save-excursion
+                 (and (condition-case nil
+                          (progn (forward-sexp -1)
+                                 (forward-sexp 1)
+                                 t)
+                        (error nil))
+                      (looking-at fieldsep1)))
+               (setq symlist (list ""))
+               (forward-sexp -1)
+               ;; Skip array expressions.
+               (while (looking-at "\\s(") (forward-sexp -1))
+               (forward-sexp 1))
+              )
+        ;; Set the current end marker.
+        (setq end (point))
+
+        ;; Cursor is at the safe end of some symbol.  Look until we
+        ;; find the logical end of this current complex symbol.
+        (condition-case nil
+            (while continuesearch
+              ;; If there are functional arguments, arrays, etc, skip them.
+              (when (looking-at "\\s(")
+                (forward-sexp 1))
+
+              ;; If there is a field separator, then skip that, plus
+              ;; the next expected symbol.
+              (if (not (looking-at fieldsep1))
+                  ;; We hit the end.
+                  (error nil)
+
+                ;; Skip the separator and the symbol.
+                (goto-char (match-end 0))
+
+                (if (looking-at "\\w\\|\\s_")
+                    ;; Skip symbols
+                    (forward-sexp 1)
+                  ;; No symbol, exit the search...
+                  (setq continuesearch nil))
+
+                (setq end (point)))
+
+              ;; Cont...
+              )
+
+          ;; Restore position if we go to far....
+          (error (goto-char end)) )
+
+        )))
 
 (define-overloadable-function semantic-ctxt-current-symbol (&optional point)
   "Return the current symbol the cursor is on at POINT in a list.
@@ -391,7 +472,7 @@ Depends on `semantic-type-relation-separator-character'."
                  ;; In the middle of a symbol, move to the end.
                  (forward-sexp 1))
                 ((looking-at fieldsep1)
-                 ;; We are in a find spot.. do nothing.
+                 ;; We are in a fine spot.. do nothing.
                  nil
                  )
                 ((save-excursion
diff --git a/lisp/cedet/semantic/db.el b/lisp/cedet/semantic/db.el
index e8784c4f85c..8d9cfcccd7d 100644
--- a/lisp/cedet/semantic/db.el
+++ b/lisp/cedet/semantic/db.el
@@ -899,7 +899,7 @@ If file does not have tags available, and DONTLOAD is nil,
 then load the tags for FILE, and create a new table object for it.
 DONTLOAD does not affect the creation of new database objects."
   ;; (message "Object Translate: %s" file)
-  (when (and file (file-exists-p file))
+  (when (and file (file-exists-p file) (file-regular-p file))
     (let* ((default-directory (file-name-directory file))
            (tab (semanticdb-file-table-object-from-hash file))
            (fullfile nil))
diff --git a/lisp/cedet/semantic/decorate/mode.el b/lisp/cedet/semantic/decorate/mode.el
index fc791f52da1..a4aa535eb1a 100644
--- a/lisp/cedet/semantic/decorate/mode.el
+++ b/lisp/cedet/semantic/decorate/mode.el
@@ -64,6 +64,14 @@ add items to this list."
   "Return the STYLE's highlighter function."
   (intern (format "%s-highlight" style)))
 
+(defsubst semantic-decorate-style-predicate-default (style)
+  "Return the STYLE's predicate function."
+  (intern (format "%s-p-default" style)))
+
+(defsubst semantic-decorate-style-highlighter-default (style)
+  "Return the STYLE's highlighter function."
+  (intern (format "%s-highlight-default" style)))
+
 ;;; Base decoration API
 ;;
 (defsubst semantic-decoration-p (object)
@@ -265,8 +273,6 @@ minor mode is enabled."
         (semantic-make-local-hook 'semantic-after-toplevel-cache-change-hook)
         (add-hook 'semantic-after-toplevel-cache-change-hook
                   'semantic-decorate-tags-after-full-reparse nil t)
-        ;; Decorate includes by default
-        (require 'semantic/decorate/include)
         ;; Add decorations to available tags.  The above hooks ensure
         ;; that new tags will be decorated when they become available.
         (semantic-decorate-add-decorations (semantic-fetch-available-tags)))
@@ -325,6 +331,8 @@ Return non-nil if the decoration style is enabled."
            (flag  (if arg
                       (> (prefix-numeric-value arg) 0)
                     (not (cdr style)))))
+      (when (null style)
+        (error "Unknown decoration style %s" name))
       (unless (eq (cdr style) flag)
         ;; Store the new flag.
         (setcdr style flag)
@@ -368,7 +376,8 @@ DOC is a documentation string describing the decoration style NAME.
 It is appended to auto-generated doc strings.
 An Optional list of FLAGS can also be specified.  Flags are:
   :enabled <value>  - specify the default enabled value for NAME.
-
+  :load <value>     - specify a feature (as a string) with the rest of
+                      the definition for decoration mode NAME.
 
 This defines two new overload functions respectively called `NAME-p'
 and `NAME-highlight', for which you must provide a default
@@ -386,9 +395,14 @@ To add other kind of decorations on a tag, `NAME-highlight' must use
 decoration API found in this library."
   (let ((predicate   (semantic-decorate-style-predicate   name))
         (highlighter (semantic-decorate-style-highlighter name))
+        (predicatedef   (semantic-decorate-style-predicate-default   name))
+        (highlighterdef (semantic-decorate-style-highlighter-default name))
         (defaultenable (if (plist-member flags :enabled)
                            (plist-get flags :enabled)
                          t))
+        (loadfile (if (plist-member flags :load)
+                      (plist-get flags :load)
+                    nil))
         )
     `(progn
        ;; Clear the menu cache so that new items are added when
@@ -408,7 +422,19 @@ decoration API found in this library."
        (add-to-list 'semantic-decoration-styles
                     (cons ',(symbol-name name)
                           ,defaultenable))
-       )))
+       ;; If there is a load file, then create the autoload tokens for
+       ;; those functions to load the token, but only if the fsym
+       ;; doesn't exist yet.
+       (when (stringp ,loadfile)
+         (unless (fboundp ',predicatedef)
+           (autoload ',predicatedef ',loadfile "Return non-nil to decorate TAG."
+             nil 'function))
+
+         (unless (fboundp ',highlighterdef)
+           (autoload ',highlighterdef ',loadfile "Decorate TAG."
+             nil 'function))
+         ))
+    ))
 
 ;;; Predefined decoration styles
 ;;
@@ -514,6 +540,16 @@ Use a primary decoration."
   (semantic-set-tag-face
    tag 'semantic-decoration-on-protected-members-face))
 
+;;; Decoration Modes in other files
+;;
+(define-semantic-decoration-style semantic-decoration-on-includes
+  "Highlight class members that are includes.
+This mode provides a nice context menu on the include statements."
+  :enabled t
+  :load "semantic/decorate/include")
+
+
+
 (provide 'semantic/decorate/mode)
 
 ;; Local variables:
diff --git a/lisp/cedet/semantic/ede-grammar.el b/lisp/cedet/semantic/ede-grammar.el
index cb2a1faaac0..17859e232a3 100644
--- a/lisp/cedet/semantic/ede-grammar.el
+++ b/lisp/cedet/semantic/ede-grammar.el
@@ -146,7 +146,7 @@ Lays claim to all -by.el, and -wy.el files."
               (let* ((package (semantic-grammar-create-package))
                      (fname (progn (string-match ".*/\\(.+\\.el\\)" package)
                                    (match-string 1 package)))
-                     (src (with-current-buffer fname (buffer-file-name)))
+                     (src (ede-expand-filename obj fname))
                      (csrc (concat (file-name-sans-extension src) ".elc")))
                 (if (< emacs-major-version 24)
                     ;; Does not have `byte-recompile-file'
diff --git a/lisp/cedet/semantic/edit.el b/lisp/cedet/semantic/edit.el
index b0540af373d..a27eab5404c 100644
--- a/lisp/cedet/semantic/edit.el
+++ b/lisp/cedet/semantic/edit.el
@@ -141,8 +141,9 @@ Argument START, END, and LENGTH specify the bounds of the change."
    (setq semantic-unmatched-syntax-cache-check t)
    (let ((inhibit-point-motion-hooks t)
          )
-     (run-hook-with-args 'semantic-change-functions start end length)
-     ))
+     (save-match-data
+       (run-hook-with-args 'semantic-change-functions start end length)
+       )))
 
 (defun semantic-changes-in-region (start end &optional buffer)
   "Find change overlays which exist in whole or in part between START and END.
diff --git a/lisp/cedet/semantic/grammar.el b/lisp/cedet/semantic/grammar.el
index 2d53c857c1e..ce658cd5d54 100644
--- a/lisp/cedet/semantic/grammar.el
+++ b/lisp/cedet/semantic/grammar.el
@@ -1484,7 +1484,10 @@ expression then Lisp symbols are completed."
   (interactive)
   (if (semantic-grammar-in-lisp-p)
       ;; We are in lisp code.  Do lisp completion.
-      (lisp-complete-symbol)
+      (let ((completion-at-point-functions
+             (append '(lisp-completion-at-point)
+                     completion-at-point-functions)))
+        (completion-at-point))
     ;; We are not in lisp code.  Do rule completion.
     (let* ((nonterms (semantic-find-tags-by-class 'nonterminal (current-buffer)))
            (sym (car (semantic-ctxt-current-symbol)))
diff --git a/lisp/cedet/semantic/idle.el b/lisp/cedet/semantic/idle.el
index 9899ab974f7..6c223c2b9f2 100644
--- a/lisp/cedet/semantic/idle.el
+++ b/lisp/cedet/semantic/idle.el
@@ -434,16 +434,27 @@ datasets."
 
 (defun semantic-idle-scheduler-work-parse-neighboring-files ()
   "Parse all the files in similar directories to buffers being edited."
-  ;; Let's check to see if EDE matters.
-  (let ((ede-auto-add-method 'never))
-    (dolist (a auto-mode-alist)
-      (when (eq (cdr a) major-mode)
-        (dolist (file (directory-files default-directory t (car a) t))
-          (semantic-throw-on-input 'parsing-mode-buffers)
-          (save-excursion
-            (semanticdb-file-table-object file)
-            ))))
-    ))
+  ;; Let's tell EDE to ignore all the files we're about to load
+  (let ((ede-auto-add-method 'never)
+        (matching-auto-mode-patterns nil))
+    ;; Collect all patterns matching files of the same mode we edit.
+    (mapc (lambda (pat) (and (eq (cdr pat) major-mode)
+                             (push (car pat) matching-auto-mode-patterns)))
+          auto-mode-alist)
+    ;; Loop over all files, and if one matches our mode, we force its
+    ;; table to load.
+    (dolist (file (directory-files default-directory t ".*" t))
+      (catch 'found
+        (mapc (lambda (pat)
+                (semantic-throw-on-input 'parsing-mode-buffers)
+                ;; We use string-match instead of passing the pattern
+                ;; into directory files, because some patterns don't
+                ;; work with directory files.
+                (and (string-match pat file)
+                     (save-excursion
+                       (semanticdb-file-table-object file))
+                     (throw 'found t)))
+              matching-auto-mode-patterns)))))
 
 
 ;;; REPARSING
@@ -840,17 +851,18 @@ visible, then highlight it."
          )
     (cond ((semantic-overlay-p region)
            (with-current-buffer (semantic-overlay-buffer region)
-             (goto-char (semantic-overlay-start region))
-             (when (pos-visible-in-window-p
-                    (point) (get-buffer-window (current-buffer) 'visible))
-               (if (< (semantic-overlay-end region) (point-at-eol))
-                   (pulse-momentary-highlight-overlay
-                    region semantic-idle-symbol-highlight-face)
-                 ;; Not the same
-                 (pulse-momentary-highlight-region
-                  (semantic-overlay-start region)
-                  (point-at-eol)
-                  semantic-idle-symbol-highlight-face)))
+             (save-excursion
+               (goto-char (semantic-overlay-start region))
+               (when (pos-visible-in-window-p
+                      (point) (get-buffer-window (current-buffer) 'visible))
+                 (if (< (semantic-overlay-end region) (point-at-eol))
+                     (pulse-momentary-highlight-overlay
+                      region semantic-idle-symbol-highlight-face)
+                   ;; Not the same
+                   (pulse-momentary-highlight-region
+                    (semantic-overlay-start region)
+                    (point-at-eol)
+                    semantic-idle-symbol-highlight-face))))
              ))
           ((vectorp region)
            (let ((start (aref region 0))
diff --git a/lisp/cedet/semantic/lex.el b/lisp/cedet/semantic/lex.el
index ba862479be5..feead78985c 100644
--- a/lisp/cedet/semantic/lex.el
+++ b/lisp/cedet/semantic/lex.el
@@ -437,7 +437,7 @@ PROPSPECS must be a list of (TYPE PROPERTY VALUE)."
           (if default
               (message
                "*Warning* default value of <%s> tokens changed to %S, was %S"
-               type default token))
+               type token default))
           (setq default token)))
       ;; Ensure the default matching spec is the first one.
       (semantic-lex-type-set type (cons default (nreverse alist))))
diff --git a/lisp/cedet/semantic/wisent/python.el b/lisp/cedet/semantic/wisent/python.el
index 8ca398ef271..719868f7635 100644
--- a/lisp/cedet/semantic/wisent/python.el
+++ b/lisp/cedet/semantic/wisent/python.el
@@ -485,6 +485,20 @@ Return a list as per `semantic-ctxt-current-symbol'.
 Return nil if there is nothing relevant."
   nil)
 
+;;; Tag Formatting
+;;
+(define-mode-local-override semantic-format-tag-abbreviate python-mode (tag &optional parent color)
+  "Format an abbreviated tag for python.
+Shortens 'code' tags, but passes through for others."
+  (cond ((semantic-tag-of-class-p tag 'code)
+         ;; Just take the first line.
+         (let ((name (semantic-tag-name tag)))
+           (when (string-match "\n" name)
+             (setq name (substring name 0 (match-beginning 0))))
+           name))
+        (t
+         (semantic-format-tag-abbreviate-default tag parent color))))
+
 ;;; Enable Semantic in `python-mode'.
 ;;
 
diff --git a/lisp/cedet/srecode/args.el b/lisp/cedet/srecode/args.el
index d6798f7523d..6bc78295fa7 100644
--- a/lisp/cedet/srecode/args.el
+++ b/lisp/cedet/srecode/args.el
@@ -26,6 +26,7 @@
 ;; a set of simple arguments for srecode templates.
 
 (require 'srecode/dictionary)
+(require 'ede)
 
 ;;; Code:
 
diff --git a/lisp/cedet/srecode/compile.el b/lisp/cedet/srecode/compile.el
index 0d68036c433..542fd49f8e5 100644
--- a/lisp/cedet/srecode/compile.el
+++ b/lisp/cedet/srecode/compile.el
@@ -200,10 +200,11 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
   "Compile a semantic recode template file into a mode-local variable."
   (interactive)
   (unless (semantic-active-p)
-    (error "You have to activate semantic-mode to compile SRecode templates."))
+    (error "You have to activate semantic-mode to compile SRecode templates"))
   (require 'srecode/insert)
-  (message "Compiling template %s..."
-           (file-name-nondirectory (buffer-file-name)))
+  (when (called-interactively-p 'interactive)
+    (message "Compiling template %s..."
+             (file-name-nondirectory (buffer-file-name))))
   (let ((tags (semantic-fetch-tags))
         (tag nil)
         (class nil)
@@ -288,10 +289,11 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
        )
       ;; Continue
       (setq tags (cdr tags)))
-
+    
     ;; MSG - Before install since nreverse whacks our list.
-    (message "%d templates compiled for %s"
-             (length table) mode)
+    (when (called-interactively-p 'interactive)
+      (message "%d templates compiled for %s"
+               (length table) mode))
 
     ;;
     ;; APPLY TO MODE
@@ -316,12 +318,14 @@ Arguments ESCAPE-START and ESCAPE-END are the current escape sequences in use."
             (if (stringp project)
                 (setq priority (+ 50 defaultdelta))
               (setq priority (+ 80 defaultdelta))))
-          (message "Templates %s has estimated priority of %d"
-                   (file-name-nondirectory (buffer-file-name))
-                   priority))
-      (message "Compiling templates %s priority %d... done!"
-               (file-name-nondirectory (buffer-file-name))
-               priority))
+          (when (called-interactively-p 'interactive)
+            (message "Templates %s has estimated priority of %d"
+                     (file-name-nondirectory (buffer-file-name))
+                     priority)))
+      (when (called-interactively-p 'interactive)
+        (message "Compiling templates %s priority %d... done!"
+                 (file-name-nondirectory (buffer-file-name))
+                 priority)))
 
     ;; Save it up!
     (srecode-compile-template-table table mode priority application framework project vars)
diff --git a/lisp/cedet/srecode/java.el b/lisp/cedet/srecode/java.el
index 29a8465c45c..1b8922c2746 100644
--- a/lisp/cedet/srecode/java.el
+++ b/lisp/cedet/srecode/java.el
@@ -27,6 +27,7 @@
 
 (require 'srecode/dictionary)
 (require 'semantic/find)
+(require 'ede)
 
 ;;;###autoload
 (defun srecode-semantic-handle-:java (dict)
diff --git a/lisp/cedet/srecode/srt-wy.el b/lisp/cedet/srecode/srt-wy.el
index 5560d35a70c..450f57d943c 100644
--- a/lisp/cedet/srecode/srt-wy.el
+++ b/lisp/cedet/srecode/srt-wy.el
@@ -131,6 +131,10 @@
         ((SET symbol insertable-string-list newline)
          (wisent-raw-tag
           (semantic-tag-new-variable $2 nil $3)))
+        ((SET symbol number newline)
+         (wisent-raw-tag
+          (semantic-tag-new-variable $2 nil
+                                     (list $3))))
         ((SHOW symbol newline)
          (wisent-raw-tag
           (semantic-tag-new-variable $2 nil t))))
@@ -290,8 +294,8 @@ It ignores whitespace, newlines and comments."
   srecode-template-separator-block
   srecode-template-wy--<keyword>-keyword-analyzer
   srecode-template-property-analyzer
-  srecode-template-wy--<symbol>-regexp-analyzer
   srecode-template-wy--<number>-regexp-analyzer
+  srecode-template-wy--<symbol>-regexp-analyzer
   srecode-template-wy--<string>-sexp-analyzer
   srecode-template-wy--<punctuation>-string-analyzer
   semantic-lex-default-action
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index c910acdbc14..e603f76f41d 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -411,6 +411,9 @@ specify different fields to sort on."
 (defvar byte-compile-bound-variables nil
   "List of dynamic variables bound in the context of the current form.
 This list lives partly on the stack.")
+(defvar byte-compile-lexical-variables nil
+  "List of variables that have been treated as lexical.
+Filled in `cconv-analyse-form' but initialized and consulted here.")
 (defvar byte-compile-const-variables nil
   "List of variables declared as constants during compilation of this file.")
 (defvar byte-compile-free-references)
@@ -1489,6 +1492,7 @@ extra args."
          (byte-compile--outbuffer nil)
          (byte-compile-function-environment nil)
          (byte-compile-bound-variables nil)
+         (byte-compile-lexical-variables nil)
          (byte-compile-const-variables nil)
          (byte-compile-free-references nil)
          (byte-compile-free-assignments nil)
@@ -2245,15 +2249,24 @@ list that represents a doc string reference.
 
 (put 'defvar   'byte-hunk-handler 'byte-compile-file-form-defvar)
 (put 'defconst 'byte-hunk-handler 'byte-compile-file-form-defvar)
-(defun byte-compile-file-form-defvar (form)
-  (when (and (symbolp (nth 1 form))
-             (not (string-match "[-*/:$]" (symbol-name (nth 1 form))))
+
+(defun byte-compile--declare-var (sym)
+  (when (and (symbolp sym)
+             (not (string-match "[-*/:$]" (symbol-name sym)))
              (byte-compile-warning-enabled-p 'lexical))
     (byte-compile-warn "global/dynamic var `%s' lacks a prefix"
-                       (nth 1 form)))
-  (push (nth 1 form) byte-compile-bound-variables)
-  (if (eq (car form) 'defconst)
-      (push (nth 1 form) byte-compile-const-variables))
+                       sym))
+  (when (memq sym byte-compile-lexical-variables)
+    (setq byte-compile-lexical-variables
+          (delq sym byte-compile-lexical-variables))
+    (byte-compile-warn "Variable `%S' declared after its first use" sym))
+  (push sym byte-compile-bound-variables))
+
+(defun byte-compile-file-form-defvar (form)
+  (let ((sym (nth 1 form)))
+    (byte-compile--declare-var sym)
+    (if (eq (car form) 'defconst)
+        (push sym byte-compile-const-variables)))
   (if (and (null (cddr form))           ;No `value' provided.
            (eq (car form) 'defvar))     ;Just a declaration.
       nil
@@ -2267,7 +2280,7 @@ list that represents a doc string reference.
      'byte-compile-file-form-define-abbrev-table)
 (defun byte-compile-file-form-define-abbrev-table (form)
   (if (eq 'quote (car-safe (car-safe (cdr form))))
-      (push (car-safe (cdr (cadr form))) byte-compile-bound-variables))
+      (byte-compile--declare-var (car-safe (cdr (cadr form)))))
   (byte-compile-keep-pending form))
 
 (put 'custom-declare-variable 'byte-hunk-handler
@@ -2275,7 +2288,7 @@ list that represents a doc string reference.
 (defun byte-compile-file-form-custom-declare-variable (form)
   (when (byte-compile-warning-enabled-p 'callargs)
     (byte-compile-nogroup-warn form))
-  (push (nth 1 (nth 1 form)) byte-compile-bound-variables)
+  (byte-compile--declare-var (nth 1 (nth 1 form)))
   (byte-compile-keep-pending form))
 
 (put 'require 'byte-hunk-handler 'byte-compile-file-form-require)
@@ -2576,19 +2589,16 @@ If FORM is a lambda or a macro, byte-compile it as a function."
   "Return a list of the variables in the lambda argument list ARGLIST."
   (remq '&rest (remq '&optional arglist)))
 
-(defun byte-compile-make-lambda-lexenv (form)
+(defun byte-compile-make-lambda-lexenv (args)
   "Return a new lexical environment for a lambda expression FORM."
-  ;; See if this is a closure or not
-  (let ((args (byte-compile-arglist-vars (cadr form))))
-    (let ((lexenv nil))
-      ;; Fill in the initial stack contents
-      (let ((stackpos 0))
-        ;; Add entries for each argument
-        (dolist (arg args)
-          (push (cons arg stackpos) lexenv)
-          (setq stackpos (1+ stackpos)))
-        ;; Return the new lexical environment
-        lexenv))))
+  (let* ((lexenv nil)
+         (stackpos 0))
+    ;; Add entries for each argument.
+    (dolist (arg args)
+      (push (cons arg stackpos) lexenv)
+      (setq stackpos (1+ stackpos)))
+    ;; Return the new lexical environment.
+    lexenv))
 
 (defun byte-compile-make-args-desc (arglist)
   (let ((mandatory 0)
@@ -2626,9 +2636,9 @@ for symbols generated by the byte compiler itself."
     (byte-compile-set-symbol-position 'lambda))
   (byte-compile-check-lambda-list (nth 1 fun))
   (let* ((arglist (nth 1 fun))
+         (arglistvars (byte-compile-arglist-vars arglist))
          (byte-compile-bound-variables
-          (append (and (not lexical-binding)
-                       (byte-compile-arglist-vars arglist))
+          (append (if (not lexical-binding) arglistvars)
                   byte-compile-bound-variables))
          (body (cdr (cdr fun)))
          (doc (if (stringp (car body))
@@ -2676,7 +2686,8 @@ for symbols generated by the byte compiler itself."
                                    ;; args (since lambda expressions should be
                                    ;; closed by now).
                                    (and lexical-binding
-                                        (byte-compile-make-lambda-lexenv fun))
+                                        (byte-compile-make-lambda-lexenv
+                                         arglistvars))
                                    reserved-csts)))
       ;; Build the actual byte-coded function.
       (cl-assert (eq 'byte-code (car-safe compiled)))
@@ -3435,32 +3446,38 @@ discarding."
 (byte-defop-compiler (/ byte-quo) byte-compile-quo)
 (byte-defop-compiler nconc)
 
+;; Is this worth it?  Both -before and -after are written in C.
 (defun byte-compile-char-before (form)
-  (cond ((= 2 (length form))
+  (cond ((or (= 1 (length form))
+             (and (= 2 (length form)) (not (nth 1 form))))
+         (byte-compile-form '(char-after (1- (point)))))
+        ((= 2 (length form))
          (byte-compile-form (list 'char-after (if (numberp (nth 1 form))
                                                   (1- (nth 1 form))
-                                                `(1- ,(nth 1 form))))))
-        ((= 1 (length form))
-         (byte-compile-form '(char-after (1- (point)))))
+                                                `(1- (or ,(nth 1 form)
+                                                         (point)))))))
         (t (byte-compile-subr-wrong-args form "0-1"))))
 
 ;; backward-... ==> forward-... with negated argument.
+;; Is this worth it?  Both -backward and -forward are written in C.
 (defun byte-compile-backward-char (form)
-  (cond ((= 2 (length form))
+  (cond ((or (= 1 (length form))
+             (and (= 2 (length form)) (not (nth 1 form))))
+         (byte-compile-form '(forward-char -1)))
+        ((= 2 (length form))
          (byte-compile-form (list 'forward-char (if (numberp (nth 1 form))
                                                     (- (nth 1 form))
-                                                  `(- ,(nth 1 form))))))
-        ((= 1 (length form))
-         (byte-compile-form '(forward-char -1)))
+                                                  `(- (or ,(nth 1 form) 1))))))
         (t (byte-compile-subr-wrong-args form "0-1"))))
 
 (defun byte-compile-backward-word (form)
-  (cond ((= 2 (length form))
+  (cond ((or (= 1 (length form))
+             (and (= 2 (length form)) (not (nth 1 form))))
+         (byte-compile-form '(forward-word -1)))
+        ((= 2 (length form))
          (byte-compile-form (list 'forward-word (if (numberp (nth 1 form))
                                                     (- (nth 1 form))
-                                                  `(- ,(nth 1 form))))))
-        ((= 1 (length form))
-         (byte-compile-form '(forward-word -1)))
+                                                  `(- (or ,(nth 1 form) 1))))))
         (t (byte-compile-subr-wrong-args form "0-1"))))
 
 (defun byte-compile-list (form)
@@ -3862,9 +3879,8 @@ that suppresses all warnings during execution of BODY."
   "Emit byte-codes to push the initialization value for CLAUSE on the stack.
 Return the offset in the form (VAR . OFFSET)."
   (let* ((var (if (consp clause) (car clause) clause)))
-    ;; We record the stack position even of dynamic bindings and
-    ;; variables in non-stack lexical environments; we'll put
-    ;; them in the proper place below.
+    ;; We record the stack position even of dynamic bindings; we'll put
+    ;; them in the proper place later.
     (prog1 (cons var byte-compile-depth)
       (if (consp clause)
           (byte-compile-form (cadr clause))
@@ -3882,33 +3898,41 @@ Return the offset in the form (VAR . OFFSET)."
 INIT-LEXENV should be a lexical-environment alist describing the
 positions of the init value that have been pushed on the stack.
 Return non-nil if the TOS value was popped."
-  ;; The presence of lexical bindings mean that we may have to
+  ;; The mix of lexical and dynamic bindings mean that we may have to
   ;; juggle things on the stack, to move them to TOS for
   ;; dynamic binding.
-  (cond ((not (byte-compile-not-lexical-var-p var))
-         ;; VAR is a simple stack-allocated lexical variable
-         (push (assq var init-lexenv)
-               byte-compile--lexical-environment)
-         nil)
-        ((eq var (caar init-lexenv))
-         ;; VAR is dynamic and is on the top of the
-         ;; stack, so we can just bind it like usual
-         (byte-compile-dynamic-variable-bind var)
-         t)
-        (t
-         ;; VAR is dynamic, but we have to get its
-         ;; value out of the middle of the stack
-         (let ((stack-pos (cdr (assq var init-lexenv))))
-           (byte-compile-stack-ref stack-pos)
-           (byte-compile-dynamic-variable-bind var)
-           ;; Now we have to store nil into its temporary
-           ;; stack position to avoid problems with GC
-           (byte-compile-push-constant nil)
-           (byte-compile-stack-set stack-pos))
-         nil)))
-
-(defun byte-compile-unbind (clauses init-lexenv
-                                    &optional preserve-body-value)
+  (if (and lexical-binding (not (byte-compile-not-lexical-var-p var)))
+      ;; VAR is a simple stack-allocated lexical variable.
+      (progn (push (assq var init-lexenv)
+                   byte-compile--lexical-environment)
+             nil)
+    ;; VAR should be dynamically bound.
+    (while (assq var byte-compile--lexical-environment)
+      ;; This dynamic binding shadows a lexical binding.
+      (setq byte-compile--lexical-environment
+            (remq (assq var byte-compile--lexical-environment)
+                  byte-compile--lexical-environment)))
+    (cond
+     ((eq var (caar init-lexenv))
+      ;; VAR is dynamic and is on the top of the
+      ;; stack, so we can just bind it like usual.
+      (byte-compile-dynamic-variable-bind var)
+      t)
+     (t
+      ;; VAR is dynamic, but we have to get its
+      ;; value out of the middle of the stack.
+      (let ((stack-pos (cdr (assq var init-lexenv))))
+        (byte-compile-stack-ref stack-pos)
+        (byte-compile-dynamic-variable-bind var)
+        ;; Now we have to store nil into its temporary
+        ;; stack position so it doesn't prevent the value from being GC'd.
+        ;; FIXME: Not worth the trouble.
+        ;; (byte-compile-push-constant nil)
+        ;; (byte-compile-stack-set stack-pos)
+        )
+      nil))))
+
+(defun byte-compile-unbind (clauses init-lexenv preserve-body-value)
   "Emit byte-codes to unbind the variables bound by CLAUSES.
 CLAUSES is a `let'-style variable binding list.  INIT-LEXENV should be a
 lexical-environment alist describing the positions of the init value that
@@ -3916,7 +3940,7 @@ have been pushed on the stack.  If PRESERVE-BODY-VALUE is true,
 then an additional value on the top of the stack, above any lexical binding
 slots, is preserved, so it will be on the top of the stack after all
 binding slots have been popped."
-  ;; Unbind dynamic variables
+  ;; Unbind dynamic variables.
   (let ((num-dynamic-bindings 0))
     (dolist (clause clauses)
       (unless (assq (if (consp clause) (car clause) clause)
@@ -3927,14 +3951,15 @@ binding slots have been popped."
   ;; Pop lexical variables off the stack, possibly preserving the
   ;; return value of the body.
   (when init-lexenv
-    ;; INIT-LEXENV contains all init values left on the stack
+    ;; INIT-LEXENV contains all init values left on the stack.
     (byte-compile-discard (length init-lexenv) preserve-body-value)))
 
 (defun byte-compile-let (form)
-  "Generate code for the `let' form FORM."
+  "Generate code for the `let' or `let*' form FORM."
   (let ((clauses (cadr form))
-        (init-lexenv nil))
-    (when (eq (car form) 'let)
+        (init-lexenv nil)
+        (is-let (eq (car form) 'let)))
+    (when is-let
       ;; First compute the binding values in the old scope.
       (dolist (var clauses)
         (push (byte-compile-push-binding-init var) init-lexenv)))
@@ -3946,28 +3971,20 @@ binding slots have been popped."
       ;; For `let', do it in reverse order, because it makes no
       ;; semantic difference, but it is a lot more efficient since the
       ;; values are now in reverse order on the stack.
-      (dolist (var (if (eq (car form) 'let) (reverse clauses) clauses))
-        (unless (eq (car form) 'let)
+      (dolist (var (if is-let (reverse clauses) clauses))
+        (unless is-let
           (push (byte-compile-push-binding-init var) init-lexenv))
         (let ((var (if (consp var) (car var) var)))
-          (cond ((null lexical-binding)
-                 ;; If there are no lexical bindings, we can do things simply.
-                 (byte-compile-dynamic-variable-bind var))
-                ((byte-compile-bind var init-lexenv)
-                 (pop init-lexenv)))))
+          (if (byte-compile-bind var init-lexenv)
+              (pop init-lexenv))))
       ;; Emit the body.
       (let ((init-stack-depth byte-compile-depth))
         (byte-compile-body-do-effect (cdr (cdr form)))
-        ;; Unbind the variables.
-        (if lexical-binding
-            ;; Unbind both lexical and dynamic variables.
-            (progn
-              (cl-assert (or (eq byte-compile-depth init-stack-depth)
-                             (eq byte-compile-depth (1+ init-stack-depth))))
-              (byte-compile-unbind clauses init-lexenv (> byte-compile-depth
-                                                          init-stack-depth)))
-          ;; Unbind dynamic variables.
-          (byte-compile-out 'byte-unbind (length clauses)))))))
+        ;; Unbind both lexical and dynamic variables.
+        (cl-assert (or (eq byte-compile-depth init-stack-depth)
+                       (eq byte-compile-depth (1+ init-stack-depth))))
+        (byte-compile-unbind clauses init-lexenv
+                             (> byte-compile-depth init-stack-depth))))))
 
 
 
diff --git a/lisp/emacs-lisp/cconv.el b/lisp/emacs-lisp/cconv.el
index ee84a9f69ba..761e33c059d 100644
--- a/lisp/emacs-lisp/cconv.el
+++ b/lisp/emacs-lisp/cconv.el
@@ -81,7 +81,6 @@
 ;;   and other oddities.
 ;; - new byte codes for unwind-protect, catch, and condition-case so that
 ;;   closures aren't needed at all.
-;; - inline source code of different binding mode by first compiling it.
 ;; - a reference to a var that is known statically to always hold a constant
 ;;   should be turned into a byte-constant rather than a byte-stack-ref.
 ;;   Hmm... right, that's called constant propagation and could be done here,
@@ -95,6 +94,7 @@
 
 ;; (defmacro dlet (binders &rest body)
 ;;   ;; Works in both lexical and non-lexical mode.
+;;   (declare (indent 1) (debug let))
 ;;   `(progn
 ;;      ,@(mapcar (lambda (binder)
 ;;                  `(defvar ,(if (consp binder) (car binder) binder)))
@@ -489,6 +489,7 @@ places where they originally did not directly appear."
 (unless (fboundp 'byte-compile-not-lexical-var-p)
   ;; Only used to test the code in non-lexbind Emacs.
   (defalias 'byte-compile-not-lexical-var-p 'boundp))
+(defvar byte-compile-lexical-variables)
 
 (defun cconv--analyse-use (vardata form varkind)
   "Analyze the use of a variable.
@@ -530,6 +531,7 @@ FORM is the parent form that binds this var."
          ;; outside of it.
          (envcopy
           (mapcar (lambda (vdata) (list (car vdata) nil nil nil nil)) env))
+         (byte-compile-bound-variables byte-compile-bound-variables)
          (newenv envcopy))
     ;; Push it before recursing, so cconv-freevars-alist contains entries in
     ;; the order they'll be used by closure-convert-rec.
@@ -541,6 +543,7 @@ FORM is the parent form that binds this var."
          (format "Argument %S is not a lexical variable" arg)))
        ((eq ?& (aref (symbol-name arg) 0)) nil) ;Ignore &rest, &optional, ...
        (t (let ((varstruct (list arg nil nil nil nil)))
+            (cl-pushnew arg byte-compile-lexical-variables)
             (push (cons (list arg) (cdr varstruct)) newvars)
             (push varstruct newenv)))))
     (dolist (form body)                   ;Analyze body forms.
@@ -579,6 +582,7 @@ and updates the data stored in ENV."
      (let ((orig-env env)
            (newvars nil)
            (var nil)
+           (byte-compile-bound-variables byte-compile-bound-variables)
            (value nil))
        (dolist (binder binders)
          (if (not (consp binder))
@@ -592,6 +596,7 @@ and updates the data stored in ENV."
            (cconv-analyse-form value (if (eq letsym 'let*) env orig-env)))
 
          (unless (byte-compile-not-lexical-var-p var)
+           (cl-pushnew var byte-compile-lexical-variables)
            (let ((varstruct (list var nil nil nil nil)))
              (push (cons binder (cdr varstruct)) newvars)
              (push varstruct env))))
@@ -616,7 +621,8 @@ and updates the data stored in ENV."
 
     (`((lambda . ,_) . ,_)             ; First element is lambda expression.
      (byte-compile-log-warning
-      "Use of deprecated ((lambda ...) ...) form" t :warning)
+      (format "Use of deprecated ((lambda %s ...) ...) form" (nth 1 (car form)))
+      t :warning)
      (dolist (exp `((function ,(car form)) . ,(cdr form)))
        (cconv-analyse-form exp env)))
 
@@ -645,6 +651,7 @@ and updates the data stored in ENV."
     (`(track-mouse . ,body)
      (cconv--analyse-function () body env form))
 
+    (`(defvar ,var) (push var byte-compile-bound-variables))
     (`(,(or `defconst `defvar) ,var ,value . ,_)
      (push var byte-compile-bound-variables)
      (cconv-analyse-form value env))
@@ -668,7 +675,9 @@ and updates the data stored in ENV."
      ;; seem worth the trouble.
      (dolist (form forms) (cconv-analyse-form form nil)))
 
-    (`(declare . ,_) nil)               ;The args don't contain code.
+    ;; `declare' should now be macro-expanded away (and if they're not, we're
+    ;; in trouble because they *can* contain code nowadays).
+    ;; (`(declare . ,_) nil)               ;The args don't contain code.
 
     (`(,_ . ,body-forms)    ; First element is a function or whatever.
      (dolist (form body-forms) (cconv-analyse-form form env)))
diff --git a/lisp/emacs-lisp/cl-lib.el b/lisp/emacs-lisp/cl-lib.el
index f3bf70b0190..52f123c83ec 100644
--- a/lisp/emacs-lisp/cl-lib.el
+++ b/lisp/emacs-lisp/cl-lib.el
@@ -156,8 +156,8 @@ an element already on the list.
                  ;; earlier and should have triggered them already.
                  (with-no-warnings ,place)
                (setq ,place (cons ,var ,place))))
-        (list 'setq place (cl-list* 'cl-adjoin x place keys)))
-    (cl-list* 'cl-callf2 'cl-adjoin x place keys)))
+        `(setq ,place (cl-adjoin ,x ,place ,@keys)))
+    `(cl-callf2 cl-adjoin ,x ,place ,@keys)))
 
 (defun cl--set-elt (seq n val)
   (if (listp seq) (setcar (nthcdr n seq) val) (aset seq n val)))
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index af19db63f30..a06abb03b95 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -267,7 +267,7 @@ including `cl-block' and `cl-eval-when'.
 ;;;;;;  cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when
 ;;;;;;  cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp
 ;;;;;;  cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
-;;;;;;  "cl-macs" "cl-macs.el" "b839ad3781c4f2f849df0639b4eba166")
+;;;;;;  "cl-macs" "cl-macs.el" "fd824d987086eafec0b1cb2efa8312f4")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'cl--compiler-macro-list* "cl-macs" "\
@@ -699,9 +699,10 @@ OPTION is either a single keyword or (KEYWORD VALUE) where
 KEYWORD can be one of :conc-name, :constructor, :copier, :predicate,
 :type, :named, :initial-offset, :print-function, or :include.
 
-Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
-SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
-one keyword is supported, `:read-only'.  If this has a non-nil
+Each SLOT may instead take the form (SNAME SDEFAULT SOPTIONS...), where
+SDEFAULT is the default value of that slot and SOPTIONS are keyword-value
+pairs for that slot.
+Currently, only one keyword is supported, `:read-only'.  If this has a non-nil
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)" nil t)
@@ -724,6 +725,8 @@ TYPE is a Common Lisp-style type specifier.
 
 \(fn OBJECT TYPE)" nil nil)
 
+(eval-and-compile (put 'cl-typep 'compiler-macro #'cl--compiler-macro-typep))
+
 (autoload 'cl-check-type "cl-macs" "\
 Verify that FORM is of type TYPE; signal an error if not.
 STRING is an optional description of the desired type.
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 4aae2c6efe5..34957d86796 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -584,7 +584,7 @@ If `load' is in WHEN, BODY is evaluated when loaded after top-level compile.
 If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level.
 
 \(fn (WHEN...) BODY...)"
-  (declare (indent 1) (debug ((&rest &or "compile" "load" "eval") body)))
+  (declare (indent 1) (debug (sexp body)))
   (if (and (fboundp 'cl--compiling-file) (cl--compiling-file)
            (not cl--not-toplevel) (not (boundp 'for-effect))) ;Horrible kludge.
       (let ((comp (or (memq 'compile when) (memq :compile-toplevel when)))
@@ -2276,9 +2276,10 @@ OPTION is either a single keyword or (KEYWORD VALUE) where
 KEYWORD can be one of :conc-name, :constructor, :copier, :predicate,
 :type, :named, :initial-offset, :print-function, or :include.
 
-Each SLOT may instead take the form (SLOT SLOT-OPTS...), where
-SLOT-OPTS are keyword-value pairs for that slot.  Currently, only
-one keyword is supported, `:read-only'.  If this has a non-nil
+Each SLOT may instead take the form (SNAME SDEFAULT SOPTIONS...), where
+SDEFAULT is the default value of that slot and SOPTIONS are keyword-value
+pairs for that slot.
+Currently, only one keyword is supported, `:read-only'.  If this has a non-nil
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)"
@@ -2574,9 +2575,16 @@ The type name can then be used in `cl-typecase', `cl-check-type', etc."
 (defun cl-typep (object type)   ; See compiler macro below.
   "Check that OBJECT is of type TYPE.
 TYPE is a Common Lisp-style type specifier."
+  (declare (compiler-macro cl--compiler-macro-typep))
   (let ((cl--object object)) ;; Yuck!!
     (eval (cl--make-type-test 'cl--object type))))
 
+(defun cl--compiler-macro-typep (form val type)
+  (if (macroexp-const-p type)
+      (macroexp-let2 macroexp-copyable-p temp val
+        (cl--make-type-test temp (cl--const-expr-val type)))
+    form))
+
 ;;;###autoload
 (defmacro cl-check-type (form type &optional string)
   "Verify that FORM is of type TYPE; signal an error if not.
@@ -2635,19 +2643,13 @@ and then returning foo."
   (let ((p args) (res nil))
     (while (consp p) (push (pop p) res))
     (setq args (nconc (nreverse res) (and p (list '&rest p)))))
-  `(cl-eval-when (compile load eval)
-     (put ',func 'compiler-macro
-          (cl-function (lambda ,(if (memq '&whole args) (delq '&whole args)
-                             (cons '_cl-whole-arg args))
-                         ,@body)))
-     ;; This is so that describe-function can locate
-     ;; the macro definition.
-     (let ((file ,(or buffer-file-name
-                      (and (boundp 'byte-compile-current-file)
-                           (stringp byte-compile-current-file)
-                           byte-compile-current-file))))
-       (if file (put ',func 'compiler-macro-file
-                     (purecopy (file-name-nondirectory file)))))))
+  (let ((fname (make-symbol (concat (symbol-name func) "--cmacro"))))
+    `(eval-and-compile
+       ;; Name the compiler-macro function, so that `symbol-file' can find it.
+       (cl-defun ,fname ,(if (memq '&whole args) (delq '&whole args)
+                           (cons '_cl-whole-arg args))
+         ,@body)
+       (put ',func 'compiler-macro #',fname))))
 
 ;;;###autoload
 (defun cl-compiler-macroexpand (form)
@@ -2763,22 +2765,16 @@ surrounded by (cl-block NAME ...).
 
 ;;;###autoload
 (defun cl--compiler-macro-adjoin (form a list &rest keys)
-  (if (and (cl--simple-expr-p a) (cl--simple-expr-p list)
-           (not (memq :key keys)))
-      `(if (cl-member ,a ,list ,@keys) ,list (cons ,a ,list))
-    form))
+  (if (memq :key keys) form
+    (macroexp-let2 macroexp-copyable-p va a
+      (macroexp-let2 macroexp-copyable-p vlist list
+        `(if (cl-member ,va ,vlist ,@keys) ,vlist (cons ,va ,vlist))))))
 
 (defun cl--compiler-macro-get (_form sym prop &optional def)
   (if def
       `(cl-getf (symbol-plist ,sym) ,prop ,def)
     `(get ,sym ,prop)))
 
-(cl-define-compiler-macro cl-typep (&whole form val type)
-  (if (macroexp-const-p type)
-      (macroexp-let2 macroexp-copyable-p temp val
-        (cl--make-type-test temp (cl--const-expr-val type)))
-    form))
-
 (dolist (y '(cl-first cl-second cl-third cl-fourth
              cl-fifth cl-sixth cl-seventh
              cl-eighth cl-ninth cl-tenth
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 867f079ce5f..319af588eac 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -472,6 +472,8 @@ the option `edebug-all-forms'."
 (or (fboundp 'edebug-original-eval-defun)
     (defalias 'edebug-original-eval-defun (symbol-function 'eval-defun)))
 
+(defvar edebug-result) ; The result of the function call returned by body.
+
 ;; We should somehow arrange to be able to do this
 ;; without actually replacing the eval-defun command.
 (defun edebug-eval-defun (edebug-it)
@@ -487,7 +489,7 @@ With a prefix argument, instrument the code for Edebug.
 
 Setting option `edebug-all-defs' to a non-nil value reverses the meaning
 of the prefix argument.  Code is then instrumented when this function is
-invoked without a prefix argument
+invoked without a prefix argument.
 
 If acting on a `defun' for FUNCTION, and the function was instrumented,
 `Edebug: FUNCTION' is printed in the minibuffer.  If not instrumented,
@@ -2106,7 +2108,6 @@ expressions; a `progn' form will be returned enclosing these forms."
 (defvar edebug-coverage) ; the coverage results of each expression of function.
 
 (defvar edebug-buffer) ; which buffer the function is in.
-(defvar edebug-result) ; the result of the function call returned by body
 (defvar edebug-outside-executing-macro)
 (defvar edebug-outside-defining-kbd-macro)
 
diff --git a/lisp/emacs-lisp/eieio-base.el b/lisp/emacs-lisp/eieio-base.el
index c8ae3f4bf1a..21190446624 100644
--- a/lisp/emacs-lisp/eieio-base.el
+++ b/lisp/emacs-lisp/eieio-base.el
@@ -31,6 +31,7 @@
 ;;; Code:
 
 (require 'eieio)
+(eval-when-compile (require 'cl))       ;FIXME: Use cl-lib!
 
 ;;; eieio-instance-inheritor
 ;;
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
new file mode 100644
index 00000000000..da475638bb7
--- /dev/null
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -0,0 +1,2264 @@
+;;; eieio-core.el --- Core implementation for eieio
+
+;; Copyright (C) 1995-1996, 1998-2013 Free Software Foundation, Inc.
+
+;; Author: Eric M. Ludlam <zappo@gnu.org>
+;; Version: 1.4
+;; Keywords: OO, lisp
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; The "core" part of EIEIO is the implementation for the object
+;; system (such as eieio-defclass, or eieio-defmethod) but not the
+;; base classes for the object system, which are defined in EIEIO.
+;;
+;; See the commentary for eieio.el for more about EIEIO itself.
+
+;;; Code:
+
+(eval-when-compile (require 'cl))       ;FIXME: Use cl-lib!
+
+;; Compatibility
+(if (fboundp 'compiled-function-arglist)
+
+    ;; XEmacs can only access a compiled functions arglist like this:
+    (defalias 'eieio-compiled-function-arglist 'compiled-function-arglist)
+
+  ;; Emacs doesn't have this function, but since FUNC is a vector, we can just
+  ;; grab the appropriate element.
+  (defun eieio-compiled-function-arglist (func)
+    "Return the argument list for the compiled function FUNC."
+    (aref func 0))
+
+  )
+
+(put 'eieio--defalias 'byte-hunk-handler
+     #'byte-compile-file-form-defalias) ;;(get 'defalias 'byte-hunk-handler)
+(defun eieio--defalias (name body)
+  "Like `defalias', but with less side-effects.
+More specifically, it has no side-effects at all when the new function
+definition is the same (`eq') as the old one."
+  (unless (and (fboundp name)
+               (eq (symbol-function name) body))
+    (defalias name body)))
+
+;;;
+;; A few functions that are better in the official EIEIO src, but
+;; used from the core.
+(declare-function slot-unbound "eieio")
+(declare-function slot-missing "eieio")
+(declare-function child-of-class-p "eieio")
+
+
+;;;
+;; Variable declarations.
+;;
+(defvar eieio-hook nil
+  "This hook is executed, then cleared each time `defclass' is called.")
+
+(defvar eieio-error-unsupported-class-tags nil
+  "Non-nil to throw an error if an encountered tag is unsupported.
+This may prevent classes from CLOS applications from being used with EIEIO
+since EIEIO does not support all CLOS tags.")
+
+(defvar eieio-skip-typecheck nil
+  "If non-nil, skip all slot typechecking.
+Set this to t permanently if a program is functioning well to get a
+small speed increase.  This variable is also used internally to handle
+default setting for optimization purposes.")
+
+(defvar eieio-optimize-primary-methods-flag t
+  "Non-nil means to optimize the method dispatch on primary methods.")
+
+(defvar eieio-initializing-object  nil
+  "Set to non-nil while initializing an object.")
+
+(defconst eieio-unbound
+  (if (and (boundp 'eieio-unbound) (symbolp eieio-unbound))
+      eieio-unbound
+    (make-symbol "unbound"))
+  "Uninterned symbol representing an unbound slot in an object.")
+
+;; This is a bootstrap for eieio-default-superclass so it has a value
+;; while it is being built itself.
+(defvar eieio-default-superclass nil)
+
+;;;
+;; Class currently in scope.
+;;
+;; When invoking methods, the running method needs to know which class
+;; is currently in scope.  Generally this is the class of the method
+;; being called, but 'call-next-method' needs to query this state,
+;; and change it to be then next super class up.
+;;
+;; Thus, the scoped class is a stack that needs to be managed.
+
+(defvar eieio--scoped-class-stack nil
+  "A stack of the classes currently in scope during method invocation.")
+
+(defun eieio--scoped-class ()
+  "Return the class currently in scope, or nil."
+  (car-safe eieio--scoped-class-stack))
+
+(defmacro eieio--with-scoped-class (class &rest forms)
+  "Set CLASS as the currently scoped class while executing FORMS."
+  `(unwind-protect
+       (progn
+         (push ,class eieio--scoped-class-stack)
+         ,@forms)
+     (pop eieio--scoped-class-stack)))
+(put 'eieio--with-scoped-class 'lisp-indent-function 1)
+
+;;;
+;; Field Accessors
+;;
+(defmacro eieio--define-field-accessors (prefix fields)
+  (declare (indent 1))
+  (let ((index 0)
+        (defs '()))
+    (dolist (field fields)
+      (let ((doc (if (listp field)
+                     (prog1 (cadr field) (setq field (car field))))))
+        (push `(defmacro ,(intern (format "eieio--%s-%s" prefix field)) (x)
+                 ,@(if doc (list (format (if (string-match "\n" doc)
+                                             "Return %s" "Return %s of a %s.")
+                                         doc prefix)))
+                 (list 'aref x ,index))
+              defs)
+        (setq index (1+ index))))
+    `(eval-and-compile
+       ,@(nreverse defs)
+       (defconst ,(intern (format "eieio--%s-num-slots" prefix)) ,index))))
+
+(eieio--define-field-accessors class
+  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
+   (symbol "symbol (self-referencing)")
+   parent children
+   (symbol-obarray "obarray permitting fast access to variable position indexes")
+   ;; @todo
+   ;; the word "public" here is leftovers from the very first version.
+   ;; Get rid of it!
+   (public-a "class attribute index")
+   (public-d "class attribute defaults index")
+   (public-doc "class documentation strings for attributes")
+   (public-type "class type for a slot")
+   (public-custom "class custom type for a slot")
+   (public-custom-label "class custom group for a slot")
+   (public-custom-group "class custom group for a slot")
+   (public-printer "printer for a slot")
+   (protection "protection for a slot")
+   (initarg-tuples "initarg tuples list")
+   (class-allocation-a "class allocated attributes")
+   (class-allocation-doc "class allocated documentation")
+   (class-allocation-type "class allocated value type")
+   (class-allocation-custom "class allocated custom descriptor")
+   (class-allocation-custom-label "class allocated custom descriptor")
+   (class-allocation-custom-group "class allocated custom group")
+   (class-allocation-printer "class allocated printer for a slot")
+   (class-allocation-protection "class allocated protection list")
+   (class-allocation-values "class allocated value vector")
+   (default-object-cache "what a newly created object would look like.
+This will speed up instantiation time as only a `copy-sequence' will
+be needed, instead of looping over all the values and setting them
+from the default.")
+   (options "storage location of tagged class options.
+Stored outright without modifications or stripping.")))
+
+(eieio--define-field-accessors object
+  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
+   (class "class struct defining OBJ")
+   name))
+
+;; FIXME: The constants below should have an `eieio-' prefix added!!
+
+(defconst method-static 0 "Index into :static tag on a method.")
+(defconst method-before 1 "Index into :before tag on a method.")
+(defconst method-primary 2 "Index into :primary tag on a method.")
+(defconst method-after 3 "Index into :after tag on a method.")
+(defconst method-num-lists 4 "Number of indexes into methods vector in which groups of functions are kept.")
+(defconst method-generic-before 4 "Index into generic :before tag on a method.")
+(defconst method-generic-primary 5 "Index into generic :primary tag on a method.")
+(defconst method-generic-after 6 "Index into generic :after tag on a method.")
+(defconst method-num-slots 7 "Number of indexes into a method's vector.")
+
+(defsubst eieio-specialized-key-to-generic-key (key)
+  "Convert a specialized KEY into a generic method key."
+  (cond ((eq key method-static) 0) ;; don't convert
+        ((< key method-num-lists) (+ key 3)) ;; The conversion
+        (t key) ;; already generic.. maybe.
+        ))
+
+
+;;; Important macros used internally in eieio.
+;;
+(defmacro eieio--check-type (type obj)
+  (unless (symbolp obj)
+    (error "eieio--check-type wants OBJ to be a variable"))
+  `(if (not ,(cond
+              ((eq 'or (car-safe type))
+               `(or ,@(mapcar (lambda (type) `(,type ,obj)) (cdr type))))
+              (t `(,type ,obj))))
+       (signal 'wrong-type-argument (list ',type ,obj))))
+
+(defmacro class-v (class)
+  "Internal: Return the class vector from the CLASS symbol."
+  ;; No check: If eieio gets this far, it has probably been checked already.
+  `(get ,class 'eieio-class-definition))
+
+(defmacro class-p (class)
+  "Return t if CLASS is a valid class vector.
+CLASS is a symbol."
+  ;; this new method is faster since it doesn't waste time checking lots of
+  ;; things.
+  `(condition-case nil
+       (eq (aref (class-v ,class) 0) 'defclass)
+     (error nil)))
+
+(defun eieio-class-name (class) "Return a Lisp like symbol name for CLASS."
+  (eieio--check-type class-p class)
+  ;; I think this is supposed to return a symbol, but to me CLASS is a symbol,
+  ;; and I wanted a string.  Arg!
+  (format "#<class %s>" (symbol-name class)))
+(define-obsolete-function-alias 'class-name #'eieio-class-name "24.4")
+
+(defmacro eieio-class-parents-fast (class)
+  "Return parent classes to CLASS with no check."
+  `(eieio--class-parent (class-v ,class)))
+
+(defmacro eieio-class-children-fast (class) "Return child classes to CLASS with no check."
+  `(eieio--class-children (class-v ,class)))
+
+(defmacro same-class-fast-p (obj class)
+  "Return t if OBJ is of class-type CLASS with no error checking."
+  `(eq (eieio--object-class ,obj) ,class))
+
+(defmacro class-constructor (class)
+  "Return the symbol representing the constructor of CLASS."
+  `(eieio--class-symbol (class-v ,class)))
+
+(defmacro generic-p (method)
+  "Return t if symbol METHOD is a generic function.
+Only methods have the symbol `eieio-method-obarray' as a property
+\(which contains a list of all bindings to that method type.)"
+  `(and (fboundp ,method) (get ,method 'eieio-method-obarray)))
+
+(defun generic-primary-only-p (method)
+  "Return t if symbol METHOD is a generic function with only primary methods.
+Only methods have the symbol `eieio-method-obarray' as a property (which
+contains a list of all bindings to that method type.)
+Methods with only primary implementations are executed in an optimized way."
+  (and (generic-p method)
+       (let ((M (get method 'eieio-method-tree)))
+         (and (< 0 (length (aref M method-primary)))
+              (not (aref M method-static))
+              (not (aref M method-before))
+              (not (aref M method-after))
+              (not (aref M method-generic-before))
+              (not (aref M method-generic-primary))
+              (not (aref M method-generic-after))))
+       ))
+
+(defun generic-primary-only-one-p (method)
+  "Return t if symbol METHOD is a generic function with only primary methods.
+Only methods have the symbol `eieio-method-obarray' as a property (which
+contains a list of all bindings to that method type.)
+Methods with only primary implementations are executed in an optimized way."
+  (and (generic-p method)
+       (let ((M (get method 'eieio-method-tree)))
+         (and (= 1 (length (aref M method-primary)))
+              (not (aref M method-static))
+              (not (aref M method-before))
+              (not (aref M method-after))
+              (not (aref M method-generic-before))
+              (not (aref M method-generic-primary))
+              (not (aref M method-generic-after))))
+       ))
+
+(defmacro class-option-assoc (list option)
+  "Return from LIST the found OPTION, or nil if it doesn't exist."
+  `(car-safe (cdr (memq ,option ,list))))
+
+(defmacro class-option (class option)
+  "Return the value stored for CLASS' OPTION.
+Return nil if that option doesn't exist."
+  `(class-option-assoc (eieio--class-options (class-v ,class)) ',option))
+
+(defmacro eieio-object-p (obj)
+  "Return non-nil if OBJ is an EIEIO object."
+  `(condition-case nil
+       (let ((tobj ,obj))
+         (and (eq (aref tobj 0) 'object)
+              (class-p (eieio--object-class tobj))))
+     (error nil)))
+(defalias 'object-p 'eieio-object-p)
+
+(defmacro class-abstract-p (class)
+  "Return non-nil if CLASS is abstract.
+Abstract classes cannot be instantiated."
+  `(class-option ,class :abstract))
+
+(defmacro class-method-invocation-order (class)
+  "Return the invocation order of CLASS.
+Abstract classes cannot be instantiated."
+  `(or (class-option ,class :method-invocation-order)
+       :breadth-first))
+
+
+
+;;;
+;; Class Creation
+
+(defvar eieio-defclass-autoload-map (make-vector 7 nil)
+  "Symbol map of superclasses we find in autoloads.")
+
+;; We autoload this because it's used in `make-autoload'.
+;;;###autoload
+(defun eieio-defclass-autoload (cname superclasses filename doc)
+  "Create autoload symbols for the EIEIO class CNAME.
+SUPERCLASSES are the superclasses that CNAME inherits from.
+DOC is the docstring for CNAME.
+This function creates a mock-class for CNAME and adds it into
+SUPERCLASSES as children.
+It creates an autoload function for CNAME's constructor."
+  ;; Assume we've already debugged inputs.
+
+  (let* ((oldc (when (class-p cname) (class-v cname)))
+         (newc (make-vector eieio--class-num-slots nil))
+         )
+    (if oldc
+        nil ;; Do nothing if we already have this class.
+
+      ;; Create the class in NEWC, but don't fill anything else in.
+      (aset newc 0 'defclass)
+      (setf (eieio--class-symbol newc) cname)
+
+      (let ((clear-parent nil))
+        ;; No parents?
+        (when (not superclasses)
+          (setq superclasses '(eieio-default-superclass)
+                clear-parent t)
+          )
+
+        ;; Hook our new class into the existing structures so we can
+        ;; autoload it later.
+        (dolist (SC superclasses)
+
+
+          ;; TODO - If we create an autoload that is in the map, that
+          ;;        map needs to be cleared!
+
+
+          ;; Does our parent exist?
+          (if (not (class-p SC))
+
+              ;; Create a symbol for this parent, and then store this
+              ;; parent on that symbol.
+              (let ((sym (intern (symbol-name SC) eieio-defclass-autoload-map)))
+                (if (not (boundp sym))
+                    (set sym (list cname))
+                  (add-to-list sym cname))
+                )
+
+            ;; We have a parent, save the child in there.
+            (when (not (member cname (eieio--class-children (class-v SC))))
+              (setf (eieio--class-children (class-v SC))
+                    (cons cname (eieio--class-children (class-v SC))))))
+
+          ;; save parent in child
+          (setf (eieio--class-parent newc) (cons SC (eieio--class-parent newc)))
+          )
+
+        ;; turn this into a usable self-pointing symbol
+        (set cname cname)
+
+        ;; Store the new class vector definition into the symbol.  We need to
+        ;; do this first so that we can call defmethod for the accessor.
+        ;; The vector will be updated by the following while loop and will not
+        ;; need to be stored a second time.
+        (put cname 'eieio-class-definition newc)
+
+        ;; Clear the parent
+        (if clear-parent (setf (eieio--class-parent newc) nil))
+
+        ;; Create an autoload on top of our constructor function.
+        (autoload cname filename doc nil nil)
+        (autoload (intern (concat (symbol-name cname) "-p")) filename "" nil nil)
+        (autoload (intern (concat (symbol-name cname) "-child-p")) filename "" nil nil)
+        (autoload (intern (concat (symbol-name cname) "-list-p")) filename "" nil nil)
+
+        ))))
+
+(defsubst eieio-class-un-autoload (cname)
+  "If class CNAME is in an autoload state, load its file."
+  (when (eq (car-safe (symbol-function cname)) 'autoload)
+    (load-library (car (cdr (symbol-function cname))))))
+
+(defun eieio-defclass (cname superclasses slots options-and-doc)
+  ;; FIXME: Most of this should be moved to the `defclass' macro.
+  "Define CNAME as a new subclass of SUPERCLASSES.
+SLOTS are the slots residing in that class definition, and options or
+documentation OPTIONS-AND-DOC is the toplevel documentation for this class.
+See `defclass' for more information."
+  ;; Run our eieio-hook each time, and clear it when we are done.
+  ;; This way people can add hooks safely if they want to modify eieio
+  ;; or add definitions when eieio is loaded or something like that.
+  (run-hooks 'eieio-hook)
+  (setq eieio-hook nil)
+
+  (eieio--check-type listp superclasses)
+
+  (let* ((pname superclasses)
+         (newc (make-vector eieio--class-num-slots nil))
+         (oldc (when (class-p cname) (class-v cname)))
+         (groups nil) ;; list of groups id'd from slots
+         (options nil)
+         (clearparent nil))
+
+    (aset newc 0 'defclass)
+    (setf (eieio--class-symbol newc) cname)
+
+    ;; If this class already existed, and we are updating its structure,
+    ;; make sure we keep the old child list.  This can cause bugs, but
+    ;; if no new slots are created, it also saves time, and prevents
+    ;; method table breakage, particularly when the users is only
+    ;; byte compiling an EIEIO file.
+    (if oldc
+        (setf (eieio--class-children newc) (eieio--class-children oldc))
+      ;; If the old class did not exist, but did exist in the autoload map, then adopt those children.
+      ;; This is like the above, but deals with autoloads nicely.
+      (let ((sym (intern-soft (symbol-name cname) eieio-defclass-autoload-map)))
+        (when sym
+          (condition-case nil
+              (setf (eieio--class-children newc) (symbol-value sym))
+            (error nil))
+          (unintern (symbol-name cname) eieio-defclass-autoload-map)
+          ))
+      )
+
+    (cond ((and (stringp (car options-and-doc))
+                (/= 1 (% (length options-and-doc) 2)))
+           (error "Too many arguments to `defclass'"))
+          ((and (symbolp (car options-and-doc))
+                (/= 0 (% (length options-and-doc) 2)))
+           (error "Too many arguments to `defclass'"))
+          )
+
+    (setq options
+          (if (stringp (car options-and-doc))
+              (cons :documentation options-and-doc)
+            options-and-doc))
+
+    (if pname
+        (progn
+          (while pname
+            (if (and (car pname) (symbolp (car pname)))
+                (if (not (class-p (car pname)))
+                    ;; bad class
+                    (error "Given parent class %s is not a class" (car pname))
+                  ;; good parent class...
+                  ;; save new child in parent
+                  (when (not (member cname (eieio--class-children (class-v (car pname)))))
+                    (setf (eieio--class-children (class-v (car pname)))
+                          (cons cname (eieio--class-children (class-v (car pname))))))
+                  ;; Get custom groups, and store them into our local copy.
+                  (mapc (lambda (g) (pushnew g groups :test #'equal))
+                        (class-option (car pname) :custom-groups))
+                  ;; save parent in child
+                  (setf (eieio--class-parent newc) (cons (car pname) (eieio--class-parent newc))))
+              (error "Invalid parent class %s" pname))
+            (setq pname (cdr pname)))
+          ;; Reverse the list of our parents so that they are prioritized in
+          ;; the same order as specified in the code.
+          (setf (eieio--class-parent newc) (nreverse (eieio--class-parent newc))) )
+      ;; If there is nothing to loop over, then inherit from the
+      ;; default superclass.
+      (unless (eq cname 'eieio-default-superclass)
+        ;; adopt the default parent here, but clear it later...
+        (setq clearparent t)
+        ;; save new child in parent
+        (if (not (member cname (eieio--class-children (class-v 'eieio-default-superclass))))
+            (setf (eieio--class-children (class-v 'eieio-default-superclass))
+                  (cons cname (eieio--class-children (class-v 'eieio-default-superclass)))))
+        ;; save parent in child
+        (setf (eieio--class-parent newc) (list eieio-default-superclass))))
+
+    ;; turn this into a usable self-pointing symbol
+    (set cname cname)
+
+    ;; These two tests must be created right away so we can have self-
+    ;; referencing classes.  ei, a class whose slot can contain only
+    ;; pointers to itself.
+
+    ;; Create the test function
+    (let ((csym (intern (concat (symbol-name cname) "-p"))))
+      (fset csym
+            (list 'lambda (list 'obj)
+                  (format "Test OBJ to see if it an object of type %s" cname)
+                  (list 'and '(eieio-object-p obj)
+                        (list 'same-class-p 'obj cname)))))
+
+    ;; Make sure the method invocation order  is a valid value.
+    (let ((io (class-option-assoc options :method-invocation-order)))
+      (when (and io (not (member io '(:depth-first :breadth-first :c3))))
+        (error "Method invocation order %s is not allowed" io)
+        ))
+
+    ;; Create a handy child test too
+    (let ((csym (intern (concat (symbol-name cname) "-child-p"))))
+      (fset csym
+            `(lambda (obj)
+               ,(format
+                  "Test OBJ to see if it an object is a child of type %s"
+                  cname)
+               (and (eieio-object-p obj)
+                    (object-of-class-p obj ,cname))))
+
+    ;; Create a handy list of the class test too
+    (let ((csym (intern (concat (symbol-name cname) "-list-p"))))
+      (fset csym
+            `(lambda (obj)
+               ,(format
+                  "Test OBJ to see if it a list of objects which are a child of type %s"
+                  cname)
+               (when (listp obj)
+                 (let ((ans t)) ;; nil is valid
+                   ;; Loop over all the elements of the input list, test
+                   ;; each to make sure it is a child of the desired object class.
+                   (while (and obj ans)
+                     (setq ans (and (eieio-object-p (car obj))
+                                    (object-of-class-p (car obj) ,cname)))
+                     (setq obj (cdr obj)))
+                   ans)))))
+
+      ;; When using typep, (typep OBJ 'myclass) returns t for objects which
+      ;; are subclasses of myclass.  For our predicates, however, it is
+      ;; important for EIEIO to be backwards compatible, where
+      ;; myobject-p, and myobject-child-p are different.
+      ;; "cl" uses this technique to specify symbols with specific typep
+      ;; test, so we can let typep have the CLOS documented behavior
+      ;; while keeping our above predicate clean.
+
+      ;; It would be cleaner to use `defsetf' here, but that requires cl
+      ;; at runtime.
+      (put cname 'cl-deftype-handler
+           (list 'lambda () `(list 'satisfies (quote ,csym)))))
+
+    ;; Before adding new slots, let's add all the methods and classes
+    ;; in from the parent class.
+    (eieio-copy-parents-into-subclass newc superclasses)
+
+    ;; Store the new class vector definition into the symbol.  We need to
+    ;; do this first so that we can call defmethod for the accessor.
+    ;; The vector will be updated by the following while loop and will not
+    ;; need to be stored a second time.
+    (put cname 'eieio-class-definition newc)
+
+    ;; Query each slot in the declaration list and mangle into the
+    ;; class structure I have defined.
+    (while slots
+      (let* ((slot1  (car slots))
+             (name    (car slot1))
+             (slot   (cdr slot1))
+             (acces   (plist-get slot ':accessor))
+             (init    (or (plist-get slot ':initform)
+                          (if (member ':initform slot) nil
+                            eieio-unbound)))
+             (initarg (plist-get slot ':initarg))
+             (docstr  (plist-get slot ':documentation))
+             (prot    (plist-get slot ':protection))
+             (reader  (plist-get slot ':reader))
+             (writer  (plist-get slot ':writer))
+             (alloc   (plist-get slot ':allocation))
+             (type    (plist-get slot ':type))
+             (custom  (plist-get slot ':custom))
+             (label   (plist-get slot ':label))
+             (customg (plist-get slot ':group))
+             (printer (plist-get slot ':printer))
+
+             (skip-nil (class-option-assoc options :allow-nil-initform))
+             )
+
+        (if eieio-error-unsupported-class-tags
+            (let ((tmp slot))
+              (while tmp
+                (if (not (member (car tmp) '(:accessor
+                                             :initform
+                                             :initarg
+                                             :documentation
+                                             :protection
+                                             :reader
+                                             :writer
+                                             :allocation
+                                             :type
+                                             :custom
+                                             :label
+                                             :group
+                                             :printer
+                                             :allow-nil-initform
+                                             :custom-groups)))
+                    (signal 'invalid-slot-type (list (car tmp))))
+                (setq tmp (cdr (cdr tmp))))))
+
+        ;; Clean up the meaning of protection.
+        (cond ((or (eq prot 'public) (eq prot :public)) (setq prot nil))
+              ((or (eq prot 'protected) (eq prot :protected)) (setq prot 'protected))
+              ((or (eq prot 'private) (eq prot :private)) (setq prot 'private))
+              ((eq prot nil) nil)
+              (t (signal 'invalid-slot-type (list ':protection prot))))
+
+        ;; Make sure the :allocation parameter has a valid value.
+        (if (not (or (not alloc) (eq alloc :class) (eq alloc :instance)))
+            (signal 'invalid-slot-type (list ':allocation alloc)))
+
+        ;; The default type specifier is supposed to be t, meaning anything.
+        (if (not type) (setq type t))
+
+        ;; Label is nil, or a string
+        (if (not (or (null label) (stringp label)))
+            (signal 'invalid-slot-type (list ':label label)))
+
+        ;; Is there an initarg, but allocation of class?
+        (if (and initarg (eq alloc :class))
+            (message "Class allocated slots do not need :initarg"))
+
+        ;; intern the symbol so we can use it blankly
+        (if initarg (set initarg initarg))
+
+        ;; The customgroup should be a list of symbols
+        (cond ((null customg)
+               (setq customg '(default)))
+              ((not (listp customg))
+               (setq customg (list customg))))
+        ;; The customgroup better be a symbol, or list of symbols.
+        (mapc (lambda (cg)
+                (if (not (symbolp cg))
+                    (signal 'invalid-slot-type (list ':group cg))))
+                customg)
+
+        ;; First up, add this slot into our new class.
+        (eieio-add-new-slot newc name init docstr type custom label customg printer
+                             prot initarg alloc 'defaultoverride skip-nil)
+
+        ;; We need to id the group, and store them in a group list attribute.
+        (mapc (lambda (cg) (pushnew cg groups :test 'equal)) customg)
+
+        ;; Anyone can have an accessor function.  This creates a function
+        ;; of the specified name, and also performs a `defsetf' if applicable
+        ;; so that users can `setf' the space returned by this function.
+        (if acces
+            (progn
+              (eieio--defmethod
+               acces (if (eq alloc :class) :static :primary) cname
+               `(lambda (this)
+                  ,(format
+                       "Retrieves the slot `%s' from an object of class `%s'"
+                       name cname)
+                  (if (slot-boundp this ',name)
+                      (eieio-oref this ',name)
+                            ;; Else - Some error?  nil?
+                            nil)))
+
+              (if (fboundp 'gv-define-setter)
+                  ;; FIXME: We should move more of eieio-defclass into the
+                  ;; defclass macro so we don't have to use `eval' and require
+                  ;; `gv' at run-time.
+                  (eval `(gv-define-setter ,acces (eieio--store eieio--object)
+                           (list 'eieio-oset eieio--object '',name
+                                 eieio--store)))
+                ;; Provide a setf method.  It would be cleaner to use
+                ;; defsetf, but that would require CL at runtime.
+                (put acces 'setf-method
+                     `(lambda (widget)
+                        (let* ((--widget-sym-- (make-symbol "--widget--"))
+                               (--store-sym-- (make-symbol "--store--")))
+                          (list
+                           (list --widget-sym--)
+                           (list widget)
+                           (list --store-sym--)
+                           (list 'eieio-oset --widget-sym-- '',name
+                                 --store-sym--)
+                           (list 'getfoo --widget-sym--))))))))
+
+        ;; If a writer is defined, then create a generic method of that
+        ;; name whose purpose is to set the value of the slot.
+        (if writer
+            (eieio--defmethod
+             writer nil cname
+             `(lambda (this value)
+                ,(format "Set the slot `%s' of an object of class `%s'"
+                              name cname)
+                (setf (slot-value this ',name) value))))
+        ;; If a reader is defined, then create a generic method
+        ;; of that name whose purpose is to access this slot value.
+        (if reader
+            (eieio--defmethod
+             reader nil cname
+             `(lambda (this)
+                ,(format "Access the slot `%s' from object of class `%s'"
+                              name cname)
+                (slot-value this ',name))))
+        )
+      (setq slots (cdr slots)))
+
+    ;; Now that everything has been loaded up, all our lists are backwards!
+    ;; Fix that up now.
+    (setf (eieio--class-public-a newc) (nreverse (eieio--class-public-a newc)))
+    (setf (eieio--class-public-d newc) (nreverse (eieio--class-public-d newc)))
+    (setf (eieio--class-public-doc newc) (nreverse (eieio--class-public-doc newc)))
+    (setf (eieio--class-public-type newc)
+          (apply 'vector (nreverse (eieio--class-public-type newc))))
+    (setf (eieio--class-public-custom newc) (nreverse (eieio--class-public-custom newc)))
+    (setf (eieio--class-public-custom-label newc) (nreverse (eieio--class-public-custom-label newc)))
+    (setf (eieio--class-public-custom-group newc) (nreverse (eieio--class-public-custom-group newc)))
+    (setf (eieio--class-public-printer newc) (nreverse (eieio--class-public-printer newc)))
+    (setf (eieio--class-protection newc) (nreverse (eieio--class-protection newc)))
+    (setf (eieio--class-initarg-tuples newc) (nreverse (eieio--class-initarg-tuples newc)))
+
+    ;; The storage for class-class-allocation-type needs to be turned into
+    ;; a vector now.
+    (setf (eieio--class-class-allocation-type newc)
+          (apply 'vector (eieio--class-class-allocation-type newc)))
+
+    ;; Also, take class allocated values, and vectorize them for speed.
+    (setf (eieio--class-class-allocation-values newc)
+          (apply 'vector (eieio--class-class-allocation-values newc)))
+
+    ;; Attach slot symbols into an obarray, and store the index of
+    ;; this slot as the variable slot in this new symbol.  We need to
+    ;; know about primes, because obarrays are best set in vectors of
+    ;; prime number length, and we also need to make our vector small
+    ;; to save space, and also optimal for the number of items we have.
+    (let* ((cnt 0)
+           (pubsyms (eieio--class-public-a newc))
+           (prots (eieio--class-protection newc))
+           (l (length pubsyms))
+           (vl (let ((primes '( 3 5 7 11 13 17 19 23 29 31 37 41 43 47
+                                  53 59 61 67 71 73 79 83 89 97 101 )))
+                 (while (and primes (< (car primes) l))
+                   (setq primes (cdr primes)))
+                 (car primes)))
+           (oa (make-vector vl 0))
+           (newsym))
+      (while pubsyms
+        (setq newsym (intern (symbol-name (car pubsyms)) oa))
+        (set newsym cnt)
+        (setq cnt (1+ cnt))
+        (if (car prots) (put newsym 'protection (car prots)))
+        (setq pubsyms (cdr pubsyms)
+              prots (cdr prots)))
+      (setf (eieio--class-symbol-obarray newc) oa)
+      )
+
+    ;; Create the constructor function
+    (if (class-option-assoc options :abstract)
+        ;; Abstract classes cannot be instantiated.  Say so.
+        (let ((abs (class-option-assoc options :abstract)))
+          (if (not (stringp abs))
+              (setq abs (format "Class %s is abstract" cname)))
+          (fset cname
+                `(lambda (&rest stuff)
+                   ,(format "You cannot create a new object of type %s" cname)
+                   (error ,abs))))
+
+      ;; Non-abstract classes need a constructor.
+      (fset cname
+            `(lambda (newname &rest slots)
+               ,(format "Create a new object with name NAME of class type %s" cname)
+               (apply 'constructor ,cname newname slots)))
+      )
+
+    ;; Set up a specialized doc string.
+    ;; Use stored value since it is calculated in a non-trivial way
+    (put cname 'variable-documentation
+         (class-option-assoc options :documentation))
+
+    ;; Save the file location where this class is defined.
+    (let ((fname (if load-in-progress
+                     load-file-name
+                   buffer-file-name)))
+      (when fname
+        (when (string-match "\\.elc\\'" fname)
+          (setq fname (substring fname 0 (1- (length fname)))))
+        (put cname 'class-location fname)))
+
+    ;; We have a list of custom groups.  Store them into the options.
+    (let ((g (class-option-assoc options :custom-groups)))
+      (mapc (lambda (cg) (pushnew cg g :test 'equal)) groups)
+      (if (memq :custom-groups options)
+          (setcar (cdr (memq :custom-groups options)) g)
+        (setq options (cons :custom-groups (cons g options)))))
+
+    ;; Set up the options we have collected.
+    (setf (eieio--class-options newc) options)
+
+    ;; if this is a superclass, clear out parent (which was set to the
+    ;; default superclass eieio-default-superclass)
+    (if clearparent (setf (eieio--class-parent newc) nil))
+
+    ;; Create the cached default object.
+    (let ((cache (make-vector (+ (length (eieio--class-public-a newc)) 3)
+                              nil)))
+      (aset cache 0 'object)
+      (setf (eieio--object-class cache) cname)
+      (setf (eieio--object-name cache) 'default-cache-object)
+      (let ((eieio-skip-typecheck t))
+        ;; All type-checking has been done to our satisfaction
+        ;; before this call.  Don't waste our time in this call..
+        (eieio-set-defaults cache t))
+      (setf (eieio--class-default-object-cache newc) cache))
+
+    ;; Return our new class object
+    ;; newc
+    cname
+    ))
+
+(defsubst eieio-eval-default-p (val)
+  "Whether the default value VAL should be evaluated for use."
+  (and (consp val) (symbolp (car val)) (fboundp (car val))))
+
+(defun eieio-perform-slot-validation-for-default (slot spec value skipnil)
+  "For SLOT, signal if SPEC does not match VALUE.
+If SKIPNIL is non-nil, then if VALUE is nil return t instead."
+  (if (and (not (eieio-eval-default-p value))
+           (not eieio-skip-typecheck)
+           (not (and skipnil (null value)))
+           (not (eieio-perform-slot-validation spec value)))
+      (signal 'invalid-slot-type (list slot spec value))))
+
+(defun eieio-add-new-slot (newc a d doc type cust label custg print prot init alloc
+                                 &optional defaultoverride skipnil)
+  "Add into NEWC attribute A.
+If A already exists in NEWC, then do nothing.  If it doesn't exist,
+then also add in D (default), DOC, TYPE, CUST, LABEL, CUSTG, PRINT, PROT, and INIT arg.
+Argument ALLOC specifies if the slot is allocated per instance, or per class.
+If optional DEFAULTOVERRIDE is non-nil, then if A exists in NEWC,
+we must override its value for a default.
+Optional argument SKIPNIL indicates if type checking should be skipped
+if default value is nil."
+  ;; Make sure we duplicate those items that are sequences.
+  (condition-case nil
+      (if (sequencep d) (setq d (copy-sequence d)))
+    ;; This copy can fail on a cons cell with a non-cons in the cdr.  Let's skip it if it doesn't work.
+    (error nil))
+  (if (sequencep type) (setq type (copy-sequence type)))
+  (if (sequencep cust) (setq cust (copy-sequence cust)))
+  (if (sequencep custg) (setq custg (copy-sequence custg)))
+
+  ;; To prevent override information w/out specification of storage,
+  ;; we need to do this little hack.
+  (if (member a (eieio--class-class-allocation-a newc)) (setq alloc ':class))
+
+  (if (or (not alloc) (and (symbolp alloc) (eq alloc ':instance)))
+      ;; In this case, we modify the INSTANCE version of a given slot.
+
+      (progn
+
+        ;; Only add this element if it is so-far unique
+        (if (not (member a (eieio--class-public-a newc)))
+            (progn
+              (eieio-perform-slot-validation-for-default a type d skipnil)
+              (setf (eieio--class-public-a newc) (cons a (eieio--class-public-a newc)))
+              (setf (eieio--class-public-d newc) (cons d (eieio--class-public-d newc)))
+              (setf (eieio--class-public-doc newc) (cons doc (eieio--class-public-doc newc)))
+              (setf (eieio--class-public-type newc) (cons type (eieio--class-public-type newc)))
+              (setf (eieio--class-public-custom newc) (cons cust (eieio--class-public-custom newc)))
+              (setf (eieio--class-public-custom-label newc) (cons label (eieio--class-public-custom-label newc)))
+              (setf (eieio--class-public-custom-group newc) (cons custg (eieio--class-public-custom-group newc)))
+              (setf (eieio--class-public-printer newc) (cons print (eieio--class-public-printer newc)))
+              (setf (eieio--class-protection newc) (cons prot (eieio--class-protection newc)))
+              (setf (eieio--class-initarg-tuples newc) (cons (cons init a) (eieio--class-initarg-tuples newc)))
+              )
+          ;; When defaultoverride is true, we are usually adding new local
+          ;; attributes which must override the default value of any slot
+          ;; passed in by one of the parent classes.
+          (when defaultoverride
+            ;; There is a match, and we must override the old value.
+            (let* ((ca (eieio--class-public-a newc))
+                   (np (member a ca))
+                   (num (- (length ca) (length np)))
+                   (dp (if np (nthcdr num (eieio--class-public-d newc))
+                         nil))
+                   (tp (if np (nth num (eieio--class-public-type newc))))
+                   )
+              (if (not np)
+                  (error "EIEIO internal error overriding default value for %s"
+                         a)
+                ;; If type is passed in, is it the same?
+                (if (not (eq type t))
+                    (if (not (equal type tp))
+                        (error
+                         "Child slot type `%s' does not match inherited type `%s' for `%s'"
+                         type tp a)))
+                ;; If we have a repeat, only update the initarg...
+                (unless (eq d eieio-unbound)
+                  (eieio-perform-slot-validation-for-default a tp d skipnil)
+                  (setcar dp d))
+                ;; If we have a new initarg, check for it.
+                (when init
+                  (let* ((inits (eieio--class-initarg-tuples newc))
+                         (inita (rassq a inits)))
+                    ;; Replace the CAR of the associate INITA.
+                    ;;(message "Initarg: %S replace %s" inita init)
+                    (setcar inita init)
+                    ))
+
+                ;; PLN Tue Jun 26 11:57:06 2007 : The protection is
+                ;; checked and SHOULD match the superclass
+                ;; protection. Otherwise an error is thrown. However
+                ;; I wonder if a more flexible schedule might be
+                ;; implemented.
+                ;;
+                ;; EML - We used to have (if prot... here,
+                ;;       but a prot of 'nil means public.
+                ;;
+                (let ((super-prot (nth num (eieio--class-protection newc)))
+                      )
+                  (if (not (eq prot super-prot))
+                      (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
+                             prot super-prot a)))
+                ;; End original PLN
+
+                ;; PLN Tue Jun 26 11:57:06 2007 :
+                ;; Do a non redundant combination of ancient custom
+                ;; groups and new ones.
+                (when custg
+                  (let* ((groups
+                          (nthcdr num (eieio--class-public-custom-group newc)))
+                         (list1 (car groups))
+                         (list2 (if (listp custg) custg (list custg))))
+                    (if (< (length list1) (length list2))
+                        (setq list1 (prog1 list2 (setq list2 list1))))
+                    (dolist (elt list2)
+                      (unless (memq elt list1)
+                        (push elt list1)))
+                    (setcar groups list1)))
+                ;;  End PLN
+
+                ;;  PLN Mon Jun 25 22:44:34 2007 : If a new cust is
+                ;;  set, simply replaces the old one.
+                (when cust
+                  ;; (message "Custom type redefined to %s" cust)
+                  (setcar (nthcdr num (eieio--class-public-custom newc)) cust))
+
+                ;; If a new label is specified, it simply replaces
+                ;; the old one.
+                (when label
+                  ;; (message "Custom label redefined to %s" label)
+                  (setcar (nthcdr num (eieio--class-public-custom-label newc)) label))
+                ;;  End PLN
+
+                ;; PLN Sat Jun 30 17:24:42 2007 : when a new
+                ;; doc is specified, simply replaces the old one.
+                (when doc
+                  ;;(message "Documentation redefined to %s" doc)
+                  (setcar (nthcdr num (eieio--class-public-doc newc))
+                          doc))
+                ;; End PLN
+
+                ;; If a new printer is specified, it simply replaces
+                ;; the old one.
+                (when print
+                  ;; (message "printer redefined to %s" print)
+                  (setcar (nthcdr num (eieio--class-public-printer newc)) print))
+
+                )))
+          ))
+
+    ;; CLASS ALLOCATED SLOTS
+    (let ((value (eieio-default-eval-maybe d)))
+      (if (not (member a (eieio--class-class-allocation-a newc)))
+          (progn
+            (eieio-perform-slot-validation-for-default a type value skipnil)
+            ;; Here we have found a :class version of a slot.  This
+            ;; requires a very different approach.
+            (setf (eieio--class-class-allocation-a newc) (cons a (eieio--class-class-allocation-a newc)))
+            (setf (eieio--class-class-allocation-doc newc) (cons doc (eieio--class-class-allocation-doc newc)))
+            (setf (eieio--class-class-allocation-type newc) (cons type (eieio--class-class-allocation-type newc)))
+            (setf (eieio--class-class-allocation-custom newc) (cons cust (eieio--class-class-allocation-custom newc)))
+            (setf (eieio--class-class-allocation-custom-label newc) (cons label (eieio--class-class-allocation-custom-label newc)))
+            (setf (eieio--class-class-allocation-custom-group newc) (cons custg (eieio--class-class-allocation-custom-group newc)))
+            (setf (eieio--class-class-allocation-protection newc) (cons prot (eieio--class-class-allocation-protection newc)))
+            ;; Default value is stored in the 'values section, since new objects
+            ;; can't initialize from this element.
+            (setf (eieio--class-class-allocation-values newc) (cons value (eieio--class-class-allocation-values newc))))
+        (when defaultoverride
+          ;; There is a match, and we must override the old value.
+          (let* ((ca (eieio--class-class-allocation-a newc))
+                 (np (member a ca))
+                 (num (- (length ca) (length np)))
+                 (dp (if np
+                         (nthcdr num
+                                 (eieio--class-class-allocation-values newc))
+                       nil))
+                 (tp (if np (nth num (eieio--class-class-allocation-type newc))
+                       nil)))
+            (if (not np)
+                (error "EIEIO internal error overriding default value for %s"
+                       a)
+              ;; If type is passed in, is it the same?
+              (if (not (eq type t))
+                  (if (not (equal type tp))
+                      (error
+                       "Child slot type `%s' does not match inherited type `%s' for `%s'"
+                       type tp a)))
+              ;; EML - Note: the only reason to override a class bound slot
+              ;;       is to change the default, so allow unbound in.
+
+              ;; If we have a repeat, only update the value...
+              (eieio-perform-slot-validation-for-default a tp value skipnil)
+              (setcar dp value))
+
+            ;; PLN Tue Jun 26 11:57:06 2007 : The protection is
+            ;; checked and SHOULD match the superclass
+            ;; protection. Otherwise an error is thrown. However
+            ;; I wonder if a more flexible schedule might be
+            ;; implemented.
+            (let ((super-prot
+                   (car (nthcdr num (eieio--class-class-allocation-protection newc)))))
+              (if (not (eq prot super-prot))
+                  (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
+                         prot super-prot a)))
+            ;; Do a non redundant combination of ancient custom groups
+            ;; and new ones.
+            (when custg
+              (let* ((groups
+                      (nthcdr num (eieio--class-class-allocation-custom-group newc)))
+                     (list1 (car groups))
+                     (list2 (if (listp custg) custg (list custg))))
+                (if (< (length list1) (length list2))
+                    (setq list1 (prog1 list2 (setq list2 list1))))
+                (dolist (elt list2)
+                  (unless (memq elt list1)
+                    (push elt list1)))
+                (setcar groups list1)))
+
+            ;; PLN Sat Jun 30 17:24:42 2007 : when a new
+            ;; doc is specified, simply replaces the old one.
+            (when doc
+              ;;(message "Documentation redefined to %s" doc)
+              (setcar (nthcdr num (eieio--class-class-allocation-doc newc))
+                      doc))
+            ;; End PLN
+
+            ;; If a new printer is specified, it simply replaces
+            ;; the old one.
+            (when print
+              ;; (message "printer redefined to %s" print)
+              (setcar (nthcdr num (eieio--class-class-allocation-printer newc)) print))
+
+            ))
+        ))
+    ))
+
+(defun eieio-copy-parents-into-subclass (newc parents)
+  "Copy into NEWC the slots of PARENTS.
+Follow the rules of not overwriting early parents when applying to
+the new child class."
+  (let ((ps (eieio--class-parent newc))
+        (sn (class-option-assoc (eieio--class-options newc)
+                                ':allow-nil-initform)))
+    (while ps
+      ;; First, duplicate all the slots of the parent.
+      (let ((pcv (class-v (car ps))))
+        (let ((pa (eieio--class-public-a pcv))
+              (pd (eieio--class-public-d pcv))
+              (pdoc (eieio--class-public-doc pcv))
+              (ptype (eieio--class-public-type pcv))
+              (pcust (eieio--class-public-custom pcv))
+              (plabel (eieio--class-public-custom-label pcv))
+              (pcustg (eieio--class-public-custom-group pcv))
+              (printer (eieio--class-public-printer pcv))
+              (pprot (eieio--class-protection pcv))
+              (pinit (eieio--class-initarg-tuples pcv))
+              (i 0))
+          (while pa
+            (eieio-add-new-slot newc
+                                 (car pa) (car pd) (car pdoc) (aref ptype i)
+                                 (car pcust) (car plabel) (car pcustg)
+                                 (car printer)
+                                 (car pprot) (car-safe (car pinit)) nil nil sn)
+            ;; Increment each value.
+            (setq pa (cdr pa)
+                  pd (cdr pd)
+                  pdoc (cdr pdoc)
+                  i (1+ i)
+                  pcust (cdr pcust)
+                  plabel (cdr plabel)
+                  pcustg (cdr pcustg)
+                  printer (cdr printer)
+                  pprot (cdr pprot)
+                  pinit (cdr pinit))
+            )) ;; while/let
+        ;; Now duplicate all the class alloc slots.
+        (let ((pa (eieio--class-class-allocation-a pcv))
+              (pdoc (eieio--class-class-allocation-doc pcv))
+              (ptype (eieio--class-class-allocation-type pcv))
+              (pcust (eieio--class-class-allocation-custom pcv))
+              (plabel (eieio--class-class-allocation-custom-label pcv))
+              (pcustg (eieio--class-class-allocation-custom-group pcv))
+              (printer (eieio--class-class-allocation-printer pcv))
+              (pprot (eieio--class-class-allocation-protection pcv))
+              (pval (eieio--class-class-allocation-values pcv))
+              (i 0))
+          (while pa
+            (eieio-add-new-slot newc
+                                 (car pa) (aref pval i) (car pdoc) (aref ptype i)
+                                 (car pcust) (car plabel) (car pcustg)
+                                 (car printer)
+                                 (car pprot) nil ':class sn)
+            ;; Increment each value.
+            (setq pa (cdr pa)
+                  pdoc (cdr pdoc)
+                  pcust (cdr pcust)
+                  plabel (cdr plabel)
+                  pcustg (cdr pcustg)
+                  printer (cdr printer)
+                  pprot (cdr pprot)
+                  i (1+ i))
+            ))) ;; while/let
+      ;; Loop over each parent class
+      (setq ps (cdr ps)))
+    ))
+
+
+;;; CLOS methods and generics
+;;
+
+(defun eieio--defgeneric-init-form (method doc-string)
+  "Form to use for the initial definition of a generic."
+  (cond
+   ((or (not (fboundp method))
+        (eq 'autoload (car-safe (symbol-function method))))
+    ;; Make sure the method tables are installed.
+    (eieiomt-install method)
+    ;; Construct the actual body of this function.
+    (eieio-defgeneric-form method doc-string))
+   ((generic-p method) (symbol-function method))           ;Leave it as-is.
+   (t (error "You cannot create a generic/method over an existing symbol: %s"
+             method))))
+
+(defun eieio-defgeneric-form (method doc-string)
+  "The lambda form that would be used as the function defined on METHOD.
+All methods should call the same EIEIO function for dispatch.
+DOC-STRING is the documentation attached to METHOD."
+  `(lambda (&rest local-args)
+     ,doc-string
+     (eieio-generic-call (quote ,method) local-args)))
+
+(defsubst eieio-defgeneric-reset-generic-form (method)
+  "Setup METHOD to call the generic form."
+  (let ((doc-string (documentation method)))
+    (fset method (eieio-defgeneric-form method doc-string))))
+
+(defun eieio-defgeneric-form-primary-only (method doc-string)
+  "The lambda form that would be used as the function defined on METHOD.
+All methods should call the same EIEIO function for dispatch.
+DOC-STRING is the documentation attached to METHOD."
+  `(lambda (&rest local-args)
+     ,doc-string
+     (eieio-generic-call-primary-only (quote ,method) local-args)))
+
+(defsubst eieio-defgeneric-reset-generic-form-primary-only (method)
+  "Setup METHOD to call the generic form."
+  (let ((doc-string (documentation method)))
+    (fset method (eieio-defgeneric-form-primary-only method doc-string))))
+
+(defun eieio-defgeneric-form-primary-only-one (method doc-string
+                                                      class
+                                                      impl
+                                                      )
+  "The lambda form that would be used as the function defined on METHOD.
+All methods should call the same EIEIO function for dispatch.
+DOC-STRING is the documentation attached to METHOD.
+CLASS is the class symbol needed for private method access.
+IMPL is the symbol holding the method implementation."
+  ;; NOTE: I tried out byte compiling this little fcn.  Turns out it
+  ;; is faster to execute this for not byte-compiled.  ie, install this,
+  ;; then measure calls going through here.  I wonder why.
+  (require 'bytecomp)
+  (let ((byte-compile-warnings nil))
+    (byte-compile
+     `(lambda (&rest local-args)
+        ,doc-string
+        ;; This is a cool cheat.  Usually we need to look up in the
+        ;; method table to find out if there is a method or not.  We can
+        ;; instead make that determination at load time when there is
+        ;; only one method.  If the first arg is not a child of the class
+        ;; of that one implementation, then clearly, there is no method def.
+        (if (not (eieio-object-p (car local-args)))
+            ;; Not an object.  Just signal.
+            (signal 'no-method-definition
+                    (list ',method local-args))
+
+          ;; We do have an object.  Make sure it is the right type.
+          (if ,(if (eq class eieio-default-superclass)
+                   nil  ; default superclass means just an obj.  Already asked.
+                 `(not (child-of-class-p (eieio--object-class (car local-args))
+                                         ',class)))
+
+              ;; If not the right kind of object, call no applicable
+              (apply 'no-applicable-method (car local-args)
+                     ',method local-args)
+
+            ;; It is ok, do the call.
+            ;; Fill in inter-call variables then evaluate the method.
+            (let ((eieio-generic-call-next-method-list nil)
+                  (eieio-generic-call-key method-primary)
+                  (eieio-generic-call-methodname ',method)
+                  (eieio-generic-call-arglst local-args)
+                  )
+              (eieio--with-scoped-class ',class
+                ,(if (< emacs-major-version 24)
+                     `(apply ,(list 'quote impl) local-args)
+                   `(apply #',impl local-args)))
+              ;(,impl local-args)
+              )))))))
+
+(defsubst eieio-defgeneric-reset-generic-form-primary-only-one (method)
+  "Setup METHOD to call the generic form."
+  (let* ((doc-string (documentation method))
+         (M (get method 'eieio-method-tree))
+         (entry (car (aref M method-primary)))
+         )
+    (fset method (eieio-defgeneric-form-primary-only-one
+                  method doc-string
+                  (car entry)
+                  (cdr entry)
+                  ))))
+
+(defun eieio-unbind-method-implementations (method)
+  "Make the generic method METHOD have no implementations.
+It will leave the original generic function in place,
+but remove reference to all implementations of METHOD."
+  (put method 'eieio-method-tree nil)
+  (put method 'eieio-method-obarray nil))
+
+(defun eieio--defmethod (method kind argclass code)
+  "Work part of the `defmethod' macro defining METHOD with ARGS."
+  (let ((key
+         ;; Find optional keys.
+         (cond ((memq kind '(:BEFORE :before)) method-before)
+               ((memq kind '(:AFTER :after)) method-after)
+               ((memq kind '(:STATIC :static)) method-static)
+               ((memq kind '(:PRIMARY :primary nil)) method-primary)
+               ;; Primary key.
+               ;; (t method-primary)
+               (t (error "Unknown method kind %S" kind)))))
+    ;; Make sure there is a generic (when called from defclass).
+    (eieio--defalias
+     method (eieio--defgeneric-init-form
+             method (or (documentation code)
+                        (format "Generically created method `%s'." method))))
+    ;; Create symbol for property to bind to.  If the first arg is of
+    ;; the form (varname vartype) and `vartype' is a class, then
+    ;; that class will be the type symbol.  If not, then it will fall
+    ;; under the type `primary' which is a non-specific calling of the
+    ;; function.
+    (if argclass
+        (if (not (class-p argclass))
+            (error "Unknown class type %s in method parameters"
+                   argclass))
+      ;; Generics are higher.
+      (setq key (eieio-specialized-key-to-generic-key key)))
+    ;; Put this lambda into the symbol so we can find it.
+    (eieiomt-add method code key argclass)
+    )
+
+  (when eieio-optimize-primary-methods-flag
+    ;; Optimizing step:
+    ;;
+    ;; If this method, after this setup, only has primary methods, then
+    ;; we can setup the generic that way.
+    (if (generic-primary-only-p method)
+        ;; If there is only one primary method, then we can go one more
+        ;; optimization step.
+        (if (generic-primary-only-one-p method)
+            (eieio-defgeneric-reset-generic-form-primary-only-one method)
+          (eieio-defgeneric-reset-generic-form-primary-only method))
+      (eieio-defgeneric-reset-generic-form method)))
+
+  method)
+
+;;; Slot type validation
+
+;; This is a hideous hack for replacing `typep' from cl-macs, to avoid
+;; requiring the CL library at run-time.  It can be eliminated if/when
+;; `typep' is merged into Emacs core.
+(defun eieio--typep (val type)
+  (if (symbolp type)
+      (cond ((get type 'cl-deftype-handler)
+             (eieio--typep val (funcall (get type 'cl-deftype-handler))))
+            ((eq type t) t)
+            ((eq type 'null)   (null val))
+            ((eq type 'atom)   (atom val))
+            ((eq type 'float)  (and (numberp val) (not (integerp val))))
+            ((eq type 'real)   (numberp val))
+            ((eq type 'fixnum) (integerp val))
+            ((memq type '(character string-char)) (characterp val))
+            (t
+             (let* ((name (symbol-name type))
+                    (namep (intern (concat name "p"))))
+               (if (fboundp namep)
+                   (funcall `(lambda () (,namep val)))
+                 (funcall `(lambda ()
+                             (,(intern (concat name "-p")) val)))))))
+    (cond ((get (car type) 'cl-deftype-handler)
+           (eieio--typep val (apply (get (car type) 'cl-deftype-handler)
+                                    (cdr type))))
+          ((memq (car type) '(integer float real number))
+           (and (eieio--typep val (car type))
+                (or (memq (cadr type) '(* nil))
+                    (if (consp (cadr type))
+                        (> val (car (cadr type)))
+                      (>= val (cadr type))))
+                (or (memq (caddr type) '(* nil))
+                    (if (consp (car (cddr type)))
+                        (< val (caar (cddr type)))
+                      (<= val (car (cddr type)))))))
+          ((memq (car type) '(and or not))
+           (eval (cons (car type)
+                       (mapcar (lambda (x)
+                                 `(eieio--typep (quote ,val) (quote ,x)))
+                               (cdr type)))))
+          ((memq (car type) '(member member*))
+           (memql val (cdr type)))
+          ((eq (car type) 'satisfies)
+           (funcall `(lambda () (,(cadr type) val))))
+          (t (error "Bad type spec: %s" type)))))
+
+(defun eieio-perform-slot-validation (spec value)
+  "Return non-nil if SPEC does not match VALUE."
+  (or (eq spec t)                       ; t always passes
+      (eq value eieio-unbound)          ; unbound always passes
+      (eieio--typep value spec)))
+
+(defun eieio-validate-slot-value (class slot-idx value slot)
+  "Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
+Checks the :type specifier.
+SLOT is the slot that is being checked, and is only used when throwing
+an error."
+  (if eieio-skip-typecheck
+      nil
+    ;; Trim off object IDX junk added in for the object index.
+    (setq slot-idx (- slot-idx 3))
+    (let ((st (aref (eieio--class-public-type (class-v class)) slot-idx)))
+      (if (not (eieio-perform-slot-validation st value))
+          (signal 'invalid-slot-type (list class slot st value))))))
+
+(defun eieio-validate-class-slot-value (class slot-idx value slot)
+  "Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
+Checks the :type specifier.
+SLOT is the slot that is being checked, and is only used when throwing
+an error."
+  (if eieio-skip-typecheck
+      nil
+    (let ((st (aref (eieio--class-class-allocation-type (class-v class))
+                    slot-idx)))
+      (if (not (eieio-perform-slot-validation st value))
+          (signal 'invalid-slot-type (list class slot st value))))))
+
+(defun eieio-barf-if-slot-unbound (value instance slotname fn)
+  "Throw a signal if VALUE is a representation of an UNBOUND slot.
+INSTANCE is the object being referenced.  SLOTNAME is the offending
+slot.  If the slot is ok, return VALUE.
+Argument FN is the function calling this verifier."
+  (if (and (eq value eieio-unbound) (not eieio-skip-typecheck))
+      (slot-unbound instance (eieio--object-class instance) slotname fn)
+    value))
+
+
+;;; Get/Set slots in an object.
+;;
+(defun eieio-oref (obj slot)
+  "Return the value in OBJ at SLOT in the object vector."
+  (eieio--check-type (or eieio-object-p class-p) obj)
+  (eieio--check-type symbolp slot)
+  (if (class-p obj) (eieio-class-un-autoload obj))
+  (let* ((class (if (class-p obj) obj (eieio--object-class obj)))
+         (c (eieio-slot-name-index class obj slot)))
+    (if (not c)
+        ;; It might be missing because it is a :class allocated slot.
+        ;; Let's check that info out.
+        (if (setq c (eieio-class-slot-name-index class slot))
+            ;; Oref that slot.
+            (aref (eieio--class-class-allocation-values (class-v class)) c)
+          ;; The slot-missing method is a cool way of allowing an object author
+          ;; to intercept missing slot definitions.  Since it is also the LAST
+          ;; thing called in this fn, its return value would be retrieved.
+          (slot-missing obj slot 'oref)
+          ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
+          )
+      (eieio--check-type eieio-object-p obj)
+      (eieio-barf-if-slot-unbound (aref obj c) obj slot 'oref))))
+
+
+(defun eieio-oref-default (obj slot)
+  "Do the work for the macro `oref-default' with similar parameters.
+Fills in OBJ's SLOT with its default value."
+  (eieio--check-type (or eieio-object-p class-p) obj)
+  (eieio--check-type symbolp slot)
+  (let* ((cl (if (eieio-object-p obj) (eieio--object-class obj) obj))
+         (c (eieio-slot-name-index cl obj slot)))
+    (if (not c)
+        ;; It might be missing because it is a :class allocated slot.
+        ;; Let's check that info out.
+        (if (setq c
+                  (eieio-class-slot-name-index cl slot))
+            ;; Oref that slot.
+            (aref (eieio--class-class-allocation-values (class-v cl))
+                  c)
+          (slot-missing obj slot 'oref-default)
+          ;;(signal 'invalid-slot-name (list (class-name cl) slot))
+          )
+      (eieio-barf-if-slot-unbound
+       (let ((val (nth (- c 3) (eieio--class-public-d (class-v cl)))))
+         (eieio-default-eval-maybe val))
+       obj cl 'oref-default))))
+
+(defun eieio-default-eval-maybe (val)
+  "Check VAL, and return what `oref-default' would provide."
+  (cond
+   ;; Is it a function call?  If so, evaluate it.
+   ((eieio-eval-default-p val)
+    (eval val))
+   ;;;; check for quoted things, and unquote them
+   ;;((and (consp val) (eq (car val) 'quote))
+   ;; (car (cdr val)))
+   ;; return it verbatim
+   (t val)))
+
+(defun eieio-oset (obj slot value)
+  "Do the work for the macro `oset'.
+Fills in OBJ's SLOT with VALUE."
+  (eieio--check-type eieio-object-p obj)
+  (eieio--check-type symbolp slot)
+  (let ((c (eieio-slot-name-index (eieio--object-class obj) obj slot)))
+    (if (not c)
+        ;; It might be missing because it is a :class allocated slot.
+        ;; Let's check that info out.
+        (if (setq c
+                  (eieio-class-slot-name-index (eieio--object-class obj) slot))
+            ;; Oset that slot.
+            (progn
+              (eieio-validate-class-slot-value (eieio--object-class obj) c value slot)
+              (aset (eieio--class-class-allocation-values (class-v (eieio--object-class obj)))
+                    c value))
+          ;; See oref for comment on `slot-missing'
+          (slot-missing obj slot 'oset value)
+          ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
+          )
+      (eieio-validate-slot-value (eieio--object-class obj) c value slot)
+      (aset obj c value))))
+
+(defun eieio-oset-default (class slot value)
+  "Do the work for the macro `oset-default'.
+Fills in the default value in CLASS' in SLOT with VALUE."
+  (eieio--check-type class-p class)
+  (eieio--check-type symbolp slot)
+  (eieio--with-scoped-class class
+    (let* ((c (eieio-slot-name-index class nil slot)))
+      (if (not c)
+          ;; It might be missing because it is a :class allocated slot.
+          ;; Let's check that info out.
+          (if (setq c (eieio-class-slot-name-index class slot))
+              (progn
+                ;; Oref that slot.
+                (eieio-validate-class-slot-value class c value slot)
+                (aset (eieio--class-class-allocation-values (class-v class)) c
+                      value))
+            (signal 'invalid-slot-name (list (eieio-class-name class) slot)))
+        (eieio-validate-slot-value class c value slot)
+        ;; Set this into the storage for defaults.
+        (setcar (nthcdr (- c 3) (eieio--class-public-d (class-v class)))
+                value)
+        ;; Take the value, and put it into our cache object.
+        (eieio-oset (eieio--class-default-object-cache (class-v class))
+                    slot value)
+        ))))
+
+
+;;; EIEIO internal search functions
+;;
+(defun eieio-slot-originating-class-p (start-class slot)
+  "Return non-nil if START-CLASS is the first class to define SLOT.
+This is for testing if the class currently in scope is the class that defines SLOT
+so that we can protect private slots."
+  (let ((par (eieio-class-parents-fast start-class))
+        (ret t))
+    (if (not par)
+        t
+      (while (and par ret)
+        (if (intern-soft (symbol-name slot)
+                         (eieio--class-symbol-obarray (class-v (car par))))
+            (setq ret nil))
+        (setq par (cdr par)))
+      ret)))
+
+(defun eieio-slot-name-index (class obj slot)
+  "In CLASS for OBJ find the index of the named SLOT.
+The slot is a symbol which is installed in CLASS by the `defclass'
+call.  OBJ can be nil, but if it is an object, and the slot in question
+is protected, access will be allowed if OBJ is a child of the currently
+scoped class.
+If SLOT is the value created with :initarg instead,
+reverse-lookup that name, and recurse with the associated slot value."
+  ;; Removed checks to outside this call
+  (let* ((fsym (intern-soft (symbol-name slot)
+                            (eieio--class-symbol-obarray (class-v class))))
+         (fsi (if (symbolp fsym) (symbol-value fsym) nil)))
+    (if (integerp fsi)
+        (cond
+         ((not (get fsym 'protection))
+          (+ 3 fsi))
+         ((and (eq (get fsym 'protection) 'protected)
+               (eieio--scoped-class)
+               (or (child-of-class-p class (eieio--scoped-class))
+                   (and (eieio-object-p obj)
+                        (child-of-class-p class (eieio--object-class obj)))))
+          (+ 3 fsi))
+         ((and (eq (get fsym 'protection) 'private)
+               (or (and (eieio--scoped-class)
+                        (eieio-slot-originating-class-p (eieio--scoped-class) slot))
+                   eieio-initializing-object))
+          (+ 3 fsi))
+         (t nil))
+      (let ((fn (eieio-initarg-to-attribute class slot)))
+        (if fn (eieio-slot-name-index class obj fn) nil)))))
+
+(defun eieio-class-slot-name-index (class slot)
+  "In CLASS find the index of the named SLOT.
+The slot is a symbol which is installed in CLASS by the `defclass'
+call.  If SLOT is the value created with :initarg instead,
+reverse-lookup that name, and recurse with the associated slot value."
+  ;; This will happen less often, and with fewer slots.  Do this the
+  ;; storage cheap way.
+  (let* ((a (eieio--class-class-allocation-a (class-v class)))
+         (l1 (length a))
+         (af (memq slot a))
+         (l2 (length af)))
+    ;; Slot # is length of the total list, minus the remaining list of
+    ;; the found slot.
+    (if af (- l1 l2))))
+
+;;;
+;; Way to assign slots based on a list.  Used for constructors, or
+;; even resetting an object at run-time
+;;
+(defun eieio-set-defaults (obj &optional set-all)
+  "Take object OBJ, and reset all slots to their defaults.
+If SET-ALL is non-nil, then when a default is nil, that value is
+reset.  If SET-ALL is nil, the slots are only reset if the default is
+not nil."
+  (eieio--with-scoped-class (eieio--object-class obj)
+    (let ((eieio-initializing-object t)
+          (pub (eieio--class-public-a (class-v (eieio--object-class obj)))))
+      (while pub
+        (let ((df (eieio-oref-default obj (car pub))))
+          (if (or df set-all)
+              (eieio-oset obj (car pub) df)))
+        (setq pub (cdr pub))))))
+
+(defun eieio-initarg-to-attribute (class initarg)
+  "For CLASS, convert INITARG to the actual attribute name.
+If there is no translation, pass it in directly (so we can cheat if
+need be... May remove that later...)"
+  (let ((tuple (assoc initarg (eieio--class-initarg-tuples (class-v class)))))
+    (if tuple
+        (cdr tuple)
+      nil)))
+
+(defun eieio-attribute-to-initarg (class attribute)
+  "In CLASS, convert the ATTRIBUTE into the corresponding init argument tag.
+This is usually a symbol that starts with `:'."
+  (let ((tuple (rassoc attribute (eieio--class-initarg-tuples (class-v class)))))
+    (if tuple
+        (car tuple)
+      nil)))
+
+;;;
+;; Method Invocation order: C3
+(defun eieio-c3-candidate (class remaining-inputs)
+  "Return CLASS if it can go in the result now, otherwise nil"
+  ;; Ensure CLASS is not in any position but the first in any of the
+  ;; element lists of REMAINING-INPUTS.
+  (and (not (let ((found nil))
+              (while (and remaining-inputs (not found))
+                (setq found (member class (cdr (car remaining-inputs)))
+                      remaining-inputs (cdr remaining-inputs)))
+              found))
+       class))
+
+(defun eieio-c3-merge-lists (reversed-partial-result remaining-inputs)
+  "Merge REVERSED-PARTIAL-RESULT REMAINING-INPUTS in a consistent order, if possible.
+If a consistent order does not exist, signal an error."
+  (if (let ((tail remaining-inputs)
+            (found nil))
+        (while (and tail (not found))
+          (setq found (car tail) tail (cdr tail)))
+        (not found))
+      ;; If all remaining inputs are empty lists, we are done.
+      (nreverse reversed-partial-result)
+    ;; Otherwise, we try to find the next element of the result. This
+    ;; is achieved by considering the first element of each
+    ;; (non-empty) input list and accepting a candidate if it is
+    ;; consistent with the rests of the input lists.
+    (let* ((found nil)
+           (tail remaining-inputs)
+           (next (progn
+                   (while (and tail (not found))
+                     (setq found (and (car tail)
+                                      (eieio-c3-candidate (caar tail)
+                                                          remaining-inputs))
+                           tail (cdr tail)))
+                   found)))
+      (if next
+          ;; The graph is consistent so far, add NEXT to result and
+          ;; merge input lists, dropping NEXT from their heads where
+          ;; applicable.
+          (eieio-c3-merge-lists
+           (cons next reversed-partial-result)
+           (mapcar (lambda (l) (if (eq (first l) next) (rest l) l))
+                   remaining-inputs))
+        ;; The graph is inconsistent, give up
+        (signal 'inconsistent-class-hierarchy (list remaining-inputs))))))
+
+(defun eieio-class-precedence-c3 (class)
+  "Return all parents of CLASS in c3 order."
+  (let ((parents (eieio-class-parents-fast class)))
+    (eieio-c3-merge-lists
+     (list class)
+     (append
+      (or
+       (mapcar
+        (lambda (x)
+          (eieio-class-precedence-c3 x))
+        parents)
+       '((eieio-default-superclass)))
+      (list parents))))
+  )
+;;;
+;; Method Invocation Order: Depth First
+
+(defun eieio-class-precedence-dfs (class)
+  "Return all parents of CLASS in depth-first order."
+  (let* ((parents (eieio-class-parents-fast class))
+         (classes (copy-sequence
+                   (apply #'append
+                          (list class)
+                          (or
+                           (mapcar
+                            (lambda (parent)
+                              (cons parent
+                                    (eieio-class-precedence-dfs parent)))
+                            parents)
+                           '((eieio-default-superclass))))))
+         (tail classes))
+    ;; Remove duplicates.
+    (while tail
+      (setcdr tail (delq (car tail) (cdr tail)))
+      (setq tail (cdr tail)))
+    classes))
+
+;;;
+;; Method Invocation Order: Breadth First
+(defun eieio-class-precedence-bfs (class)
+  "Return all parents of CLASS in breadth-first order."
+  (let ((result)
+        (queue (or (eieio-class-parents-fast class)
+                   '(eieio-default-superclass))))
+    (while queue
+      (let ((head (pop queue)))
+        (unless (member head result)
+          (push head result)
+          (unless (eq head 'eieio-default-superclass)
+            (setq queue (append queue (or (eieio-class-parents-fast head)
+                                          '(eieio-default-superclass))))))))
+    (cons class (nreverse result)))
+  )
+
+;;;
+;; Method Invocation Order
+
+(defun eieio-class-precedence-list (class)
+  "Return (transitively closed) list of parents of CLASS.
+The order, in which the parents are returned depends on the
+method invocation orders of the involved classes."
+  (if (or (null class) (eq class 'eieio-default-superclass))
+      nil
+    (case (class-method-invocation-order class)
+      (:depth-first
+       (eieio-class-precedence-dfs class))
+      (:breadth-first
+       (eieio-class-precedence-bfs class))
+      (:c3
+       (eieio-class-precedence-c3 class))))
+  )
+(define-obsolete-function-alias
+  'class-precedence-list 'eieio-class-precedence-list "24.4")
+
+
+;;; CLOS generics internal function handling
+;;
+(defvar eieio-generic-call-methodname nil
+  "When using `call-next-method', provides a context on how to do it.")
+(defvar eieio-generic-call-arglst nil
+  "When using `call-next-method', provides a context for parameters.")
+(defvar eieio-generic-call-key nil
+  "When using `call-next-method', provides a context for the current key.
+Keys are a number representing :before, :primary, and :after methods.")
+(defvar eieio-generic-call-next-method-list nil
+  "When executing a PRIMARY or STATIC method, track the 'next-method'.
+During executions, the list is first generated, then as each next method
+is called, the next method is popped off the stack.")
+
+(define-obsolete-variable-alias 'eieio-pre-method-execution-hooks
+  'eieio-pre-method-execution-functions "24.3")
+(defvar eieio-pre-method-execution-functions nil
+  "Abnormal hook run just before an EIEIO method is executed.
+The hook function must accept one argument, the list of forms
+about to be executed.")
+
+(defun eieio-generic-call (method args)
+  "Call METHOD with ARGS.
+ARGS provides the context on which implementation to use.
+This should only be called from a generic function."
+  ;; We must expand our arguments first as they are always
+  ;; passed in as quoted symbols
+  (let ((newargs nil) (mclass nil)  (lambdas nil) (tlambdas nil) (keys nil)
+        (eieio-generic-call-methodname method)
+        (eieio-generic-call-arglst args)
+        (firstarg nil)
+        (primarymethodlist nil))
+    ;; get a copy
+    (setq newargs args
+          firstarg (car newargs))
+    ;; Is the class passed in autoloaded?
+    ;; Since class names are also constructors, they can be autoloaded
+    ;; via the autoload command.  Check for this, and load them in.
+    ;; It is ok if it doesn't turn out to be a class.  Probably want that
+    ;; function loaded anyway.
+    (if (and (symbolp firstarg)
+             (fboundp firstarg)
+             (listp (symbol-function firstarg))
+             (eq 'autoload (car (symbol-function firstarg))))
+        (load (nth 1 (symbol-function firstarg))))
+    ;; Determine the class to use.
+    (cond ((eieio-object-p firstarg)
+           (setq mclass (eieio--object-class firstarg)))
+          ((class-p firstarg)
+           (setq mclass firstarg))
+          )
+    ;; Make sure the class is a valid class
+    ;; mclass can be nil (meaning a generic for should be used.
+    ;; mclass cannot have a value that is not a class, however.
+    (when (and (not (null mclass)) (not (class-p mclass)))
+      (error "Cannot dispatch method %S on class %S"
+             method mclass)
+      )
+    ;; Now create a list in reverse order of all the calls we have
+    ;; make in order to successfully do this right.  Rules:
+    ;; 1) Only call generics if scoped-class is not defined
+    ;;    This prevents multiple calls in the case of recursion
+    ;; 2) Only call static if this is a static method.
+    ;; 3) Only call specifics if the definition allows for them.
+    ;; 4) Call in order based on :before, :primary, and :after
+    (when (eieio-object-p firstarg)
+      ;; Non-static calls do all this stuff.
+
+      ;; :after methods
+      (setq tlambdas
+            (if mclass
+                (eieiomt-method-list method method-after mclass)
+              (list (eieio-generic-form method method-after nil)))
+            ;;(or (and mclass (eieio-generic-form method method-after mclass))
+            ;;  (eieio-generic-form method method-after nil))
+            )
+      (setq lambdas (append tlambdas lambdas)
+            keys (append (make-list (length tlambdas) method-after) keys))
+
+      ;; :primary methods
+      (setq tlambdas
+            (or (and mclass (eieio-generic-form method method-primary mclass))
+                (eieio-generic-form method method-primary nil)))
+      (when tlambdas
+        (setq lambdas (cons tlambdas lambdas)
+              keys (cons method-primary keys)
+              primarymethodlist
+              (eieiomt-method-list method method-primary mclass)))
+
+      ;; :before methods
+      (setq tlambdas
+            (if mclass
+                (eieiomt-method-list method method-before mclass)
+              (list (eieio-generic-form method method-before nil)))
+            ;;(or (and mclass (eieio-generic-form method method-before mclass))
+            ;;  (eieio-generic-form method method-before nil))
+            )
+      (setq lambdas (append tlambdas lambdas)
+            keys (append (make-list (length tlambdas) method-before) keys))
+      )
+
+    (if mclass
+        ;; For the case of a class,
+        ;; if there were no methods found, then there could be :static methods.
+        (when (not lambdas)
+          (setq tlambdas
+                (eieio-generic-form method method-static mclass))
+          (setq lambdas (cons tlambdas lambdas)
+                keys (cons method-static keys)
+                primarymethodlist  ;; Re-use even with bad name here
+                (eieiomt-method-list method method-static mclass)))
+      ;; For the case of no class (ie - mclass == nil) then there may
+      ;; be a primary method.
+      (setq tlambdas
+            (eieio-generic-form method method-primary nil))
+      (when tlambdas
+        (setq lambdas (cons tlambdas lambdas)
+              keys (cons method-primary keys)
+              primarymethodlist
+              (eieiomt-method-list method method-primary nil)))
+      )
+
+    (run-hook-with-args 'eieio-pre-method-execution-functions
+                        primarymethodlist)
+
+    ;; Now loop through all occurrences forms which we must execute
+    ;; (which are happily sorted now) and execute them all!
+    (let ((rval nil) (lastval nil) (rvalever nil) (found nil))
+      (while lambdas
+        (if (car lambdas)
+            (eieio--with-scoped-class (cdr (car lambdas))
+              (let* ((eieio-generic-call-key (car keys))
+                     (has-return-val
+                      (or (= eieio-generic-call-key method-primary)
+                          (= eieio-generic-call-key method-static)))
+                     (eieio-generic-call-next-method-list
+                      ;; Use the cdr, as the first element is the fcn
+                      ;; we are calling right now.
+                      (when has-return-val (cdr primarymethodlist)))
+                     )
+                (setq found t)
+                ;;(setq rval (apply (car (car lambdas)) newargs))
+                (setq lastval (apply (car (car lambdas)) newargs))
+                (when has-return-val
+                  (setq rval lastval
+                        rvalever t))
+                )))
+        (setq lambdas (cdr lambdas)
+              keys (cdr keys)))
+      (if (not found)
+          (if (eieio-object-p (car args))
+              (setq rval (apply 'no-applicable-method (car args) method args)
+                    rvalever t)
+            (signal
+             'no-method-definition
+             (list method args))))
+      ;; Right Here... it could be that lastval is returned when
+      ;; rvalever is nil.  Is that right?
+      rval)))
+
+(defun eieio-generic-call-primary-only (method args)
+  "Call METHOD with ARGS for methods with only :PRIMARY implementations.
+ARGS provides the context on which implementation to use.
+This should only be called from a generic function.
+
+This method is like `eieio-generic-call', but only
+implementations in the :PRIMARY slot are queried.  After many
+years of use, it appears that over 90% of methods in use
+have :PRIMARY implementations only.  We can therefore optimize
+for this common case to improve performance."
+  ;; We must expand our arguments first as they are always
+  ;; passed in as quoted symbols
+  (let ((newargs nil) (mclass nil)  (lambdas nil)
+        (eieio-generic-call-methodname method)
+        (eieio-generic-call-arglst args)
+        (firstarg nil)
+        (primarymethodlist nil)
+        )
+    ;; get a copy
+    (setq newargs args
+          firstarg (car newargs))
+
+    ;; Determine the class to use.
+    (cond ((eieio-object-p firstarg)
+           (setq mclass (eieio--object-class firstarg)))
+          ((not firstarg)
+           (error "Method %s called on nil" method))
+          ((not (eieio-object-p firstarg))
+           (error "Primary-only method %s called on something not an object" method))
+          (t
+           (error "EIEIO Error: Improperly classified method %s as primary only"
+                  method)
+          ))
+    ;; Make sure the class is a valid class
+    ;; mclass can be nil (meaning a generic for should be used.
+    ;; mclass cannot have a value that is not a class, however.
+    (when (null mclass)
+      (error "Cannot dispatch method %S on class %S" method mclass)
+      )
+
+    ;; :primary methods
+    (setq lambdas (eieio-generic-form method method-primary mclass))
+    (setq primarymethodlist  ;; Re-use even with bad name here
+          (eieiomt-method-list method method-primary mclass))
+
+    ;; Now loop through all occurrences forms which we must execute
+    ;; (which are happily sorted now) and execute them all!
+    (eieio--with-scoped-class (cdr lambdas)
+      (let* ((rval nil) (lastval nil) (rvalever nil)
+             (eieio-generic-call-key method-primary)
+             ;; Use the cdr, as the first element is the fcn
+             ;; we are calling right now.
+             (eieio-generic-call-next-method-list (cdr primarymethodlist))
+             )
+
+        (if (or (not lambdas) (not (car lambdas)))
+
+            ;; No methods found for this impl...
+            (if (eieio-object-p (car args))
+                (setq rval (apply 'no-applicable-method (car args) method args)
+                      rvalever t)
+              (signal
+               'no-method-definition
+               (list method args)))
+
+          ;; Do the regular implementation here.
+
+          (run-hook-with-args 'eieio-pre-method-execution-functions
+                              lambdas)
+
+          (setq lastval (apply (car lambdas) newargs))
+          (setq rval lastval
+                rvalever t)
+          )
+
+        ;; Right Here... it could be that lastval is returned when
+        ;; rvalever is nil.  Is that right?
+        rval))))
+
+(defun eieiomt-method-list (method key class)
+  "Return an alist list of methods lambdas.
+METHOD is the method name.
+KEY represents either :before, or :after methods.
+CLASS is the starting class to search from in the method tree.
+If CLASS is nil, then an empty list of methods should be returned."
+  ;; Note: eieiomt - the MT means MethodTree.  See more comments below
+  ;; for the rest of the eieiomt methods.
+
+  ;; Collect lambda expressions stored for the class and its parent
+  ;; classes.
+  (let (lambdas)
+    (dolist (ancestor (eieio-class-precedence-list class))
+      ;; Lookup the form to use for the PRIMARY object for the next level
+      (let ((tmpl (eieio-generic-form method key ancestor)))
+        (when (and tmpl
+                   (or (not lambdas)
+                       ;; This prevents duplicates coming out of the
+                       ;; class method optimizer.  Perhaps we should
+                       ;; just not optimize before/afters?
+                       (not (member tmpl lambdas))))
+          (push tmpl lambdas))))
+
+    ;; Return collected lambda. For :after methods, return in current
+    ;; order (most general class last); Otherwise, reverse order.
+    (if (eq key method-after)
+        lambdas
+      (nreverse lambdas))))
+
+
+;;;
+;; eieio-method-tree : eieiomt-
+;;
+;; Stored as eieio-method-tree in property list of a generic method
+;;
+;; (eieio-method-tree . [BEFORE PRIMARY AFTER
+;;                       genericBEFORE genericPRIMARY genericAFTER])
+;; and
+;; (eieio-method-obarray . [BEFORE PRIMARY AFTER
+;;                          genericBEFORE genericPRIMARY genericAFTER])
+;;    where the association is a vector.
+;;    (aref 0  -- all static methods.
+;;    (aref 1  -- all methods classified as :before
+;;    (aref 2  -- all methods classified as :primary
+;;    (aref 3  -- all methods classified as :after
+;;    (aref 4  -- a generic classified as :before
+;;    (aref 5  -- a generic classified as :primary
+;;    (aref 6  -- a generic classified as :after
+;;
+(defvar eieiomt-optimizing-obarray nil
+  "While mapping atoms, this contain the obarray being optimized.")
+
+(defun eieiomt-install (method-name)
+  "Install the method tree, and obarray onto METHOD-NAME.
+Do not do the work if they already exist."
+  (let ((emtv (get method-name 'eieio-method-tree))
+        (emto (get method-name 'eieio-method-obarray)))
+    (if (or (not emtv) (not emto))
+        (progn
+          (setq emtv (put method-name 'eieio-method-tree
+                          (make-vector method-num-slots nil))
+                emto (put method-name 'eieio-method-obarray
+                          (make-vector method-num-slots nil)))
+          (aset emto 0 (make-vector 11 0))
+          (aset emto 1 (make-vector 11 0))
+          (aset emto 2 (make-vector 41 0))
+          (aset emto 3 (make-vector 11 0))
+          ))))
+
+(defun eieiomt-add (method-name method key class)
+  "Add to METHOD-NAME the forms METHOD in a call position KEY for CLASS.
+METHOD-NAME is the name created by a call to `defgeneric'.
+METHOD are the forms for a given implementation.
+KEY is an integer (see comment in eieio.el near this function) which
+is associated with the :static :before :primary and :after tags.
+It also indicates if CLASS is defined or not.
+CLASS is the class this method is associated with."
+  (if (or (> key method-num-slots) (< key 0))
+      (error "eieiomt-add: method key error!"))
+  (let ((emtv (get method-name 'eieio-method-tree))
+        (emto (get method-name 'eieio-method-obarray)))
+    ;; Make sure the method tables are available.
+    (if (or (not emtv) (not emto))
+        (error "Programmer error: eieiomt-add"))
+    ;; only add new cells on if it doesn't already exist!
+    (if (assq class (aref emtv key))
+        (setcdr (assq class (aref emtv key)) method)
+      (aset emtv key (cons (cons class method) (aref emtv key))))
+    ;; Add function definition into newly created symbol, and store
+    ;; said symbol in the correct obarray, otherwise use the
+    ;; other array to keep this stuff
+    (if (< key method-num-lists)
+        (let ((nsym (intern (symbol-name class) (aref emto key))))
+          (fset nsym method)))
+    ;; Save the defmethod file location in a symbol property.
+    (let ((fname (if load-in-progress
+                     load-file-name
+                   buffer-file-name))
+          loc)
+      (when fname
+        (when (string-match "\\.elc$" fname)
+          (setq fname (substring fname 0 (1- (length fname)))))
+        (setq loc (get method-name 'method-locations))
+        (pushnew (list class fname) loc :test 'equal)
+        (put method-name 'method-locations loc)))
+    ;; Now optimize the entire obarray
+    (if (< key method-num-lists)
+        (let ((eieiomt-optimizing-obarray (aref emto key)))
+          ;; @todo - Is this overkill?  Should we just clear the symbol?
+          (mapatoms 'eieiomt-sym-optimize eieiomt-optimizing-obarray)))
+    ))
+
+(defun eieiomt-next (class)
+  "Return the next parent class for CLASS.
+If CLASS is a superclass, return variable `eieio-default-superclass'.
+If CLASS is variable `eieio-default-superclass' then return nil.
+This is different from function `class-parent' as class parent returns
+nil for superclasses.  This function performs no type checking!"
+  ;; No type-checking because all calls are made from functions which
+  ;; are safe and do checking for us.
+  (or (eieio-class-parents-fast class)
+      (if (eq class 'eieio-default-superclass)
+          nil
+        '(eieio-default-superclass))))
+
+(defun eieiomt-sym-optimize (s)
+  "Find the next class above S which has a function body for the optimizer."
+  ;; Set the value to nil in case there is no nearest cell.
+  (set s nil)
+  ;; Find the nearest cell that has a function body. If we find one,
+  ;; we replace the nil from above.
+  (let ((external-symbol (intern-soft (symbol-name s))))
+    (catch 'done
+      (dolist (ancestor (rest (eieio-class-precedence-list external-symbol)))
+        (let ((ov (intern-soft (symbol-name ancestor)
+                               eieiomt-optimizing-obarray)))
+          (when (fboundp ov)
+            (set s ov) ;; store ov as our next symbol
+            (throw 'done ancestor)))))))
+
+(defun eieio-generic-form (method key class)
+ "Return the lambda form belonging to METHOD using KEY based upon CLASS.
+If CLASS is not a class then use `generic' instead.  If class has
+no form, but has a parent class, then trace to that parent class.
+The first time a form is requested from a symbol, an optimized path
+is memorized for faster future use."
+ (let ((emto (aref (get method 'eieio-method-obarray)
+                   (if class key (eieio-specialized-key-to-generic-key key)))))
+   (if (class-p class)
+       ;; 1) find our symbol
+       (let ((cs (intern-soft (symbol-name class) emto)))
+         (if (not cs)
+             ;; 2) If there isn't one, then make one.
+             ;;    This can be slow since it only occurs once
+             (progn
+               (setq cs (intern (symbol-name class) emto))
+               ;; 2.1) Cache its nearest neighbor with a quick optimize
+               ;;      which should only occur once for this call ever
+               (let ((eieiomt-optimizing-obarray emto))
+                 (eieiomt-sym-optimize cs))))
+         ;; 3) If it's bound return this one.
+         (if (fboundp  cs)
+             (cons cs (eieio--class-symbol (class-v class)))
+           ;; 4) If it's not bound then this variable knows something
+           (if (symbol-value cs)
+               (progn
+                 ;; 4.1) This symbol holds the next class in its value
+                 (setq class (symbol-value cs)
+                       cs (intern-soft (symbol-name class) emto))
+                 ;; 4.2) The optimizer should always have chosen a
+                 ;;      function-symbol
+                 ;;(if (fboundp cs)
+                 (cons cs (eieio--class-symbol (class-v (intern (symbol-name class)))))
+                   ;;(error "EIEIO optimizer: erratic data loss!"))
+                 )
+               ;; There never will be a funcall...
+               nil)))
+     ;; for a generic call, what is a list, is the function body we want.
+     (let ((emtl (aref (get method 'eieio-method-tree)
+                       (if class key (eieio-specialized-key-to-generic-key key)))))
+       (if emtl
+           ;; The car of EMTL is supposed to be a class, which in this
+           ;; case is nil, so skip it.
+           (cons (cdr (car emtl)) nil)
+         nil)))))
+
+
+;;; Here are some special types of errors
+;;
+(intern "no-method-definition")
+(put 'no-method-definition 'error-conditions '(no-method-definition error))
+(put 'no-method-definition 'error-message "No method definition")
+
+(intern "no-next-method")
+(put 'no-next-method 'error-conditions '(no-next-method error))
+(put 'no-next-method 'error-message "No next method")
+
+(intern "invalid-slot-name")
+(put 'invalid-slot-name 'error-conditions '(invalid-slot-name error))
+(put 'invalid-slot-name 'error-message "Invalid slot name")
+
+(intern "invalid-slot-type")
+(put 'invalid-slot-type 'error-conditions '(invalid-slot-type error nil))
+(put 'invalid-slot-type 'error-message "Invalid slot type")
+
+(intern "unbound-slot")
+(put 'unbound-slot 'error-conditions '(unbound-slot error nil))
+(put 'unbound-slot 'error-message "Unbound slot")
+
+(intern "inconsistent-class-hierarchy")
+(put 'inconsistent-class-hierarchy 'error-conditions
+     '(inconsistent-class-hierarchy error nil))
+(put 'inconsistent-class-hierarchy 'error-message "Inconsistent class hierarchy")
+
+;;; Obsolete backward compatibility functions.
+;; Needed to run byte-code compiled with the EIEIO of Emacs-23.
+
+(defun eieio-defmethod (method args)
+  "Obsolete work part of an old version of the `defmethod' macro."
+  (let ((key nil) (body nil) (firstarg nil) (argfix nil) (argclass nil) loopa)
+    ;; find optional keys
+    (setq key
+          (cond ((memq (car args) '(:BEFORE :before))
+                 (setq args (cdr args))
+                 method-before)
+                ((memq (car args) '(:AFTER :after))
+                 (setq args (cdr args))
+                 method-after)
+                ((memq (car args) '(:STATIC :static))
+                 (setq args (cdr args))
+                 method-static)
+                ((memq (car args) '(:PRIMARY :primary))
+                 (setq args (cdr args))
+                 method-primary)
+                ;; Primary key.
+                (t method-primary)))
+    ;; Get body, and fix contents of args to be the arguments of the fn.
+    (setq body (cdr args)
+          args (car args))
+    (setq loopa args)
+    ;; Create a fixed version of the arguments.
+    (while loopa
+      (setq argfix (cons (if (listp (car loopa)) (car (car loopa)) (car loopa))
+                         argfix))
+      (setq loopa (cdr loopa)))
+    ;; Make sure there is a generic.
+    (eieio-defgeneric
+     method
+     (if (stringp (car body))
+         (car body) (format "Generically created method `%s'." method)))
+    ;; create symbol for property to bind to.  If the first arg is of
+    ;; the form (varname vartype) and `vartype' is a class, then
+    ;; that class will be the type symbol.  If not, then it will fall
+    ;; under the type `primary' which is a non-specific calling of the
+    ;; function.
+    (setq firstarg (car args))
+    (if (listp firstarg)
+        (progn
+          (setq argclass  (nth 1 firstarg))
+          (if (not (class-p argclass))
+              (error "Unknown class type %s in method parameters"
+                     (nth 1 firstarg))))
+      ;; Generics are higher.
+      (setq key (eieio-specialized-key-to-generic-key key)))
+    ;; Put this lambda into the symbol so we can find it.
+    (if (byte-code-function-p (car-safe body))
+        (eieiomt-add method (car-safe body) key argclass)
+      (eieiomt-add method (append (list 'lambda (reverse argfix)) body)
+                   key argclass))
+    )
+
+  (when eieio-optimize-primary-methods-flag
+    ;; Optimizing step:
+    ;;
+    ;; If this method, after this setup, only has primary methods, then
+    ;; we can setup the generic that way.
+    (if (generic-primary-only-p method)
+        ;; If there is only one primary method, then we can go one more
+        ;; optimization step.
+        (if (generic-primary-only-one-p method)
+            (eieio-defgeneric-reset-generic-form-primary-only-one method)
+          (eieio-defgeneric-reset-generic-form-primary-only method))
+      (eieio-defgeneric-reset-generic-form method)))
+
+  method)
+(make-obsolete 'eieio-defmethod 'eieio--defmethod "24.1")
+
+(defun eieio-defgeneric (method doc-string)
+  "Obsolete work part of an old version of the `defgeneric' macro."
+  (if (and (fboundp method) (not (generic-p method))
+           (or (byte-code-function-p (symbol-function method))
+               (not (eq 'autoload (car (symbol-function method)))))
+           )
+      (error "You cannot create a generic/method over an existing symbol: %s"
+             method))
+  ;; Don't do this over and over.
+  (unless (fboundp 'method)
+    ;; This defun tells emacs where the first definition of this
+    ;; method is defined.
+    `(defun ,method nil)
+    ;; Make sure the method tables are installed.
+    (eieiomt-install method)
+    ;; Apply the actual body of this function.
+    (fset method (eieio-defgeneric-form method doc-string))
+    ;; Return the method
+    'method))
+(make-obsolete 'eieio-defgeneric nil "24.1")
+
+(provide 'eieio-core)
+
+;;; eieio-core.el ends here
diff --git a/lisp/emacs-lisp/eieio.el b/lisp/emacs-lisp/eieio.el
index 37b1ec5fa94..3cdf1f078bd 100644
--- a/lisp/emacs-lisp/eieio.el
+++ b/lisp/emacs-lisp/eieio.el
@@ -54,223 +54,7 @@
   (interactive)
   (message eieio-version))
 
-(eval-and-compile
-;; About the above.  EIEIO must process its own code when it compiles
-;; itself, thus, by eval-and-compiling ourselves, we solve the problem.
-
-;; Compatibility
-(if (fboundp 'compiled-function-arglist)
-
-    ;; XEmacs can only access a compiled functions arglist like this:
-    (defalias 'eieio-compiled-function-arglist 'compiled-function-arglist)
-
-  ;; Emacs doesn't have this function, but since FUNC is a vector, we can just
-  ;; grab the appropriate element.
-  (defun eieio-compiled-function-arglist (func)
-    "Return the argument list for the compiled function FUNC."
-    (aref func 0))
-
-  )
-
-
-;;;
-;; Variable declarations.
-;;
-
-(defvar eieio-hook nil
-  "This hook is executed, then cleared each time `defclass' is called.")
-
-(defvar eieio-error-unsupported-class-tags nil
-  "Non-nil to throw an error if an encountered tag is unsupported.
-This may prevent classes from CLOS applications from being used with EIEIO
-since EIEIO does not support all CLOS tags.")
-
-(defvar eieio-skip-typecheck nil
-  "If non-nil, skip all slot typechecking.
-Set this to t permanently if a program is functioning well to get a
-small speed increase.  This variable is also used internally to handle
-default setting for optimization purposes.")
-
-(defvar eieio-optimize-primary-methods-flag t
-  "Non-nil means to optimize the method dispatch on primary methods.")
-
-(defvar eieio-initializing-object  nil
-  "Set to non-nil while initializing an object.")
-
-(defconst eieio-unbound
-  (if (and (boundp 'eieio-unbound) (symbolp eieio-unbound))
-      eieio-unbound
-    (make-symbol "unbound"))
-  "Uninterned symbol representing an unbound slot in an object.")
-
-;; This is a bootstrap for eieio-default-superclass so it has a value
-;; while it is being built itself.
-(defvar eieio-default-superclass nil))
-
-(defmacro eieio--define-field-accessors (prefix fields)
-  (declare (indent 1))
-  (let ((index 0)
-        (defs '()))
-    (dolist (field fields)
-      (let ((doc (if (listp field)
-                     (prog1 (cadr field) (setq field (car field))))))
-        (push `(defmacro ,(intern (format "eieio--%s-%s" prefix field)) (x)
-                 ,@(if doc (list (format (if (string-match "\n" doc)
-                                             "Return %s" "Return %s of a %s.")
-                                         doc prefix)))
-                 (list 'aref x ,index))
-              defs)
-        (setq index (1+ index))))
-    `(eval-and-compile
-       ,@(nreverse defs)
-       (defconst ,(intern (format "eieio--%s-num-slots" prefix)) ,index))))
-
-(eieio--define-field-accessors class
-  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
-   (symbol "symbol (self-referencing)")
-   parent children
-   (symbol-obarray "obarray permitting fast access to variable position indexes")
-   ;; @todo
-   ;; the word "public" here is leftovers from the very first version.
-   ;; Get rid of it!
-   (public-a "class attribute index")
-   (public-d "class attribute defaults index")
-   (public-doc "class documentation strings for attributes")
-   (public-type "class type for a slot")
-   (public-custom "class custom type for a slot")
-   (public-custom-label "class custom group for a slot")
-   (public-custom-group "class custom group for a slot")
-   (public-printer "printer for a slot")
-   (protection "protection for a slot")
-   (initarg-tuples "initarg tuples list")
-   (class-allocation-a "class allocated attributes")
-   (class-allocation-doc "class allocated documentation")
-   (class-allocation-type "class allocated value type")
-   (class-allocation-custom "class allocated custom descriptor")
-   (class-allocation-custom-label "class allocated custom descriptor")
-   (class-allocation-custom-group "class allocated custom group")
-   (class-allocation-printer "class allocated printer for a slot")
-   (class-allocation-protection "class allocated protection list")
-   (class-allocation-values "class allocated value vector")
-   (default-object-cache "what a newly created object would look like.
-This will speed up instantiation time as only a `copy-sequence' will
-be needed, instead of looping over all the values and setting them
-from the default.")
-   (options "storage location of tagged class options.
-Stored outright without modifications or stripping.")))
-
-(eieio--define-field-accessors object
-  (-unused-0 ;;FIXME: not sure, but at least there was no accessor!
-   (class "class struct defining OBJ")
-   name))
-
-(eval-and-compile
-;; FIXME: The constants below should have an `eieio-' prefix added!!
-
-(defconst method-static 0 "Index into :static tag on a method.")
-(defconst method-before 1 "Index into :before tag on a method.")
-(defconst method-primary 2 "Index into :primary tag on a method.")
-(defconst method-after 3 "Index into :after tag on a method.")
-(defconst method-num-lists 4 "Number of indexes into methods vector in which groups of functions are kept.")
-(defconst method-generic-before 4 "Index into generic :before tag on a method.")
-(defconst method-generic-primary 5 "Index into generic :primary tag on a method.")
-(defconst method-generic-after 6 "Index into generic :after tag on a method.")
-(defconst method-num-slots 7 "Number of indexes into a method's vector.")
-
-(defsubst eieio-specialized-key-to-generic-key (key)
-  "Convert a specialized KEY into a generic method key."
-  (cond ((eq key method-static) 0) ;; don't convert
-        ((< key method-num-lists) (+ key 3)) ;; The conversion
-        (t key) ;; already generic.. maybe.
-        ))
-
-
-;;; Important macros used in eieio.
-;;
-(defmacro class-v (class)
-  "Internal: Return the class vector from the CLASS symbol."
-  ;; No check: If eieio gets this far, it's probably been checked already.
-  `(get ,class 'eieio-class-definition))
-
-(defmacro class-p (class)
-  "Return t if CLASS is a valid class vector.
-CLASS is a symbol."
-  ;; this new method is faster since it doesn't waste time checking lots of
-  ;; things.
-  `(condition-case nil
-       (eq (aref (class-v ,class) 0) 'defclass)
-     (error nil)))
-
-(defmacro eieio-object-p (obj)
-  "Return non-nil if OBJ is an EIEIO object."
-  `(condition-case nil
-       (let ((tobj ,obj))
-         (and (eq (aref tobj 0) 'object)
-              (class-p (eieio--object-class tobj))))
-     (error nil)))
-(defalias 'object-p 'eieio-object-p)
-
-(defmacro class-constructor (class)
-  "Return the symbol representing the constructor of CLASS."
-  `(eieio--class-symbol (class-v ,class)))
-
-(defmacro generic-p (method)
-  "Return t if symbol METHOD is a generic function.
-Only methods have the symbol `eieio-method-obarray' as a property
-\(which contains a list of all bindings to that method type.)"
-  `(and (fboundp ,method) (get ,method 'eieio-method-obarray)))
-
-(defun generic-primary-only-p (method)
-  "Return t if symbol METHOD is a generic function with only primary methods.
-Only methods have the symbol `eieio-method-obarray' as a property (which
-contains a list of all bindings to that method type.)
-Methods with only primary implementations are executed in an optimized way."
-  (and (generic-p method)
-       (let ((M (get method 'eieio-method-tree)))
-         (and (< 0 (length (aref M method-primary)))
-              (not (aref M method-static))
-              (not (aref M method-before))
-              (not (aref M method-after))
-              (not (aref M method-generic-before))
-              (not (aref M method-generic-primary))
-              (not (aref M method-generic-after))))
-       ))
-
-(defun generic-primary-only-one-p (method)
-  "Return t if symbol METHOD is a generic function with only primary methods.
-Only methods have the symbol `eieio-method-obarray' as a property (which
-contains a list of all bindings to that method type.)
-Methods with only primary implementations are executed in an optimized way."
-  (and (generic-p method)
-       (let ((M (get method 'eieio-method-tree)))
-         (and (= 1 (length (aref M method-primary)))
-              (not (aref M method-static))
-              (not (aref M method-before))
-              (not (aref M method-after))
-              (not (aref M method-generic-before))
-              (not (aref M method-generic-primary))
-              (not (aref M method-generic-after))))
-       ))
-
-(defmacro class-option-assoc (list option)
-  "Return from LIST the found OPTION, or nil if it doesn't exist."
-  `(car-safe (cdr (memq ,option ,list))))
-
-(defmacro class-option (class option)
-  "Return the value stored for CLASS' OPTION.
-Return nil if that option doesn't exist."
-  `(class-option-assoc (eieio--class-options (class-v ,class)) ',option))
-
-(defmacro class-abstract-p (class)
-  "Return non-nil if CLASS is abstract.
-Abstract classes cannot be instantiated."
-  `(class-option ,class :abstract))
-
-(defmacro class-method-invocation-order (class)
-  "Return the invocation order of CLASS.
-Abstract classes cannot be instantiated."
-  `(or (class-option ,class :method-invocation-order)
-       :breadth-first))
+(require 'eieio-core)
 
 
 ;;; Defining a new class
@@ -331,829 +115,8 @@ Options in CLOS not supported in EIEIO:
 
 Due to the way class options are set up, you can add any tags you wish,
 and reference them using the function `class-option'."
-  ;; We must `eval-and-compile' this so that when we byte compile
-  ;; an eieio program, there is no need to load it ahead of time.
-  ;; It also provides lots of nice debugging errors at compile time.
-  `(eval-and-compile
-     (eieio-defclass ',name ',superclass ',slots ',options-and-doc)))
-
-(defvar eieio-defclass-autoload-map (make-vector 7 nil)
-  "Symbol map of superclasses we find in autoloads.")
-
-;; We autoload this because it's used in `make-autoload'.
-;;;###autoload
-(defun eieio-defclass-autoload (cname superclasses filename doc)
-  "Create autoload symbols for the EIEIO class CNAME.
-SUPERCLASSES are the superclasses that CNAME inherits from.
-DOC is the docstring for CNAME.
-This function creates a mock-class for CNAME and adds it into
-SUPERCLASSES as children.
-It creates an autoload function for CNAME's constructor."
-  ;; Assume we've already debugged inputs.
-
-  (let* ((oldc (when (class-p cname) (class-v cname)))
-         (newc (make-vector eieio--class-num-slots nil))
-         )
-    (if oldc
-        nil ;; Do nothing if we already have this class.
-
-      ;; Create the class in NEWC, but don't fill anything else in.
-      (aset newc 0 'defclass)
-      (setf (eieio--class-symbol newc) cname)
-
-      (let ((clear-parent nil))
-        ;; No parents?
-        (when (not superclasses)
-          (setq superclasses '(eieio-default-superclass)
-                clear-parent t)
-          )
-
-        ;; Hook our new class into the existing structures so we can
-        ;; autoload it later.
-        (dolist (SC superclasses)
-
-
-          ;; TODO - If we create an autoload that is in the map, that
-          ;;        map needs to be cleared!
-
-
-          ;; Does our parent exist?
-          (if (not (class-p SC))
-
-              ;; Create a symbol for this parent, and then store this
-              ;; parent on that symbol.
-              (let ((sym (intern (symbol-name SC) eieio-defclass-autoload-map)))
-                (if (not (boundp sym))
-                    (set sym (list cname))
-                  (add-to-list sym cname))
-                )
-
-            ;; We have a parent, save the child in there.
-            (when (not (member cname (eieio--class-children (class-v SC))))
-              (setf (eieio--class-children (class-v SC))
-                    (cons cname (eieio--class-children (class-v SC))))))
-
-          ;; save parent in child
-          (setf (eieio--class-parent newc) (cons SC (eieio--class-parent newc)))
-          )
-
-        ;; turn this into a usable self-pointing symbol
-        (set cname cname)
-
-        ;; Store the new class vector definition into the symbol.  We need to
-        ;; do this first so that we can call defmethod for the accessor.
-        ;; The vector will be updated by the following while loop and will not
-        ;; need to be stored a second time.
-        (put cname 'eieio-class-definition newc)
-
-        ;; Clear the parent
-        (if clear-parent (setf (eieio--class-parent newc) nil))
-
-        ;; Create an autoload on top of our constructor function.
-        (autoload cname filename doc nil nil)
-        (autoload (intern (concat (symbol-name cname) "-p")) filename "" nil nil)
-        (autoload (intern (concat (symbol-name cname) "-child-p")) filename "" nil nil)
-        (autoload (intern (concat (symbol-name cname) "-list-p")) filename "" nil nil)
-
-        ))))
-
-(defsubst eieio-class-un-autoload (cname)
-  "If class CNAME is in an autoload state, load its file."
-  (when (eq (car-safe (symbol-function cname)) 'autoload)
-    (load-library (car (cdr (symbol-function cname))))))
-
-(defmacro eieio--check-type (type obj)
-  (unless (symbolp obj)
-    (error "eieio--check-type wants OBJ to be a variable"))
-  `(if (not ,(cond
-              ((eq 'or (car-safe type))
-               `(or ,@(mapcar (lambda (type) `(,type ,obj)) (cdr type))))
-              (t `(,type ,obj))))
-       (signal 'wrong-type-argument (list ',type ,obj))))
-
-(defun eieio-defclass (cname superclasses slots options-and-doc)
-  ;; FIXME: Most of this should be moved to the `defclass' macro.
-  "Define CNAME as a new subclass of SUPERCLASSES.
-SLOTS are the slots residing in that class definition, and options or
-documentation OPTIONS-AND-DOC is the toplevel documentation for this class.
-See `defclass' for more information."
-  ;; Run our eieio-hook each time, and clear it when we are done.
-  ;; This way people can add hooks safely if they want to modify eieio
-  ;; or add definitions when eieio is loaded or something like that.
-  (run-hooks 'eieio-hook)
-  (setq eieio-hook nil)
-
-  (eieio--check-type listp superclasses)
-
-  (let* ((pname superclasses)
-         (newc (make-vector eieio--class-num-slots nil))
-         (oldc (when (class-p cname) (class-v cname)))
-         (groups nil) ;; list of groups id'd from slots
-         (options nil)
-         (clearparent nil))
-
-    (aset newc 0 'defclass)
-    (setf (eieio--class-symbol newc) cname)
-
-    ;; If this class already existed, and we are updating its structure,
-    ;; make sure we keep the old child list.  This can cause bugs, but
-    ;; if no new slots are created, it also saves time, and prevents
-    ;; method table breakage, particularly when the users is only
-    ;; byte compiling an EIEIO file.
-    (if oldc
-        (setf (eieio--class-children newc) (eieio--class-children oldc))
-      ;; If the old class did not exist, but did exist in the autoload map, then adopt those children.
-      ;; This is like the above, but deals with autoloads nicely.
-      (let ((sym (intern-soft (symbol-name cname) eieio-defclass-autoload-map)))
-        (when sym
-          (condition-case nil
-              (setf (eieio--class-children newc) (symbol-value sym))
-            (error nil))
-          (unintern (symbol-name cname) eieio-defclass-autoload-map)
-          ))
-      )
-
-    (cond ((and (stringp (car options-and-doc))
-                (/= 1 (% (length options-and-doc) 2)))
-           (error "Too many arguments to `defclass'"))
-          ((and (symbolp (car options-and-doc))
-                (/= 0 (% (length options-and-doc) 2)))
-           (error "Too many arguments to `defclass'"))
-          )
-
-    (setq options
-          (if (stringp (car options-and-doc))
-              (cons :documentation options-and-doc)
-            options-and-doc))
-
-    (if pname
-        (progn
-          (while pname
-            (if (and (car pname) (symbolp (car pname)))
-                (if (not (class-p (car pname)))
-                    ;; bad class
-                    (error "Given parent class %s is not a class" (car pname))
-                  ;; good parent class...
-                  ;; save new child in parent
-                  (when (not (member cname (eieio--class-children (class-v (car pname)))))
-                    (setf (eieio--class-children (class-v (car pname)))
-                          (cons cname (eieio--class-children (class-v (car pname))))))
-                  ;; Get custom groups, and store them into our local copy.
-                  (mapc (lambda (g) (add-to-list 'groups g))
-                        (class-option (car pname) :custom-groups))
-                  ;; save parent in child
-                  (setf (eieio--class-parent newc) (cons (car pname) (eieio--class-parent newc))))
-              (error "Invalid parent class %s" pname))
-            (setq pname (cdr pname)))
-          ;; Reverse the list of our parents so that they are prioritized in
-          ;; the same order as specified in the code.
-          (setf (eieio--class-parent newc) (nreverse (eieio--class-parent newc))) )
-      ;; If there is nothing to loop over, then inherit from the
-      ;; default superclass.
-      (unless (eq cname 'eieio-default-superclass)
-        ;; adopt the default parent here, but clear it later...
-        (setq clearparent t)
-        ;; save new child in parent
-        (if (not (member cname (eieio--class-children (class-v 'eieio-default-superclass))))
-            (setf (eieio--class-children (class-v 'eieio-default-superclass))
-                  (cons cname (eieio--class-children (class-v 'eieio-default-superclass)))))
-        ;; save parent in child
-        (setf (eieio--class-parent newc) (list eieio-default-superclass))))
-
-    ;; turn this into a usable self-pointing symbol
-    (set cname cname)
-
-    ;; These two tests must be created right away so we can have self-
-    ;; referencing classes.  ei, a class whose slot can contain only
-    ;; pointers to itself.
-
-    ;; Create the test function
-    (let ((csym (intern (concat (symbol-name cname) "-p"))))
-      (fset csym
-            (list 'lambda (list 'obj)
-                  (format "Test OBJ to see if it an object of type %s" cname)
-                  (list 'and '(eieio-object-p obj)
-                        (list 'same-class-p 'obj cname)))))
-
-    ;; Make sure the method invocation order  is a valid value.
-    (let ((io (class-option-assoc options :method-invocation-order)))
-      (when (and io (not (member io '(:depth-first :breadth-first :c3))))
-        (error "Method invocation order %s is not allowed" io)
-        ))
-
-    ;; Create a handy child test too
-    (let ((csym (intern (concat (symbol-name cname) "-child-p"))))
-      (fset csym
-            `(lambda (obj)
-               ,(format
-                  "Test OBJ to see if it an object is a child of type %s"
-                  cname)
-               (and (eieio-object-p obj)
-                    (object-of-class-p obj ,cname))))
-
-    ;; Create a handy list of the class test too
-    (let ((csym (intern (concat (symbol-name cname) "-list-p"))))
-      (fset csym
-            `(lambda (obj)
-               ,(format
-                  "Test OBJ to see if it a list of objects which are a child of type %s"
-                  cname)
-               (when (listp obj)
-                 (let ((ans t)) ;; nil is valid
-                   ;; Loop over all the elements of the input list, test
-                   ;; each to make sure it is a child of the desired object class.
-                   (while (and obj ans)
-                     (setq ans (and (eieio-object-p (car obj))
-                                    (object-of-class-p (car obj) ,cname)))
-                     (setq obj (cdr obj)))
-                   ans)))))
-
-      ;; When using typep, (typep OBJ 'myclass) returns t for objects which
-      ;; are subclasses of myclass.  For our predicates, however, it is
-      ;; important for EIEIO to be backwards compatible, where
-      ;; myobject-p, and myobject-child-p are different.
-      ;; "cl" uses this technique to specify symbols with specific typep
-      ;; test, so we can let typep have the CLOS documented behavior
-      ;; while keeping our above predicate clean.
-
-      ;; It would be cleaner to use `defsetf' here, but that requires cl
-      ;; at runtime.
-      (put cname 'cl-deftype-handler
-           (list 'lambda () `(list 'satisfies (quote ,csym)))))
-
-    ;; Before adding new slots, let's add all the methods and classes
-    ;; in from the parent class.
-    (eieio-copy-parents-into-subclass newc superclasses)
-
-    ;; Store the new class vector definition into the symbol.  We need to
-    ;; do this first so that we can call defmethod for the accessor.
-    ;; The vector will be updated by the following while loop and will not
-    ;; need to be stored a second time.
-    (put cname 'eieio-class-definition newc)
-
-    ;; Query each slot in the declaration list and mangle into the
-    ;; class structure I have defined.
-    (while slots
-      (let* ((slot1  (car slots))
-             (name    (car slot1))
-             (slot   (cdr slot1))
-             (acces   (plist-get slot ':accessor))
-             (init    (or (plist-get slot ':initform)
-                          (if (member ':initform slot) nil
-                            eieio-unbound)))
-             (initarg (plist-get slot ':initarg))
-             (docstr  (plist-get slot ':documentation))
-             (prot    (plist-get slot ':protection))
-             (reader  (plist-get slot ':reader))
-             (writer  (plist-get slot ':writer))
-             (alloc   (plist-get slot ':allocation))
-             (type    (plist-get slot ':type))
-             (custom  (plist-get slot ':custom))
-             (label   (plist-get slot ':label))
-             (customg (plist-get slot ':group))
-             (printer (plist-get slot ':printer))
-
-             (skip-nil (class-option-assoc options :allow-nil-initform))
-             )
-
-        (if eieio-error-unsupported-class-tags
-            (let ((tmp slot))
-              (while tmp
-                (if (not (member (car tmp) '(:accessor
-                                             :initform
-                                             :initarg
-                                             :documentation
-                                             :protection
-                                             :reader
-                                             :writer
-                                             :allocation
-                                             :type
-                                             :custom
-                                             :label
-                                             :group
-                                             :printer
-                                             :allow-nil-initform
-                                             :custom-groups)))
-                    (signal 'invalid-slot-type (list (car tmp))))
-                (setq tmp (cdr (cdr tmp))))))
-
-        ;; Clean up the meaning of protection.
-        (cond ((or (eq prot 'public) (eq prot :public)) (setq prot nil))
-              ((or (eq prot 'protected) (eq prot :protected)) (setq prot 'protected))
-              ((or (eq prot 'private) (eq prot :private)) (setq prot 'private))
-              ((eq prot nil) nil)
-              (t (signal 'invalid-slot-type (list ':protection prot))))
-
-        ;; Make sure the :allocation parameter has a valid value.
-        (if (not (or (not alloc) (eq alloc :class) (eq alloc :instance)))
-            (signal 'invalid-slot-type (list ':allocation alloc)))
-
-        ;; The default type specifier is supposed to be t, meaning anything.
-        (if (not type) (setq type t))
-
-        ;; Label is nil, or a string
-        (if (not (or (null label) (stringp label)))
-            (signal 'invalid-slot-type (list ':label label)))
-
-        ;; Is there an initarg, but allocation of class?
-        (if (and initarg (eq alloc :class))
-            (message "Class allocated slots do not need :initarg"))
-
-        ;; intern the symbol so we can use it blankly
-        (if initarg (set initarg initarg))
-
-        ;; The customgroup should be a list of symbols
-        (cond ((null customg)
-               (setq customg '(default)))
-              ((not (listp customg))
-               (setq customg (list customg))))
-        ;; The customgroup better be a symbol, or list of symbols.
-        (mapc (lambda (cg)
-                (if (not (symbolp cg))
-                    (signal 'invalid-slot-type (list ':group cg))))
-                customg)
-
-        ;; First up, add this slot into our new class.
-        (eieio-add-new-slot newc name init docstr type custom label customg printer
-                             prot initarg alloc 'defaultoverride skip-nil)
-
-        ;; We need to id the group, and store them in a group list attribute.
-        (mapc (lambda (cg) (add-to-list 'groups cg)) customg)
-
-        ;; Anyone can have an accessor function.  This creates a function
-        ;; of the specified name, and also performs a `defsetf' if applicable
-        ;; so that users can `setf' the space returned by this function.
-        (if acces
-            (progn
-              (eieio--defmethod
-               acces (if (eq alloc :class) :static :primary) cname
-               `(lambda (this)
-                  ,(format
-                       "Retrieves the slot `%s' from an object of class `%s'"
-                       name cname)
-                  (if (slot-boundp this ',name)
-                      (eieio-oref this ',name)
-                            ;; Else - Some error?  nil?
-                            nil)))
-
-              (if (fboundp 'gv-define-setter)
-                  ;; FIXME: We should move more of eieio-defclass into the
-                  ;; defclass macro so we don't have to use `eval' and require
-                  ;; `gv' at run-time.
-                  (eval `(gv-define-setter ,acces (eieio--store eieio--object)
-                           (list 'eieio-oset eieio--object '',name
-                                 eieio--store)))
-                ;; Provide a setf method.  It would be cleaner to use
-                ;; defsetf, but that would require CL at runtime.
-                (put acces 'setf-method
-                     `(lambda (widget)
-                        (let* ((--widget-sym-- (make-symbol "--widget--"))
-                               (--store-sym-- (make-symbol "--store--")))
-                          (list
-                           (list --widget-sym--)
-                           (list widget)
-                           (list --store-sym--)
-                           (list 'eieio-oset --widget-sym-- '',name
-                                 --store-sym--)
-                           (list 'getfoo --widget-sym--))))))))
-
-        ;; If a writer is defined, then create a generic method of that
-        ;; name whose purpose is to set the value of the slot.
-        (if writer
-            (eieio--defmethod
-             writer nil cname
-             `(lambda (this value)
-                ,(format "Set the slot `%s' of an object of class `%s'"
-                              name cname)
-                (setf (slot-value this ',name) value))))
-        ;; If a reader is defined, then create a generic method
-        ;; of that name whose purpose is to access this slot value.
-        (if reader
-            (eieio--defmethod
-             reader nil cname
-             `(lambda (this)
-                ,(format "Access the slot `%s' from object of class `%s'"
-                              name cname)
-                (slot-value this ',name))))
-        )
-      (setq slots (cdr slots)))
-
-    ;; Now that everything has been loaded up, all our lists are backwards!
-    ;; Fix that up now.
-    (setf (eieio--class-public-a newc) (nreverse (eieio--class-public-a newc)))
-    (setf (eieio--class-public-d newc) (nreverse (eieio--class-public-d newc)))
-    (setf (eieio--class-public-doc newc) (nreverse (eieio--class-public-doc newc)))
-    (setf (eieio--class-public-type newc)
-          (apply 'vector (nreverse (eieio--class-public-type newc))))
-    (setf (eieio--class-public-custom newc) (nreverse (eieio--class-public-custom newc)))
-    (setf (eieio--class-public-custom-label newc) (nreverse (eieio--class-public-custom-label newc)))
-    (setf (eieio--class-public-custom-group newc) (nreverse (eieio--class-public-custom-group newc)))
-    (setf (eieio--class-public-printer newc) (nreverse (eieio--class-public-printer newc)))
-    (setf (eieio--class-protection newc) (nreverse (eieio--class-protection newc)))
-    (setf (eieio--class-initarg-tuples newc) (nreverse (eieio--class-initarg-tuples newc)))
-
-    ;; The storage for class-class-allocation-type needs to be turned into
-    ;; a vector now.
-    (setf (eieio--class-class-allocation-type newc)
-          (apply 'vector (eieio--class-class-allocation-type newc)))
-
-    ;; Also, take class allocated values, and vectorize them for speed.
-    (setf (eieio--class-class-allocation-values newc)
-          (apply 'vector (eieio--class-class-allocation-values newc)))
-
-    ;; Attach slot symbols into an obarray, and store the index of
-    ;; this slot as the variable slot in this new symbol.  We need to
-    ;; know about primes, because obarrays are best set in vectors of
-    ;; prime number length, and we also need to make our vector small
-    ;; to save space, and also optimal for the number of items we have.
-    (let* ((cnt 0)
-           (pubsyms (eieio--class-public-a newc))
-           (prots (eieio--class-protection newc))
-           (l (length pubsyms))
-           (vl (let ((primes '( 3 5 7 11 13 17 19 23 29 31 37 41 43 47
-                                  53 59 61 67 71 73 79 83 89 97 101 )))
-                 (while (and primes (< (car primes) l))
-                   (setq primes (cdr primes)))
-                 (car primes)))
-           (oa (make-vector vl 0))
-           (newsym))
-      (while pubsyms
-        (setq newsym (intern (symbol-name (car pubsyms)) oa))
-        (set newsym cnt)
-        (setq cnt (1+ cnt))
-        (if (car prots) (put newsym 'protection (car prots)))
-        (setq pubsyms (cdr pubsyms)
-              prots (cdr prots)))
-      (setf (eieio--class-symbol-obarray newc) oa)
-      )
-
-    ;; Create the constructor function
-    (if (class-option-assoc options :abstract)
-        ;; Abstract classes cannot be instantiated.  Say so.
-        (let ((abs (class-option-assoc options :abstract)))
-          (if (not (stringp abs))
-              (setq abs (format "Class %s is abstract" cname)))
-          (fset cname
-                `(lambda (&rest stuff)
-                   ,(format "You cannot create a new object of type %s" cname)
-                   (error ,abs))))
-
-      ;; Non-abstract classes need a constructor.
-      (fset cname
-            `(lambda (newname &rest slots)
-               ,(format "Create a new object with name NAME of class type %s" cname)
-               (apply 'constructor ,cname newname slots)))
-      )
-
-    ;; Set up a specialized doc string.
-    ;; Use stored value since it is calculated in a non-trivial way
-    (put cname 'variable-documentation
-         (class-option-assoc options :documentation))
-
-    ;; Save the file location where this class is defined.
-    (let ((fname (if load-in-progress
-                     load-file-name
-                   buffer-file-name))
-          loc)
-      (when fname
-        (when (string-match "\\.elc\\'" fname)
-          (setq fname (substring fname 0 (1- (length fname)))))
-        (put cname 'class-location fname)))
-
-    ;; We have a list of custom groups.  Store them into the options.
-    (let ((g (class-option-assoc options :custom-groups)))
-      (mapc (lambda (cg) (add-to-list 'g cg)) groups)
-      (if (memq :custom-groups options)
-          (setcar (cdr (memq :custom-groups options)) g)
-        (setq options (cons :custom-groups (cons g options)))))
-
-    ;; Set up the options we have collected.
-    (setf (eieio--class-options newc) options)
-
-    ;; if this is a superclass, clear out parent (which was set to the
-    ;; default superclass eieio-default-superclass)
-    (if clearparent (setf (eieio--class-parent newc) nil))
-
-    ;; Create the cached default object.
-    (let ((cache (make-vector (+ (length (eieio--class-public-a newc)) 3)
-                              nil)))
-      (aset cache 0 'object)
-      (setf (eieio--object-class cache) cname)
-      (setf (eieio--object-name cache) 'default-cache-object)
-      (let ((eieio-skip-typecheck t))
-        ;; All type-checking has been done to our satisfaction
-        ;; before this call.  Don't waste our time in this call..
-        (eieio-set-defaults cache t))
-      (setf (eieio--class-default-object-cache newc) cache))
-
-    ;; Return our new class object
-    ;; newc
-    cname
-    ))
+  `(eieio-defclass ',name ',superclass ',slots ',options-and-doc))
 
-(defun eieio-perform-slot-validation-for-default (slot spec value skipnil)
-  "For SLOT, signal if SPEC does not match VALUE.
-If SKIPNIL is non-nil, then if VALUE is nil return t instead."
-  (if (and (not (eieio-eval-default-p value))
-           (not eieio-skip-typecheck)
-           (not (and skipnil (null value)))
-           (not (eieio-perform-slot-validation spec value)))
-      (signal 'invalid-slot-type (list slot spec value))))
-
-(defun eieio-add-new-slot (newc a d doc type cust label custg print prot init alloc
-                                 &optional defaultoverride skipnil)
-  "Add into NEWC attribute A.
-If A already exists in NEWC, then do nothing.  If it doesn't exist,
-then also add in D (default), DOC, TYPE, CUST, LABEL, CUSTG, PRINT, PROT, and INIT arg.
-Argument ALLOC specifies if the slot is allocated per instance, or per class.
-If optional DEFAULTOVERRIDE is non-nil, then if A exists in NEWC,
-we must override its value for a default.
-Optional argument SKIPNIL indicates if type checking should be skipped
-if default value is nil."
-  ;; Make sure we duplicate those items that are sequences.
-  (condition-case nil
-      (if (sequencep d) (setq d (copy-sequence d)))
-    ;; This copy can fail on a cons cell with a non-cons in the cdr.  Let's skip it if it doesn't work.
-    (error nil))
-  (if (sequencep type) (setq type (copy-sequence type)))
-  (if (sequencep cust) (setq cust (copy-sequence cust)))
-  (if (sequencep custg) (setq custg (copy-sequence custg)))
-
-  ;; To prevent override information w/out specification of storage,
-  ;; we need to do this little hack.
-  (if (member a (eieio--class-class-allocation-a newc)) (setq alloc ':class))
-
-  (if (or (not alloc) (and (symbolp alloc) (eq alloc ':instance)))
-      ;; In this case, we modify the INSTANCE version of a given slot.
-
-      (progn
-
-        ;; Only add this element if it is so-far unique
-        (if (not (member a (eieio--class-public-a newc)))
-            (progn
-              (eieio-perform-slot-validation-for-default a type d skipnil)
-              (setf (eieio--class-public-a newc) (cons a (eieio--class-public-a newc)))
-              (setf (eieio--class-public-d newc) (cons d (eieio--class-public-d newc)))
-              (setf (eieio--class-public-doc newc) (cons doc (eieio--class-public-doc newc)))
-              (setf (eieio--class-public-type newc) (cons type (eieio--class-public-type newc)))
-              (setf (eieio--class-public-custom newc) (cons cust (eieio--class-public-custom newc)))
-              (setf (eieio--class-public-custom-label newc) (cons label (eieio--class-public-custom-label newc)))
-              (setf (eieio--class-public-custom-group newc) (cons custg (eieio--class-public-custom-group newc)))
-              (setf (eieio--class-public-printer newc) (cons print (eieio--class-public-printer newc)))
-              (setf (eieio--class-protection newc) (cons prot (eieio--class-protection newc)))
-              (setf (eieio--class-initarg-tuples newc) (cons (cons init a) (eieio--class-initarg-tuples newc)))
-              )
-          ;; When defaultoverride is true, we are usually adding new local
-          ;; attributes which must override the default value of any slot
-          ;; passed in by one of the parent classes.
-          (when defaultoverride
-            ;; There is a match, and we must override the old value.
-            (let* ((ca (eieio--class-public-a newc))
-                   (np (member a ca))
-                   (num (- (length ca) (length np)))
-                   (dp (if np (nthcdr num (eieio--class-public-d newc))
-                         nil))
-                   (tp (if np (nth num (eieio--class-public-type newc))))
-                   )
-              (if (not np)
-                  (error "EIEIO internal error overriding default value for %s"
-                         a)
-                ;; If type is passed in, is it the same?
-                (if (not (eq type t))
-                    (if (not (equal type tp))
-                        (error
-                         "Child slot type `%s' does not match inherited type `%s' for `%s'"
-                         type tp a)))
-                ;; If we have a repeat, only update the initarg...
-                (unless (eq d eieio-unbound)
-                  (eieio-perform-slot-validation-for-default a tp d skipnil)
-                  (setcar dp d))
-                ;; If we have a new initarg, check for it.
-                (when init
-                  (let* ((inits (eieio--class-initarg-tuples newc))
-                         (inita (rassq a inits)))
-                    ;; Replace the CAR of the associate INITA.
-                    ;;(message "Initarg: %S replace %s" inita init)
-                    (setcar inita init)
-                    ))
-
-                ;; PLN Tue Jun 26 11:57:06 2007 : The protection is
-                ;; checked and SHOULD match the superclass
-                ;; protection. Otherwise an error is thrown. However
-                ;; I wonder if a more flexible schedule might be
-                ;; implemented.
-                ;;
-                ;; EML - We used to have (if prot... here,
-                ;;       but a prot of 'nil means public.
-                ;;
-                (let ((super-prot (nth num (eieio--class-protection newc)))
-                      )
-                  (if (not (eq prot super-prot))
-                      (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
-                             prot super-prot a)))
-                ;; End original PLN
-
-                ;; PLN Tue Jun 26 11:57:06 2007 :
-                ;; Do a non redundant combination of ancient custom
-                ;; groups and new ones.
-                (when custg
-                  (let* ((groups
-                          (nthcdr num (eieio--class-public-custom-group newc)))
-                         (list1 (car groups))
-                         (list2 (if (listp custg) custg (list custg))))
-                    (if (< (length list1) (length list2))
-                        (setq list1 (prog1 list2 (setq list2 list1))))
-                    (dolist (elt list2)
-                      (unless (memq elt list1)
-                        (push elt list1)))
-                    (setcar groups list1)))
-                ;;  End PLN
-
-                ;;  PLN Mon Jun 25 22:44:34 2007 : If a new cust is
-                ;;  set, simply replaces the old one.
-                (when cust
-                  ;; (message "Custom type redefined to %s" cust)
-                  (setcar (nthcdr num (eieio--class-public-custom newc)) cust))
-
-                ;; If a new label is specified, it simply replaces
-                ;; the old one.
-                (when label
-                  ;; (message "Custom label redefined to %s" label)
-                  (setcar (nthcdr num (eieio--class-public-custom-label newc)) label))
-                ;;  End PLN
-
-                ;; PLN Sat Jun 30 17:24:42 2007 : when a new
-                ;; doc is specified, simply replaces the old one.
-                (when doc
-                  ;;(message "Documentation redefined to %s" doc)
-                  (setcar (nthcdr num (eieio--class-public-doc newc))
-                          doc))
-                ;; End PLN
-
-                ;; If a new printer is specified, it simply replaces
-                ;; the old one.
-                (when print
-                  ;; (message "printer redefined to %s" print)
-                  (setcar (nthcdr num (eieio--class-public-printer newc)) print))
-
-                )))
-          ))
-
-    ;; CLASS ALLOCATED SLOTS
-    (let ((value (eieio-default-eval-maybe d)))
-      (if (not (member a (eieio--class-class-allocation-a newc)))
-          (progn
-            (eieio-perform-slot-validation-for-default a type value skipnil)
-            ;; Here we have found a :class version of a slot.  This
-            ;; requires a very different approach.
-            (setf (eieio--class-class-allocation-a newc) (cons a (eieio--class-class-allocation-a newc)))
-            (setf (eieio--class-class-allocation-doc newc) (cons doc (eieio--class-class-allocation-doc newc)))
-            (setf (eieio--class-class-allocation-type newc) (cons type (eieio--class-class-allocation-type newc)))
-            (setf (eieio--class-class-allocation-custom newc) (cons cust (eieio--class-class-allocation-custom newc)))
-            (setf (eieio--class-class-allocation-custom-label newc) (cons label (eieio--class-class-allocation-custom-label newc)))
-            (setf (eieio--class-class-allocation-custom-group newc) (cons custg (eieio--class-class-allocation-custom-group newc)))
-            (setf (eieio--class-class-allocation-protection newc) (cons prot (eieio--class-class-allocation-protection newc)))
-            ;; Default value is stored in the 'values section, since new objects
-            ;; can't initialize from this element.
-            (setf (eieio--class-class-allocation-values newc) (cons value (eieio--class-class-allocation-values newc))))
-        (when defaultoverride
-          ;; There is a match, and we must override the old value.
-          (let* ((ca (eieio--class-class-allocation-a newc))
-                 (np (member a ca))
-                 (num (- (length ca) (length np)))
-                 (dp (if np
-                         (nthcdr num
-                                 (eieio--class-class-allocation-values newc))
-                       nil))
-                 (tp (if np (nth num (eieio--class-class-allocation-type newc))
-                       nil)))
-            (if (not np)
-                (error "EIEIO internal error overriding default value for %s"
-                       a)
-              ;; If type is passed in, is it the same?
-              (if (not (eq type t))
-                  (if (not (equal type tp))
-                      (error
-                       "Child slot type `%s' does not match inherited type `%s' for `%s'"
-                       type tp a)))
-              ;; EML - Note: the only reason to override a class bound slot
-              ;;       is to change the default, so allow unbound in.
-
-              ;; If we have a repeat, only update the value...
-              (eieio-perform-slot-validation-for-default a tp value skipnil)
-              (setcar dp value))
-
-            ;; PLN Tue Jun 26 11:57:06 2007 : The protection is
-            ;; checked and SHOULD match the superclass
-            ;; protection. Otherwise an error is thrown. However
-            ;; I wonder if a more flexible schedule might be
-            ;; implemented.
-            (let ((super-prot
-                   (car (nthcdr num (eieio--class-class-allocation-protection newc)))))
-              (if (not (eq prot super-prot))
-                  (error "Child slot protection `%s' does not match inherited protection `%s' for `%s'"
-                         prot super-prot a)))
-            ;; Do a non redundant combination of ancient custom groups
-            ;; and new ones.
-            (when custg
-              (let* ((groups
-                      (nthcdr num (eieio--class-class-allocation-custom-group newc)))
-                     (list1 (car groups))
-                     (list2 (if (listp custg) custg (list custg))))
-                (if (< (length list1) (length list2))
-                    (setq list1 (prog1 list2 (setq list2 list1))))
-                (dolist (elt list2)
-                  (unless (memq elt list1)
-                    (push elt list1)))
-                (setcar groups list1)))
-
-            ;; PLN Sat Jun 30 17:24:42 2007 : when a new
-            ;; doc is specified, simply replaces the old one.
-            (when doc
-              ;;(message "Documentation redefined to %s" doc)
-              (setcar (nthcdr num (eieio--class-class-allocation-doc newc))
-                      doc))
-            ;; End PLN
-
-            ;; If a new printer is specified, it simply replaces
-            ;; the old one.
-            (when print
-              ;; (message "printer redefined to %s" print)
-              (setcar (nthcdr num (eieio--class-class-allocation-printer newc)) print))
-
-            ))
-        ))
-    ))
-
-(defun eieio-copy-parents-into-subclass (newc parents)
-  "Copy into NEWC the slots of PARENTS.
-Follow the rules of not overwriting early parents when applying to
-the new child class."
-  (let ((ps (eieio--class-parent newc))
-        (sn (class-option-assoc (eieio--class-options newc)
-                                ':allow-nil-initform)))
-    (while ps
-      ;; First, duplicate all the slots of the parent.
-      (let ((pcv (class-v (car ps))))
-        (let ((pa (eieio--class-public-a pcv))
-              (pd (eieio--class-public-d pcv))
-              (pdoc (eieio--class-public-doc pcv))
-              (ptype (eieio--class-public-type pcv))
-              (pcust (eieio--class-public-custom pcv))
-              (plabel (eieio--class-public-custom-label pcv))
-              (pcustg (eieio--class-public-custom-group pcv))
-              (printer (eieio--class-public-printer pcv))
-              (pprot (eieio--class-protection pcv))
-              (pinit (eieio--class-initarg-tuples pcv))
-              (i 0))
-          (while pa
-            (eieio-add-new-slot newc
-                                 (car pa) (car pd) (car pdoc) (aref ptype i)
-                                 (car pcust) (car plabel) (car pcustg)
-                                 (car printer)
-                                 (car pprot) (car-safe (car pinit)) nil nil sn)
-            ;; Increment each value.
-            (setq pa (cdr pa)
-                  pd (cdr pd)
-                  pdoc (cdr pdoc)
-                  i (1+ i)
-                  pcust (cdr pcust)
-                  plabel (cdr plabel)
-                  pcustg (cdr pcustg)
-                  printer (cdr printer)
-                  pprot (cdr pprot)
-                  pinit (cdr pinit))
-            )) ;; while/let
-        ;; Now duplicate all the class alloc slots.
-        (let ((pa (eieio--class-class-allocation-a pcv))
-              (pdoc (eieio--class-class-allocation-doc pcv))
-              (ptype (eieio--class-class-allocation-type pcv))
-              (pcust (eieio--class-class-allocation-custom pcv))
-              (plabel (eieio--class-class-allocation-custom-label pcv))
-              (pcustg (eieio--class-class-allocation-custom-group pcv))
-              (printer (eieio--class-class-allocation-printer pcv))
-              (pprot (eieio--class-class-allocation-protection pcv))
-              (pval (eieio--class-class-allocation-values pcv))
-              (i 0))
-          (while pa
-            (eieio-add-new-slot newc
-                                 (car pa) (aref pval i) (car pdoc) (aref ptype i)
-                                 (car pcust) (car plabel) (car pcustg)
-                                 (car printer)
-                                 (car pprot) nil ':class sn)
-            ;; Increment each value.
-            (setq pa (cdr pa)
-                  pdoc (cdr pdoc)
-                  pcust (cdr pcust)
-                  plabel (cdr plabel)
-                  pcustg (cdr pcustg)
-                  printer (cdr printer)
-                  pprot (cdr pprot)
-                  i (1+ i))
-            ))) ;; while/let
-      ;; Loop over each parent class
-      (setq ps (cdr ps)))
-    ))
 
 ;;; CLOS style implementation of object creators.
 ;;
@@ -1187,17 +150,6 @@ a string."
 
 ;;; CLOS methods and generics
 ;;
-
-(put 'eieio--defalias 'byte-hunk-handler
-     #'byte-compile-file-form-defalias) ;;(get 'defalias 'byte-hunk-handler)
-(defun eieio--defalias (name body)
-  "Like `defalias', but with less side-effects.
-More specifically, it has no side-effects at all when the new function
-definition is the same (`eq') as the old one."
-  (unless (and (fboundp name)
-               (eq (symbol-function name) body))
-    (defalias name body)))
-
 (defmacro defgeneric (method args &optional doc-string)
   "Create a generic function METHOD.
 DOC-STRING is the base documentation for this class.  A generic
@@ -1209,115 +161,6 @@ top level documentation to a method."
   `(eieio--defalias ',method
                     (eieio--defgeneric-init-form ',method ,doc-string)))
 
-(defun eieio--defgeneric-init-form (method doc-string)
-  "Form to use for the initial definition of a generic."
-  (cond
-   ((or (not (fboundp method))
-        (eq 'autoload (car-safe (symbol-function method))))
-    ;; Make sure the method tables are installed.
-    (eieiomt-install method)
-    ;; Construct the actual body of this function.
-    (eieio-defgeneric-form method doc-string))
-   ((generic-p method) (symbol-function method))           ;Leave it as-is.
-   (t (error "You cannot create a generic/method over an existing symbol: %s"
-             method))))
-
-(defun eieio-defgeneric-form (method doc-string)
-  "The lambda form that would be used as the function defined on METHOD.
-All methods should call the same EIEIO function for dispatch.
-DOC-STRING is the documentation attached to METHOD."
-  `(lambda (&rest local-args)
-     ,doc-string
-     (eieio-generic-call (quote ,method) local-args)))
-
-(defsubst eieio-defgeneric-reset-generic-form (method)
-  "Setup METHOD to call the generic form."
-  (let ((doc-string (documentation method)))
-    (fset method (eieio-defgeneric-form method doc-string))))
-
-(defun eieio-defgeneric-form-primary-only (method doc-string)
-  "The lambda form that would be used as the function defined on METHOD.
-All methods should call the same EIEIO function for dispatch.
-DOC-STRING is the documentation attached to METHOD."
-  `(lambda (&rest local-args)
-     ,doc-string
-     (eieio-generic-call-primary-only (quote ,method) local-args)))
-
-(defsubst eieio-defgeneric-reset-generic-form-primary-only (method)
-  "Setup METHOD to call the generic form."
-  (let ((doc-string (documentation method)))
-    (fset method (eieio-defgeneric-form-primary-only method doc-string))))
-
-(defun eieio-defgeneric-form-primary-only-one (method doc-string
-                                                      class
-                                                      impl
-                                                      )
-  "The lambda form that would be used as the function defined on METHOD.
-All methods should call the same EIEIO function for dispatch.
-DOC-STRING is the documentation attached to METHOD.
-CLASS is the class symbol needed for private method access.
-IMPL is the symbol holding the method implementation."
-  ;; NOTE: I tried out byte compiling this little fcn.  Turns out it
-  ;; is faster to execute this for not byte-compiled.  ie, install this,
-  ;; then measure calls going through here.  I wonder why.
-  (require 'bytecomp)
-  (let ((byte-compile-warnings nil))
-    (byte-compile
-     `(lambda (&rest local-args)
-        ,doc-string
-        ;; This is a cool cheat.  Usually we need to look up in the
-        ;; method table to find out if there is a method or not.  We can
-        ;; instead make that determination at load time when there is
-        ;; only one method.  If the first arg is not a child of the class
-        ;; of that one implementation, then clearly, there is no method def.
-        (if (not (eieio-object-p (car local-args)))
-            ;; Not an object.  Just signal.
-            (signal 'no-method-definition
-                    (list ',method local-args))
-
-          ;; We do have an object.  Make sure it is the right type.
-          (if ,(if (eq class eieio-default-superclass)
-                   nil  ; default superclass means just an obj.  Already asked.
-                 `(not (child-of-class-p (eieio--object-class (car local-args))
-                                         ',class)))
-
-              ;; If not the right kind of object, call no applicable
-              (apply 'no-applicable-method (car local-args)
-                     ',method local-args)
-
-            ;; It is ok, do the call.
-            ;; Fill in inter-call variables then evaluate the method.
-            (let ((scoped-class ',class)
-                  (eieio-generic-call-next-method-list nil)
-                  (eieio-generic-call-key method-primary)
-                  (eieio-generic-call-methodname ',method)
-                  (eieio-generic-call-arglst local-args)
-                  )
-              ,(if (< emacs-major-version 24)
-                  `(apply ,(list 'quote impl) local-args)
-                `(apply #',impl local-args))
-              ;(,impl local-args)
-              )))))))
-
-(defsubst eieio-defgeneric-reset-generic-form-primary-only-one (method)
-  "Setup METHOD to call the generic form."
-  (let* ((doc-string (documentation method))
-         (M (get method 'eieio-method-tree))
-         (entry (car (aref M method-primary)))
-         )
-    (fset method (eieio-defgeneric-form-primary-only-one
-                  method doc-string
-                  (car entry)
-                  (cdr entry)
-                  ))))
-
-(defun eieio-unbind-method-implementations (method)
-  "Make the generic method METHOD have no implementations.
-It will leave the original generic function in place,
-but remove reference to all implementations of METHOD."
-  (put method 'eieio-method-tree nil)
-  (put method 'eieio-method-obarray nil))
-
 (defmacro defmethod (method &rest args)
   "Create a new METHOD through `defgeneric' with ARGS.
 
@@ -1358,139 +201,6 @@ Summary:
               (format "Generically created method `%s'." method)))
        (eieio--defmethod ',method ',key ',class #',code))))
 
-(defun eieio--defmethod (method kind argclass code)
-  "Work part of the `defmethod' macro defining METHOD with ARGS."
-  (let ((key
-         ;; Find optional keys.
-         (cond ((memq kind '(:BEFORE :before)) method-before)
-               ((memq kind '(:AFTER :after)) method-after)
-               ((memq kind '(:STATIC :static)) method-static)
-               ((memq kind '(:PRIMARY :primary nil)) method-primary)
-               ;; Primary key.
-               ;; (t method-primary)
-               (t (error "Unknown method kind %S" kind)))))
-    ;; Make sure there is a generic (when called from defclass).
-    (eieio--defalias
-     method (eieio--defgeneric-init-form
-             method (or (documentation code)
-                        (format "Generically created method `%s'." method))))
-    ;; Create symbol for property to bind to.  If the first arg is of
-    ;; the form (varname vartype) and `vartype' is a class, then
-    ;; that class will be the type symbol.  If not, then it will fall
-    ;; under the type `primary' which is a non-specific calling of the
-    ;; function.
-    (if argclass
-        (if (not (class-p argclass))
-            (error "Unknown class type %s in method parameters"
-                   argclass))
-      ;; Generics are higher.
-      (setq key (eieio-specialized-key-to-generic-key key)))
-    ;; Put this lambda into the symbol so we can find it.
-    (eieiomt-add method code key argclass)
-    )
-
-  (when eieio-optimize-primary-methods-flag
-    ;; Optimizing step:
-    ;;
-    ;; If this method, after this setup, only has primary methods, then
-    ;; we can setup the generic that way.
-    (if (generic-primary-only-p method)
-        ;; If there is only one primary method, then we can go one more
-        ;; optimization step.
-        (if (generic-primary-only-one-p method)
-            (eieio-defgeneric-reset-generic-form-primary-only-one method)
-          (eieio-defgeneric-reset-generic-form-primary-only method))
-      (eieio-defgeneric-reset-generic-form method)))
-
-  method)
-
-;;; Slot type validation
-
-;; This is a hideous hack for replacing `typep' from cl-macs, to avoid
-;; requiring the CL library at run-time.  It can be eliminated if/when
-;; `typep' is merged into Emacs core.
-(defun eieio--typep (val type)
-  (if (symbolp type)
-      (cond ((get type 'cl-deftype-handler)
-             (eieio--typep val (funcall (get type 'cl-deftype-handler))))
-            ((eq type t) t)
-            ((eq type 'null)   (null val))
-            ((eq type 'atom)   (atom val))
-            ((eq type 'float)  (and (numberp val) (not (integerp val))))
-            ((eq type 'real)   (numberp val))
-            ((eq type 'fixnum) (integerp val))
-            ((memq type '(character string-char)) (characterp val))
-            (t
-             (let* ((name (symbol-name type))
-                    (namep (intern (concat name "p"))))
-               (if (fboundp namep)
-                   (funcall `(lambda () (,namep val)))
-                 (funcall `(lambda ()
-                             (,(intern (concat name "-p")) val)))))))
-    (cond ((get (car type) 'cl-deftype-handler)
-           (eieio--typep val (apply (get (car type) 'cl-deftype-handler)
-                                    (cdr type))))
-          ((memq (car type) '(integer float real number))
-           (and (eieio--typep val (car type))
-                (or (memq (cadr type) '(* nil))
-                    (if (consp (cadr type))
-                        (> val (car (cadr type)))
-                      (>= val (cadr type))))
-                (or (memq (caddr type) '(* nil))
-                    (if (consp (car (cddr type)))
-                        (< val (caar (cddr type)))
-                      (<= val (car (cddr type)))))))
-          ((memq (car type) '(and or not))
-           (eval (cons (car type)
-                       (mapcar (lambda (x)
-                                 `(eieio--typep (quote ,val) (quote ,x)))
-                               (cdr type)))))
-          ((memq (car type) '(member member*))
-           (memql val (cdr type)))
-          ((eq (car type) 'satisfies)
-           (funcall `(lambda () (,(cadr type) val))))
-          (t (error "Bad type spec: %s" type)))))
-
-(defun eieio-perform-slot-validation (spec value)
-  "Return non-nil if SPEC does not match VALUE."
-  (or (eq spec t)                       ; t always passes
-      (eq value eieio-unbound)          ; unbound always passes
-      (eieio--typep value spec)))
-
-(defun eieio-validate-slot-value (class slot-idx value slot)
-  "Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
-Checks the :type specifier.
-SLOT is the slot that is being checked, and is only used when throwing
-an error."
-  (if eieio-skip-typecheck
-      nil
-    ;; Trim off object IDX junk added in for the object index.
-    (setq slot-idx (- slot-idx 3))
-    (let ((st (aref (eieio--class-public-type (class-v class)) slot-idx)))
-      (if (not (eieio-perform-slot-validation st value))
-          (signal 'invalid-slot-type (list class slot st value))))))
-
-(defun eieio-validate-class-slot-value (class slot-idx value slot)
-  "Make sure that for CLASS referencing SLOT-IDX, VALUE is valid.
-Checks the :type specifier.
-SLOT is the slot that is being checked, and is only used when throwing
-an error."
-  (if eieio-skip-typecheck
-      nil
-    (let ((st (aref (eieio--class-class-allocation-type (class-v class))
-                    slot-idx)))
-      (if (not (eieio-perform-slot-validation st value))
-          (signal 'invalid-slot-type (list class slot st value))))))
-
-(defun eieio-barf-if-slot-unbound (value instance slotname fn)
-  "Throw a signal if VALUE is a representation of an UNBOUND slot.
-INSTANCE is the object being referenced.  SLOTNAME is the offending
-slot.  If the slot is ok, return VALUE.
-Argument FN is the function calling this verifier."
-  (if (and (eq value eieio-unbound) (not eieio-skip-typecheck))
-      (slot-unbound instance (eieio-object-class instance) slotname fn)
-    value))
-
 ;;; Get/Set slots in an object.
 ;;
 (defmacro oref (obj slot)
@@ -1499,28 +209,6 @@ Slot is the name of the slot when created by `defclass' or the label
 created by the :initarg tag."
   `(eieio-oref ,obj (quote ,slot)))
 
-(defun eieio-oref (obj slot)
-  "Return the value in OBJ at SLOT in the object vector."
-  (eieio--check-type (or eieio-object-p class-p) obj)
-  (eieio--check-type symbolp slot)
-  (if (class-p obj) (eieio-class-un-autoload obj))
-  (let* ((class (if (class-p obj) obj (eieio--object-class obj)))
-         (c (eieio-slot-name-index class obj slot)))
-    (if (not c)
-        ;; It might be missing because it is a :class allocated slot.
-        ;; Let's check that info out.
-        (if (setq c (eieio-class-slot-name-index class slot))
-            ;; Oref that slot.
-            (aref (eieio--class-class-allocation-values (class-v class)) c)
-          ;; The slot-missing method is a cool way of allowing an object author
-          ;; to intercept missing slot definitions.  Since it is also the LAST
-          ;; thing called in this fn, its return value would be retrieved.
-          (slot-missing obj slot 'oref)
-          ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
-          )
-      (eieio--check-type eieio-object-p obj)
-      (eieio-barf-if-slot-unbound (aref obj c) obj slot 'oref))))
-
 (defalias 'slot-value 'eieio-oref)
 (defalias 'set-slot-value 'eieio-oset)
 
@@ -1531,45 +219,6 @@ tag.  SLOT can be the slot name, or the tag specified by the :initarg
 tag in the `defclass' call."
   `(eieio-oref-default ,obj (quote ,slot)))
 
-(defun eieio-oref-default (obj slot)
-  "Do the work for the macro `oref-default' with similar parameters.
-Fills in OBJ's SLOT with its default value."
-  (eieio--check-type (or eieio-object-p class-p) obj)
-  (eieio--check-type symbolp slot)
-  (let* ((cl (if (eieio-object-p obj) (eieio--object-class obj) obj))
-         (c (eieio-slot-name-index cl obj slot)))
-    (if (not c)
-        ;; It might be missing because it is a :class allocated slot.
-        ;; Let's check that info out.
-        (if (setq c
-                  (eieio-class-slot-name-index cl slot))
-            ;; Oref that slot.
-            (aref (eieio--class-class-allocation-values (class-v cl))
-                  c)
-          (slot-missing obj slot 'oref-default)
-          ;;(signal 'invalid-slot-name (list (class-name cl) slot))
-          )
-      (eieio-barf-if-slot-unbound
-       (let ((val (nth (- c 3) (eieio--class-public-d (class-v cl)))))
-         (eieio-default-eval-maybe val))
-       obj cl 'oref-default))))
-
-(defsubst eieio-eval-default-p (val)
-  "Whether the default value VAL should be evaluated for use."
-  (and (consp val) (symbolp (car val)) (fboundp (car val))))
-
-(defun eieio-default-eval-maybe (val)
-  "Check VAL, and return what `oref-default' would provide."
-  (cond
-   ;; Is it a function call?  If so, evaluate it.
-   ((eieio-eval-default-p val)
-    (eval val))
-   ;;;; check for quoted things, and unquote them
-   ;;((and (consp val) (eq (car val) 'quote))
-   ;; (car (cdr val)))
-   ;; return it verbatim
-   (t val)))
-
 ;;; Handy CLOS macros
 ;;
 (defmacro with-slots (spec-list object &rest body)
@@ -1607,13 +256,6 @@ variable name of the same name as the slot."
 (define-obsolete-function-alias
   'object-class-fast #'eieio--object-class "24.4")
 
-(defun eieio-class-name (class) "Return a Lisp like symbol name for CLASS."
-  (eieio--check-type class-p class)
-  ;; I think this is supposed to return a symbol, but to me CLASS is a symbol,
-  ;; and I wanted a string.  Arg!
-  (format "#<class %s>" (symbol-name class)))
-(define-obsolete-function-alias 'class-name #'eieio-class-name "24.4")
-
 (defun eieio-object-name (obj &optional extra)
   "Return a Lisp like symbol string for object OBJ.
 If EXTRA, include that in the string returned to represent the symbol."
@@ -1650,10 +292,6 @@ If EXTRA, include that in the string returned to represent the symbol."
 (define-obsolete-function-alias
   'object-class-name 'eieio-object-class-name "24.4")
 
-(defmacro eieio-class-parents-fast (class)
-  "Return parent classes to CLASS with no check."
-  `(eieio--class-parent (class-v ,class)))
-
 (defun eieio-class-parents (class)
   "Return parent classes to CLASS.  (overload of variable).
 
@@ -1662,130 +300,14 @@ The CLOS function `class-direct-superclasses' is aliased to this function."
   (eieio-class-parents-fast class))
 (define-obsolete-function-alias 'class-parents #'eieio-class-parents "24.4")
 
-(defmacro eieio-class-children-fast (class) "Return child classes to CLASS with no check."
-  `(eieio--class-children (class-v ,class)))
-
 (defun eieio-class-children (class)
   "Return child classes to CLASS.
-
 The CLOS function `class-direct-subclasses' is aliased to this function."
   (eieio--check-type class-p class)
   (eieio-class-children-fast class))
 (define-obsolete-function-alias
   'class-children #'eieio-class-children "24.4")
 
-(defun eieio-c3-candidate (class remaining-inputs)
-  "Return CLASS if it can go in the result now, otherwise nil"
-  ;; Ensure CLASS is not in any position but the first in any of the
-  ;; element lists of REMAINING-INPUTS.
-  (and (not (let ((found nil))
-              (while (and remaining-inputs (not found))
-                (setq found (member class (cdr (car remaining-inputs)))
-                      remaining-inputs (cdr remaining-inputs)))
-              found))
-       class))
-
-(defun eieio-c3-merge-lists (reversed-partial-result remaining-inputs)
-  "Merge REVERSED-PARTIAL-RESULT REMAINING-INPUTS in a consistent order, if possible.
-If a consistent order does not exist, signal an error."
-  (if (let ((tail remaining-inputs)
-            (found nil))
-        (while (and tail (not found))
-          (setq found (car tail) tail (cdr tail)))
-        (not found))
-      ;; If all remaining inputs are empty lists, we are done.
-      (nreverse reversed-partial-result)
-    ;; Otherwise, we try to find the next element of the result. This
-    ;; is achieved by considering the first element of each
-    ;; (non-empty) input list and accepting a candidate if it is
-    ;; consistent with the rests of the input lists.
-    (let* ((found nil)
-           (tail remaining-inputs)
-           (next (progn
-                   (while (and tail (not found))
-                     (setq found (and (car tail)
-                                      (eieio-c3-candidate (caar tail)
-                                                          remaining-inputs))
-                           tail (cdr tail)))
-                   found)))
-      (if next
-          ;; The graph is consistent so far, add NEXT to result and
-          ;; merge input lists, dropping NEXT from their heads where
-          ;; applicable.
-          (eieio-c3-merge-lists
-           (cons next reversed-partial-result)
-           (mapcar (lambda (l) (if (eq (first l) next) (rest l) l))
-                   remaining-inputs))
-        ;; The graph is inconsistent, give up
-        (signal 'inconsistent-class-hierarchy (list remaining-inputs))))))
-
-(defun eieio-class-precedence-dfs (class)
-  "Return all parents of CLASS in depth-first order."
-  (let* ((parents (eieio-class-parents-fast class))
-         (classes (copy-sequence
-                   (apply #'append
-                          (list class)
-                          (or
-                           (mapcar
-                            (lambda (parent)
-                              (cons parent
-                                    (eieio-class-precedence-dfs parent)))
-                            parents)
-                           '((eieio-default-superclass))))))
-         (tail classes))
-    ;; Remove duplicates.
-    (while tail
-      (setcdr tail (delq (car tail) (cdr tail)))
-      (setq tail (cdr tail)))
-    classes))
-
-(defun eieio-class-precedence-bfs (class)
-  "Return all parents of CLASS in breadth-first order."
-  (let ((result)
-        (queue (or (eieio-class-parents-fast class)
-                   '(eieio-default-superclass))))
-    (while queue
-      (let ((head (pop queue)))
-        (unless (member head result)
-          (push head result)
-          (unless (eq head 'eieio-default-superclass)
-            (setq queue (append queue (or (eieio-class-parents-fast head)
-                                          '(eieio-default-superclass))))))))
-    (cons class (nreverse result)))
-  )
-
-(defun eieio-class-precedence-c3 (class)
-  "Return all parents of CLASS in c3 order."
-  (let ((parents (eieio-class-parents-fast class)))
-    (eieio-c3-merge-lists
-     (list class)
-     (append
-      (or
-       (mapcar
-        (lambda (x)
-          (eieio-class-precedence-c3 x))
-        parents)
-       '((eieio-default-superclass)))
-      (list parents))))
-  )
-
-(defun eieio-class-precedence-list (class)
-  "Return (transitively closed) list of parents of CLASS.
-The order, in which the parents are returned depends on the
-method invocation orders of the involved classes."
-  (if (or (null class) (eq class 'eieio-default-superclass))
-      nil
-    (case (class-method-invocation-order class)
-      (:depth-first
-       (eieio-class-precedence-dfs class))
-      (:breadth-first
-       (eieio-class-precedence-bfs class))
-      (:c3
-       (eieio-class-precedence-c3 class))))
-  )
-(define-obsolete-function-alias
-  'class-precedence-list 'eieio-class-precedence-list "24.4")
-
 ;; Official CLOS functions.
 (define-obsolete-function-alias
   'class-direct-superclasses #'eieio-class-parents "24.4")
@@ -1797,10 +319,6 @@ method invocation orders of the involved classes."
   `(car (eieio-class-parents ,class)))
 (define-obsolete-function-alias 'class-parent #'eieio-class-parent "24.4")
 
-(defmacro same-class-fast-p (obj class)
-  "Return t if OBJ is of class-type CLASS with no error checking."
-  `(eq (eieio--object-class ,obj) ,class))
-
 (defun same-class-p (obj class) "Return t if OBJ is of class-type CLASS."
   (eieio--check-type class-p class)
   (eieio--check-type eieio-object-p obj)
@@ -1848,29 +366,6 @@ SLOT is the slot name as specified in `defclass' or the tag created
 with in the :initarg slot.  VALUE can be any Lisp object."
   `(eieio-oset ,obj (quote ,slot) ,value))
 
-(defun eieio-oset (obj slot value)
-  "Do the work for the macro `oset'.
-Fills in OBJ's SLOT with VALUE."
-  (eieio--check-type eieio-object-p obj)
-  (eieio--check-type symbolp slot)
-  (let ((c (eieio-slot-name-index (eieio--object-class obj) obj slot)))
-    (if (not c)
-        ;; It might be missing because it is a :class allocated slot.
-        ;; Let's check that info out.
-        (if (setq c
-                  (eieio-class-slot-name-index (eieio--object-class obj) slot))
-            ;; Oset that slot.
-            (progn
-              (eieio-validate-class-slot-value (eieio--object-class obj) c value slot)
-              (aset (eieio--class-class-allocation-values (class-v (eieio--object-class obj)))
-                    c value))
-          ;; See oref for comment on `slot-missing'
-          (slot-missing obj slot 'oset value)
-          ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
-          )
-      (eieio-validate-slot-value (eieio--object-class obj) c value slot)
-      (aset obj c value))))
-
 (defmacro oset-default (class slot value)
   "Set the default slot in CLASS for SLOT to VALUE.
 The default value is usually set with the :initform tag during class
@@ -1878,32 +373,6 @@ creation.  This allows users to change the default behavior of classes
 after they are created."
   `(eieio-oset-default ,class (quote ,slot) ,value))
 
-(defun eieio-oset-default (class slot value)
-  "Do the work for the macro `oset-default'.
-Fills in the default value in CLASS' in SLOT with VALUE."
-  (eieio--check-type class-p class)
-  (eieio--check-type symbolp slot)
-  (let* ((scoped-class class)
-         (c (eieio-slot-name-index class nil slot)))
-    (if (not c)
-        ;; It might be missing because it is a :class allocated slot.
-        ;; Let's check that info out.
-        (if (setq c (eieio-class-slot-name-index class slot))
-            (progn
-              ;; Oref that slot.
-              (eieio-validate-class-slot-value class c value slot)
-              (aset (eieio--class-class-allocation-values (class-v class)) c
-                    value))
-          (signal 'invalid-slot-name (list (eieio-class-name class) slot)))
-      (eieio-validate-slot-value class c value slot)
-      ;; Set this into the storage for defaults.
-      (setcar (nthcdr (- c 3) (eieio--class-public-d (class-v class)))
-              value)
-      ;; Take the value, and put it into our cache object.
-      (eieio-oset (eieio--class-default-object-cache (class-v class))
-                  slot value)
-      )))
-
 ;;; CLOS queries into classes and slots
 ;;
 (defun slot-boundp (object slot)
@@ -2019,337 +488,9 @@ If SLOT is unbound, do nothing."
   (if (not (slot-boundp object slot))
       nil
     (eieio-oset object slot (delete item (eieio-oref object slot)))))
-
-;;; EIEIO internal search functions
-;;
-(defun eieio-slot-originating-class-p (start-class slot)
-  "Return non-nil if START-CLASS is the first class to define SLOT.
-This is for testing if `scoped-class' is the class that defines SLOT
-so that we can protect private slots."
-  (let ((par (eieio-class-parents start-class))
-        (ret t))
-    (if (not par)
-        t
-      (while (and par ret)
-        (if (intern-soft (symbol-name slot)
-                         (eieio--class-symbol-obarray (class-v (car par))))
-            (setq ret nil))
-        (setq par (cdr par)))
-      ret)))
-
-(defun eieio-slot-name-index (class obj slot)
-  "In CLASS for OBJ find the index of the named SLOT.
-The slot is a symbol which is installed in CLASS by the `defclass'
-call.  OBJ can be nil, but if it is an object, and the slot in question
-is protected, access will be allowed if OBJ is a child of the currently
-`scoped-class'.
-If SLOT is the value created with :initarg instead,
-reverse-lookup that name, and recurse with the associated slot value."
-  ;; Removed checks to outside this call
-  (let* ((fsym (intern-soft (symbol-name slot)
-                            (eieio--class-symbol-obarray (class-v class))))
-         (fsi (if (symbolp fsym) (symbol-value fsym) nil)))
-    (if (integerp fsi)
-        (cond
-         ((not (get fsym 'protection))
-          (+ 3 fsi))
-         ((and (eq (get fsym 'protection) 'protected)
-               (bound-and-true-p scoped-class)
-               (or (child-of-class-p class scoped-class)
-                   (and (eieio-object-p obj)
-                        (child-of-class-p class (eieio-object-class obj)))))
-          (+ 3 fsi))
-         ((and (eq (get fsym 'protection) 'private)
-               (or (and (bound-and-true-p scoped-class)
-                        (eieio-slot-originating-class-p scoped-class slot))
-                   eieio-initializing-object))
-          (+ 3 fsi))
-         (t nil))
-      (let ((fn (eieio-initarg-to-attribute class slot)))
-        (if fn (eieio-slot-name-index class obj fn) nil)))))
-
-(defun eieio-class-slot-name-index (class slot)
-  "In CLASS find the index of the named SLOT.
-The slot is a symbol which is installed in CLASS by the `defclass'
-call.  If SLOT is the value created with :initarg instead,
-reverse-lookup that name, and recurse with the associated slot value."
-  ;; This will happen less often, and with fewer slots.  Do this the
-  ;; storage cheap way.
-  (let* ((a (eieio--class-class-allocation-a (class-v class)))
-         (l1 (length a))
-         (af (memq slot a))
-         (l2 (length af)))
-    ;; Slot # is length of the total list, minus the remaining list of
-    ;; the found slot.
-    (if af (- l1 l2))))
-
-;;; CLOS generics internal function handling
-;;
-(defvar eieio-generic-call-methodname nil
-  "When using `call-next-method', provides a context on how to do it.")
-(defvar eieio-generic-call-arglst nil
-  "When using `call-next-method', provides a context for parameters.")
-(defvar eieio-generic-call-key nil
-  "When using `call-next-method', provides a context for the current key.
-Keys are a number representing :before, :primary, and :after methods.")
-(defvar eieio-generic-call-next-method-list nil
-  "When executing a PRIMARY or STATIC method, track the 'next-method'.
-During executions, the list is first generated, then as each next method
-is called, the next method is popped off the stack.")
-
-(define-obsolete-variable-alias 'eieio-pre-method-execution-hooks
-  'eieio-pre-method-execution-functions "24.3")
-(defvar eieio-pre-method-execution-functions nil
-  "Abnormal hook run just before an EIEIO method is executed.
-The hook function must accept one argument, the list of forms
-about to be executed.")
-
-(defun eieio-generic-call (method args)
-  "Call METHOD with ARGS.
-ARGS provides the context on which implementation to use.
-This should only be called from a generic function."
-  ;; We must expand our arguments first as they are always
-  ;; passed in as quoted symbols
-  (let ((newargs nil) (mclass nil)  (lambdas nil) (tlambdas nil) (keys nil)
-        (eieio-generic-call-methodname method)
-        (eieio-generic-call-arglst args)
-        (firstarg nil)
-        (primarymethodlist nil))
-    ;; get a copy
-    (setq newargs args
-          firstarg (car newargs))
-    ;; Is the class passed in autoloaded?
-    ;; Since class names are also constructors, they can be autoloaded
-    ;; via the autoload command.  Check for this, and load them in.
-    ;; It's ok if it doesn't turn out to be a class.  Probably want that
-    ;; function loaded anyway.
-    (if (and (symbolp firstarg)
-             (fboundp firstarg)
-             (listp (symbol-function firstarg))
-             (eq 'autoload (car (symbol-function firstarg))))
-        (load (nth 1 (symbol-function firstarg))))
-    ;; Determine the class to use.
-    (cond ((eieio-object-p firstarg)
-           (setq mclass (eieio--object-class firstarg)))
-          ((class-p firstarg)
-           (setq mclass firstarg))
-          )
-    ;; Make sure the class is a valid class
-    ;; mclass can be nil (meaning a generic for should be used.
-    ;; mclass cannot have a value that is not a class, however.
-    (when (and (not (null mclass)) (not (class-p mclass)))
-      (error "Cannot dispatch method %S on class %S"
-             method mclass)
-      )
-    ;; Now create a list in reverse order of all the calls we have
-    ;; make in order to successfully do this right.  Rules:
-    ;; 1) Only call generics if scoped-class is not defined
-    ;;    This prevents multiple calls in the case of recursion
-    ;; 2) Only call static if this is a static method.
-    ;; 3) Only call specifics if the definition allows for them.
-    ;; 4) Call in order based on :before, :primary, and :after
-    (when (eieio-object-p firstarg)
-      ;; Non-static calls do all this stuff.
-
-      ;; :after methods
-      (setq tlambdas
-            (if mclass
-                (eieiomt-method-list method method-after mclass)
-              (list (eieio-generic-form method method-after nil)))
-            ;;(or (and mclass (eieio-generic-form method method-after mclass))
-            ;;  (eieio-generic-form method method-after nil))
-            )
-      (setq lambdas (append tlambdas lambdas)
-            keys (append (make-list (length tlambdas) method-after) keys))
-
-      ;; :primary methods
-      (setq tlambdas
-            (or (and mclass (eieio-generic-form method method-primary mclass))
-                (eieio-generic-form method method-primary nil)))
-      (when tlambdas
-        (setq lambdas (cons tlambdas lambdas)
-              keys (cons method-primary keys)
-              primarymethodlist
-              (eieiomt-method-list method method-primary mclass)))
-
-      ;; :before methods
-      (setq tlambdas
-            (if mclass
-                (eieiomt-method-list method method-before mclass)
-              (list (eieio-generic-form method method-before nil)))
-            ;;(or (and mclass (eieio-generic-form method method-before mclass))
-            ;;  (eieio-generic-form method method-before nil))
-            )
-      (setq lambdas (append tlambdas lambdas)
-            keys (append (make-list (length tlambdas) method-before) keys))
-      )
-
-    (if mclass
-        ;; For the case of a class,
-        ;; if there were no methods found, then there could be :static methods.
-        (when (not lambdas)
-          (setq tlambdas
-                (eieio-generic-form method method-static mclass))
-          (setq lambdas (cons tlambdas lambdas)
-                keys (cons method-static keys)
-                primarymethodlist  ;; Re-use even with bad name here
-                (eieiomt-method-list method method-static mclass)))
-      ;; For the case of no class (ie - mclass == nil) then there may
-      ;; be a primary method.
-      (setq tlambdas
-            (eieio-generic-form method method-primary nil))
-      (when tlambdas
-        (setq lambdas (cons tlambdas lambdas)
-              keys (cons method-primary keys)
-              primarymethodlist
-              (eieiomt-method-list method method-primary nil)))
-      )
-
-    (run-hook-with-args 'eieio-pre-method-execution-functions
-                        primarymethodlist)
-
-    ;; Now loop through all occurrences forms which we must execute
-    ;; (which are happily sorted now) and execute them all!
-    (let ((rval nil) (lastval nil) (rvalever nil) (found nil))
-      (while lambdas
-        (if (car lambdas)
-            (let* ((scoped-class (cdr (car lambdas)))
-                   (eieio-generic-call-key (car keys))
-                   (has-return-val
-                    (or (= eieio-generic-call-key method-primary)
-                        (= eieio-generic-call-key method-static)))
-                   (eieio-generic-call-next-method-list
-                    ;; Use the cdr, as the first element is the fcn
-                    ;; we are calling right now.
-                    (when has-return-val (cdr primarymethodlist)))
-                   )
-              (setq found t)
-              ;;(setq rval (apply (car (car lambdas)) newargs))
-              (setq lastval (apply (car (car lambdas)) newargs))
-              (when has-return-val
-                (setq rval lastval
-                      rvalever t))
-              ))
-        (setq lambdas (cdr lambdas)
-              keys (cdr keys)))
-      (if (not found)
-          (if (eieio-object-p (car args))
-              (setq rval (apply 'no-applicable-method (car args) method args)
-                    rvalever t)
-            (signal
-             'no-method-definition
-             (list method args))))
-      ;; Right Here... it could be that lastval is returned when
-      ;; rvalever is nil.  Is that right?
-      rval)))
-
-(defun eieio-generic-call-primary-only (method args)
-  "Call METHOD with ARGS for methods with only :PRIMARY implementations.
-ARGS provides the context on which implementation to use.
-This should only be called from a generic function.
-
-This method is like `eieio-generic-call', but only
-implementations in the :PRIMARY slot are queried.  After many
-years of use, it appears that over 90% of methods in use
-have :PRIMARY implementations only.  We can therefore optimize
-for this common case to improve performance."
-  ;; We must expand our arguments first as they are always
-  ;; passed in as quoted symbols
-  (let ((newargs nil) (mclass nil)  (lambdas nil)
-        (eieio-generic-call-methodname method)
-        (eieio-generic-call-arglst args)
-        (firstarg nil)
-        (primarymethodlist nil)
-        )
-    ;; get a copy
-    (setq newargs args
-          firstarg (car newargs))
-
-    ;; Determine the class to use.
-    (cond ((eieio-object-p firstarg)
-           (setq mclass (eieio--object-class firstarg)))
-          ((not firstarg)
-           (error "Method %s called on nil" method))
-          ((not (eieio-object-p firstarg))
-           (error "Primary-only method %s called on something not an object" method))
-          (t
-           (error "EIEIO Error: Improperly classified method %s as primary only"
-                  method)
-          ))
-    ;; Make sure the class is a valid class
-    ;; mclass can be nil (meaning a generic for should be used.
-    ;; mclass cannot have a value that is not a class, however.
-    (when (null mclass)
-      (error "Cannot dispatch method %S on class %S" method mclass)
-      )
-
-    ;; :primary methods
-    (setq lambdas (eieio-generic-form method method-primary mclass))
-    (setq primarymethodlist  ;; Re-use even with bad name here
-          (eieiomt-method-list method method-primary mclass))
-
-    ;; Now loop through all occurrences forms which we must execute
-    ;; (which are happily sorted now) and execute them all!
-    (let* ((rval nil) (lastval nil) (rvalever nil)
-           (scoped-class (cdr lambdas))
-           (eieio-generic-call-key method-primary)
-           ;; Use the cdr, as the first element is the fcn
-           ;; we are calling right now.
-           (eieio-generic-call-next-method-list (cdr primarymethodlist))
-           )
-
-      (if (or (not lambdas) (not (car lambdas)))
-
-          ;; No methods found for this impl...
-          (if (eieio-object-p (car args))
-              (setq rval (apply 'no-applicable-method (car args) method args)
-                    rvalever t)
-            (signal
-             'no-method-definition
-             (list method args)))
-
-        ;; Do the regular implementation here.
-
-        (run-hook-with-args 'eieio-pre-method-execution-functions
-                            lambdas)
-
-        (setq lastval (apply (car lambdas) newargs))
-        (setq rval lastval
-              rvalever t)
-        )
 
-      ;; Right Here... it could be that lastval is returned when
-      ;; rvalever is nil.  Is that right?
-      rval)))
-
-(defun eieiomt-method-list (method key class)
-  "Return an alist list of methods lambdas.
-METHOD is the method name.
-KEY represents either :before, or :after methods.
-CLASS is the starting class to search from in the method tree.
-If CLASS is nil, then an empty list of methods should be returned."
-  ;; Note: eieiomt - the MT means MethodTree.  See more comments below
-  ;; for the rest of the eieiomt methods.
-
-  ;; Collect lambda expressions stored for the class and its parent
-  ;; classes.
-  (let (lambdas)
-    (dolist (ancestor (eieio-class-precedence-list class))
-      ;; Lookup the form to use for the PRIMARY object for the next level
-      (let ((tmpl (eieio-generic-form method key ancestor)))
-        (when (and tmpl
-                   (or (not lambdas)
-                       ;; This prevents duplicates coming out of the
-                       ;; class method optimizer.  Perhaps we should
-                       ;; just not optimize before/afters?
-                       (not (member tmpl lambdas))))
-          (push tmpl lambdas))))
-
-    ;; Return collected lambda. For :after methods, return in current
-    ;; order (most general class last); Otherwise, reverse order.
-    (if (eq key method-after)
-        lambdas
-      (nreverse lambdas))))
+;;;
+;; Method Calling Functions
 
 (defun next-method-p ()
   "Return non-nil if there is a next method.
@@ -2367,7 +508,7 @@ If REPLACEMENT-ARGS is non-nil, then use them instead of
 arguments passed in at the top level.
 
 Use `next-method-p' to find out if there is a next method to call."
-  (if (not (bound-and-true-p scoped-class))
+  (if (not (eieio--scoped-class))
       (error "`call-next-method' not called within a class specific method"))
   (if (and (/= eieio-generic-call-key method-primary)
            (/= eieio-generic-call-key method-static))
@@ -2381,231 +522,10 @@ Use `next-method-p' to find out if there is a next method to call."
       (let* ((eieio-generic-call-next-method-list
               (cdr eieio-generic-call-next-method-list))
              (eieio-generic-call-arglst newargs)
-             (scoped-class (cdr next))
              (fcn (car next))
              )
-        (apply fcn newargs)
-        ))))
-
-;;;
-;; eieio-method-tree : eieiomt-
-;;
-;; Stored as eieio-method-tree in property list of a generic method
-;;
-;; (eieio-method-tree . [BEFORE PRIMARY AFTER
-;;                       genericBEFORE genericPRIMARY genericAFTER])
-;; and
-;; (eieio-method-obarray . [BEFORE PRIMARY AFTER
-;;                          genericBEFORE genericPRIMARY genericAFTER])
-;;    where the association is a vector.
-;;    (aref 0  -- all static methods.
-;;    (aref 1  -- all methods classified as :before
-;;    (aref 2  -- all methods classified as :primary
-;;    (aref 3  -- all methods classified as :after
-;;    (aref 4  -- a generic classified as :before
-;;    (aref 5  -- a generic classified as :primary
-;;    (aref 6  -- a generic classified as :after
-;;
-(defvar eieiomt-optimizing-obarray nil
-  "While mapping atoms, this contain the obarray being optimized.")
-
-(defun eieiomt-install (method-name)
-  "Install the method tree, and obarray onto METHOD-NAME.
-Do not do the work if they already exist."
-  (let ((emtv (get method-name 'eieio-method-tree))
-        (emto (get method-name 'eieio-method-obarray)))
-    (if (or (not emtv) (not emto))
-        (progn
-          (setq emtv (put method-name 'eieio-method-tree
-                          (make-vector method-num-slots nil))
-                emto (put method-name 'eieio-method-obarray
-                          (make-vector method-num-slots nil)))
-          (aset emto 0 (make-vector 11 0))
-          (aset emto 1 (make-vector 11 0))
-          (aset emto 2 (make-vector 41 0))
-          (aset emto 3 (make-vector 11 0))
-          ))))
-
-(defun eieiomt-add (method-name method key class)
-  "Add to METHOD-NAME the forms METHOD in a call position KEY for CLASS.
-METHOD-NAME is the name created by a call to `defgeneric'.
-METHOD are the forms for a given implementation.
-KEY is an integer (see comment in eieio.el near this function) which
-is associated with the :static :before :primary and :after tags.
-It also indicates if CLASS is defined or not.
-CLASS is the class this method is associated with."
-  (if (or (> key method-num-slots) (< key 0))
-      (error "eieiomt-add: method key error!"))
-  (let ((emtv (get method-name 'eieio-method-tree))
-        (emto (get method-name 'eieio-method-obarray)))
-    ;; Make sure the method tables are available.
-    (if (or (not emtv) (not emto))
-        (error "Programmer error: eieiomt-add"))
-    ;; only add new cells on if it doesn't already exist!
-    (if (assq class (aref emtv key))
-        (setcdr (assq class (aref emtv key)) method)
-      (aset emtv key (cons (cons class method) (aref emtv key))))
-    ;; Add function definition into newly created symbol, and store
-    ;; said symbol in the correct obarray, otherwise use the
-    ;; other array to keep this stuff
-    (if (< key method-num-lists)
-        (let ((nsym (intern (symbol-name class) (aref emto key))))
-          (fset nsym method)))
-    ;; Save the defmethod file location in a symbol property.
-    (let ((fname (if load-in-progress
-                     load-file-name
-                   buffer-file-name))
-          loc)
-      (when fname
-        (when (string-match "\\.elc$" fname)
-          (setq fname (substring fname 0 (1- (length fname)))))
-        (setq loc (get method-name 'method-locations))
-        (add-to-list 'loc
-                     (list class fname))
-        (put method-name 'method-locations loc)))
-    ;; Now optimize the entire obarray
-    (if (< key method-num-lists)
-        (let ((eieiomt-optimizing-obarray (aref emto key)))
-          ;; @todo - Is this overkill?  Should we just clear the symbol?
-          (mapatoms 'eieiomt-sym-optimize eieiomt-optimizing-obarray)))
-    ))
-
-(defun eieiomt-next (class)
-  "Return the next parent class for CLASS.
-If CLASS is a superclass, return variable `eieio-default-superclass'.
-If CLASS is variable `eieio-default-superclass' then return nil.
-This is different from function `class-parent' as class parent returns
-nil for superclasses.  This function performs no type checking!"
-  ;; No type-checking because all calls are made from functions which
-  ;; are safe and do checking for us.
-  (or (eieio-class-parents-fast class)
-      (if (eq class 'eieio-default-superclass)
-          nil
-        '(eieio-default-superclass))))
-
-(defun eieiomt-sym-optimize (s)
-  "Find the next class above S which has a function body for the optimizer."
-  ;; Set the value to nil in case there is no nearest cell.
-  (set s nil)
-  ;; Find the nearest cell that has a function body. If we find one,
-  ;; we replace the nil from above.
-  (let ((external-symbol (intern-soft (symbol-name s))))
-    (catch 'done
-      (dolist (ancestor (rest (eieio-class-precedence-list external-symbol)))
-        (let ((ov (intern-soft (symbol-name ancestor)
-                               eieiomt-optimizing-obarray)))
-          (when (fboundp ov)
-            (set s ov) ;; store ov as our next symbol
-            (throw 'done ancestor)))))))
-
-(defun eieio-generic-form (method key class)
- "Return the lambda form belonging to METHOD using KEY based upon CLASS.
-If CLASS is not a class then use `generic' instead.  If class has
-no form, but has a parent class, then trace to that parent class.
-The first time a form is requested from a symbol, an optimized path
-is memorized for faster future use."
- (let ((emto (aref (get method 'eieio-method-obarray)
-                   (if class key (eieio-specialized-key-to-generic-key key)))))
-   (if (class-p class)
-       ;; 1) find our symbol
-       (let ((cs (intern-soft (symbol-name class) emto)))
-         (if (not cs)
-             ;; 2) If there isn't one, then make one.
-             ;;    This can be slow since it only occurs once
-             (progn
-               (setq cs (intern (symbol-name class) emto))
-               ;; 2.1) Cache its nearest neighbor with a quick optimize
-               ;;      which should only occur once for this call ever
-               (let ((eieiomt-optimizing-obarray emto))
-                 (eieiomt-sym-optimize cs))))
-         ;; 3) If it's bound return this one.
-         (if (fboundp  cs)
-             (cons cs (eieio--class-symbol (class-v class)))
-           ;; 4) If it's not bound then this variable knows something
-           (if (symbol-value cs)
-               (progn
-                 ;; 4.1) This symbol holds the next class in its value
-                 (setq class (symbol-value cs)
-                       cs (intern-soft (symbol-name class) emto))
-                 ;; 4.2) The optimizer should always have chosen a
-                 ;;      function-symbol
-                 ;;(if (fboundp cs)
-                 (cons cs (eieio--class-symbol (class-v (intern (symbol-name class)))))
-                   ;;(error "EIEIO optimizer: erratic data loss!"))
-                 )
-               ;; There never will be a funcall...
-               nil)))
-     ;; for a generic call, what is a list, is the function body we want.
-     (let ((emtl (aref (get method 'eieio-method-tree)
-                       (if class key (eieio-specialized-key-to-generic-key key)))))
-       (if emtl
-           ;; The car of EMTL is supposed to be a class, which in this
-           ;; case is nil, so skip it.
-           (cons (cdr (car emtl)) nil)
-         nil)))))
-
-;;;
-;; Way to assign slots based on a list.  Used for constructors, or
-;; even resetting an object at run-time
-;;
-(defun eieio-set-defaults (obj &optional set-all)
-  "Take object OBJ, and reset all slots to their defaults.
-If SET-ALL is non-nil, then when a default is nil, that value is
-reset.  If SET-ALL is nil, the slots are only reset if the default is
-not nil."
-  (let ((scoped-class (eieio--object-class obj))
-        (eieio-initializing-object t)
-        (pub (eieio--class-public-a (class-v (eieio--object-class obj)))))
-    (while pub
-      (let ((df (eieio-oref-default obj (car pub))))
-        (if (or df set-all)
-            (eieio-oset obj (car pub) df)))
-      (setq pub (cdr pub)))))
-
-(defun eieio-initarg-to-attribute (class initarg)
-  "For CLASS, convert INITARG to the actual attribute name.
-If there is no translation, pass it in directly (so we can cheat if
-need be... May remove that later...)"
-  (let ((tuple (assoc initarg (eieio--class-initarg-tuples (class-v class)))))
-    (if tuple
-        (cdr tuple)
-      nil)))
-
-(defun eieio-attribute-to-initarg (class attribute)
-  "In CLASS, convert the ATTRIBUTE into the corresponding init argument tag.
-This is usually a symbol that starts with `:'."
-  (let ((tuple (rassoc attribute (eieio--class-initarg-tuples (class-v class)))))
-    (if tuple
-        (car tuple)
-      nil)))
-
-
-;;; Here are some special types of errors
-;;
-(intern "no-method-definition")
-(put 'no-method-definition 'error-conditions '(no-method-definition error))
-(put 'no-method-definition 'error-message "No method definition")
-
-(intern "no-next-method")
-(put 'no-next-method 'error-conditions '(no-next-method error))
-(put 'no-next-method 'error-message "No next method")
-
-(intern "invalid-slot-name")
-(put 'invalid-slot-name 'error-conditions '(invalid-slot-name error))
-(put 'invalid-slot-name 'error-message "Invalid slot name")
-
-(intern "invalid-slot-type")
-(put 'invalid-slot-type 'error-conditions '(invalid-slot-type error nil))
-(put 'invalid-slot-type 'error-message "Invalid slot type")
-
-(intern "unbound-slot")
-(put 'unbound-slot 'error-conditions '(unbound-slot error nil))
-(put 'unbound-slot 'error-message "Unbound slot")
-
-(intern "inconsistent-class-hierarchy")
-(put 'inconsistent-class-hierarchy 'error-conditions
-     '(inconsistent-class-hierarchy error nil))
-(put 'inconsistent-class-hierarchy 'error-message "Inconsistent class hierarchy")
+        (eieio--with-scoped-class (cdr next)
+          (apply fcn newargs)) ))))
 
 ;;; Here are some CLOS items that need the CL package
 ;;
@@ -2678,7 +598,7 @@ Called from the constructor routine.")
 (defmethod shared-initialize ((obj eieio-default-superclass) slots)
   "Set slots of OBJ with SLOTS which is a list of name/value pairs.
 Called from the constructor routine."
-  (let ((scoped-class (eieio--object-class obj)))
+  (eieio--with-scoped-class (eieio--object-class obj)
     (while slots
       (let ((rn (eieio-initarg-to-attribute (eieio--object-class obj)
                                             (car slots))))
@@ -2700,27 +620,27 @@ call `shared-initialize' yourself, or you can call `call-next-method'
 to have this constructor called automatically.  If these steps are
 not taken, then new objects of your class will not have their values
 dynamically set from SLOTS."
-    ;; First, see if any of our defaults are `lambda', and
-    ;; re-evaluate them and apply the value to our slots.
-    (let* ((scoped-class (class-v (eieio--object-class this)))
-           (slot (eieio--class-public-a scoped-class))
-           (defaults (eieio--class-public-d scoped-class)))
-      (while slot
-        ;; For each slot, see if we need to evaluate it.
-        ;;
-        ;; Paul Landes said in an email:
-        ;; > CL evaluates it if it can, and otherwise, leaves it as
-        ;; > the quoted thing as you already have.  This is by the
-        ;; > Sonya E. Keene book and other things I've look at on the
-        ;; > web.
-        (let ((dflt (eieio-default-eval-maybe (car defaults))))
-          (when (not (eq dflt (car defaults)))
-            (eieio-oset this (car slot) dflt) ))
-        ;; Next.
-        (setq slot (cdr slot)
-              defaults (cdr defaults))))
-    ;; Shared initialize will parse our slots for us.
-    (shared-initialize this slots))
+  ;; First, see if any of our defaults are `lambda', and
+  ;; re-evaluate them and apply the value to our slots.
+  (let* ((this-class (class-v (eieio--object-class this)))
+         (slot (eieio--class-public-a this-class))
+         (defaults (eieio--class-public-d this-class)))
+    (while slot
+      ;; For each slot, see if we need to evaluate it.
+      ;;
+      ;; Paul Landes said in an email:
+      ;; > CL evaluates it if it can, and otherwise, leaves it as
+      ;; > the quoted thing as you already have.  This is by the
+      ;; > Sonya E. Keene book and other things I've look at on the
+      ;; > web.
+      (let ((dflt (eieio-default-eval-maybe (car defaults))))
+        (when (not (eq dflt (car defaults)))
+          (eieio-oset this (car slot) dflt) ))
+      ;; Next.
+      (setq slot (cdr slot)
+            defaults (cdr defaults))))
+  ;; Shared initialize will parse our slots for us.
+  (shared-initialize this slots))
 
 (defgeneric slot-missing (object slot-name operation &optional new-value)
   "Method invoked when an attempt to access a slot in OBJECT fails.")
@@ -2940,102 +860,6 @@ This may create or delete slots, but does not affect the return value
 of `eq'."
   (error "EIEIO: `change-class' is unimplemented"))
 
-)
-
-;;; Obsolete backward compatibility functions.
-;; Needed to run byte-code compiled with the EIEIO of Emacs-23.
-
-(defun eieio-defmethod (method args)
-  "Obsolete work part of an old version of the `defmethod' macro."
-  (let ((key nil) (body nil) (firstarg nil) (argfix nil) (argclass nil) loopa)
-    ;; find optional keys
-    (setq key
-          (cond ((memq (car args) '(:BEFORE :before))
-                 (setq args (cdr args))
-                 method-before)
-                ((memq (car args) '(:AFTER :after))
-                 (setq args (cdr args))
-                 method-after)
-                ((memq (car args) '(:STATIC :static))
-                 (setq args (cdr args))
-                 method-static)
-                ((memq (car args) '(:PRIMARY :primary))
-                 (setq args (cdr args))
-                 method-primary)
-                ;; Primary key.
-                (t method-primary)))
-    ;; Get body, and fix contents of args to be the arguments of the fn.
-    (setq body (cdr args)
-          args (car args))
-    (setq loopa args)
-    ;; Create a fixed version of the arguments.
-    (while loopa
-      (setq argfix (cons (if (listp (car loopa)) (car (car loopa)) (car loopa))
-                         argfix))
-      (setq loopa (cdr loopa)))
-    ;; Make sure there is a generic.
-    (eieio-defgeneric
-     method
-     (if (stringp (car body))
-         (car body) (format "Generically created method `%s'." method)))
-    ;; create symbol for property to bind to.  If the first arg is of
-    ;; the form (varname vartype) and `vartype' is a class, then
-    ;; that class will be the type symbol.  If not, then it will fall
-    ;; under the type `primary' which is a non-specific calling of the
-    ;; function.
-    (setq firstarg (car args))
-    (if (listp firstarg)
-        (progn
-          (setq argclass  (nth 1 firstarg))
-          (if (not (class-p argclass))
-              (error "Unknown class type %s in method parameters"
-                     (nth 1 firstarg))))
-      ;; Generics are higher.
-      (setq key (eieio-specialized-key-to-generic-key key)))
-    ;; Put this lambda into the symbol so we can find it.
-    (if (byte-code-function-p (car-safe body))
-        (eieiomt-add method (car-safe body) key argclass)
-      (eieiomt-add method (append (list 'lambda (reverse argfix)) body)
-                   key argclass))
-    )
-
-  (when eieio-optimize-primary-methods-flag
-    ;; Optimizing step:
-    ;;
-    ;; If this method, after this setup, only has primary methods, then
-    ;; we can setup the generic that way.
-    (if (generic-primary-only-p method)
-        ;; If there is only one primary method, then we can go one more
-        ;; optimization step.
-        (if (generic-primary-only-one-p method)
-            (eieio-defgeneric-reset-generic-form-primary-only-one method)
-          (eieio-defgeneric-reset-generic-form-primary-only method))
-      (eieio-defgeneric-reset-generic-form method)))
-
-  method)
-(make-obsolete 'eieio-defmethod 'eieio--defmethod "24.1")
-
-(defun eieio-defgeneric (method doc-string)
-  "Obsolete work part of an old version of the `defgeneric' macro."
-  (if (and (fboundp method) (not (generic-p method))
-           (or (byte-code-function-p (symbol-function method))
-               (not (eq 'autoload (car (symbol-function method)))))
-           )
-      (error "You cannot create a generic/method over an existing symbol: %s"
-             method))
-  ;; Don't do this over and over.
-  (unless (fboundp 'method)
-    ;; This defun tells emacs where the first definition of this
-    ;; method is defined.
-    `(defun ,method nil)
-    ;; Make sure the method tables are installed.
-    (eieiomt-install method)
-    ;; Apply the actual body of this function.
-    (fset method (eieio-defgeneric-form method doc-string))
-    ;; Return the method
-    'method))
-(make-obsolete 'eieio-defgeneric nil "24.1")
-
 ;;; Interfacing with edebug
 ;;
 (defun eieio-edebug-prin1-to-string (object &optional noescape)
diff --git a/lisp/emacs-lisp/generic.el b/lisp/emacs-lisp/generic.el
index dd5ff0ec694..cb86a554335 100644
--- a/lisp/emacs-lisp/generic.el
+++ b/lisp/emacs-lisp/generic.el
@@ -93,6 +93,8 @@
 
 ;;; Code:
 
+(eval-when-compile (require 'pcase))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Internal Variables
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -224,18 +226,11 @@ Some generic modes are defined in `generic-x.el'."
   (funcall (intern mode)))
 
 ;;; Comment Functionality
-(defun generic-mode-set-comments (comment-list)
-  "Set up comment functionality for generic mode."
-  (let ((st (make-syntax-table))
-        (chars nil)
-        (comstyles))
-    (make-local-variable 'comment-start)
-    (make-local-variable 'comment-start-skip)
-    (make-local-variable 'comment-end)
 
-    ;; Go through all the comments
+(defun generic--normalise-comments (comment-list)
+  (let ((normalized '()))
     (dolist (start comment-list)
-      (let (end (comstyle ""))
+      (let (end)
         ;; Normalize
         (when (consp start)
           (setq end (cdr start))
@@ -244,58 +239,79 @@ Some generic modes are defined in `generic-x.el'."
         (cond
          ((characterp end)   (setq end (char-to-string end)))
          ((zerop (length end)) (setq end "\n")))
+        (push (cons start end) normalized)))
+    (nreverse normalized)))
 
-        ;; Setup the vars for `comment-region'
-        (if comment-start
-            ;; We have already setup a comment-style, so use style b
-            (progn
-              (setq comstyle "b")
-              (setq comment-start-skip
-                    (concat comment-start-skip "\\|" (regexp-quote start) "+\\s-*")))
-          ;; First comment-style
-          (setq comment-start start)
-          (setq comment-end (if (string-equal end "\n") "" end))
-          (setq comment-start-skip (concat (regexp-quote start) "+\\s-*")))
-
-       ;; Reuse comstyles if necessary
-       (setq comstyle
+(defun generic-set-comment-syntax (st comment-list)
+  "Set up comment functionality for generic mode."
+  (let ((chars nil)
+        (comstyles)
+        (comstyle "")
+        (comment-start nil))
+
+    ;; Go through all the comments.
+    (pcase-dolist (`(,start . ,end) comment-list)
+      (let ((comstyle
+             ;; Reuse comstyles if necessary.
              (or (cdr (assoc start comstyles))
                  (cdr (assoc end comstyles))
-                 comstyle))
+                 ;; Otherwise, use a style not yet in use.
+                 (if (not (rassoc "" comstyles)) "")
+                 (if (not (rassoc "b" comstyles)) "b")
+                 "c")))
        (push (cons start comstyle) comstyles)
        (push (cons end comstyle) comstyles)
 
-        ;; Setup the syntax table
+        ;; Setup the syntax table.
         (if (= (length start) 1)
-            (modify-syntax-entry (string-to-char start)
+            (modify-syntax-entry (aref start 0)
                                  (concat "< " comstyle) st)
-          (let ((c0 (elt start 0)) (c1 (elt start 1)))
-            ;; Store the relevant info but don't update yet
+          (let ((c0 (aref start 0)) (c1 (aref start 1)))
+            ;; Store the relevant info but don't update yet.
             (push (cons c0 (concat (cdr (assoc c0 chars)) "1")) chars)
             (push (cons c1 (concat (cdr (assoc c1 chars))
                                    (concat "2" comstyle))) chars)))
         (if (= (length end) 1)
-            (modify-syntax-entry (string-to-char end)
+            (modify-syntax-entry (aref end 0)
                                  (concat ">" comstyle) st)
-          (let ((c0 (elt end 0)) (c1 (elt end 1)))
-            ;; Store the relevant info but don't update yet
+          (let ((c0 (aref end 0)) (c1 (aref end 1)))
+            ;; Store the relevant info but don't update yet.
             (push (cons c0 (concat (cdr (assoc c0 chars))
                                    (concat "3" comstyle))) chars)
             (push (cons c1 (concat (cdr (assoc c1 chars)) "4")) chars)))))
 
     ;; Process the chars that were part of a 2-char comment marker
+    (with-syntax-table st               ;For `char-syntax'.
     (dolist (cs (nreverse chars))
       (modify-syntax-entry (car cs)
                            (concat (char-to-string (char-syntax (car cs)))
                                    " " (cdr cs))
-                           st))
+                             st)))))
+
+(defun generic-set-comment-vars (comment-list)
+  (when comment-list
+    (setq-local comment-start (caar comment-list))
+    (setq-local comment-end
+                (let ((end (cdar comment-list)))
+                  (if (string-equal end "\n") "" end)))
+    (setq-local comment-start-skip
+                (concat (regexp-opt (mapcar #'car comment-list))
+                        "+[ \t]*"))
+    (setq-local comment-end-skip
+                (concat "[ \t]*" (regexp-opt (mapcar #'cdr comment-list))))))
+
+(defun generic-mode-set-comments (comment-list)
+  "Set up comment functionality for generic mode."
+  (let ((st (make-syntax-table))
+        (comment-list (generic--normalise-comments comment-list)))
+    (generic-set-comment-syntax st comment-list)
+    (generic-set-comment-vars comment-list)
     (set-syntax-table st)))
 
 (defun generic-bracket-support ()
   "Imenu support for [KEYWORD] constructs found in INF, INI and Samba files."
-  (setq imenu-generic-expression
-        '((nil "^\\[\\(.*\\)\\]" 1))
-        imenu-case-fold-search t))
+  (setq-local imenu-generic-expression '((nil "^\\[\\(.*\\)\\]" 1)))
+  (setq-local imenu-case-fold-search t))
 
 ;;;###autoload
 (defun generic-make-keywords-list (keyword-list face &optional prefix suffix)
@@ -306,6 +322,7 @@ expression that matches these keywords and concatenates it with
 PREFIX and SUFFIX.  Then it returns a construct based on this
 regular expression that can be used as an element of
 `font-lock-keywords'."
+  (declare (obsolete regexp-opt "24.4"))
   (unless (listp keyword-list)
     (error "Keywords argument must be a list of strings"))
   (list (concat prefix "\\_<"
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 8d74afac285..cbd8854e7d6 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -225,11 +225,13 @@ font-lock keywords will not be case sensitive."
   (setq-local syntax-begin-function 'beginning-of-defun)
   (setq font-lock-defaults
         `((lisp-font-lock-keywords
-           lisp-font-lock-keywords-1 lisp-font-lock-keywords-2)
+           lisp-font-lock-keywords-1
+           lisp-font-lock-keywords-2)
           nil ,keywords-case-insensitive nil nil
           (font-lock-mark-block-function . mark-defun)
           (font-lock-syntactic-face-function
-           . lisp-font-lock-syntactic-face-function))))
+           . lisp-font-lock-syntactic-face-function)))
+  (prog-prettify-install lisp--prettify-symbols-alist))
 
 (defun lisp-outline-level ()
   "Lisp mode `outline-level' function."
@@ -266,6 +268,7 @@ font-lock keywords will not be case sensitive."
 
 (defvar lisp-mode-shared-map
   (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map prog-mode-map)
     (define-key map "\e\C-q" 'indent-sexp)
     (define-key map "\177" 'backward-delete-char-untabify)
     ;; This gets in the way when viewing a Lisp file in view-mode.  As
@@ -447,6 +450,9 @@ All commands in `lisp-mode-shared-map' are inherited by this map.")
   :type 'hook
   :group 'lisp)
 
+(defconst lisp--prettify-symbols-alist
+  '(("lambda"  . ?λ)))
+
 (define-derived-mode emacs-lisp-mode prog-mode "Emacs-Lisp"
   "Major mode for editing Lisp code to run in Emacs.
 Commands:
@@ -808,6 +814,7 @@ With argument, print output into current buffer."
 (defun eval-sexp-add-defvars (exp &optional pos)
   "Prepend EXP with all the `defvar's that precede it in the buffer.
 POS specifies the starting position where EXP was found and defaults to point."
+  (setq exp (macroexpand-all exp))      ;Eager macro-expansion.
   (if (not lexical-binding)
       exp
     (save-excursion
diff --git a/lisp/emacs-lisp/lisp.el b/lisp/emacs-lisp/lisp.el
index b221d2f823d..a31bef2391d 100644
--- a/lisp/emacs-lisp/lisp.el
+++ b/lisp/emacs-lisp/lisp.el
@@ -1,4 +1,4 @@
-;;; lisp.el --- Lisp editing commands for Emacs
+;;; lisp.el --- Lisp editing commands for Emacs  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 1985-1986, 1994, 2000-2013 Free Software Foundation,
 ;; Inc.
@@ -262,9 +262,9 @@ is called as a function to find the defun's beginning."
       ;; convention, fallback on the old implementation.
       (wrong-number-of-arguments
        (if (> arg 0)
-           (dotimes (i arg)
+           (dotimes (_ arg)
              (funcall beginning-of-defun-function))
-         (dotimes (i (- arg))
+         (dotimes (_ (- arg))
            (funcall end-of-defun-function))))))
 
    ((or defun-prompt-regexp open-paren-in-column-0-is-defun-start)
@@ -442,7 +442,7 @@ it marks the next defun after the ones already marked."
              (beginning-of-defun))
            (re-search-backward "^\n" (- (point) 1) t)))))
 
-(defun narrow-to-defun (&optional arg)
+(defun narrow-to-defun (&optional _arg)
   "Make text outside current defun invisible.
 The defun visible is the one that contains point or follows point.
 Optional ARG is ignored."
@@ -662,10 +662,96 @@ considered."
         (completion-in-region (nth 0 data) (nth 1 data) (nth 2 data)
                               (plist-get plist :predicate))))))
 
-
-(defun lisp-completion-at-point (&optional predicate)
+(defun lisp--local-variables-1 (vars sexp)
+  "Return the vars locally bound around the witness, or nil if not found."
+  (let (res)
+    (while
+        (unless
+            (setq res
+                  (pcase sexp
+                    (`(,(or `let `let*) ,bindings)
+                     (let ((vars vars))
+                       (when (eq 'let* (car sexp))
+                         (dolist (binding (cdr (reverse bindings)))
+                           (push (or (car-safe binding) binding) vars)))
+                       (lisp--local-variables-1
+                        vars (car (cdr-safe (car (last bindings)))))))
+                    (`(,(or `let `let*) ,bindings . ,body)
+                     (let ((vars vars))
+                       (dolist (binding bindings)
+                         (push (or (car-safe binding) binding) vars))
+                       (lisp--local-variables-1 vars (car (last body)))))
+                    (`(lambda ,_) (setq sexp nil))
+                    (`(lambda ,args . ,body)
+                     (lisp--local-variables-1
+                      (append args vars) (car (last body))))
+                    (`(condition-case ,_ ,e) (lisp--local-variables-1 vars e))
+                    (`(condition-case ,v ,_ . ,catches)
+                     (lisp--local-variables-1
+                      (cons v vars) (cdr (car (last catches)))))
+                    (`(,_ . ,_)
+                     (lisp--local-variables-1 vars (car (last sexp))))
+                    (`lisp--witness--lisp (or vars '(nil)))
+                    (_ nil)))
+          (setq sexp (ignore-errors (butlast sexp)))))
+    res))
+
+(defun lisp--local-variables ()
+  "Return a list of locally let-bound variables at point."
+  (save-excursion
+    (skip-syntax-backward "w_")
+    (let* ((ppss (syntax-ppss))
+           (txt (buffer-substring-no-properties (or (car (nth 9 ppss)) (point))
+                                                (or (nth 8 ppss) (point))))
+           (closer ()))
+      (dolist (p (nth 9 ppss))
+        (push (cdr (syntax-after p)) closer))
+      (setq closer (apply #'string closer))
+      (let* ((sexp (car (read-from-string
+                         (concat txt "lisp--witness--lisp" closer))))
+             (macroexpand-advice (lambda (expander form &rest args)
+                                   (condition-case nil
+                                       (apply expander form args)
+                                     (error form))))
+             (sexp
+              (unwind-protect
+                  (progn
+                    (advice-add 'macroexpand :around macroexpand-advice)
+                    (macroexpand-all sexp))
+                (advice-remove 'macroexpand macroexpand-advice)))
+             (vars (lisp--local-variables-1 nil sexp)))
+        (delq nil
+              (mapcar (lambda (var)
+                        (and (symbolp var)
+                             (not (string-match (symbol-name var) "\\`[&_]"))
+                             ;; Eliminate uninterned vars.
+                             (intern-soft var)
+                             var))
+                      vars))))))
+
+(defvar lisp--local-variables-completion-table
+  ;; Use `defvar' rather than `defconst' since defconst would purecopy this
+  ;; value, which would doubly fail: it would fail because purecopy can't
+  ;; handle the recursive bytecode object, and it would fail because it would
+  ;; move `lastpos' and `lastvars' to pure space where they'd be immutable!
+  (let ((lastpos nil) (lastvars nil))
+    (letrec ((hookfun (lambda ()
+                        (setq lastpos nil)
+                        (remove-hook 'post-command-hook hookfun))))
+      (completion-table-dynamic
+       (lambda (_string)
+         (save-excursion
+           (skip-syntax-backward "_w")
+           (let ((newpos (cons (point) (current-buffer))))
+             (unless (equal lastpos newpos)
+               (add-hook 'post-command-hook hookfun)
+               (setq lastpos newpos)
+               (setq lastvars
+                     (mapcar #'symbol-name (lisp--local-variables))))))
+         lastvars)))))
+
+(defun lisp-completion-at-point (&optional _predicate)
   "Function used for `completion-at-point-functions' in `emacs-lisp-mode'."
-  ;; FIXME: the `end' could be after point?
   (with-syntax-table emacs-lisp-mode-syntax-table
     (let* ((pos (point))
            (beg (condition-case nil
@@ -691,7 +777,9 @@ considered."
                 ;; use it to provide a more specific completion table in some
                 ;; cases.  E.g. filter out keywords that are not understood by
                 ;; the macro/function being called.
-                (list nil obarray       ;Could be anything.
+                (list nil (completion-table-in-turn
+                           lisp--local-variables-completion-table
+                           obarray)       ;Could be anything.
                       :annotation-function
                       (lambda (str) (if (fboundp (intern-soft str)) " <f>")))
               ;; Looks like a funcall position.  Let's double check.
diff --git a/lisp/emacs-lisp/macroexp.el b/lisp/emacs-lisp/macroexp.el
index 6bb796434fd..e8b513fcd3e 100644
--- a/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@ -111,15 +111,20 @@ and also to avoid outputting the warning during normal execution."
        (funcall (eval (cadr form)))
        (byte-compile-constant nil)))
 
+(defun macroexp--compiling-p ()
+  "Return non-nil if we're macroexpanding for the compiler."
+  ;; FIXME: ¡¡Major Ugly Hack!! To determine whether the output of this
+  ;; macro-expansion will be processed by the byte-compiler, we check
+  ;; circumstantial evidence.
+  (member '(declare-function . byte-compile-macroexpand-declare-function)
+          macroexpand-all-environment))
+
+
 (defun macroexp--warn-and-return (msg form)
   (let ((when-compiled (lambda () (byte-compile-log-warning msg t))))
     (cond
      ((null msg) form)
-     ;; FIXME: ¡¡Major Ugly Hack!! To determine whether the output of this
-     ;; macro-expansion will be processed by the byte-compiler, we check
-     ;; circumstantial evidence.
-     ((member '(declare-function . byte-compile-macroexpand-declare-function)
-                macroexpand-all-environment)
+     ((macroexp--compiling-p)
       `(progn
          (macroexp--funcall-if-compiled ',when-compiled)
          ,form))
diff --git a/lisp/emacs-lisp/package-x.el b/lisp/emacs-lisp/package-x.el
index a3ce1672a63..17919d9bbeb 100644
--- a/lisp/emacs-lisp/package-x.el
+++ b/lisp/emacs-lisp/package-x.el
@@ -162,9 +162,11 @@ DESCRIPTION is the text of the news item."
                                description
                                archive-url))
 
-(defun package-upload-buffer-internal (pkg-info extension &optional archive-url)
+(declare-function lm-commentary "lisp-mnt" (&optional file))
+
+(defun package-upload-buffer-internal (pkg-desc extension &optional archive-url)
   "Upload a package whose contents are in the current buffer.
-PKG-INFO is the package info, see `package-buffer-info'.
+PKG-DESC is the `package-desc'.
 EXTENSION is the file extension, a string.  It can be either
 \"el\" or \"tar\".
 
@@ -196,18 +198,18 @@ if it exists."
         (error "Aborted")))
     (save-excursion
       (save-restriction
-        (let* ((file-type (cond
-                           ((equal extension "el") 'single)
-                           ((equal extension "tar") 'tar)
-                           (t (error "Unknown extension `%s'" extension))))
-               (file-name (aref pkg-info 0))
-               (pkg-name (intern file-name))
-               (requires (aref pkg-info 1))
-               (desc (if (string= (aref pkg-info 2) "")
+        (let* ((file-type (package-desc-kind pkg-desc))
+               (pkg-name (package-desc-name pkg-desc))
+               (requires (package-desc-reqs pkg-desc))
+               (desc (if (eq (package-desc-summary pkg-desc)
+                             package--default-summary)
                          (read-string "Description of package: ")
-                       (aref pkg-info 2)))
-               (pkg-version (aref pkg-info 3))
-               (commentary (aref pkg-info 4))
+                       (package-desc-summary pkg-desc)))
+               (pkg-version (package-desc-version pkg-desc))
+               (commentary
+                (pcase file-type
+                  (`single (lm-commentary))
+                  (`tar nil))) ;; FIXME: Get it from the README file.
                (split-version (version-to-list pkg-version))
                (pkg-buffer (current-buffer)))
 
@@ -215,7 +217,8 @@ if it exists."
           ;; from `package-archive-upload-base' otherwise.
           (let ((contents (or (package--archive-contents-from-url archive-url)
                               (package--archive-contents-from-file)))
-                (new-desc (vector split-version requires desc file-type)))
+                (new-desc (package-make-ac-desc
+                           split-version requires desc file-type)))
             (if (> (car contents) package-archive-version)
                 (error "Unrecognized archive version %d" (car contents)))
             (let ((elt (assq pkg-name (cdr contents))))
@@ -232,6 +235,7 @@ if it exists."
             ;; this and the package itself.  For now we assume ELPA is
             ;; writable via file primitives.
             (let ((print-level nil)
+                  (print-quoted t)
                   (print-length nil))
               (write-region (concat (pp-to-string contents) "\n")
                             nil
@@ -241,29 +245,29 @@ if it exists."
             ;; If there is a commentary section, write it.
             (when commentary
               (write-region commentary nil
-                            (expand-file-name
-                             (concat (symbol-name pkg-name) "-readme.txt")
-                             package-archive-upload-base)))
+                            (expand-file-name
+                             (concat (symbol-name pkg-name) "-readme.txt")
+                             package-archive-upload-base)))
 
             (set-buffer pkg-buffer)
             (write-region (point-min) (point-max)
                           (expand-file-name
-                           (concat file-name "-" pkg-version "." extension)
+                           (format "%s-%s.%s" pkg-name pkg-version extension)
                            package-archive-upload-base)
                           nil nil nil 'excl)
 
             ;; Write a news entry.
             (and package-update-news-on-upload
                  archive-url
-                 (package--update-news (concat file-name "." extension)
+                 (package--update-news (format "%s.%s" pkg-name extension)
                                        pkg-version desc archive-url))
 
             ;; special-case "package": write a second copy so that the
             ;; installer can easily find the latest version.
-            (if (string= file-name "package")
+            (if (eq pkg-name 'package)
                 (write-region (point-min) (point-max)
                               (expand-file-name
-                               (concat file-name "." extension)
+                               (format "%s.%s" pkg-name extension)
                                package-archive-upload-base)
                               nil nil nil 'ask))))))))
 
@@ -275,8 +279,8 @@ destination, prompt for one."
   (save-excursion
     (save-restriction
       ;; Find the package in this buffer.
-      (let ((pkg-info (package-buffer-info)))
-        (package-upload-buffer-internal pkg-info "el")))))
+      (let ((pkg-desc (package-buffer-info)))
+        (package-upload-buffer-internal pkg-desc "el")))))
 
 (defun package-upload-file (file)
   "Upload the Emacs Lisp package FILE to the package archive.
@@ -288,12 +292,13 @@ destination, prompt for one."
   (interactive "fPackage file name: ")
   (with-temp-buffer
     (insert-file-contents-literally file)
-    (let ((info (cond
-                 ((string-match "\\.tar$" file) (package-tar-file-info file))
-                 ((string-match "\\.el$" file) (package-buffer-info))
-                 (t (error "Unrecognized extension `%s'"
-                           (file-name-extension file))))))
-      (package-upload-buffer-internal info (file-name-extension file)))))
+    (let ((pkg-desc
+           (cond
+            ((string-match "\\.tar\\'" file) (package-tar-file-info file))
+            ((string-match "\\.el\\'" file) (package-buffer-info))
+            (t (error "Unrecognized extension `%s'"
+                      (file-name-extension file))))))
+      (package-upload-buffer-internal pkg-desc (file-name-extension file)))))
 
 (defun package-gnus-summary-upload ()
   "Upload a package contained in the current *Article* buffer.
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index 41b635bbe30..d5176abded0 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -170,6 +170,8 @@
 
 ;;; Code:
 
+(eval-when-compile (require 'cl-lib))
+
 (require 'tabulated-list)
 
 (defgroup package nil
@@ -262,11 +264,8 @@ Lower version numbers than this will probably be understood as well.")
 ;; We don't prime the cache since it tends to get out of date.
 (defvar package-archive-contents nil
   "Cache of the contents of the Emacs Lisp Package Archive.
-This is an alist mapping package names (symbols) to package
-descriptor vectors.  These are like the vectors for `package-alist'
-but have extra entries: one which is 'tar for tar packages and
-'single for single-file packages, and one which is the name of
-the archive from which it came.")
+This is an alist mapping package names (symbols) to
+`package--desc' structures.")
 (put 'package-archive-contents 'risky-local-variable t)
 
 (defcustom package-user-dir (locate-user-emacs-file "elpa")
@@ -297,6 +296,62 @@ contrast, `package-user-dir' contains packages for personal use."
   :group 'package
   :version "24.1")
 
+(defvar package--default-summary "No description available.")
+
+(cl-defstruct (package-desc
+               ;; Rename the default constructor from `make-package-desc'.
+               (:constructor package-desc-create)
+               ;; Has the same interface as the old `define-package',
+               ;; which is still used in the "foo-pkg.el" files. Extra
+               ;; options can be supported by adding additional keys.
+               (:constructor
+                package-desc-from-define
+                (name-string version-string &optional summary requirements
+                 &key kind archive
+                 &aux
+                 (name (intern name-string))
+                 (version (version-to-list version-string))
+                 (reqs (mapcar #'(lambda (elt)
+                                   (list (car elt)
+                                         (version-to-list (cadr elt))))
+                               (if (eq 'quote (car requirements))
+                                   (nth 1 requirements)
+                                 requirements))))))
+  "Structure containing information about an individual package.
+
+Slots:
+
+`name' Name of the package, as a symbol.
+
+`version' Version of the package, as a version list.
+
+`summary' Short description of the package, typically taken from
+the first line of the file.
+
+`reqs' Requirements of the package. A list of (PACKAGE
+VERSION-LIST) naming the dependent package and the minimum
+required version.
+
+`kind' The distribution format of the package. Currently, it is
+either `single' or `tar'.
+
+`archive' The name of the archive (as a string) whence this
+package came."
+  name
+  version
+  (summary package--default-summary)
+  reqs
+  kind
+  archive)
+
+;; Package descriptor format used in finder-inf.el and package--builtins.
+(cl-defstruct (package--bi-desc
+               (:constructor package-make-builtin (version summary))
+               (:type vector))
+  version
+  reqs
+  summary)
+
 ;; The value is precomputed in finder-inf.el, but don't load that
 ;; until it's needed (i.e. when `package-initialize' is called).
 (defvar package--builtins nil
@@ -305,27 +360,14 @@ The actual value is initialized by loading the library
 `finder-inf'; this is not done until it is needed, e.g. by the
 function `package-built-in-p'.
 
-Each element has the form (PKG . DESC), where PKG is a package
-name (a symbol) and DESC is a vector that describes the package.
-The vector DESC has the form [VERSION-LIST REQS DOCSTRING].
-  VERSION-LIST is a version list.
-  REQS is a list of packages required by the package, each
-   requirement having the form (NAME VL), where NAME is a string
-   and VL is a version list.
-  DOCSTRING is a brief description of the package.")
+Each element has the form (PKG . PACKAGE-BI-DESC), where PKG is a package
+name (a symbol) and DESC is a `package--bi-desc' structure.")
 (put 'package--builtins 'risky-local-variable t)
 
 (defvar package-alist nil
   "Alist of all packages available for activation.
 Each element has the form (PKG . DESC), where PKG is a package
-name (a symbol) and DESC is a vector that describes the package.
-
-The vector DESC has the form [VERSION-LIST REQS DOCSTRING].
-  VERSION-LIST is a version list.
-  REQS is a list of packages required by the package, each
-   requirement having the form (NAME VL) where NAME is a string
-   and VL is a version list.
-  DOCSTRING is a brief description of the package.
+name (a symbol) and DESC is a `package-desc' structure.
 
 This variable is set automatically by `package-load-descriptor',
 called via `package-initialize'.  To change which packages are
@@ -339,7 +381,10 @@ loaded and/or activated, customize `package-load-list'.")
 (defvar package-obsolete-alist nil
   "Representation of obsolete packages.
 Like `package-alist', but maps package name to a second alist.
-The inner alist is keyed by version.")
+The inner alist is keyed by version.
+
+Each element of the list is (NAME . VERSION-ALIST), where each
+entry in VERSION-ALIST is (VERSION-LIST . PACKAGE-DESC).")
 (put 'package-obsolete-alist 'risky-local-variable t)
 
 (defun package-version-join (vlist)
@@ -430,26 +475,16 @@ the package by calling `package-load-descriptor'."
          ;; Actually load the descriptor:
          (package-load-descriptor dir subdir))))
 
-(defsubst package-desc-vers (desc)
-  "Extract version from a package description vector."
-  (aref desc 0))
+(define-obsolete-function-alias 'package-desc-vers 'package-desc-version "24.4")
 
-(defsubst package-desc-reqs (desc)
-  "Extract requirements from a package description vector."
-  (aref desc 1))
+(define-obsolete-function-alias 'package-desc-doc 'package-desc-summary "24.4")
 
-(defsubst package-desc-doc (desc)
-  "Extract doc string from a package description vector."
-  (aref desc 2))
-
-(defsubst package-desc-kind (desc)
-  "Extract the kind of download from an archive package description vector."
-  (aref desc 3))
 
 (defun package--dir (name version)
+  ;; FIXME: Keep this as a field in the package-desc.
   "Return the directory where a package is installed, or nil if none.
-NAME and VERSION are both strings."
-  (let* ((subdir (concat name "-" version))
+NAME is a symbol and VERSION is a string."
+  (let* ((subdir (format "%s-%s" name version))
          (dir-list (cons package-user-dir package-directory-list))
          pkg-dir)
     (while dir-list
@@ -460,9 +495,9 @@ NAME and VERSION are both strings."
           (setq dir-list (cdr dir-list)))))
     pkg-dir))
 
-(defun package-activate-1 (package pkg-vec)
-  (let* ((name (symbol-name package))
-         (version-str (package-version-join (package-desc-vers pkg-vec)))
+(defun package-activate-1 (pkg-desc)
+  (let* ((name (package-desc-name pkg-desc))
+         (version-str (package-version-join (package-desc-version pkg-desc)))
          (pkg-dir (package--dir name version-str)))
     (unless pkg-dir
       (error "Internal error: unable to find directory for `%s-%s'"
@@ -475,8 +510,8 @@ NAME and VERSION are both strings."
       (push pkg-dir Info-directory-list))
     ;; Add to load path, add autoloads, and activate the package.
     (push pkg-dir load-path)
-    (load (expand-file-name (concat name "-autoloads") pkg-dir) nil t)
-    (push package package-activated-list)
+    (load (expand-file-name (format "%s-autoloads" name) pkg-dir) nil t)
+    (push name package-activated-list)
     ;; Don't return nil.
     t))
 
@@ -489,7 +524,12 @@ specifying the minimum acceptable version."
       (version-list-<= min-version (version-to-list emacs-version))
     (let ((elt (assq package package--builtins)))
       (and elt (version-list-<= min-version
-                                (package-desc-vers (cdr elt)))))))
+                                (package--bi-desc-version (cdr elt)))))))
+
+(defun package--from-builtin (bi-desc)
+  (package-desc-create :name (pop bi-desc)
+                       :version (package--bi-desc-version bi-desc)
+                       :summary (package--bi-desc-summary bi-desc)))
 
 ;; This function goes ahead and activates a newer version of a package
 ;; if an older one was already activated.  This is not ideal; we'd at
@@ -504,7 +544,7 @@ Return nil if the package could not be activated."
         available-version found)
     ;; Check if PACKAGE is available in `package-alist'.
     (when pkg-vec
-      (setq available-version (package-desc-vers pkg-vec)
+      (setq available-version (package-desc-version pkg-vec)
             found (version-list-<= min-version available-version)))
     (cond
      ;; If no such package is found, maybe it's built-in.
@@ -525,7 +565,7 @@ Return nil if the package could not be activated."
 Required package `%s-%s' is unavailable"
                   package (car fail) (package-version-join (cadr fail)))
           ;; If all goes well, activate the package itself.
-          (package-activate-1 package pkg-vec)))))))
+          (package-activate-1 pkg-vec)))))))
 
 (defun package-mark-obsolete (package pkg-vec)
   "Put package on the obsolete list, if not already there."
@@ -533,11 +573,11 @@ Required package `%s-%s' is unavailable"
     (if elt
         ;; If this obsolete version does not exist in the list, update
         ;; it the list.
-        (unless (assoc (package-desc-vers pkg-vec) (cdr elt))
-          (setcdr elt (cons (cons (package-desc-vers pkg-vec) pkg-vec)
+        (unless (assoc (package-desc-version pkg-vec) (cdr elt))
+          (setcdr elt (cons (cons (package-desc-version pkg-vec) pkg-vec)
                             (cdr elt))))
       ;; Make a new association.
-      (push (cons package (list (cons (package-desc-vers pkg-vec)
+      (push (cons package (list (cons (package-desc-version pkg-vec)
                                       pkg-vec)))
             package-obsolete-alist))))
 
@@ -555,21 +595,17 @@ REQUIREMENTS is a list of dependencies on other packages.
 EXTRA-PROPERTIES is currently unused."
   (let* ((name (intern name-string))
          (version (version-to-list version-string))
-         (new-pkg-desc
-          (cons name
-                (vector version
-                        (mapcar
-                         (lambda (elt)
-                           (list (car elt)
-                                 (version-to-list (car (cdr elt)))))
-                         requirements)
-                        docstring)))
+         (new-pkg-desc (cons name
+                             (package-desc-from-define name-string
+                                                       version-string
+                                                       docstring
+                                                       requirements)))
          (old-pkg (assq name package-alist)))
     (cond
      ;; If there's no old package, just add this to `package-alist'.
      ((null old-pkg)
       (push new-pkg-desc package-alist))
-     ((version-list-< (package-desc-vers (cdr old-pkg)) version)
+     ((version-list-< (package-desc-version (cdr old-pkg)) version)
       ;; Remove the old package and declare it obsolete.
       (package-mark-obsolete name (cdr old-pkg))
       (setq package-alist (cons new-pkg-desc
@@ -577,7 +613,7 @@ EXTRA-PROPERTIES is currently unused."
      ;; You can have two packages with the same version, e.g. one in
      ;; the system package directory and one in your private
      ;; directory.  We just let the first one win.
-     ((not (version-list-= (package-desc-vers (cdr old-pkg)) version))
+     ((not (version-list-= (package-desc-version (cdr old-pkg)) version))
       ;; The package is born obsolete.
       (package-mark-obsolete name (cdr new-pkg-desc))))))
 
@@ -603,14 +639,15 @@ EXTRA-PROPERTIES is currently unused."
 
 (defun package-generate-autoloads (name pkg-dir)
   (require 'autoload)         ;Load before we let-bind generated-autoload-file!
-  (let* ((auto-name (concat name "-autoloads.el"))
+  (let* ((auto-name (format "%s-autoloads.el" name))
          ;;(ignore-name (concat name "-pkg.el"))
          (generated-autoload-file (expand-file-name auto-name pkg-dir))
          (version-control 'never))
     (package-autoload-ensure-default-file generated-autoload-file)
     (update-directory-autoloads pkg-dir)
     (let ((buf (find-buffer-visiting generated-autoload-file)))
-      (when buf (kill-buffer buf)))))
+      (when buf (kill-buffer buf)))
+    auto-name))
 
 (defvar tar-parse-info)
 (declare-function tar-untar-buffer "tar-mode" ())
@@ -644,57 +681,62 @@ untar into a directory named DIR; otherwise, signal an error."
     ;; FIXME: should we delete PKG-DIR if it exists?
     (let* ((default-directory (file-name-as-directory package-user-dir)))
       (package-untar-buffer dirname)
-      (package--make-autoloads-and-compile name pkg-dir))))
+      (package--make-autoloads-and-compile package pkg-dir))))
 
 (defun package--make-autoloads-and-compile (name pkg-dir)
   "Generate autoloads and do byte-compilation for package named NAME.
 PKG-DIR is the name of the package directory."
-  (package-generate-autoloads name pkg-dir)
-  (let ((load-path (cons pkg-dir load-path)))
+  (let ((auto-name (package-generate-autoloads name pkg-dir))
+        (load-path (cons pkg-dir load-path)))
     ;; We must load the autoloads file before byte compiling, in
     ;; case there are magic cookies to set up non-trivial paths.
-    (load (expand-file-name (concat name "-autoloads") pkg-dir) nil t)
+    (load auto-name nil t)
+    ;; FIXME: Compilation should be done as a separate, optional, step.
+    ;; E.g. for multi-package installs, we should first install all packages
+    ;; and then compile them.
     (byte-recompile-directory pkg-dir 0 t)))
 
 (defun package--write-file-no-coding (file-name)
   (let ((buffer-file-coding-system 'no-conversion))
     (write-region (point-min) (point-max) file-name)))
 
-(defun package-unpack-single (file-name version desc requires)
+(defun package-unpack-single (name version desc requires)
   "Install the contents of the current buffer as a package."
-  ;; Special case "package".
-  (if (string= file-name "package")
+  ;; Special case "package".  FIXME: Should this still be supported?
+  (if (eq name 'package)
       (package--write-file-no-coding
-       (expand-file-name (concat file-name ".el") package-user-dir))
-    (let* ((pkg-dir  (expand-file-name (concat file-name "-"
+       (expand-file-name (format "%s.el" name) package-user-dir))
+    (let* ((pkg-dir  (expand-file-name (format "%s-%s" name
                                                (package-version-join
                                                 (version-to-list version)))
                                        package-user-dir))
-           (el-file  (expand-file-name (concat file-name ".el") pkg-dir))
-           (pkg-file (expand-file-name (concat file-name "-pkg.el") pkg-dir)))
+           (el-file  (expand-file-name (format "%s.el" name) pkg-dir))
+           (pkg-file (expand-file-name (format "%s-pkg.el" name) pkg-dir)))
       (make-directory pkg-dir t)
       (package--write-file-no-coding el-file)
       (let ((print-level nil)
+            (print-quoted t)
             (print-length nil))
         (write-region
          (concat
           (prin1-to-string
            (list 'define-package
-                 file-name
+                 (symbol-name name)
                  version
                  desc
-                 (list 'quote
-                       ;; Turn version lists into string form.
-                       (mapcar
-                        (lambda (elt)
-                          (list (car elt)
-                                (package-version-join (cadr elt))))
-                        requires))))
+                 (when requires         ;Don't bother quoting nil.
+                   (list 'quote
+                         ;; Turn version lists into string form.
+                         (mapcar
+                          (lambda (elt)
+                            (list (car elt)
+                                  (package-version-join (cadr elt))))
+                          requires)))))
           "\n")
          nil
          pkg-file
          nil nil nil 'excl))
-      (package--make-autoloads-and-compile file-name pkg-dir))))
+      (package--make-autoloads-and-compile name pkg-dir))))
 
 (defmacro package--with-work-buffer (location file &rest body)
   "Run BODY in a buffer containing the contents of FILE at LOCATION.
@@ -744,7 +786,7 @@ It will move point to somewhere in the headers."
   (let ((location (package-archive-base name))
         (file (concat (symbol-name name) "-" version ".el")))
     (package--with-work-buffer location file
-      (package-unpack-single (symbol-name name) version desc requires))))
+      (package-unpack-single name version desc requires))))
 
 (defun package-download-tar (name version)
   "Download and install a tar package."
@@ -762,7 +804,7 @@ MIN-VERSION should be a version list."
   (let ((pkg-desc (assq package package-alist)))
     (if pkg-desc
         (version-list-<= min-version
-                         (package-desc-vers (cdr pkg-desc)))
+                         (package-desc-version (cdr pkg-desc)))
       ;; Also check built-in packages.
       (package-built-in-p package min-version))))
 
@@ -785,7 +827,7 @@ not included in this list."
       (unless (package-installed-p next-pkg next-version)
         ;; A package is required, but not installed.  It might also be
         ;; blocked via `package-load-list'.
-        (let ((pkg-desc (assq next-pkg package-archive-contents))
+        (let ((pkg-desc (cdr (assq next-pkg package-archive-contents)))
               hold)
           (when (setq hold (assq next-pkg package-load-list))
             (setq hold (cadr hold))
@@ -805,17 +847,17 @@ but version %s required"
                    (symbol-name next-pkg)
                    (package-version-join next-version)))
           (unless (version-list-<= next-version
-                                   (package-desc-vers (cdr pkg-desc)))
+                                   (package-desc-version pkg-desc))
             (error
              "Need package `%s-%s', but only %s is available"
              (symbol-name next-pkg) (package-version-join next-version)
-             (package-version-join (package-desc-vers (cdr pkg-desc)))))
+             (package-version-join (package-desc-version pkg-desc))))
           ;; Move to front, so it gets installed early enough (bug#14082).
           (setq package-list (cons next-pkg (delq next-pkg package-list)))
           (setq package-list
                 (package-compute-transaction package-list
                                              (package-desc-reqs
-                                              (cdr pkg-desc))))))))
+                                              pkg-desc)))))))
   package-list)
 
 (defun package-read-from-string (str)
@@ -867,13 +909,29 @@ If the archive version is too new, signal an error."
       (dolist (package contents)
         (package--add-to-archive-contents package archive)))))
 
+;; Package descriptor objects used inside the "archive-contents" file.
+;; Changing this defstruct implies changing the format of the
+;; "archive-contents" files.
+(cl-defstruct (package--ac-desc
+               (:constructor package-make-ac-desc (version reqs summary kind))
+               (:copier nil)
+               (:type vector))
+  version reqs summary kind)
+
 (defun package--add-to-archive-contents (package archive)
   "Add the PACKAGE from the given ARCHIVE if necessary.
-Also, add the originating archive to the end of the package vector."
-  (let* ((name    (car package))
-         (version (package-desc-vers (cdr package)))
-         (entry   (cons name
-                        (vconcat (cdr package) (vector archive))))
+PACKAGE should have the form (NAME . PACKAGE--AC-DESC).
+Also, add the originating archive to the `package-desc' structure."
+  (let* ((name (car package))
+         (pkg-desc
+          (package-desc-create
+           :name name
+           :version (package--ac-desc-version (cdr package))
+           :reqs (package--ac-desc-reqs (cdr package))
+           :summary (package--ac-desc-summary (cdr package))
+           :kind (package--ac-desc-kind (cdr package))
+           :archive archive))
+         (entry (cons name pkg-desc))
          (existing-package (assq name package-archive-contents))
          (pinned-to-archive (assoc name package-pinned-packages)))
     (cond ((and pinned-to-archive
@@ -881,9 +939,9 @@ Also, add the originating archive to the end of the package vector."
                 (not (equal (cdr pinned-to-archive) archive)))
            nil)
           ((not existing-package)
-           (add-to-list 'package-archive-contents entry))
-          ((version-list-< (package-desc-vers (cdr existing-package))
-                           version)
+           (push entry package-archive-contents))
+          ((version-list-< (package-desc-version (cdr existing-package))
+                           (package-desc-version pkg-desc))
            ;; Replace the entry with this one.
            (setq package-archive-contents
                  (cons entry
@@ -902,14 +960,14 @@ using `package-compute-transaction'."
            ;; `package-load-list', download the held version.
            (hold (cadr (assq elt package-load-list)))
            (v-string (or (and (stringp hold) hold)
-                         (package-version-join (package-desc-vers desc))))
+                         (package-version-join (package-desc-version desc))))
            (kind (package-desc-kind desc)))
       (cond
        ((eq kind 'tar)
         (package-download-tar elt v-string))
        ((eq kind 'single)
         (package-download-single elt v-string
-                                 (package-desc-doc desc)
+                                 (package-desc-summary desc)
                                  (package-desc-reqs desc)))
        (t
         (error "Unknown package kind: %s" (symbol-name kind))))
@@ -961,17 +1019,7 @@ Otherwise return nil."
       (error nil))))
 
 (defun package-buffer-info ()
-  "Return a vector describing the package in the current buffer.
-The vector has the form
-
-   [FILENAME REQUIRES DESCRIPTION VERSION COMMENTARY]
-
-FILENAME is the file name, a string, sans the \".el\" extension.
-REQUIRES is a list of requirements, each requirement having the
- form (NAME VER); NAME is a string and VER is a version list.
-DESCRIPTION is the package description, a string.
-VERSION is the version, a string.
-COMMENTARY is the commentary section, a string, or nil if none.
+  "Return a `package-desc' describing the package in the current buffer.
 
 If the buffer does not contain a conforming package, signal an
 error.  If there is a package, narrow the buffer to the file's
@@ -990,25 +1038,18 @@ boundaries."
     (require 'lisp-mnt)
     ;; Use some headers we've invented to drive the process.
     (let* ((requires-str (lm-header "package-requires"))
-           (requires (if requires-str
-                         (package-read-from-string requires-str)))
            ;; Prefer Package-Version; if defined, the package author
            ;; probably wants us to use it.  Otherwise try Version.
            (pkg-version
             (or (package-strip-rcs-id (lm-header "package-version"))
-                (package-strip-rcs-id (lm-header "version"))))
-           (commentary (lm-commentary)))
+                (package-strip-rcs-id (lm-header "version")))))
       (unless pkg-version
         (error
          "Package lacks a \"Version\" or \"Package-Version\" header"))
-      ;; Turn string version numbers into list form.
-      (setq requires
-            (mapcar
-             (lambda (elt)
-               (list (car elt)
-                     (version-to-list (car (cdr elt)))))
-             requires))
-      (vector file-name requires desc pkg-version commentary))))
+      (package-desc-from-define
+       file-name pkg-version desc
+       (if requires-str (package-read-from-string requires-str))
+       :kind 'single))))
 
 (defun package-tar-file-info (file)
   "Find package information for a tar file.
@@ -1025,67 +1066,46 @@ The return result is a vector like `package-buffer-info'."
            (pkg-def-contents (shell-command-to-string
                               ;; Requires GNU tar.
                               (concat "tar -xOf " file " "
-
                                       pkg-name "-" pkg-version "/"
                                       pkg-name "-pkg.el")))
            (pkg-def-parsed (package-read-from-string pkg-def-contents)))
       (unless (eq (car pkg-def-parsed) 'define-package)
         (error "No `define-package' sexp is present in `%s-pkg.el'" pkg-name))
-      (let ((name-str       (nth 1 pkg-def-parsed))
-            (version-string (nth 2 pkg-def-parsed))
-            (docstring      (nth 3 pkg-def-parsed))
-            (requires       (nth 4 pkg-def-parsed))
-            (readme (shell-command-to-string
-                     ;; Requires GNU tar.
-                     (concat "tar -xOf " file " "
-                             pkg-name "-" pkg-version "/README"))))
-        (unless (equal pkg-version version-string)
+      (let ((pkg-desc
+             (apply #'package-desc-from-define (append (cdr pkg-def-parsed)
+                                                       '(:kind tar)))))
+        (unless (equal pkg-version
+                       (package-version-join (package-desc-version pkg-desc)))
           (error "Package has inconsistent versions"))
-        (unless (equal pkg-name name-str)
+        (unless (equal pkg-name (symbol-name (package-desc-name pkg-desc)))
           (error "Package has inconsistent names"))
-        ;; Kind of a hack.
-        (if (string-match ": Not found in archive" readme)
-            (setq readme nil))
-        ;; Turn string version numbers into list form.
-        (if (eq (car requires) 'quote)
-            (setq requires (car (cdr requires))))
-        (setq requires
-              (mapcar (lambda (elt)
-                        (list (car elt)
-                              (version-to-list (cadr elt))))
-                      requires))
-        (vector pkg-name requires docstring version-string readme)))))
+        pkg-desc))))
+
 
 ;;;###autoload
-(defun package-install-from-buffer (pkg-info type)
+(defun package-install-from-buffer (pkg-desc)
   "Install a package from the current buffer.
 When called interactively, the current buffer is assumed to be a
 single .el file that follows the packaging guidelines; see info
 node `(elisp)Packaging'.
 
-When called from Lisp, PKG-INFO is a vector describing the
-information, of the type returned by `package-buffer-info'; and
-TYPE is the package type (either `single' or `tar')."
-  (interactive (list (package-buffer-info) 'single))
+When called from Lisp, PKG-DESC is a `package-desc' describing the
+information)."
+  (interactive (list (package-buffer-info)))
   (save-excursion
     (save-restriction
-      (let* ((file-name (aref pkg-info 0))
-             (requires  (aref pkg-info 1))
-             (desc (if (string= (aref pkg-info 2) "")
-                       "No description available."
-                     (aref pkg-info 2)))
-             (pkg-version (aref pkg-info 3)))
+      (let* ((name      (package-desc-name pkg-desc))
+             (requires  (package-desc-reqs pkg-desc))
+             (desc      (package-desc-summary pkg-desc))
+             (pkg-version (package-desc-version pkg-desc)))
         ;; Download and install the dependencies.
         (let ((transaction (package-compute-transaction nil requires)))
           (package-download-transaction transaction))
         ;; Install the package itself.
-        (cond
-         ((eq type 'single)
-          (package-unpack-single file-name pkg-version desc requires))
-         ((eq type 'tar)
-          (package-unpack (intern file-name) pkg-version))
-         (t
-          (error "Unknown type: %s" (symbol-name type))))
+        (pcase (package-desc-kind pkg-desc)
+         (`single (package-unpack-single name pkg-version desc requires))
+         (`tar    (package-unpack name pkg-version))
+         (type    (error "Unknown type: %S" type)))
         ;; Try to activate it.
         (package-initialize)))))
 
@@ -1097,10 +1117,10 @@ The file can either be a tar file or an Emacs Lisp file."
   (with-temp-buffer
     (insert-file-contents-literally file)
     (cond
-     ((string-match "\\.el$" file)
-      (package-install-from-buffer (package-buffer-info) 'single))
-     ((string-match "\\.tar$" file)
-      (package-install-from-buffer (package-tar-file-info file) 'tar))
+     ((string-match "\\.el\\'" file)
+      (package-install-from-buffer (package-buffer-info)))
+     ((string-match "\\.tar\\'" file)
+      (package-install-from-buffer (package-tar-file-info file)))
      (t (error "Unrecognized extension `%s'" (file-name-extension file))))))
 
 (defun package-delete (name version)
@@ -1118,7 +1138,7 @@ The file can either be a tar file or an Emacs Lisp file."
 (defun package-archive-base (name)
   "Return the archive containing the package NAME."
   (let ((desc (cdr (assq (intern-soft name) package-archive-contents))))
-    (cdr (assoc (aref desc (- (length desc) 1)) package-archives))))
+    (cdr (assoc (package-desc-archive desc) package-archives))))
 
 (defun package--download-one-archive (archive file)
   "Retrieve an archive file FILE from ARCHIVE, and cache it.
@@ -1163,7 +1183,7 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
   (package-read-all-archive-contents)
   (unless no-activate
     (dolist (elt package-alist)
-      (package-activate (car elt) (package-desc-vers (cdr elt)))))
+      (package-activate (car elt) (package-desc-version (cdr elt)))))
   (setq package--initialized t))
 
 
@@ -1210,22 +1230,22 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
     (cond
      ;; Loaded packages are in `package-alist'.
      ((setq desc (cdr (assq package package-alist)))
-      (setq version (package-version-join (package-desc-vers desc)))
+      (setq version (package-version-join (package-desc-version desc)))
       (if (setq pkg-dir (package--dir package-name version))
           (insert "an installed package.\n\n")
         ;; This normally does not happen.
         (insert "a deleted package.\n\n")))
      ;; Available packages are in `package-archive-contents'.
      ((setq desc (cdr (assq package package-archive-contents)))
-      (setq version (package-version-join (package-desc-vers desc))
-            archive (aref desc (- (length desc) 1))
+      (setq version (package-version-join (package-desc-version desc))
+            archive (package-desc-archive desc)
             installable t)
       (if built-in
           (insert "a built-in package.\n\n")
         (insert "an uninstalled package.\n\n")))
      (built-in
-      (setq desc (cdr built-in)
-            version (package-version-join (package-desc-vers desc)))
+      (setq desc (package--from-builtin built-in)
+            version (package-version-join (package-desc-version desc)))
       (insert "a built-in package.\n\n"))
      (t
       (insert "an orphan package.\n\n")))
@@ -1246,7 +1266,8 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
              (insert "'.")))
           (installable
            (if built-in
-               (insert (propertize "Built-in." 'font-lock-face 'font-lock-builtin-face)
+               (insert (propertize "Built-in."
+                                   'font-lock-face 'font-lock-builtin-face)
                        "  Alternate version available")
              (insert "Available"))
            (insert " from " archive)
@@ -1261,7 +1282,8 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
                                  'package-symbol package
                                  'action 'package-install-button-action)))
           (built-in
-           (insert (propertize "Built-in." 'font-lock-face 'font-lock-builtin-face)))
+           (insert (propertize "Built-in."
+                               'font-lock-face 'font-lock-builtin-face)))
           (t (insert "Deleted.")))
     (insert "\n")
     (and version (> (length version) 0)
@@ -1286,7 +1308,7 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
           (help-insert-xref-button text 'help-package name))
         (insert "\n")))
     (insert "    " (propertize "Summary" 'font-lock-face 'bold)
-            ": " (if desc (package-desc-doc desc)) "\n\n")
+            ": " (if desc (package-desc-summary desc)) "\n\n")
 
     (if built-in
         ;; For built-in packages, insert the commentary.
@@ -1418,10 +1440,10 @@ If the alist stored in the symbol LISTNAME lacks an entry for a
 package PACKAGE with descriptor DESC, add one.  The alist is
 keyed with cons cells (PACKAGE . VERSION-LIST), where PACKAGE is
 a symbol and VERSION-LIST is a version list."
-  `(let* ((version (package-desc-vers ,desc))
+  `(let* ((version (package-desc-version ,desc))
           (key (cons ,package version)))
      (unless (assoc key ,listname)
-       (push (list key ,status (package-desc-doc ,desc)) ,listname))))
+       (push (list key ,status (package-desc-summary ,desc)) ,listname))))
 
 (defun package-menu--generate (remember-pos packages)
   "Populate the Package Menu.
@@ -1444,7 +1466,7 @@ or a list of package names (symbols) to display."
       (setq name (car elt))
       (when (and (not (eq name 'emacs)) ; Hide the `emacs' package.
                  (or (eq packages t) (memq name packages)))
-        (package--push name (cdr elt) "built-in" info-list)))
+        (package--push name (package--from-builtin elt) "built-in" info-list)))
 
     ;; Available and disabled packages:
     (dolist (elt package-archive-contents)
diff --git a/lisp/emacs-lisp/smie.el b/lisp/emacs-lisp/smie.el
index a88b9d70930..f9d0fd9366b 100644
--- a/lisp/emacs-lisp/smie.el
+++ b/lisp/emacs-lisp/smie.el
@@ -957,7 +957,7 @@ If non-nil, it will blink not only for \"begin..end\" but also for \"if...else\"
     (let ((ender (funcall smie-backward-token-function)))
       (cond
        ((not (and ender (rassoc ender smie-closer-alist)))
-        ;; This not is one of the begin..end we know how to check.
+        ;; This is not one of the begin..end we know how to check.
         (blink-matching-check-mismatch start end))
        ((not start) t)
        ((eq t (car (rassoc ender smie-closer-alist))) nil)
@@ -1012,6 +1012,9 @@ This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'.
                      (or (eq (char-before) last-command-event)
                          (not (memq (char-before)
                                     smie-blink-matching-triggers)))
+                     ;; FIXME: For octave's "switch ... case ... case" we flash
+                     ;; `switch' at the end of the first `case' and we burp
+                     ;; "mismatch" at the end of the second `case'.
                      (or smie-blink-matching-inners
                          (not (numberp (nth 2 (assoc token smie-grammar))))))
             ;; The major mode might set blink-matching-check-function
@@ -1021,87 +1024,90 @@ This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'.
             (let ((blink-matching-check-function #'smie-blink-matching-check))
               (blink-matching-open))))))))
 
-(defface smie-matching-block-highlight '((t (:inherit highlight)))
-  "Face used to highlight matching block."
-  :group 'smie)
-
-(defvar smie--highlight-matching-block-overlay nil)
-(defvar-local smie--highlight-matching-block-lastpos -1)
-
-(defun smie-highlight-matching-block ()
-  (when (and smie-closer-alist
-             (/= (point) smie--highlight-matching-block-lastpos))
-    (unless (overlayp smie--highlight-matching-block-overlay)
-      (setq smie--highlight-matching-block-overlay
-            (make-overlay (point) (point))))
-    (setq smie--highlight-matching-block-lastpos (point))
-    (let ((beg-of-tok
-           (lambda (&optional start)
-             "Move to the beginning of current token at START."
-             (let* ((token)
-                    (start (or start (point)))
-                    (beg (progn
+(defvar-local smie--matching-block-data-cache nil)
+
+(defun smie--opener/closer-at-point ()
+  "Return (OPENER TOKEN START END) or nil.
+OPENER is non-nil if TOKEN is an opener and nil if it's a closer."
+  (let* ((start (point))
+         ;; Move to a previous position outside of a token.
+         (_ (funcall smie-backward-token-function))
+         ;; Move to the end of the token before point.
+         (btok (funcall smie-forward-token-function))
+         (bend (point)))
+    (cond
+     ;; Token before point is a closer?
+     ((and (>= bend start) (rassoc btok smie-closer-alist))
+      (funcall smie-backward-token-function)
+      (when (< (point) start)
+        (prog1 (list nil btok (point) bend)
+          (goto-char bend))))
+     ;; Token around point is an opener?
+     ((and (> bend start) (assoc btok smie-closer-alist))
+      (funcall smie-backward-token-function)
+      (when (<= (point) start) (list t btok (point) bend)))
+     ((<= bend start)
+      (let ((atok (funcall smie-forward-token-function))
+            (aend (point)))
+        (cond
+         ((< aend start) nil)           ;Hopefully shouldn't happen.
+         ;; Token after point is a closer?
+         ((assoc atok smie-closer-alist)
+          (funcall smie-backward-token-function)
+          (when (<= (point) start)
+            (list t atok (point) aend)))))))))
+
+(defun smie--matching-block-data (orig &rest args)
+  "A function suitable for `show-paren-data-function' (which see)."
+  (if (or (null smie-closer-alist)
+          (eq (point) (car smie--matching-block-data-cache)))
+      (or (cdr smie--matching-block-data-cache)
+          (apply orig args))
+    (setq smie--matching-block-data-cache (list (point)))
+    (unless (nth 8 (syntax-ppss))
+      (condition-case nil
+          (let ((here (smie--opener/closer-at-point)))
+            (when (and here
+                       (or smie-blink-matching-inners
+                           (not (numberp
+                                 (nth (if (nth 0 here) 1 2)
+                                      (assoc (nth 1 here) smie-grammar))))))
+              (let ((there
+                     (cond
+                      ((car here)       ; Opener.
+                       (let ((data (smie-forward-sexp 'halfsexp))
+                             (tend (point)))
+                         (unless (car data)
                            (funcall smie-backward-token-function)
-                           (forward-comment (point-max))
-                           (point)))
-                    (end (progn
-                           (setq token (funcall smie-forward-token-function))
-                           (forward-comment (- (point)))
-                           (point))))
-               (if (and (<= beg start) (<= start end)
-                        (or (assoc token smie-closer-alist)
-                            (rassoc token smie-closer-alist)))
-                   (progn (goto-char beg) token)
-                 (goto-char start)
-                 nil))))
-          (highlight
-           (lambda (beg end)
-             (move-overlay smie--highlight-matching-block-overlay
-                           beg end (current-buffer))
-             (overlay-put smie--highlight-matching-block-overlay
-                          'face 'smie-matching-block-highlight))))
-      (overlay-put smie--highlight-matching-block-overlay 'face nil)
-      (unless (nth 8 (syntax-ppss))
-        (save-excursion
-          (condition-case nil
-              (let ((token
-                     (or (funcall beg-of-tok)
-                         (funcall beg-of-tok
-                                  (prog1 (point)
-                                    (funcall smie-forward-token-function))))))
-                (cond
-                 ((assoc token smie-closer-alist) ; opener
-                  (forward-sexp 1)
-                  (let ((end (point))
-                        (closer (funcall smie-backward-token-function)))
-                    (when (rassoc closer smie-closer-alist)
-                      (funcall highlight (point) end))))
-                 ((rassoc token smie-closer-alist) ; closer
-                  (funcall smie-forward-token-function)
-                  (forward-sexp -1)
-                  (let ((beg (point))
-                        (opener (funcall smie-forward-token-function)))
-                    (when (assoc opener smie-closer-alist)
-                      (funcall highlight beg (point)))))))
-            (scan-error)))))))
-
-(defvar smie--highlight-matching-block-timer nil)
-
-;;;###autoload
-(define-minor-mode smie-highlight-matching-block-mode nil
-  :global t :group 'smie
-  (when (timerp smie--highlight-matching-block-timer)
-    (cancel-timer smie--highlight-matching-block-timer))
-  (setq smie--highlight-matching-block-timer nil)
-  (if smie-highlight-matching-block-mode
-      (progn
-        (remove-hook 'post-self-insert-hook #'smie-blink-matching-open 'local)
-        (setq smie--highlight-matching-block-timer
-              (run-with-idle-timer 0.2 t #'smie-highlight-matching-block)))
-    (when smie--highlight-matching-block-overlay
-      (delete-overlay smie--highlight-matching-block-overlay)
-      (setq smie--highlight-matching-block-overlay nil))
-    (kill-local-variable 'smie--highlight-matching-block-lastpos)))
+                           (list (member (cons (nth 1 here) (nth 2 data))
+                                         smie-closer-alist)
+                                 (point) tend))))
+                      (t                ;Closer.
+                       (let ((data (smie-backward-sexp 'halfsexp))
+                             (htok (nth 1 here)))
+                         (if (car data)
+                             (let* ((hprec (nth 2 (assoc htok smie-grammar)))
+                                    (ttok (nth 2 data))
+                                    (tprec (nth 1 (assoc ttok smie-grammar))))
+                               (when (and (numberp hprec) ;Here is an inner.
+                                          (eq hprec tprec))
+                                 (goto-char (nth 1 data))
+                                 (let ((tbeg (point)))
+                                   (funcall smie-forward-token-function)
+                                   (list t tbeg (point)))))
+                           (let ((tbeg (point)))
+                             (funcall smie-forward-token-function)
+                             (list (member (cons (nth 2 data) htok)
+                                           smie-closer-alist)
+                                   tbeg (point)))))))))
+                ;; Update the cache.
+                (setcdr smie--matching-block-data-cache
+                        (list (nth 2 here)  (nth 3 here)
+                              (nth 1 there) (nth 2 there)
+                              (not (nth 0 there)))))))
+        (scan-error nil))
+      (goto-char (car smie--matching-block-data-cache)))
+    (apply #'smie--matching-block-data orig args)))
 
 ;;; The indentation engine.
 
@@ -1799,9 +1805,10 @@ KEYWORDS are additional arguments, which can use the following keywords:
       (setq-local smie-closer-alist ca)
       ;; Only needed for interactive calls to blink-matching-open.
       (setq-local blink-matching-check-function #'smie-blink-matching-check)
-      (unless smie-highlight-matching-block-mode
-        (add-hook 'post-self-insert-hook
-                  #'smie-blink-matching-open 'append 'local))
+      (add-hook 'post-self-insert-hook
+                #'smie-blink-matching-open 'append 'local)
+      (add-function :around (local 'show-paren-data-function)
+                    #'smie--matching-block-data)
       ;; Setup smie-blink-matching-triggers.  Rather than wait for SPC to
       ;; blink, try to blink as soon as we type the last char of a block ender.
       (let ((closers (sort (mapcar #'cdr smie-closer-alist) #'string-lessp))
diff --git a/lisp/emacs-lisp/syntax.el b/lisp/emacs-lisp/syntax.el
index 0a4758a9ccd..3e850320133 100644
--- a/lisp/emacs-lisp/syntax.el
+++ b/lisp/emacs-lisp/syntax.el
@@ -56,12 +56,13 @@
   ;; syntax-ppss-flush-cache since that would not only flush the cache but also
   ;; reset syntax-propertize--done which should not be done in this case).
   "Mode-specific function to apply `syntax-table' text properties.
-The value of this variable is a function to be called by Font
-Lock mode, prior to performing syntactic fontification on a
-stretch of text.  It is given two arguments, START and END: the
-start and end of the text to be fontified.  Major modes can
-specify a custom function to apply `syntax-table' properties to
-override the default syntax table in special cases.
+It is the work horse of `syntax-propertize', which is called by things like
+Font-Lock and indentation.
+
+It is given two arguments, START and END: the start and end of the text to
+which `syntax-table' might need to be applied.  Major modes can use this to
+override the buffer's syntax table for special syntactic constructs that
+cannot be handled just by the buffer's syntax-table.
 
 The specified function may call `syntax-ppss' on any position
 before END, but it should not call `syntax-ppss-flush-cache',
diff --git a/lisp/emacs-lisp/trace.el b/lisp/emacs-lisp/trace.el
index 42643bf2317..f605c2865c0 100644
--- a/lisp/emacs-lisp/trace.el
+++ b/lisp/emacs-lisp/trace.el
@@ -262,7 +262,17 @@ be printed along with the arguments in the trace."
 
 (defun trace--read-args (prompt)
   (cons
-   (intern (completing-read prompt obarray 'fboundp t))
+   (let ((default (function-called-at-point))
+         (beg (string-match ":[ \t]*\\'" prompt)))
+     (intern (completing-read (if default
+                                  (format
+                                   "%s (default %s)%s"
+                                   (substring prompt 0 beg)
+                                   default
+                                   (if beg (substring prompt beg) ": "))
+                                prompt)
+                              obarray 'fboundp t nil nil
+                              (if default (symbol-name default)))))
    (when current-prefix-arg
      (list
       (read-buffer "Output to buffer: " trace-buffer)
diff --git a/lisp/epa.el b/lisp/epa.el
index b567df5f40b..14f8879c1c6 100644
--- a/lisp/epa.el
+++ b/lisp/epa.el
@@ -620,21 +620,24 @@ If SECRET is non-nil, list secret keys instead of public keys."
                    (floor (* (/ current (float total)) 100))))
       (message "%s..." prompt))))
 
+(defun epa-read-file-name (input)
+  "Interactively read an output file name based on INPUT file name."
+  (setq input (file-name-sans-extension (expand-file-name input)))
+  (expand-file-name
+   (read-file-name
+    (concat "To file (default " (file-name-nondirectory input) ") ")
+    (file-name-directory input)
+    input)))
+
 ;;;###autoload
-(defun epa-decrypt-file (decrypt-file plain-file)
-  "Decrypt DECRYPT-FILE into PLAIN-FILE."
+(defun epa-decrypt-file (decrypt-file &optional plain-file)
+  "Decrypt DECRYPT-FILE into PLAIN-FILE.
+If you do not specify PLAIN-FILE, this functions prompts for the value to use."
   (interactive
-   (let (file default-name plain)
-     (setq file (read-file-name "File to decrypt: "))
-     (setq default-name (file-name-sans-extension (expand-file-name file)))
-     (setq plain (expand-file-name
-                  (read-file-name
-                   (concat "To file (default "
-                           (file-name-nondirectory default-name)
-                           ") ")
-                   (file-name-directory default-name)
-                   default-name)))
+   (let* ((file (read-file-name "File to decrypt: "))
+          (plain (epa-read-file-name file)))
      (list file plain)))
+  (or plain-file (setq plain-file (epa-read-file-name decrypt-file)))
   (setq decrypt-file (expand-file-name decrypt-file))
   (let ((context (epg-make-context epa-protocol)))
     (epg-context-set-passphrase-callback context
diff --git a/lisp/erc/ChangeLog b/lisp/erc/ChangeLog
index 4f5be776b09..76766144c18 100644
--- a/lisp/erc/ChangeLog
+++ b/lisp/erc/ChangeLog
@@ -1,3 +1,7 @@
+2013-05-30  Glenn Morris  <rgm@gnu.org>
+
+        * erc-backend.el: Require erc at run-time too.
+
 2013-05-21  Glenn Morris  <rgm@gnu.org>
 
         * erc-log.el (erc-network-name): Declare.
diff --git a/lisp/erc/erc-backend.el b/lisp/erc/erc-backend.el
index 3d3ac791f08..4200d4aff7f 100644
--- a/lisp/erc/erc-backend.el
+++ b/lisp/erc/erc-backend.el
@@ -102,7 +102,8 @@
 ;; There's a fairly strong mutual dependency between erc.el and erc-backend.el.
 ;; Luckily, erc.el does not need erc-backend.el for macroexpansion whereas the
 ;; reverse is true:
-(eval-when-compile (provide 'erc-backend) (require 'erc))
+(provide 'erc-backend)
+(require 'erc)
 
 ;;;; Variables and options
 
diff --git a/lisp/eshell/em-cmpl.el b/lisp/eshell/em-cmpl.el
index 426db3232ed..7120f639a70 100644
--- a/lisp/eshell/em-cmpl.el
+++ b/lisp/eshell/em-cmpl.el
@@ -243,6 +243,12 @@ to writing a completion function."
 
 ;;; Functions:
 
+(defun eshell-complete-lisp-symbol ()
+  "Try to complete the text around point as a Lisp symbol."
+  (interactive)
+  (let ((completion-at-point-functions '(lisp-completion-at-point)))
+    (completion-at-point)))
+
 (defun eshell-cmpl-initialize ()
   "Initialize the completions module."
   (set (make-local-variable 'pcomplete-command-completion-function)
@@ -279,17 +285,17 @@ to writing a completion function."
        eshell-cmpl-restore-window-delay)
   (set (make-local-variable 'pcomplete-use-paring)
        eshell-cmpl-use-paring)
-  ;; `pcomplete-arg-quote-list' should only be set after all the
+  ;; `comint-file-name-quote-list' should only be set after all the
   ;; load-hooks for any other extension modules have been run, which
   ;; is true at the time `eshell-mode-hook' is run
   (add-hook 'eshell-mode-hook
             (function
              (lambda ()
-               (set (make-local-variable 'pcomplete-arg-quote-list)
+               (set (make-local-variable 'comint-file-name-quote-list)
                     eshell-special-chars-outside-quoting))) nil t)
   (add-hook 'pcomplete-quote-arg-hook 'eshell-quote-backslash nil t)
-  (define-key eshell-mode-map [(meta tab)] 'lisp-complete-symbol)
-  (define-key eshell-mode-map [(meta control ?i)] 'lisp-complete-symbol)
+  (define-key eshell-mode-map [(meta tab)] 'eshell-complete-lisp-symbol)
+  (define-key eshell-mode-map [(meta control ?i)] 'eshell-complete-lisp-symbol)
   (define-key eshell-command-map [(meta ?h)] 'eshell-completion-help)
   (define-key eshell-command-map [tab] 'pcomplete-expand-and-complete)
   (define-key eshell-command-map [(control ?i)]
@@ -347,7 +353,7 @@ to writing a completion function."
                (setq begin (1+ (cadr delim))
                      args (eshell-parse-arguments begin end)))
               ((eq (car delim) ?\()
-               (lisp-complete-symbol)
+               (eshell-complete-lisp-symbol)
                (throw 'pcompleted t))
               (t
                (insert-and-inherit "\t")
diff --git a/lisp/eshell/em-dirs.el b/lisp/eshell/em-dirs.el
index c93bbe9ecb1..e8fbe0518ac 100644
--- a/lisp/eshell/em-dirs.el
+++ b/lisp/eshell/em-dirs.el
@@ -207,7 +207,8 @@ Thus, this does not include the current directory.")
   (when eshell-cd-on-directory
     (make-local-variable 'eshell-interpreter-alist)
     (setq eshell-interpreter-alist
-          (cons (cons 'eshell-lone-directory-p
+          (cons (cons #'(lambda (file args)
+                          (eshell-lone-directory-p file))
                       'eshell-dirs-substitute-cd)
                 eshell-interpreter-alist)))
 
diff --git a/lisp/eshell/em-script.el b/lisp/eshell/em-script.el
index 711b2e21468..b073928738f 100644
--- a/lisp/eshell/em-script.el
+++ b/lisp/eshell/em-script.el
@@ -61,9 +61,10 @@ This includes when running `eshell-command'."
   "Initialize the script parsing code."
   (make-local-variable 'eshell-interpreter-alist)
   (setq eshell-interpreter-alist
-        (cons '((lambda (file)
-                  (string= (file-name-nondirectory file)
-                           "eshell")) . eshell/source)
+        (cons (cons #'(lambda (file args)
+                        (string= (file-name-nondirectory file)
+                                 "eshell"))
+                    'eshell/source)
               eshell-interpreter-alist))
   (make-local-variable 'eshell-complex-commands)
   (setq eshell-complex-commands
diff --git a/lisp/eshell/em-term.el b/lisp/eshell/em-term.el
index e5360f2deb4..2932f443e4f 100644
--- a/lisp/eshell/em-term.el
+++ b/lisp/eshell/em-term.el
@@ -31,6 +31,7 @@
 
 ;;; Code:
 
+(require 'cl-lib)
 (require 'esh-util)
 (require 'esh-ext)
 (eval-when-compile (require 'eshell))
@@ -61,10 +62,57 @@ which commands are considered visual in nature."
     "less" "more"                       ; M-x view-file
     "lynx" "ncftp"                      ; w3.el, ange-ftp
     "pine" "tin" "trn" "elm")           ; GNUS!!
-  "A list of commands that present their output in a visual fashion."
+  "A list of commands that present their output in a visual fashion.
+
+Commands listed here are run in a term buffer.
+
+See also `eshell-visual-subcommands' and `eshell-visual-options'."
   :type '(repeat string)
   :group 'eshell-term)
 
+(defcustom eshell-visual-subcommands
+  nil
+  "An alist of subcommands that present their output in a visual fashion.
+
+An alist of the form
+
+  ((COMMAND1 SUBCOMMAND1 SUBCOMMAND2...)
+   (COMMAND2 SUBCOMMAND1 ...))
+
+of commands with subcommands that present their output in a
+visual fashion.  A likely entry is
+
+  (\"git\" \"log\" \"diff\" \"show\")
+
+because git shows logs and diffs using a pager by default.
+
+See also `eshell-visual-commands' and `eshell-visual-options'."
+  :type '(repeat (cons (string :tag "Command")
+                       (repeat (string :tag "Subcommand"))))
+  :version "24.4"
+  :group 'eshell-term)
+
+(defcustom eshell-visual-options
+  nil
+  "An alist of the form
+
+  ((COMMAND1 OPTION1 OPTION2...)
+   (COMMAND2 OPTION1 ...))
+
+of commands with options that present their output in a visual
+fashion.  For example, a sensible entry would be
+
+  (\"git\" \"--help\")
+
+because \"git <command> --help\" shows the command's
+documentation with a pager.
+
+See also `eshell-visual-commands' and `eshell-visual-subcommands'."
+  :type '(repeat (cons (string :tag "Command")
+                       (repeat (string :tag "Option"))))
+  :version "24.4"
+  :group 'eshell-term)
+
 ;; If you change this from term-term-name, you need to ensure that the
 ;; value you choose exists in the system's terminfo database.  (Bug#12485)
 (defcustom eshell-term-name term-term-name
@@ -77,8 +125,10 @@ used."
 
 (defcustom eshell-escape-control-x t
   "If non-nil, allow <C-x> to be handled by Emacs key in visual buffers.
-See the variable `eshell-visual-commands'.  If this variable is set to
-nil, <C-x> will send that control character to the invoked process."
+See the variables `eshell-visual-commands',
+`eshell-visual-subcommands', and `eshell-visual-options'.  If
+this variable is set to nil, <C-x> will send that control
+character to the invoked process."
   :type 'boolean
   :group 'eshell-term)
 
@@ -92,19 +142,29 @@ nil, <C-x> will send that control character to the invoked process."
   "Initialize the `term' interface code."
   (make-local-variable 'eshell-interpreter-alist)
   (setq eshell-interpreter-alist
-        (cons (cons (function
-                     (lambda (command)
-                       (member (file-name-nondirectory command)
-                               eshell-visual-commands)))
+        (cons (cons #'eshell-visual-command-p
                     'eshell-exec-visual)
               eshell-interpreter-alist)))
 
+(defun eshell-visual-command-p (command args)
+  "Returns non-nil when given a visual command.
+If either COMMAND or a subcommand in ARGS (e.g. git log) is a
+visual command, returns non-nil."
+  (let ((command (file-name-nondirectory command)))
+    (and (eshell-interactive-output-p)
+         (or (member command eshell-visual-commands)
+             (member (car args)
+                     (cdr (assoc command eshell-visual-subcommands)))
+             (cl-intersection args
+                              (cdr (assoc command eshell-visual-options))
+                              :test 'string=)))))
+
 (defun eshell-exec-visual (&rest args)
   "Run the specified PROGRAM in a terminal emulation buffer.
 ARGS are passed to the program.  At the moment, no piping of input is
 allowed."
   (let* (eshell-interpreter-alist
-         (interp (eshell-find-interpreter (car args)))
+         (interp (eshell-find-interpreter (car args) (cdr args)))
          (program (car interp))
          (args (eshell-flatten-list
                 (eshell-stringify-list (append (cdr interp)
diff --git a/lisp/eshell/esh-ext.el b/lisp/eshell/esh-ext.el
index c4e4c000bda..474e536de2e 100644
--- a/lisp/eshell/esh-ext.el
+++ b/lisp/eshell/esh-ext.el
@@ -125,9 +125,10 @@ Each member is a cons cell of the form:
 
   (MATCH . INTERPRETER)
 
-MATCH should be a regexp, which is matched against the command name,
-or a function.  If either returns a non-nil value, then INTERPRETER
-will be used for that command.
+MATCH should be a regexp, which is matched against the command
+name, or a function of arity 2 receiving the COMMAND and its
+ARGS (a list).  If either returns a non-nil value, then
+INTERPRETER will be used for that command.
 
 If INTERPRETER is a string, it will be called as the command name,
 with the original command name passed as the first argument, with all
@@ -215,6 +216,7 @@ causing the user to wonder if anything's really going on..."
   (setq args (eshell-stringify-list (eshell-flatten-list args)))
   (let ((interp (eshell-find-interpreter
                  command
+                 args
                  ;; `eshell-find-interpreter' does not work correctly
                  ;; for Tramp file name syntax.  But we don't need to
                  ;; know the interpreter in that case, therefore the
@@ -267,7 +269,7 @@ Return nil, or a list of the form:
                 (list (match-string 1)
                       file)))))))
 
-(defun eshell-find-interpreter (file &optional no-examine-p)
+(defun eshell-find-interpreter (file args &optional no-examine-p)
   "Find the command interpreter with which to execute FILE.
 If NO-EXAMINE-P is non-nil, FILE will not be inspected for a script
 line of the form #!<interp>."
@@ -277,8 +279,9 @@ line of the form #!<interp>."
             (dolist (possible eshell-interpreter-alist)
               (cond
                ((functionp (car possible))
-                (and (funcall (car possible) file)
-                     (throw 'found (cdr possible))))
+                (let ((fn (car possible)))
+                  (and (funcall fn file args)
+                       (throw 'found (cdr possible)))))
                ((stringp (car possible))
                 (and (string-match (car possible) file)
                      (throw 'found (cdr possible))))
@@ -312,7 +315,7 @@ line of the form #!<interp>."
             (setq interp (eshell-script-interpreter fullname))
             (if interp
                 (setq interp
-                      (cons (car (eshell-find-interpreter (car interp) t))
+                      (cons (car (eshell-find-interpreter (car interp) args t))
                             (cdr interp)))))
           (or interp (list fullname)))))))
 
diff --git a/lisp/eshell/esh-mode.el b/lisp/eshell/esh-mode.el
index ee857cf20f3..5346bd16fd2 100644
--- a/lisp/eshell/esh-mode.el
+++ b/lisp/eshell/esh-mode.el
@@ -326,11 +326,8 @@ and the hook `eshell-exit-hook'."
       (if mode-line-elt
           (setcar mode-line-elt 'eshell-command-running-string))))
 
-  (define-key eshell-mode-map [return] 'eshell-send-input)
-  (define-key eshell-mode-map [(control ?m)] 'eshell-send-input)
-  (define-key eshell-mode-map [(control ?j)] 'eshell-send-input)
-  (define-key eshell-mode-map [(meta return)] 'eshell-queue-input)
-  (define-key eshell-mode-map [(meta control ?m)] 'eshell-queue-input)
+  (define-key eshell-mode-map "\r" 'eshell-send-input)
+  (define-key eshell-mode-map "\M-\r" 'eshell-queue-input)
   (define-key eshell-mode-map [(meta control ?l)] 'eshell-show-output)
   (define-key eshell-mode-map [(control ?a)] 'eshell-bol)
 
diff --git a/lisp/finder.el b/lisp/finder.el
index 3d988b41bde..f6593c554eb 100644
--- a/lisp/finder.el
+++ b/lisp/finder.el
@@ -206,7 +206,8 @@ from; the default is `load-path'."
               (setq version (ignore-errors (version-to-list version)))
               (setq entry (assq package package--builtins))
               (cond ((null entry)
-                     (push (cons package (vector version nil summary))
+                     (push (cons package
+                                 (package-make-builtin version summary))
                            package--builtins))
                     ((eq base-name package)
                      (setq desc (cdr entry))
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index d18aea61236..8f4363b0bdf 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -2328,7 +2328,7 @@ in which C preprocessor directives are used. e.g. `asm-mode' and
         (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\\|\\(?:user-\\)?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 3cfca4525f0..ac5cdfafca2 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,108 @@
+2013-06-11  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * eww.el (eww-convert-widgets): Make widgets from non-tabular layouts
+        work, too.
+        (eww-tag-select): Implement <select>.
+
+2013-06-10  Albert Krewinkel  <krewinkel@moltkeplatz.de>
+
+        * sieve-manage.el (sieve-manage-open): work with STARTTLS: shorten
+        stream managing functions by using open-protocol-stream to do most of
+        the work. Has the nice benefit of enabling STARTTLS.
+        Wait for capabilities after STARTTLS: following RFC5804, the server
+        sends new capabilities after successfully establishing a TLS connection
+        with the client. The client should update the cached list of
+        capabilities, but we just ignore the answer for now.
+        (sieve-manage-network-p, sieve-manage-network-open)
+        (sieve-manage-starttls-p, sieve-manage-starttls-open)
+        (sieve-manage-forward, sieve-manage-streams)
+        (sieve-manage-stream-alist): Remove unneeded functions neither in the
+        API, nor called by any other function.
+        Enable Multibyte for SieveManage buffers: The parser won't properly
+        handle umlauts and line endings unless multibyte is turned on in the
+        process buffer.
+
+2013-06-11  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * eww.el (eww-tag-input): Support password fields.
+        (eww-submit): Support POST.
+
+2013-06-10  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * eww.el (eww-tag-form): Protect against degenerate forms.
+
+        * shr.el (shr-expand-url): Expand URLs that start with a slash
+        correctly.
+
+        * eww.el (eww-submit): Get submit button logic right.
+
+        * shr.el (shr-final-table-render): New variable to signal when we're
+        doing the final table rendering so that we can collect more data at
+        that point.
+
+        * eww.el (eww-submit): Make form submission work.
+        (eww-tag-input): Implement submit buttons.
+        (eww-click-radio): Implement radio and checkboxes.
+        (eww-submit): Handle hidden elements.
+
+        * shr.el (shr-descend): Allow other packages to override (or provide)
+        rendering of elements.
+        (shr-expand-url): Strip query strings from URLs before expanding them.
+
+        * eww.el: Don't require cl-lib.
+        (eww-tag-form): Start form support.
+
+        * eww.el: Start writing a new, tiny web browser.
+        (eww-previous-url): New command.
+        (eww-quit): New command.
+
+2013-06-10  Albert Krewinkel  <krewinkel@moltkeplatz.de>
+
+        * sieve.el: Put point at beginning of buffer when viewing a script.
+        (sieve-open-server): respect the PORT parameter. Show the correct port
+        number in sieve-buffer's header. Fixed code to also work with a string
+        as port specifier. Properly close the connection on pressing 'q'. Make
+        sieve-manage-quit close the connection and process buffer. Also, remove
+        duplicate keybinding for 'q'.
+
+2013-06-10  Roy Hashimoto  <roy.hashimoto@gmail.com>  (tiny change)
+
+        * mm-view.el (mm-pkcs7-signed-magic): Allow newline in the regexp and
+        make it easier to read.
+        (mm-pkcs7-enveloped-magic): Ditto.
+
+2013-06-06  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * gnus-ems.el (gnus-image-type-available-p): Test `display-images-p'
+        before `image-type-available-p' to avoid loading the image libraries
+        needlessly.
+
+2013-06-04  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-art.el (article-date-ut, article-update-date-lapsed): Don't
+        assume Date header begins with "Date", that may be customized into
+        something like "X-Sent" using gnus-article-time-format.
+        (article-transform-date): Allow multi-line Date header.
+
+2013-06-02  David Engster  <deng@randomsample.de>
+
+        * registry.el (initialize-instance, registry-lookup)
+        (registry-lookup-breaks-before-lexbind, registry-lookup-secondary)
+        (registry-lookup-secondary-value, registry-search, registry-delete)
+        (registry-insert, registry-reindex, registry-size, registry-prune): Do
+        not wrap methods in `eval-and-compile'.  This breaks due to latest
+        changes in EIEIO (introduction of eieio-core.el).
+
+2013-05-30  Glenn Morris  <rgm@gnu.org>
+
+        * nnmail.el (nnmail-fancy-expiry-target):
+        Also bind mail-dont-reply-to-names.
+
+        * spam-stat.el (spam-stat-save):
+        No need to tweak font-lock in temp buffers.
+
+        * shr.el (shr-put-image): Silence compiler.
+
 2013-05-29  Glenn Morris  <rgm@gnu.org>
 
         * gnus-ems.el (set-process-plist): Every supported Emacs has this.
diff --git a/lisp/gnus/eww.el b/lisp/gnus/eww.el
new file mode 100644
index 00000000000..3e799732ecb
--- /dev/null
+++ b/lisp/gnus/eww.el
@@ -0,0 +1,349 @@
+;;; eww.el --- Emacs Web Wowser
+
+;; Copyright (C) 2013 Free Software Foundation, Inc.
+
+;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
+;; Keywords: html
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; Code:
+
+(eval-when-compile (require 'cl))
+(require 'shr)
+(require 'url)
+(require 'mm-url)
+
+(defvar eww-current-url nil)
+(defvar eww-history nil)
+
+;;;###autoload
+(defun eww (url)
+  "Fetch URL and render the page."
+  (interactive "sUrl: ")
+  (url-retrieve url 'eww-render (list url)))
+
+(defun eww-render (status url &optional point)
+  (let* ((headers (eww-parse-headers))
+         (content-type
+          (mail-header-parse-content-type
+           (or (cdr (assoc "content-type" headers))
+               "text/plain")))
+         (charset (intern
+                   (downcase
+                    (or (cdr (assq 'charset (cdr content-type)))
+                        "utf8"))))
+         (data-buffer (current-buffer)))
+    (unwind-protect
+        (progn
+          (cond
+           ((equal (car content-type) "text/html")
+            (eww-display-html charset url))
+           ((string-match "^image/" (car content-type))
+            (eww-display-image))
+           (t
+            (eww-display-raw charset)))
+          (when point
+            (goto-char point)))
+      (kill-buffer data-buffer))))
+
+(defun eww-parse-headers ()
+  (let ((headers nil))
+    (while (and (not (eobp))
+                (not (eolp)))
+      (when (looking-at "\\([^:]+\\): *\\(.*\\)")
+        (push (cons (downcase (match-string 1))
+                    (match-string 2))
+              headers))
+      (forward-line 1))
+    (unless (eobp)
+      (forward-line 1))
+    headers))
+
+(defun eww-display-html (charset url)
+  (unless (eq charset 'utf8)
+    (decode-coding-region (point) (point-max) charset))
+  (let ((document
+         (list
+          'base (list (cons 'href url))
+          (libxml-parse-html-region (point) (point-max)))))
+    (eww-setup-buffer)
+    (setq eww-current-url url)
+    (let ((inhibit-read-only t)
+          (shr-external-rendering-functions
+           '((form . eww-tag-form)
+             (input . eww-tag-input)
+             (select . eww-tag-select))))
+      (shr-insert-document document)
+      (eww-convert-widgets))
+    (goto-char (point-min))))
+
+(defun eww-display-raw (charset)
+  (let ((data (buffer-substring (point) (point-max))))
+    (eww-setup-buffer)
+    (let ((inhibit-read-only t))
+      (insert data))
+    (goto-char (point-min))))
+
+(defun eww-display-image ()
+  (let ((data (buffer-substring (point) (point-max))))
+    (eww-setup-buffer)
+    (let ((inhibit-read-only t))
+      (shr-put-image data nil))
+    (goto-char (point-min))))
+
+(defun eww-setup-buffer ()
+  (pop-to-buffer (get-buffer-create "*eww*"))
+  (remove-overlays)
+  (setq widget-field-list nil)
+  (let ((inhibit-read-only t))
+    (erase-buffer))
+  (eww-mode))
+
+(defvar eww-mode-map
+  (let ((map (make-sparse-keymap)))
+    (suppress-keymap map)
+    (define-key map "q" 'eww-quit)
+    (define-key map "g" 'eww-reload)
+    (define-key map [tab] 'widget-forward)
+    (define-key map [backtab] 'widget-backward)
+    (define-key map [delete] 'scroll-down-command)
+    (define-key map "\177" 'scroll-down-command)
+    (define-key map " " 'scroll-up-command)
+    (define-key map "p" 'eww-previous-url)
+    ;;(define-key map "n" 'eww-next-url)
+    map))
+
+(defun eww-mode ()
+  "Mode for browsing the web.
+
+\\{eww-mode-map}"
+  (interactive)
+  (setq major-mode 'eww-mode
+        mode-name "eww")
+  (set (make-local-variable 'eww-current-url) 'author)
+  (set (make-local-variable 'browse-url-browser-function) 'eww-browse-url)
+  ;;(setq buffer-read-only t)
+  (use-local-map eww-mode-map))
+
+(defun eww-browse-url (url &optional new-window)
+  (push (list eww-current-url (point))
+        eww-history)
+  (eww url))
+
+(defun eww-quit ()
+  "Exit the Emacs Web Wowser."
+  (interactive)
+  (setq eww-history nil)
+  (kill-buffer (current-buffer)))
+
+(defun eww-previous-url ()
+  "Go to the previously displayed page."
+  (interactive)
+  (when (zerop (length eww-history))
+    (error "No previous page"))
+  (let ((prev (pop eww-history)))
+    (url-retrieve (car prev) 'eww-render (list (car prev) (cadr prev)))))
+
+(defun eww-reload ()
+  "Reload the current page."
+  (interactive)
+  (url-retrieve eww-current-url 'eww-render
+                (list eww-current-url (point))))
+
+;; Form support.
+
+(defvar eww-form nil)
+
+(defun eww-tag-form (cont)
+  (let ((eww-form
+         (list (assq :method cont)
+               (assq :action cont)))
+        (start (point)))
+    (shr-ensure-paragraph)
+    (shr-generic cont)
+    (shr-ensure-paragraph)
+    (when (> (point) start)
+      (put-text-property start (1+ start)
+                         'eww-form eww-form))))
+
+(defun eww-tag-input (cont)
+  (let* ((start (point))
+         (type (downcase (or (cdr (assq :type cont))
+                             "text")))
+         (widget
+          (cond
+           ((equal type "submit")
+            (list
+             'push-button
+             :notify 'eww-submit
+             :name (cdr (assq :name cont))
+             :eww-form eww-form
+             (or (cdr (assq :value cont)) "Submit")))
+           ((or (equal type "radio")
+                (equal type "checkbox"))
+            (list 'checkbox
+                  :notify 'eww-click-radio
+                  :name (cdr (assq :name cont))
+                  :checkbox-value (cdr (assq :value cont))
+                  :checkbox-type type
+                  :eww-form eww-form
+                  (cdr (assq :checked cont))))
+           ((equal type "hidden")
+            (list 'hidden
+                  :name (cdr (assq :name cont))
+                  :value (cdr (assq :value cont))))
+           (t
+            (list
+             'editable-field
+             :size (string-to-number
+                    (or (cdr (assq :size cont))
+                        "40"))
+             :value (or (cdr (assq :value cont)) "")
+             :secret (and (equal type "password") ?*)
+             :action 'eww-submit
+             :name (cdr (assq :name cont))
+             :eww-form eww-form)))))
+    (if (eq (car widget) 'hidden)
+        (when shr-final-table-render
+          (nconc eww-form (list widget)))
+      (apply 'widget-create widget))
+    (put-text-property start (point) 'eww-widget widget)
+    (insert " ")))
+
+(defun eww-tag-select (cont)
+  (shr-ensure-paragraph)
+  (let ((menu (list 'menu-choice
+                    :name (cdr (assq :name cont))
+                    :eww-form eww-form))
+        (options nil)
+        (start (point)))
+    (dolist (elem cont)
+      (when (eq (car elem) 'option)
+        (when (cdr (assq :selected (cdr elem)))
+          (nconc menu (list :value
+                            (cdr (assq :value (cdr elem))))))
+        (push (list 'item
+                    :value (cdr (assq :value (cdr elem)))
+                    :tag (cdr (assq 'text (cdr elem))))
+              options)))
+    (nconc menu options)
+    (apply 'widget-create menu)
+    (put-text-property start (point) 'eww-widget menu)
+    (shr-ensure-paragraph)))
+
+(defun eww-click-radio (widget &rest ignore)
+  (let ((form (plist-get (cdr widget) :eww-form))
+        (name (plist-get (cdr widget) :name)))
+    (when (equal (plist-get (cdr widget) :type) "radio")
+      (if (widget-value widget)
+          ;; Switch all the other radio buttons off.
+          (dolist (overlay (overlays-in (point-min) (point-max)))
+            (let ((field (plist-get (overlay-properties overlay) 'button)))
+              (when (and (eq (plist-get (cdr field) :eww-form) form)
+                         (equal name (plist-get (cdr field) :name)))
+                (unless (eq field widget)
+                  (widget-value-set field nil)))))
+        (widget-value-set widget t)))
+    (eww-fix-widget-keymap)))
+
+(defun eww-submit (widget &rest ignore)
+  (let ((form (plist-get (cdr widget) :eww-form))
+        (first-button t)
+        values)
+    (dolist (overlay (sort (overlays-in (point-min) (point-max))
+                           (lambda (o1 o2)
+                             (< (overlay-start o1) (overlay-start o2)))))
+      (let ((field (or (plist-get (overlay-properties overlay) 'field)
+                       (plist-get (overlay-properties overlay) 'button)
+                       (plist-get (overlay-properties overlay) 'eww-hidden))))
+        (when (eq (plist-get (cdr field) :eww-form) form)
+          (let ((name (plist-get (cdr field) :name)))
+            (when name
+              (cond
+               ((eq (car field) 'checkbox)
+                (when (widget-value field)
+                  (push (cons name (plist-get (cdr field) :checkbox-value))
+                        values)))
+               ((eq (car field) 'eww-hidden)
+                (push (cons name (plist-get (cdr field) :value))
+                      values))
+               ((eq (car field) 'push-button)
+                ;; We want the values from buttons if we hit a button,
+                ;; or we're submitting something and this is the first
+                ;; button displayed.
+                (when (or (and (eq (car widget) 'push-button)
+                               (eq widget field))
+                          (and (not (eq (car widget) 'push-button))
+                               (eq (car field) 'push-button)
+                               first-button))
+                  (setq first-button nil)
+                  (push (cons name (widget-value field))
+                        values)))
+               (t
+                (push (cons name (widget-value field))
+                      values))))))))
+    (dolist (elem form)
+      (when (and (consp elem)
+                 (eq (car elem) 'hidden))
+        (push (cons (plist-get (cdr elem) :name)
+                    (plist-get (cdr elem) :value))
+              values)))
+    (let ((shr-base eww-current-url))
+      (if (and (stringp (cdr (assq :method form)))
+               (equal (downcase (cdr (assq :method form))) "post"))
+          (let ((url-request-method "POST")
+                (url-request-extra-headers
+                 '(("Content-Type" . "application/x-www-form-urlencoded")))
+                (url-request-data (mm-url-encode-www-form-urlencoded values)))
+            (eww-browse-url (shr-expand-url (cdr (assq :action form)))))
+        (eww-browse-url
+         (shr-expand-url
+          (concat
+           (cdr (assq :action form))
+           "?"
+           (mm-url-encode-www-form-urlencoded values))))))))
+
+(defun eww-convert-widgets ()
+  (let ((start (point-min))
+        widget)
+    ;; Some widgets come from different buffers (rendered for tables),
+    ;; so we need to nix out the list of widgets and recreate them.
+    (setq widget-field-list nil
+          widget-field-new nil)
+    (while (setq start (next-single-property-change start 'eww-widget))
+      (setq widget (get-text-property start 'eww-widget))
+      (goto-char start)
+      (let ((end (next-single-property-change start 'eww-widget)))
+        (dolist (overlay (overlays-in start end))
+          (when (or (plist-get (overlay-properties overlay) 'button)
+                    (plist-get (overlay-properties overlay) 'field))
+            (delete-overlay overlay)))
+        (delete-region start end))
+      (apply 'widget-create widget))
+    (widget-setup)
+    (eww-fix-widget-keymap)))
+
+(defun eww-fix-widget-keymap ()
+  (dolist (overlay (overlays-in (point-min) (point-max)))
+    (when (plist-get (overlay-properties overlay) 'button)
+      (overlay-put overlay 'local-map widget-keymap))))
+
+(provide 'eww)
+
+;;; eww.el ends here
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index 23603bc7722..65f4b76ad19 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -3430,15 +3430,13 @@ possible values."
          (visible-date (mail-fetch-field "Date"))
          pos date bface eface)
     (save-excursion
-      (goto-char (point-min))
-      (when (re-search-forward "^Date:" nil t)
-        (setq bface (get-text-property (point-at-bol) 'face)
-              eface (get-text-property (1- (point-at-eol)) 'face)))
-      ;; Delete any old Date headers.
       (if date-position
           (progn
             (goto-char date-position)
             (setq date (get-text-property (point) 'original-date))
+            (when (looking-at "[^:]+:[\t ]*")
+              (setq bface (get-text-property (match-beginning 0) 'face)
+                    eface (get-text-property (match-end 0) 'face)))
             (delete-region (point)
                            (progn
                              (gnus-article-forward-header)
@@ -3454,12 +3452,26 @@ possible values."
             (narrow-to-region pos (if (search-forward "\n\n" nil t)
                                       (1+ (match-beginning 0))
                                     (point-max)))
-            (goto-char (point-min))
-            (while (re-search-forward "^Date:" nil t)
-              (setq date (get-text-property (match-beginning 0) 'original-date))
-              (delete-region (point-at-bol) (progn
-                                              (gnus-article-forward-header)
-                                              (point))))
+            (while (setq pos (text-property-not-all pos (point-max)
+                                                    'gnus-date-type nil))
+              (setq date (get-text-property pos 'original-date))
+              (goto-char pos)
+              (when (looking-at "[^:]+:[\t ]*")
+                (setq bface (get-text-property (match-beginning 0) 'face)
+                      eface (get-text-property (match-end 0) 'face)))
+              (delete-region pos (or (text-property-any pos (point-max)
+                                                        'gnus-date-type nil)
+                                     (point-max))))
+            (unless date ;; the 1st time
+              (goto-char (point-min))
+              (while (re-search-forward "^Date:[\t ]*" nil t)
+                (setq date (get-text-property (match-beginning 0)
+                                              'original-date)
+                      bface (get-text-property (match-beginning 0) 'face)
+                      eface (get-text-property (match-end 0) 'face))
+                (delete-region (point-at-bol) (progn
+                                                (gnus-article-forward-header)
+                                                (point)))))
             (when (and (not date)
                        visible-date)
               (setq date visible-date))
@@ -3476,20 +3488,25 @@ possible values."
                        (list type))
                       (t
                        type)))
-    (insert (article-make-date-line date (or this-type 'ut)) "\n")
-    (forward-line -1)
-    (beginning-of-line)
-    (put-text-property (point) (1+ (point))
-                       'original-date date)
-    (put-text-property (point) (1+ (point))
-                       'gnus-date-type this-type)
+    (goto-char
+     (prog1
+         (point)
+       (add-text-properties
+        (point)
+        (progn
+          (insert (article-make-date-line date (or this-type 'ut)) "\n")
+          (point))
+        (list 'original-date date 'gnus-date-type this-type))))
     ;; Do highlighting.
-    (when (looking-at "\\([^:]+\\): *\\(.*\\)$")
-      (put-text-property (match-beginning 1) (1+ (match-end 1))
-                         'face bface)
-      (put-text-property (match-beginning 2) (match-end 2)
-                         'face eface))
-    (forward-line 1)))
+    (when (looking-at
+           "\\([^:]+:\\)[\t ]*\\(\\(?:[^\t\n ]+[\t ]+\\)*[^\t\n ]+\\)?")
+      (put-text-property (match-beginning 1) (match-end 1) 'face bface)
+      (when (match-beginning 2)
+        (put-text-property (match-beginning 2) (match-end 2) 'face eface))
+      (while (and (zerop (forward-line 1))
+                  (looking-at "[\t ]+\\(\\(?:[^\t\n ]+[\t ]+\\)*[^\t\n ]+\\)?"))
+        (when (match-beginning 1)
+          (put-text-property (match-beginning 1) (match-end 1) 'face eface))))))
 
 (defun article-make-date-line (date type)
   "Return a DATE line of TYPE."
@@ -3669,25 +3686,26 @@ function and want to see what the date was before converting."
            (when (eq major-mode 'gnus-article-mode)
              (let ((old-line (count-lines (point-min) (point)))
                    (old-column (- (point) (line-beginning-position)))
-                   (window-start
-                    (window-start (get-buffer-window (current-buffer)))))
-               (goto-char (point-min))
-               (while (re-search-forward "^Date:" nil t)
-                 (let ((type (get-text-property (match-beginning 0)
-                                                'gnus-date-type)))
-                   (when (memq type '(lapsed combined-lapsed user-format))
-                     (when (and window-start
-                                (not (= window-start
-                                        (save-excursion
-                                          (forward-line 1)
-                                          (point)))))
-                       (setq window-start nil))
-                     (save-excursion
-                       (article-date-ut type t (match-beginning 0)))
-                     (forward-line 1)
-                     (when window-start
-                       (set-window-start (get-buffer-window (current-buffer))
-                                         (point))))))
+                   (window-start (window-start w))
+                   (pos (point-min))
+                   type next end)
+               (while (setq pos (text-property-not-all pos (point-max)
+                                                       'gnus-date-type nil))
+                 (setq next (or (next-single-property-change pos
+                                                             'gnus-date-type)
+                                (point-max)))
+                 (setq type (get-text-property pos 'gnus-date-type))
+                 (when (memq type '(lapsed combined-lapsed user-defined))
+                   (article-date-ut type t pos)
+                   (setq end (or (next-single-property-change pos
+                                                              'gnus-date-type)
+                                 (point-max)))
+                   (when window-start
+                     (if (/= window-start next)
+                         (setq window-start nil)
+                       (set-window-start w end)))
+                   (setq next end))
+                 (setq pos next))
                (goto-char (point-min))
                (when (> old-column 0)
                  (setq old-line (1- old-line)))
diff --git a/lisp/gnus/gnus-ems.el b/lisp/gnus/gnus-ems.el
index 4d9b5798247..f9ef70f9580 100644
--- a/lisp/gnus/gnus-ems.el
+++ b/lisp/gnus/gnus-ems.el
@@ -165,10 +165,10 @@
 
 (defun gnus-image-type-available-p (type)
   (and (fboundp 'image-type-available-p)
-       (image-type-available-p type)
        (if (fboundp 'display-images-p)
            (display-images-p)
-         t)))
+         t)
+       (image-type-available-p type)))
 
 (defun gnus-create-image (file &optional type data-p &rest props)
   (let ((face (plist-get props :face)))
diff --git a/lisp/gnus/mm-view.el b/lisp/gnus/mm-view.el
index ac6170a3cdf..b1cba27c335 100644
--- a/lisp/gnus/mm-view.el
+++ b/lisp/gnus/mm-view.el
@@ -660,14 +660,26 @@ If MODE is not set, try to find mode automatically."
 ;;      id-signedData OBJECT IDENTIFIER ::= { iso(1) member-body(2)
 ;;          us(840) rsadsi(113549) pkcs(1) pkcs7(7) 2 }
 (defvar mm-pkcs7-signed-magic
-  "\x30\x5c\x28\x80\x5c\x7c\x81\x2e\x5c\x7c\x82\x2e\x2e\x5c\x7c\x83\x2e\x2e\
-\x2e\x5c\x29\x06\x09\x5c\x2a\x86\x48\x86\xf7\x0d\x01\x07\x02")
+  (concat
+    "0"
+    "\\(\\(\x80\\)"
+    "\\|\\(\x81\\(.\\|\n\\)\\{1\\}\\)"
+    "\\|\\(\x82\\(.\\|\n\\)\\{2\\}\\)"
+    "\\|\\(\x83\\(.\\|\n\\)\\{3\\}\\)"
+    "\\)"
+    "\x06\x09\\*\x86H\x86\xf7\x0d\x01\x07\x02"))
 
 ;;      id-envelopedData OBJECT IDENTIFIER ::= { iso(1) member-body(2)
 ;;          us(840) rsadsi(113549) pkcs(1) pkcs7(7) 3 }
 (defvar mm-pkcs7-enveloped-magic
-  "\x30\x5c\x28\x80\x5c\x7c\x81\x2e\x5c\x7c\x82\x2e\x2e\x5c\x7c\x83\x2e\x2e\
-\x2e\x5c\x29\x06\x09\x5c\x2a\x86\x48\x86\xf7\x0d\x01\x07\x03")
+  (concat
+    "0"
+    "\\(\\(\x80\\)"
+    "\\|\\(\x81\\(.\\|\n\\)\\{1\\}\\)"
+    "\\|\\(\x82\\(.\\|\n\\)\\{2\\}\\)"
+    "\\|\\(\x83\\(.\\|\n\\)\\{3\\}\\)"
+    "\\)"
+    "\x06\x09\\*\x86H\x86\xf7\x0d\x01\x07\x03"))
 
 (defun mm-view-pkcs7-get-type (handle)
   (mm-with-unibyte-buffer
diff --git a/lisp/gnus/nnmail.el b/lisp/gnus/nnmail.el
index 28b28369ae4..5be449e9a6b 100644
--- a/lisp/gnus/nnmail.el
+++ b/lisp/gnus/nnmail.el
@@ -1952,8 +1952,10 @@ If TIME is nil, then return the cutoff time for oldness instead."
        ((and (equal header 'to-from)
              (or (string-match (cadr regexp-target-pair) from)
                  (and (string-match (cadr regexp-target-pair) to)
-                      (let ((rmail-dont-reply-to-names
-                             (message-dont-reply-to-names)))
+                      (let* ((mail-dont-reply-to-names
+                              (message-dont-reply-to-names))
+                             (rmail-dont-reply-to-names ; obsolete since 24.1
+                              mail-dont-reply-to-names))
                         (equal (if (fboundp 'rmail-dont-reply-to)
                                    (rmail-dont-reply-to from)
                                  (mail-dont-reply-to from)) "")))))
diff --git a/lisp/gnus/registry.el b/lisp/gnus/registry.el
index 79f07812b2d..37fe6440743 100644
--- a/lisp/gnus/registry.el
+++ b/lisp/gnus/registry.el
@@ -119,60 +119,59 @@
          :type hash-table
          :documentation "The data hashtable.")))
 
-(eval-and-compile
-  (defmethod initialize-instance :AFTER ((this registry-db) slots)
-    "Set value of data slot of THIS after initialization."
-    (with-slots (data tracker) this
-      (unless (member :data slots)
-        (setq data
-              (make-hash-table :size 10000 :rehash-size 2.0 :test 'equal)))
-      (unless (member :tracker slots)
-        (setq tracker (make-hash-table :size 100 :rehash-size 2.0)))))
-
-  (defmethod registry-lookup ((db registry-db) keys)
-    "Search for KEYS in the registry-db THIS.
+(defmethod initialize-instance :AFTER ((this registry-db) slots)
+  "Set value of data slot of THIS after initialization."
+  (with-slots (data tracker) this
+    (unless (member :data slots)
+      (setq data
+            (make-hash-table :size 10000 :rehash-size 2.0 :test 'equal)))
+    (unless (member :tracker slots)
+      (setq tracker (make-hash-table :size 100 :rehash-size 2.0)))))
+
+(defmethod registry-lookup ((db registry-db) keys)
+  "Search for KEYS in the registry-db THIS.
 Returns an alist of the key followed by the entry in a list, not a cons cell."
-    (let ((data (oref db :data)))
-      (delq nil
-            (mapcar
-             (lambda (k)
-               (when (gethash k data)
-                 (list k (gethash k data))))
-             keys))))
-
-  (defmethod registry-lookup-breaks-before-lexbind ((db registry-db) keys)
-    "Search for KEYS in the registry-db THIS.
+  (let ((data (oref db :data)))
+    (delq nil
+          (mapcar
+           (lambda (k)
+             (when (gethash k data)
+               (list k (gethash k data))))
+           keys))))
+
+(defmethod registry-lookup-breaks-before-lexbind ((db registry-db) keys)
+  "Search for KEYS in the registry-db THIS.
 Returns an alist of the key followed by the entry in a list, not a cons cell."
-    (let ((data (oref db :data)))
-      (delq nil
-            (loop for key in keys
-                  when (gethash key data)
-                  collect (list key (gethash key data))))))
-
-  (defmethod registry-lookup-secondary ((db registry-db) tracksym
-                                        &optional create)
-    "Search for TRACKSYM in the registry-db THIS.
+  (let ((data (oref db :data)))
+    (delq nil
+          (loop for key in keys
+                when (gethash key data)
+                collect (list key (gethash key data))))))
+
+(defmethod registry-lookup-secondary ((db registry-db) tracksym
+                                      &optional create)
+  "Search for TRACKSYM in the registry-db THIS.
 When CREATE is not nil, create the secondary index hashtable if needed."
-    (let ((h (gethash tracksym (oref db :tracker))))
-      (if h
-          h
-        (when create
-          (puthash tracksym
-                   (make-hash-table :size 800 :rehash-size 2.0 :test 'equal)
-                   (oref db :tracker))
-          (gethash tracksym (oref db :tracker))))))
-
-  (defmethod registry-lookup-secondary-value ((db registry-db) tracksym val
-                                              &optional set)
-    "Search for TRACKSYM with value VAL in the registry-db THIS.
+  (let ((h (gethash tracksym (oref db :tracker))))
+    (if h
+        h
+      (when create
+        (puthash tracksym
+                 (make-hash-table :size 800 :rehash-size 2.0 :test 'equal)
+                 (oref db :tracker))
+        (gethash tracksym (oref db :tracker))))))
+
+(defmethod registry-lookup-secondary-value ((db registry-db) tracksym val
+                                            &optional set)
+  "Search for TRACKSYM with value VAL in the registry-db THIS.
 When SET is not nil, set it for VAL (use t for an empty list)."
-    ;; either we're asked for creation or there should be an existing index
-    (when (or set (registry-lookup-secondary db tracksym))
-      ;; set the entry if requested,
-      (when set
-        (puthash val (if (eq t set) '() set)
-                 (registry-lookup-secondary db tracksym t)))
-      (gethash val (registry-lookup-secondary db tracksym)))))
+  ;; either we're asked for creation or there should be an existing index
+  (when (or set (registry-lookup-secondary db tracksym))
+    ;; set the entry if requested,
+    (when set
+      (puthash val (if (eq t set) '() set)
+               (registry-lookup-secondary db tracksym t)))
+    (gethash val (registry-lookup-secondary db tracksym))))
 
 (defun registry--match (mode entry check-list)
   ;; for all members
@@ -194,166 +193,165 @@ When SET is not nil, set it for VAL (use t for an empty list)."
       (or found
           (registry--match mode entry (cdr-safe check-list))))))
 
-(eval-and-compile
-  (defmethod registry-search ((db registry-db) &rest spec)
-    "Search for SPEC across the registry-db THIS.
+(defmethod registry-search ((db registry-db) &rest spec)
+  "Search for SPEC across the registry-db THIS.
 For example calling with :member '(a 1 2) will match entry '((a 3 1)).
 Calling with :all t (any non-nil value) will match all.
 Calling with :regex '\(a \"h.llo\") will match entry '((a \"hullo\" \"bye\").
 The test order is to check :all first, then :member, then :regex."
-    (when db
-      (let ((all (plist-get spec :all))
-            (member (plist-get spec :member))
-            (regex (plist-get spec :regex)))
-        (loop for k being the hash-keys of (oref db :data)
-              using (hash-values v)
-              when (or
-                    ;; :all non-nil returns all
-                    all
-                    ;; member matching
-                    (and member (registry--match :member v member))
-                    ;; regex matching
-                    (and regex (registry--match :regex v regex)))
-              collect k))))
-
-  (defmethod registry-delete ((db registry-db) keys assert &rest spec)
-    "Delete KEYS from the registry-db THIS.
+  (when db
+    (let ((all (plist-get spec :all))
+          (member (plist-get spec :member))
+          (regex (plist-get spec :regex)))
+      (loop for k being the hash-keys of (oref db :data)
+            using (hash-values v)
+            when (or
+                  ;; :all non-nil returns all
+                  all
+                  ;; member matching
+                  (and member (registry--match :member v member))
+                  ;; regex matching
+                  (and regex (registry--match :regex v regex)))
+            collect k))))
+
+(defmethod registry-delete ((db registry-db) keys assert &rest spec)
+  "Delete KEYS from the registry-db THIS.
 If KEYS is nil, use SPEC to do a search.
 Updates the secondary ('tracked') indices as well.
 With assert non-nil, errors out if the key does not exist already."
-    (let* ((data (oref db :data))
-           (keys (or keys
-                     (apply 'registry-search db spec)))
-           (tracked (oref db :tracked)))
-
-      (dolist (key keys)
-        (let ((entry (gethash key data)))
-          (when assert
-            (assert entry nil
-                    "Key %s does not exists in database" key))
-          ;; clean entry from the secondary indices
-          (dolist (tr tracked)
-            ;; is this tracked symbol indexed?
-            (when (registry-lookup-secondary db tr)
-              ;; for every value in the entry under that key...
-              (dolist (val (cdr-safe (assq tr entry)))
-                (let* ((value-keys (registry-lookup-secondary-value
-                                    db tr val)))
-                  (when (member key value-keys)
-                    ;; override the previous value
-                    (registry-lookup-secondary-value
-                     db tr val
-                     ;; with the indexed keys MINUS the current key
-                     ;; (we pass t when the list is empty)
-                     (or (delete key value-keys) t)))))))
-          (remhash key data)))
-      keys))
-
-  (defmethod registry-size ((db registry-db))
-    "Returns the size of the registry-db object THIS.
+  (let* ((data (oref db :data))
+         (keys (or keys
+                   (apply 'registry-search db spec)))
+         (tracked (oref db :tracked)))
+
+    (dolist (key keys)
+      (let ((entry (gethash key data)))
+        (when assert
+          (assert entry nil
+                  "Key %s does not exists in database" key))
+        ;; clean entry from the secondary indices
+        (dolist (tr tracked)
+          ;; is this tracked symbol indexed?
+          (when (registry-lookup-secondary db tr)
+            ;; for every value in the entry under that key...
+            (dolist (val (cdr-safe (assq tr entry)))
+              (let* ((value-keys (registry-lookup-secondary-value
+                                  db tr val)))
+                (when (member key value-keys)
+                  ;; override the previous value
+                  (registry-lookup-secondary-value
+                   db tr val
+                   ;; with the indexed keys MINUS the current key
+                   ;; (we pass t when the list is empty)
+                   (or (delete key value-keys) t)))))))
+        (remhash key data)))
+    keys))
+
+(defmethod registry-size ((db registry-db))
+  "Returns the size of the registry-db object THIS.
 This is the key count of the :data slot."
-    (hash-table-count (oref db :data)))
+  (hash-table-count (oref db :data)))
 
-  (defmethod registry-full ((db registry-db))
-    "Checks if registry-db THIS is full."
-    (>= (registry-size db)
-       (oref db :max-hard)))
+(defmethod registry-full ((db registry-db))
+  "Checks if registry-db THIS is full."
+  (>= (registry-size db)
+      (oref db :max-hard)))
 
-  (defmethod registry-insert ((db registry-db) key entry)
-    "Insert ENTRY under KEY into the registry-db THIS.
+(defmethod registry-insert ((db registry-db) key entry)
+  "Insert ENTRY under KEY into the registry-db THIS.
 Updates the secondary ('tracked') indices as well.
 Errors out if the key exists already."
 
-    (assert (not (gethash key (oref db :data))) nil
-            "Key already exists in database")
-
-    (assert (not (registry-full db))
-            nil
-            "registry max-hard size limit reached")
-
-    ;; store the entry
-    (puthash key entry (oref db :data))
-
-    ;; store the secondary indices
+  (assert (not (gethash key (oref db :data))) nil
+          "Key already exists in database")
+
+  (assert (not (registry-full db))
+          nil
+          "registry max-hard size limit reached")
+
+  ;; store the entry
+  (puthash key entry (oref db :data))
+
+  ;; store the secondary indices
+  (dolist (tr (oref db :tracked))
+    ;; for every value in the entry under that key...
+    (dolist (val (cdr-safe (assq tr entry)))
+      (let* ((value-keys (registry-lookup-secondary-value db tr val)))
+        (pushnew key value-keys :test 'equal)
+        (registry-lookup-secondary-value db tr val value-keys))))
+  entry)
+
+(defmethod registry-reindex ((db registry-db))
+  "Rebuild the secondary indices of registry-db THIS."
+  (let ((count 0)
+        (expected (* (length (oref db :tracked)) (registry-size db))))
     (dolist (tr (oref db :tracked))
-      ;; for every value in the entry under that key...
-      (dolist (val (cdr-safe (assq tr entry)))
-        (let* ((value-keys (registry-lookup-secondary-value db tr val)))
-          (pushnew key value-keys :test 'equal)
-          (registry-lookup-secondary-value db tr val value-keys))))
-    entry)
-
-  (defmethod registry-reindex ((db registry-db))
-    "Rebuild the secondary indices of registry-db THIS."
-    (let ((count 0)
-          (expected (* (length (oref db :tracked)) (registry-size db))))
-      (dolist (tr (oref db :tracked))
-        (let (values)
-          (maphash
-           (lambda (key v)
-             (incf count)
-             (when (and (< 0 expected)
-                        (= 0 (mod count 1000)))
-               (message "reindexing: %d of %d (%.2f%%)"
-                        count expected (/ (* 100 count) expected)))
-             (dolist (val (cdr-safe (assq tr v)))
-               (let* ((value-keys (registry-lookup-secondary-value db tr val)))
-                 (push key value-keys)
-                 (registry-lookup-secondary-value db tr val value-keys))))
-           (oref db :data))))))
-
-  (defmethod registry-prune ((db registry-db) &optional sortfun)
-    "Prunes the registry-db object THIS.
+      (let (values)
+        (maphash
+         (lambda (key v)
+           (incf count)
+           (when (and (< 0 expected)
+                      (= 0 (mod count 1000)))
+             (message "reindexing: %d of %d (%.2f%%)"
+                      count expected (/ (* 100 count) expected)))
+           (dolist (val (cdr-safe (assq tr v)))
+             (let* ((value-keys (registry-lookup-secondary-value db tr val)))
+               (push key value-keys)
+               (registry-lookup-secondary-value db tr val value-keys))))
+         (oref db :data))))))
+
+(defmethod registry-prune ((db registry-db) &optional sortfun)
+  "Prunes the registry-db object THIS.
 Removes only entries without the :precious keys if it can,
 then removes oldest entries first.
 Returns the number of deleted entries.
 If SORTFUN is given, tries to keep entries that sort *higher*.
 SORTFUN is passed only the two keys so it must look them up directly."
-    (dolist (collector '(registry-prune-soft-candidates
-                         registry-prune-hard-candidates))
-      (let* ((size (registry-size db))
-             (collected (funcall collector db))
-             (limit (nth 0 collected))
-             (candidates (nth 1 collected))
-             ;; sort the candidates if SORTFUN was given
-             (candidates (if sortfun (sort candidates sortfun) candidates))
-             (candidates-count (length candidates))
-             ;; are we over max-soft?
-             (prune-needed (> size limit)))
-
-        ;; while we have more candidates than we need to remove...
-        (while (and (> candidates-count (- size limit)) candidates)
-          (decf candidates-count)
-          (setq candidates (cdr candidates)))
-
-        (registry-delete db candidates nil)
-        (length candidates))))
-
-  (defmethod registry-prune-soft-candidates ((db registry-db))
-    "Collects pruning candidates from the registry-db object THIS.
+  (dolist (collector '(registry-prune-soft-candidates
+                       registry-prune-hard-candidates))
+    (let* ((size (registry-size db))
+           (collected (funcall collector db))
+           (limit (nth 0 collected))
+           (candidates (nth 1 collected))
+           ;; sort the candidates if SORTFUN was given
+           (candidates (if sortfun (sort candidates sortfun) candidates))
+           (candidates-count (length candidates))
+           ;; are we over max-soft?
+           (prune-needed (> size limit)))
+
+      ;; while we have more candidates than we need to remove...
+      (while (and (> candidates-count (- size limit)) candidates)
+        (decf candidates-count)
+        (setq candidates (cdr candidates)))
+
+      (registry-delete db candidates nil)
+      (length candidates))))
+
+(defmethod registry-prune-soft-candidates ((db registry-db))
+  "Collects pruning candidates from the registry-db object THIS.
 Proposes only entries without the :precious keys."
-    (let* ((precious (oref db :precious))
-           (precious-p (lambda (entry-key)
-                         (cdr (memq (car entry-key) precious))))
-           (data (oref db :data))
-           (limit (oref db :max-soft))
-           (candidates (loop for k being the hash-keys of data
-                             using (hash-values v)
-                             when (notany precious-p v)
-                             collect k)))
-      (list limit candidates)))
-
-  (defmethod registry-prune-hard-candidates ((db registry-db))
-    "Collects pruning candidates from the registry-db object THIS.
+  (let* ((precious (oref db :precious))
+         (precious-p (lambda (entry-key)
+                       (cdr (memq (car entry-key) precious))))
+         (data (oref db :data))
+         (limit (oref db :max-soft))
+         (candidates (loop for k being the hash-keys of data
+                           using (hash-values v)
+                           when (notany precious-p v)
+                           collect k)))
+    (list limit candidates)))
+
+(defmethod registry-prune-hard-candidates ((db registry-db))
+  "Collects pruning candidates from the registry-db object THIS.
 Proposes any entries over the max-hard limit minus size * prune-factor."
-    (let* ((data (oref db :data))
-           ;; prune to (size * prune-factor) below the max-hard limit so
-           ;; we're not pruning all the time
-           (limit (max 0 (- (oref db :max-hard)
-                            (* (registry-size db) (oref db :prune-factor)))))
-           (candidates (loop for k being the hash-keys of data
-                             collect k)))
-      (list limit candidates))))
+  (let* ((data (oref db :data))
+         ;; prune to (size * prune-factor) below the max-hard limit so
+         ;; we're not pruning all the time
+         (limit (max 0 (- (oref db :max-hard)
+                          (* (registry-size db) (oref db :prune-factor)))))
+         (candidates (loop for k being the hash-keys of data
+                           collect k)))
+    (list limit candidates)))
 
 (provide 'registry)
 ;;; registry.el ends here
diff --git a/lisp/gnus/shr.el b/lisp/gnus/shr.el
index 2d2272d6c11..d9e267e5288 100644
--- a/lisp/gnus/shr.el
+++ b/lisp/gnus/shr.el
@@ -114,6 +114,8 @@ cid: URL as the argument.")
 (defvar shr-stylesheet nil)
 (defvar shr-base nil)
 (defvar shr-ignore-cache nil)
+(defvar shr-external-rendering-functions nil)
+(defvar shr-final-table-render nil)
 
 (defvar shr-map
   (let ((map (make-sparse-keymap)))
@@ -291,7 +293,12 @@ size, and full-buffer size."
     (nreverse result)))
 
 (defun shr-descend (dom)
-  (let ((function (intern (concat "shr-tag-" (symbol-name (car dom))) obarray))
+  (let ((function
+         (or
+          ;; Allow other packages to override (or provide) rendering
+          ;; of elements.
+          (cdr (assq (car dom) shr-external-rendering-functions))
+          (intern (concat "shr-tag-" (symbol-name (car dom))) obarray)))
         (style (cdr (assq :style (cdr dom))))
         (shr-stylesheet shr-stylesheet)
         (start (point)))
@@ -478,20 +485,27 @@ size, and full-buffer size."
     (not failed)))
 
 (defun shr-expand-url (url)
-  (cond
-   ;; Absolute URL.
-   ((or (not url)
-        (string-match "\\`[a-z]*:" url)
-        (not shr-base))
-    url)
-   ((and (string-match "\\`//" url)
-         (string-match "\\`[a-z]*:" shr-base))
-    (concat (match-string 0 shr-base) url))
-   ((and (not (string-match "/\\'" shr-base))
-         (not (string-match "\\`/" url)))
-    (concat shr-base "/" url))
-   (t
-    (concat shr-base url))))
+  (if (or (not url)
+          (string-match "\\`[a-z]*:" url)
+          (not shr-base))
+      ;; Absolute URL.
+      url
+    (let ((base shr-base))
+      ;; Chop off query string.
+      (when (string-match "^\\([^?]+\\)[?]" base)
+        (setq base (match-string 1 base)))
+      (cond
+       ((and (string-match "\\`//" url)
+             (string-match "\\`[a-z]*:" base))
+        (concat (match-string 0 base) url))
+       ((and (not (string-match "/\\'" base))
+             (not (string-match "\\`/" url)))
+        (concat base "/" url))
+       ((and (string-match "\\`/" url)
+             (string-match "\\(\\`[^:]*://[^/]+\\)/" base))
+        (concat (match-string 1 base) url))
+       (t
+        (concat base url))))))
 
 (defun shr-ensure-newline ()
   (unless (zerop (current-column))
@@ -631,12 +645,13 @@ size, and full-buffer size."
                   (overlay-put overlay 'face 'default)))
             (insert-image image (or alt "*")))
           (put-text-property start (point) 'image-size size)
-          (when (if (fboundp 'image-multi-frame-p)
-                    ;; Only animate multi-frame things that specify a
-                    ;; delay; eg animated gifs as opposed to
-                    ;; multi-page tiffs.  FIXME?
-                    (cdr (image-multi-frame-p image))
-                  (image-animated-p image))
+          (when (cond ((fboundp 'image-multi-frame-p)
+                       ;; Only animate multi-frame things that specify a
+                       ;; delay; eg animated gifs as opposed to
+                       ;; multi-page tiffs.  FIXME?
+                       (cdr (image-multi-frame-p image)))
+                      ((fboundp 'image-animated-p)
+                       (image-animated-p image)))
             (image-animate image nil 60)))
         image)
     (insert alt)))
@@ -944,7 +959,8 @@ ones, in case fg and bg are nil."
       plist)))
 
 (defun shr-tag-base (cont)
-  (setq shr-base (cdr (assq :href cont))))
+  (setq shr-base (cdr (assq :href cont)))
+  (shr-generic cont))
 
 (defun shr-tag-a (cont)
   (let ((url (cdr (assq :href cont)))
@@ -1166,7 +1182,8 @@ ones, in case fg and bg are nil."
              (frame-width))
       (setq truncate-lines t))
     ;; Then render the table again with these new "hard" widths.
-    (shr-insert-table (shr-make-table cont sketch-widths t) sketch-widths))
+    (let ((shr-final-table-render t))
+      (shr-insert-table (shr-make-table cont sketch-widths t) sketch-widths)))
   ;; Finally, insert all the images after the table.  The Emacs buffer
   ;; model isn't strong enough to allow us to put the images actually
   ;; into the tables.
diff --git a/lisp/gnus/sieve-manage.el b/lisp/gnus/sieve-manage.el
index b96261764e5..23ab24152d9 100644
--- a/lisp/gnus/sieve-manage.el
+++ b/lisp/gnus/sieve-manage.el
@@ -3,6 +3,7 @@
 ;; Copyright (C) 2001-2013 Free Software Foundation, Inc.
 
 ;; Author: Simon Josefsson <simon@josefsson.org>
+;;         Albert Krewinkel <tarleb@moltkeplatz.de>
 
 ;; This file is part of GNU Emacs.
 
@@ -66,6 +67,7 @@
 ;; 2001-10-31 Committed to Oort Gnus.
 ;; 2002-07-27 Added DELETESCRIPT.  Suggested by Ned Ludd.
 ;; 2002-08-03 Use SASL library.
+;; 2013-06-05 Enabled STARTTLS support, fixed bit rot.
 
 ;;; Code:
 
@@ -82,7 +84,6 @@
   (require 'sasl)
   (require 'starttls))
 (autoload 'sasl-find-mechanism "sasl")
-(autoload 'starttls-open-stream "starttls")
 (autoload 'auth-source-search "auth-source")
 
 ;; User customizable variables:
@@ -107,23 +108,6 @@
   :type 'string
   :group 'sieve-manage)
 
-(defcustom sieve-manage-streams '(network starttls shell)
-  "Priority of streams to consider when opening connection to server."
-  :group 'sieve-manage)
-
-(defcustom sieve-manage-stream-alist
-  '((network   sieve-manage-network-p          sieve-manage-network-open)
-    (shell     sieve-manage-shell-p            sieve-manage-shell-open)
-    (starttls  sieve-manage-starttls-p         sieve-manage-starttls-open))
-  "Definition of network streams.
-
-\(NAME CHECK OPEN)
-
-NAME names the stream, CHECK is a function returning non-nil if the
-server support the stream and OPEN is a function for opening the
-stream."
-  :group 'sieve-manage)
-
 (defcustom sieve-manage-authenticators '(digest-md5
                                          cram-md5
                                          scram-md5
@@ -156,8 +140,7 @@ for doing the actual authentication."
   :group 'sieve-manage)
 
 (defcustom sieve-manage-default-stream 'network
-  "Default stream type to use for `sieve-manage'.
-Must be a name of a stream in `sieve-manage-stream-alist'."
+  "Default stream type to use for `sieve-manage'."
   :version "24.1"
   :type 'symbol
   :group 'sieve-manage)
@@ -185,17 +168,21 @@ Valid states are `closed', `initial', `nonauth', and `auth'.")
 (defvar sieve-manage-capability nil)
 
 ;; Internal utility functions
-
-(defmacro sieve-manage-disable-multibyte ()
-  "Enable multibyte in the current buffer."
-  (unless (featurep 'xemacs)
-    '(set-buffer-multibyte nil)))
+(defun sieve-manage-make-process-buffer ()
+  (with-current-buffer
+      (generate-new-buffer (format " *sieve %s:%s*"
+                                   sieve-manage-server
+                                   sieve-manage-port))
+    (mapc 'make-local-variable sieve-manage-local-variables)
+    (mm-enable-multibyte)
+    (buffer-disable-undo)
+    (current-buffer)))
 
 (defun sieve-manage-erase (&optional p buffer)
   (let ((buffer (or buffer (current-buffer))))
     (and sieve-manage-log
          (with-current-buffer (get-buffer-create sieve-manage-log)
-           (sieve-manage-disable-multibyte)
+           (mm-enable-multibyte)
            (buffer-disable-undo)
            (goto-char (point-max))
            (insert-buffer-substring buffer (with-current-buffer buffer
@@ -204,71 +191,32 @@ Valid states are `closed', `initial', `nonauth', and `auth'.")
                                             (point-max)))))))
   (delete-region (point-min) (or p (point-max))))
 
-(defun sieve-manage-open-1 (buffer)
+(defun sieve-manage-open-server (server port &optional stream buffer)
+  "Open network connection to SERVER on PORT.
+Return the buffer associated with the connection."
   (with-current-buffer buffer
     (sieve-manage-erase)
-    (setq sieve-manage-state 'initial
-          sieve-manage-process
-          (condition-case ()
-              (funcall (nth 2 (assq sieve-manage-stream
-                                    sieve-manage-stream-alist))
-                       "sieve" buffer sieve-manage-server sieve-manage-port)
-            ((error quit) nil)))
-    (when sieve-manage-process
-      (while (and (eq sieve-manage-state 'initial)
-                  (memq (process-status sieve-manage-process) '(open run)))
-        (message "Waiting for response from %s..." sieve-manage-server)
-        (accept-process-output sieve-manage-process 1))
-      (message "Waiting for response from %s...done" sieve-manage-server)
-      (and (memq (process-status sieve-manage-process) '(open run))
-           sieve-manage-process))))
-
-;; Streams
-
-(defun sieve-manage-network-p (buffer)
-  t)
-
-(defun sieve-manage-network-open (name buffer server port)
-  (let* ((port (or port sieve-manage-default-port))
-         (coding-system-for-read sieve-manage-coding-system-for-read)
-         (coding-system-for-write sieve-manage-coding-system-for-write)
-         (process (open-network-stream name buffer server port)))
-    (when process
-      (while (and (memq (process-status process) '(open run))
-                  (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
-                  (goto-char (point-min))
-                  (not (sieve-manage-parse-greeting-1)))
-        (accept-process-output process 1)
-        (sit-for 1))
-      (sieve-manage-erase nil buffer)
-      (when (memq (process-status process) '(open run))
-        process))))
-
-(defun sieve-manage-starttls-p (buffer)
-  (condition-case ()
-      (progn
-        (require 'starttls)
-        (call-process "starttls"))
-    (error nil)))
-
-(defun sieve-manage-starttls-open (name buffer server port)
-  (let* ((port (or port sieve-manage-default-port))
-         (coding-system-for-read sieve-manage-coding-system-for-read)
-         (coding-system-for-write sieve-manage-coding-system-for-write)
-         (process (starttls-open-stream name buffer server port))
-         done)
-    (when process
-      (while (and (memq (process-status process) '(open run))
-                  (set-buffer buffer) ;; XXX "blue moon" nntp.el bug
-                  (goto-char (point-min))
-                  (not (sieve-manage-parse-greeting-1)))
-        (accept-process-output process 1)
-        (sit-for 1))
-      (sieve-manage-erase nil buffer)
-      (sieve-manage-send "STARTTLS")
-      (starttls-negotiate process))
-    (when (memq (process-status process) '(open run))
-      process)))
+    (setq sieve-manage-state 'initial)
+    (destructuring-bind (proc . props)
+        (open-protocol-stream
+         "SIEVE" buffer server port
+         :type stream
+         :capability-command "CAPABILITY\r\n"
+         :end-of-command "^\\(OK\\|NO\\).*\n"
+         :success "^OK.*\n"
+         :return-list t
+         :starttls-function
+         '(lambda (capabilities)
+            (when (string-match "\\bSTARTTLS\\b" capabilities)
+              "STARTTLS\r\n")))
+      (setq sieve-manage-process proc)
+      (setq sieve-manage-capability
+            (sieve-manage-parse-capability (getf props :capabilities)))
+      ;; Ignore new capabilities issues after successful STARTTLS
+      (when (and (memq stream '(nil network starttls))
+                 (eq (getf props :type) 'tls))
+        (sieve-manage-drop-next-answer))
+      (current-buffer))))
 
 ;; Authenticators
 (defun sieve-sasl-auth (buffer mech)
@@ -396,63 +344,33 @@ Optional argument AUTH indicates authenticator to use, see
 If nil, chooses the best stream the server is capable of.
 Optional argument BUFFER is buffer (buffer, or string naming buffer)
 to work in."
-  (or port (setq port sieve-manage-default-port))
-  (setq buffer (or buffer (format " *sieve* %s:%s" server port)))
-  (with-current-buffer (get-buffer-create buffer)
-    (mapc 'make-local-variable sieve-manage-local-variables)
-    (sieve-manage-disable-multibyte)
-    (buffer-disable-undo)
-    (setq sieve-manage-server (or server sieve-manage-server))
-    (setq sieve-manage-port port)
-    (setq sieve-manage-stream (or stream sieve-manage-stream))
+  (setq sieve-manage-port (or port sieve-manage-default-port))
+  (with-current-buffer (or buffer (sieve-manage-make-process-buffer))
+    (setq sieve-manage-server (or server
+                                  sieve-manage-server)
+          sieve-manage-stream (or stream
+                                  sieve-manage-stream
+                                  sieve-manage-default-stream)
+          sieve-manage-auth   (or auth
+                                  sieve-manage-auth))
     (message "sieve: Connecting to %s..." sieve-manage-server)
-    (if (let ((sieve-manage-stream
-               (or sieve-manage-stream sieve-manage-default-stream)))
-          (sieve-manage-open-1 buffer))
-        ;; Choose stream.
-        (let (stream-changed)
-          (message "sieve: Connecting to %s...done" sieve-manage-server)
-          (when (null sieve-manage-stream)
-            (let ((streams sieve-manage-streams))
-              (while (setq stream (pop streams))
-                (if (funcall (nth 1 (assq stream
-                                          sieve-manage-stream-alist)) buffer)
-                    (setq stream-changed
-                          (not (eq (or sieve-manage-stream
-                                       sieve-manage-default-stream)
-                                   stream))
-                          sieve-manage-stream stream
-                          streams nil)))
-              (unless sieve-manage-stream
-                (error "Couldn't figure out a stream for server"))))
-          (when stream-changed
-            (message "sieve: Reconnecting with stream `%s'..."
-                     sieve-manage-stream)
-            (sieve-manage-close buffer)
-            (if (sieve-manage-open-1 buffer)
-                (message "sieve: Reconnecting with stream `%s'...done"
-                         sieve-manage-stream)
-              (message "sieve: Reconnecting with stream `%s'...failed"
-                       sieve-manage-stream))
-            (setq sieve-manage-capability nil))
-          (if (sieve-manage-opened buffer)
-              ;; Choose authenticator
-              (when (and (null sieve-manage-auth)
-                         (not (eq sieve-manage-state 'auth)))
-                (let ((auths sieve-manage-authenticators))
-                  (while (setq auth (pop auths))
-                    (if (funcall (nth 1 (assq
-                                         auth
-                                         sieve-manage-authenticator-alist))
-                                 buffer)
-                        (setq sieve-manage-auth auth
-                              auths nil)))
-                  (unless sieve-manage-auth
-                    (error "Couldn't figure out authenticator for server"))))))
-      (message "sieve: Connecting to %s...failed" sieve-manage-server))
-    (when (sieve-manage-opened buffer)
+    (sieve-manage-open-server sieve-manage-server
+                              sieve-manage-port
+                              sieve-manage-stream
+                              (current-buffer))
+    (when (sieve-manage-opened (current-buffer))
+      ;; Choose authenticator
+      (when (and (null sieve-manage-auth)
+                 (not (eq sieve-manage-state 'auth)))
+        (dolist (auth sieve-manage-authenticators)
+          (when (funcall (nth 1 (assq auth sieve-manage-authenticator-alist))
+                       buffer)
+            (setq sieve-manage-auth auth)
+            (return)))
+        (unless sieve-manage-auth
+          (error "Couldn't figure out authenticator for server")))
       (sieve-manage-erase)
-      buffer)))
+      (current-buffer))))
 
 (defun sieve-manage-authenticate (&optional buffer)
   "Authenticate on server in BUFFER.
@@ -544,12 +462,22 @@ If NAME is nil, return the full server list of capabilities."
 
 ;; Protocol parsing routines
 
+(defun sieve-manage-wait-for-answer ()
+  (let ((pattern "^\\(OK\\|NO\\).*\n")
+        pos)
+    (while (not pos)
+      (setq pos (search-forward-regexp pattern nil t))
+      (goto-char (point-min))
+      (sleep-for 0 50))
+    pos))
+
+(defun sieve-manage-drop-next-answer ()
+  (sieve-manage-wait-for-answer)
+  (sieve-manage-erase))
+
 (defun sieve-manage-ok-p (rsp)
   (string= (downcase (or (car-safe rsp) "")) "ok"))
 
-(defsubst sieve-manage-forward ()
-  (or (eobp) (forward-char)))
-
 (defun sieve-manage-is-okno ()
   (when (looking-at (concat
                      "^\\(OK\\|NO\\)\\( (\\([^)]+\\))\\)?\\( \\(.*\\)\\)?"
@@ -571,21 +499,15 @@ If NAME is nil, return the full server list of capabilities."
     (sieve-manage-erase)
     rsp))
 
-(defun sieve-manage-parse-capability-1 ()
-  "Accept a managesieve greeting."
-  (let (str)
-    (while (setq str (sieve-manage-is-string))
-      (if (eq (char-after) ? )
-          (progn
-            (sieve-manage-forward)
-            (push (list str (sieve-manage-is-string))
-                  sieve-manage-capability))
-        (push (list str) sieve-manage-capability))
-      (forward-line)))
-  (when (re-search-forward (concat "^OK.*" sieve-manage-server-eol) nil t)
-    (setq sieve-manage-state 'nonauth)))
-
-(defalias 'sieve-manage-parse-greeting-1 'sieve-manage-parse-capability-1)
+(defun sieve-manage-parse-capability (str)
+  "Parse managesieve capability string `STR'.
+Set variable `sieve-manage-capability' to "
+  (let ((capas (remove-if #'null
+                          (mapcar #'split-string-and-unquote
+                                  (split-string str "\n")))))
+    (when (string= "OK" (caar (last capas)))
+      (setq sieve-manage-state 'nonauth))
+    capas))
 
 (defun sieve-manage-is-string ()
   (cond ((looking-at "\"\\([^\"]+\\)\"")
@@ -639,7 +561,7 @@ If NAME is nil, return the full server list of capabilities."
   (setq cmdstr (concat cmdstr sieve-manage-client-eol))
   (and sieve-manage-log
        (with-current-buffer (get-buffer-create sieve-manage-log)
-         (sieve-manage-disable-multibyte)
+         (mm-enable-multibyte)
          (buffer-disable-undo)
          (goto-char (point-max))
          (insert cmdstr)))
diff --git a/lisp/gnus/sieve.el b/lisp/gnus/sieve.el
index 0e46cb66361..2c11c039d56 100644
--- a/lisp/gnus/sieve.el
+++ b/lisp/gnus/sieve.el
@@ -109,7 +109,6 @@ require \"fileinto\";
     ;; various
     (define-key map "?" 'sieve-help)
     (define-key map "h" 'sieve-help)
-    (define-key map "q" 'kill-buffer)
     ;; activating
     (define-key map "m" 'sieve-activate)
     (define-key map "u" 'sieve-deactivate)
@@ -152,6 +151,8 @@ require \"fileinto\";
 (defun sieve-manage-quit ()
   "Quit."
   (interactive)
+  (sieve-manage-close sieve-manage-buffer)
+  (kill-buffer sieve-manage-buffer)
   (kill-buffer (current-buffer)))
 
 (defun sieve-activate (&optional pos)
@@ -206,6 +207,7 @@ require \"fileinto\";
       (insert sieve-template))
     (sieve-mode)
     (setq sieve-buffer-script-name name)
+    (beginning-of-buffer)
     (message
      (substitute-command-keys
       "Press \\[sieve-upload] to upload script to server."))))
@@ -256,10 +258,9 @@ Used to bracket operations which move point in the sieve-buffer."
   (setq buffer-read-only nil)
   (erase-buffer)
   (buffer-disable-undo)
-  (insert "\
-Server  : " server ":" (or port sieve-manage-default-port) "
-
-")
+  (let* ((port (or port sieve-manage-default-port))
+         (header (format "Server : %s:%s\n\n" server port)))
+    (insert header))
   (set (make-local-variable 'sieve-buffer-header-end)
        (point-max)))
 
@@ -305,7 +306,7 @@ Server  : " server ":" (or port sieve-manage-default-port) "
   (with-current-buffer
       (or ;; open server
        (set (make-local-variable 'sieve-manage-buffer)
-            (sieve-manage-open server))
+            (sieve-manage-open server port))
        (error "Error opening server %s" server))
     (sieve-manage-authenticate)))
 
diff --git a/lisp/gnus/spam-stat.el b/lisp/gnus/spam-stat.el
index d75e8198842..135bfd48e5f 100644
--- a/lisp/gnus/spam-stat.el
+++ b/lisp/gnus/spam-stat.el
@@ -412,8 +412,7 @@ With a prefix argument save unconditionally."
   (when (or force spam-stat-dirty)
     (let ((coding-system-for-write spam-stat-coding-system))
       (with-temp-file spam-stat-file
-        (let ((standard-output (current-buffer))
-              (font-lock-maximum-size 0))
+        (let ((standard-output (current-buffer)))
           (insert (format ";-*- coding: %s; -*-\n" spam-stat-coding-system))
           (insert (format "(setq spam-stat-ngood %d spam-stat-nbad %d
 spam-stat (spam-stat-to-hash-table '(" spam-stat-ngood spam-stat-nbad))
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index bdf86016844..86bb67e87c2 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -435,14 +435,19 @@ suitable file is found, return nil."
   (let ((handler (function-get function 'compiler-macro)))
     (when handler
       (insert "\nThis function has a compiler macro")
-      (let ((lib (get function 'compiler-macro-file)))
-        ;; FIXME: rather than look at the compiler-macro-file property,
-        ;; just look at `handler' itself.
-        (when (stringp lib)
-          (insert (format " in `%s'" lib))
-          (save-excursion
-            (re-search-backward "`\\([^`']+\\)'" nil t)
-            (help-xref-button 1 'help-function-cmacro function lib))))
+      (if (symbolp handler)
+          (progn
+            (insert (format " `%s'" handler))
+            (save-excursion
+              (re-search-backward "`\\([^`']+\\)'" nil t)
+              (help-xref-button 1 'help-function handler)))
+        ;; FIXME: Obsolete since 24.4.
+        (let ((lib (get function 'compiler-macro-file)))
+          (when (stringp lib)
+            (insert (format " in `%s'" lib))
+            (save-excursion
+              (re-search-backward "`\\([^`']+\\)'" nil t)
+              (help-xref-button 1 'help-function-cmacro function lib)))))
       (insert ".\n"))))
 
 (defun help-fns--signature (function doc real-def real-function)
diff --git a/lisp/help-mode.el b/lisp/help-mode.el
index b5aca1a4445..b56adc2a4a9 100644
--- a/lisp/help-mode.el
+++ b/lisp/help-mode.el
@@ -204,7 +204,7 @@ The format is (FUNCTION ARGS...).")
                        (message "Unable to find location in file"))))
   'help-echo (purecopy "mouse-2, RET: find function's definition"))
 
-(define-button-type 'help-function-cmacro
+(define-button-type 'help-function-cmacro ; FIXME: Obsolete since 24.4.
   :supertype 'help-xref
   'help-function (lambda (fun file)
                    (setq file (locate-library file t))
@@ -213,7 +213,7 @@ The format is (FUNCTION ARGS...).")
                          (pop-to-buffer (find-file-noselect file))
                          (goto-char (point-min))
                          (if (re-search-forward
-                              (format "^[ \t]*(define-compiler-macro[ \t]+%s"
+                              (format "^[ \t]*(\\(cl-\\)?define-compiler-macro[ \t]+%s"
                                       (regexp-quote (symbol-name fun))) nil t)
                              (forward-line 0)
                            (message "Unable to find location in file")))
diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index e2dc4eac67b..d0a82cd97b0 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -37,18 +37,18 @@
 ;;
 ;;    In program source code highlight a variable to quickly see all
 ;;    places it is modified or referenced:
-;;    M-x highlight-regexp ground_contact_switches_closed RET RET
+;;    M-x highlight-regexp RET ground_contact_switches_closed RET RET
 ;;
 ;;    In a shell or other buffer that is showing lots of program
 ;;    output, highlight the parts of the output you're interested in:
-;;    M-x highlight-regexp Total execution time [0-9]+ RET hi-blue-b RET
+;;    M-x highlight-regexp RET Total execution time [0-9]+ RET hi-blue-b RET
 ;;
 ;;    In buffers displaying tables, highlight the lines you're interested in:
-;;    M-x highlight-lines-matching-regexp January 2000 RET hi-black-b RET
+;;    M-x highlight-lines-matching-regexp RET January 2000 RET hi-black-b RET
 ;;
 ;;    When writing text, highlight personal cliches.  This can be
 ;;    amusing.
-;;    M-x highlight-phrase as can be seen RET RET
+;;    M-x highlight-phrase RET as can be seen RET RET
 ;;
 ;;  Setup:
 ;;
@@ -252,6 +252,10 @@ a library is being loaded.")
       '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
         :help "Highlight lines containing match of PATTERN (a regexp)."))
 
+    (define-key-after map [highlight-symbol-at-point]
+      '(menu-item "Highlight Symbol at Point" highlight-symbol-at-point
+        :help "Highlight symbol found near point without prompting."))
+
     (define-key-after map [unhighlight-regexp]
       '(menu-item "Remove Highlighting..." unhighlight-regexp
         :help "Remove previously entered highlighting pattern."
@@ -274,6 +278,7 @@ a library is being loaded.")
     (define-key map "\C-xwl" 'highlight-lines-matching-regexp)
     (define-key map "\C-xwp" 'highlight-phrase)
     (define-key map "\C-xwh" 'highlight-regexp)
+    (define-key map "\C-xw." 'highlight-symbol-at-point)
     (define-key map "\C-xwr" 'unhighlight-regexp)
     (define-key map "\C-xwb" 'hi-lock-write-interactive-patterns)
     map)
@@ -333,6 +338,10 @@ which can be called interactively, are:
 \\[highlight-lines-matching-regexp] REGEXP FACE
   Highlight lines containing matches of REGEXP in current buffer with FACE.
 
+\\[highlight-symbol-at-point]
+  Highlight the symbol found near point without prompting, using the next
+  available face automatically.
+
 \\[unhighlight-regexp] REGEXP
   Remove highlighting on matches of REGEXP in current buffer.
 
@@ -490,6 +499,27 @@ highlighting will not update as you type."
   (unless hi-lock-mode (hi-lock-mode 1))
   (hi-lock-set-pattern regexp face))
 
+;;;###autoload
+(defalias 'highlight-symbol-at-point 'hi-lock-face-symbol-at-point)
+;;;###autoload
+(defun hi-lock-face-symbol-at-point ()
+  "Set face of each match of the symbol at point.
+Use `find-tag-default-as-regexp' to retrieve the symbol at point.
+Use non-nil `hi-lock-auto-select-face' to retrieve the next face
+from `hi-lock-face-defaults' automatically.
+
+Use Font lock mode, if enabled, to highlight symbol at point.
+Otherwise, use overlays for highlighting.  If overlays are used,
+the highlighting will not update as you type."
+  (interactive)
+  (let* ((regexp (hi-lock-regexp-okay
+                  (find-tag-default-as-regexp)))
+         (hi-lock-auto-select-face t)
+         (face (hi-lock-read-face-name)))
+    (or (facep face) (setq face 'hi-yellow))
+    (unless hi-lock-mode (hi-lock-mode 1))
+    (hi-lock-set-pattern regexp face)))
+
 (defun hi-lock-keyword->face (keyword)
   (cadr (cadr (cadr keyword))))    ; Keyword looks like (REGEXP (0 'FACE) ...).
 
diff --git a/lisp/ido.el b/lisp/ido.el
index 8087124765c..47c05b080f7 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -3276,14 +3276,18 @@ for first matching file."
 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
   ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
   (let ((filenames
-         (split-string
-          (shell-command-to-string
-           (concat "find "
-                   (shell-quote-argument dir)
-                   " -name "
-                   (shell-quote-argument
-                    (concat (if prefix "" "*") file "*"))
-                   " -type " (if finddir "d" "f") " -print"))))
+         (delq nil
+               (mapcar (lambda (name)
+                         (unless (ido-ignore-item-p name ido-ignore-files t)
+                           name))
+                       (split-string
+                        (shell-command-to-string
+                         (concat "find "
+                                 (shell-quote-argument dir)
+                                 (if ido-case-fold " -iname " " -name ")
+                                 (shell-quote-argument
+                                  (concat (if prefix "" "*") file "*"))
+                                 " -type " (if finddir "d" "f") " -print"))))))
         filename d f
         res)
     (while filenames
@@ -3297,7 +3301,7 @@ for first matching file."
     res))
 
 (defun ido-flatten-merged-list (items)
-  ;; Create a list of directory names based on a merged directory list.
+  "Create a list of directory names based on a merged directory list."
   (let (res)
     (while items
       (let* ((item (car items))
@@ -3400,7 +3404,7 @@ for first matching file."
     res))
 
 (defun ido-make-buffer-list-1 (&optional frame visible)
-  ;; Return list of non-ignored buffer names
+  "Return list of non-ignored buffer names."
   (delq nil
         (mapcar
          (lambda (x)
@@ -3410,12 +3414,12 @@ for first matching file."
          (buffer-list frame))))
 
 (defun ido-make-buffer-list (default)
-  ;; Return the current list of buffers.
-  ;; Currently visible buffers are put at the end of the list.
-  ;; The hook `ido-make-buffer-list-hook' is run after the list has been
-  ;; created to allow the user to further modify the order of the buffer names
-  ;; in this list.  If DEFAULT is non-nil, and corresponds to an existing buffer,
-  ;; it is put to the start of the list.
+  "Return the current list of buffers.
+Currently visible buffers are put at the end of the list.
+The hook `ido-make-buffer-list-hook' is run after the list has been
+created to allow the user to further modify the order of the buffer names
+in this list.  If DEFAULT is non-nil, and corresponds to an existing buffer,
+it is put to the start of the list."
   (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
          (ido-temp-list (ido-make-buffer-list-1 (selected-frame) ido-current-buffers)))
     (if ido-temp-list
@@ -3457,9 +3461,9 @@ This is to make them appear as if they were \"virtual buffers\"."
                  (nreverse (mapcar #'car ido-virtual-buffers))))))
 
 (defun ido-make-choice-list (default)
-  ;; Return the current list of choices.
-  ;; If DEFAULT is non-nil, and corresponds to an element of choices,
-  ;; it is put to the start of the list.
+  "Return the current list of choices.
+If DEFAULT is non-nil, and corresponds to an element of choices,
+it is put to the start of the list."
   (let ((ido-temp-list ido-choice-list))
     (if default
         (progn
@@ -3471,7 +3475,7 @@ This is to make them appear as if they were \"virtual buffers\"."
     ido-temp-list))
 
 (defun ido-to-end (items)
-  ;; Move the elements from ITEMS to the end of `ido-temp-list'
+  "Move the elements from ITEMS to the end of `ido-temp-list'."
   (mapc
    (lambda (elem)
      (setq ido-temp-list (delq elem ido-temp-list)))
@@ -3515,8 +3519,8 @@ This is to make them appear as if they were \"virtual buffers\"."
     (file-name-all-completions "" dir))))
 
 (defun ido-file-name-all-completions (dir)
-  ;; Return name of all files in DIR
-  ;; Uses and updates ido-dir-file-cache
+  "Return name of all files in DIR.
+Uses and updates `ido-dir-file-cache'."
   (cond
    ((ido-is-unc-root dir)
     (mapcar
@@ -3565,7 +3569,7 @@ This is to make them appear as if they were \"virtual buffers\"."
     (ido-file-name-all-completions-1 dir))))
 
 (defun ido-remove-cached-dir (dir)
-  ;; Remove dir from ido-dir-file-cache
+  "Remove DIR from `ido-dir-file-cache'."
   (if (and ido-dir-file-cache
            (stringp dir) (> (length dir) 0))
       (let ((cached (assoc dir ido-dir-file-cache)))
@@ -3574,8 +3578,8 @@ This is to make them appear as if they were \"virtual buffers\"."
 
 
 (defun ido-make-file-list-1 (dir &optional merged)
-  ;; Return list of non-ignored files in DIR
-  ;; If MERGED is non-nil, each file is cons'ed with DIR
+  "Return list of non-ignored files in DIR
+If MERGED is non-nil, each file is cons'ed with DIR."
   (and (or (ido-is-tramp-root dir) (ido-is-unc-root dir)
            (file-directory-p dir))
        (delq nil
@@ -3586,11 +3590,11 @@ This is to make them appear as if they were \"virtual buffers\"."
               (ido-file-name-all-completions dir)))))
 
 (defun ido-make-file-list (default)
-  ;; Return the current list of files.
-  ;; Currently visible files are put at the end of the list.
-  ;; The hook `ido-make-file-list-hook' is run after the list has been
-  ;; created to allow the user to further modify the order of the file names
-  ;; in this list.
+  "Return the current list of files.
+Currently visible files are put at the end of the list.
+The hook `ido-make-file-list-hook' is run after the list has been
+created to allow the user to further modify the order of the file names
+in this list."
   (let ((ido-temp-list (ido-make-file-list-1 ido-current-directory)))
     (setq ido-temp-list (sort ido-temp-list
                               (if ido-file-extensions-order
@@ -3631,8 +3635,8 @@ This is to make them appear as if they were \"virtual buffers\"."
     ido-temp-list))
 
 (defun ido-make-dir-list-1 (dir &optional merged)
-  ;; Return list of non-ignored subdirs in DIR
-  ;; If MERGED is non-nil, each subdir is cons'ed with DIR
+  "Return list of non-ignored subdirs in DIR.
+If MERGED is non-nil, each subdir is cons'ed with DIR."
   (and (or (ido-is-tramp-root dir) (file-directory-p dir))
        (delq nil
              (mapcar
@@ -3642,10 +3646,10 @@ This is to make them appear as if they were \"virtual buffers\"."
               (ido-file-name-all-completions dir)))))
 
 (defun ido-make-dir-list (default)
-  ;; Return the current list of directories.
-  ;; The hook `ido-make-dir-list-hook' is run after the list has been
-  ;; created to allow the user to further modify the order of the
-  ;; directory names in this list.
+  "Return the current list of directories.
+The hook `ido-make-dir-list-hook' is run after the list has been
+created to allow the user to further modify the order of the
+directory names in this list."
   (let ((ido-temp-list (ido-make-dir-list-1 ido-current-directory)))
     (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
     (ido-to-end  ;; move . files to end
@@ -3676,10 +3680,9 @@ This is to make them appear as if they were \"virtual buffers\"."
 (defvar ido-bufs-in-frame)
 
 (defun ido-get-buffers-in-frames (&optional current)
-  ;; Return the list of buffers that are visible in the current frame.
-  ;; If optional argument `current' is given, restrict searching to the
-  ;; current frame, rather than all frames, regardless of value of
-  ;; `ido-all-frames'.
+  "Return the list of buffers that are visible in the current frame.
+If optional argument CURRENT is given, restrict searching to the current
+frame, rather than all frames, regardless of value of `ido-all-frames'."
   (let ((ido-bufs-in-frame nil))
     (walk-windows 'ido-get-bufname nil
                   (if current
@@ -3688,7 +3691,7 @@ This is to make them appear as if they were \"virtual buffers\"."
     ido-bufs-in-frame))
 
 (defun ido-get-bufname (win)
-  ;; Used by `ido-get-buffers-in-frames' to walk through all windows
+  "Used by `ido-get-buffers-in-frames' to walk through all windows."
   (let ((buf (buffer-name (window-buffer win))))
         (unless (or (member buf ido-bufs-in-frame)
                     (member buf ido-ignore-item-temp-list))
@@ -3701,7 +3704,7 @@ This is to make them appear as if they were \"virtual buffers\"."
 ;;; FIND MATCHING ITEMS
 
 (defun ido-set-matches-1 (items &optional do-full)
-  ;; Return list of matches in items
+  "Return list of matches in ITEMS."
   (let* ((case-fold-search  ido-case-fold)
          (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
          (text (if slash (substring ido-text 0 -1) ido-text))
@@ -3789,13 +3792,13 @@ This is to make them appear as if they were \"virtual buffers\"."
 
 
 (defun ido-set-matches ()
-  ;; Set `ido-matches' to the list of items matching prompt
+  "Set `ido-matches' to the list of items matching prompt."
   (when ido-rescan
     (setq ido-matches (ido-set-matches-1 (reverse ido-cur-list) (not ido-rotate))
           ido-rotate nil)))
 
 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
-  ;; Return t if the buffer or file NAME should be ignored.
+  "Return t if the buffer or file NAME should be ignored."
   (or (member name ido-ignore-item-temp-list)
       (and
        ido-process-ignore-lists re-list
@@ -3835,7 +3838,7 @@ This is to make them appear as if they were \"virtual buffers\"."
 (defvar ido-change-word-sub)
 
 (defun ido-find-common-substring (items subs)
-  ;; Return common string following SUBS in each element of ITEMS.
+  "Return common string following SUBS in each element of ITEMS."
   (let (res
         alist
         ido-change-word-sub)
@@ -3855,8 +3858,8 @@ This is to make them appear as if they were \"virtual buffers\"."
         comp))))
 
 (defun ido-word-matching-substring (word)
-  ;; Return part of WORD before 1st match to `ido-change-word-sub'.
-  ;; If `ido-change-word-sub' cannot be found in WORD, return nil.
+  "Return part of WORD before first match to `ido-change-word-sub'.
+If `ido-change-word-sub' cannot be found in WORD, return nil."
   (let ((case-fold-search ido-case-fold))
     (let ((m (string-match ido-change-word-sub (ido-name word))))
       (if m
@@ -3865,7 +3868,7 @@ This is to make them appear as if they were \"virtual buffers\"."
         nil))))
 
 (defun ido-makealist (res)
-  ;; Return dotted pair (RES . 1).
+  "Return dotted pair (RES . 1)."
   (cons res 1))
 
 (defun ido-choose-completion-string (choice &rest ignored)
@@ -4048,8 +4051,8 @@ Record command in `command-history' if optional RECORD is non-nil."
 
 
 (defun ido-buffer-window-other-frame  (buffer)
-  ;; Return window pointer if BUFFER is visible in another frame.
-  ;; If BUFFER is visible in the current frame, return nil.
+  "Return window pointer if BUFFER is visible in another frame.
+If BUFFER is visible in the current frame, return nil."
   (let ((blist (ido-get-buffers-in-frames 'current)))
     ;;If the buffer is visible in current frame, return nil
     (if (member buffer blist)
@@ -4533,9 +4536,8 @@ For details of keybindings, see `ido-find-file'."
         ))))
 
 (defun ido-completions (name)
-  ;; Return the string that is displayed after the user's text.
-  ;; Modified from `icomplete-completions'.
-
+  "Return the string that is displayed after the user's text.
+Modified from `icomplete-completions'."
   (let* ((comps ido-matches)
          (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
                    ido-merged-indicator))
diff --git a/lisp/ielm.el b/lisp/ielm.el
index 610cc3ea364..4280a49af6e 100644
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -167,7 +167,7 @@ This variable is buffer-local.")
 
 (defvar ielm-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\t" 'completion-at-point)
     (define-key map "\C-m" 'ielm-return)
     (define-key map "\C-j" 'ielm-send-input)
     (define-key map "\e\C-x" 'eval-defun)         ; for consistency with
@@ -209,12 +209,13 @@ This variable is buffer-local.")
 
 (defun ielm-complete-symbol nil
   "Complete the Lisp symbol before point."
-  ;; A wrapper for lisp-complete symbol that returns non-nil if
+  ;; A wrapper for completion-at-point that returns non-nil if
   ;; completion has occurred
   (let* ((btick (buffer-modified-tick))
          (cbuffer (get-buffer "*Completions*"))
-         (ctick (and cbuffer (buffer-modified-tick cbuffer))))
-    (lisp-complete-symbol)
+         (ctick (and cbuffer (buffer-modified-tick cbuffer)))
+         (completion-at-point-functions '(lisp-completion-at-point)))
+    (completion-at-point)
      ;; completion has occurred if:
     (or
      ;; the buffer has been modified
@@ -461,7 +462,7 @@ Uses the interface provided by `comint-mode' (which see).
   Inputs longer than one line are moved to the line following the
   prompt (but see variable `ielm-dynamic-multiline-inputs').
 
-* \\[comint-dynamic-complete] completes Lisp symbols (or filenames, within strings),
+* \\[completion-at-point] completes Lisp symbols (or filenames, within strings),
   or indents the line if there is nothing to complete.
 
 The current working buffer may be changed (with a call to `set-buffer',
@@ -498,7 +499,7 @@ Customized bindings may be defined in `ielm-map', which currently contains:
   (set (make-local-variable 'paragraph-start) comint-prompt-regexp)
   (setq comint-input-sender 'ielm-input-sender)
   (setq comint-process-echoes nil)
-  (set (make-local-variable 'comint-dynamic-complete-functions)
+  (set (make-local-variable 'completion-at-point-functions)
        '(ielm-tab comint-replace-by-expanded-history
          ielm-complete-filename ielm-complete-symbol))
   (set (make-local-variable 'ielm-prompt-internal) ielm-prompt)
@@ -513,8 +514,6 @@ Customized bindings may be defined in `ielm-map', which currently contains:
   (set (make-local-variable 'indent-line-function) 'ielm-indent-line)
   (set (make-local-variable 'ielm-working-buffer) (current-buffer))
   (set (make-local-variable 'fill-paragraph-function) 'lisp-fill-paragraph)
-  (add-hook 'completion-at-point-functions
-            'lisp-completion-at-point nil 'local)
 
   ;; Value holders
   (set (make-local-variable '*) nil)
diff --git a/lisp/image.el b/lisp/image.el
index ec7b41bf126..804dc3af5ea 100644
--- a/lisp/image.el
+++ b/lisp/image.el
@@ -624,7 +624,12 @@ in which case you might want to use `image-default-frame-delay'."
           (setq delay image-default-frame-delay))
       (cons images delay))))
 
-(define-obsolete-function-alias 'image-animated-p 'image-multi-frame-p "24.4")
+(defun image-animated-p (image)
+  "Like `image-multi-frame-p', but returns nil if no delay is specified."
+  (let ((multi (image-multi-frame-p image)))
+    (and (cdr multi) multi)))
+
+(make-obsolete 'image-animated-p 'image-multi-frame-p "24.4")
 
 ;; "Destructively"?
 (defun image-animate (image &optional index limit)
diff --git a/lisp/international/mule-conf.el b/lisp/international/mule-conf.el
index a31a90d9cfb..48487b850df 100644
--- a/lisp/international/mule-conf.el
+++ b/lisp/international/mule-conf.el
@@ -1508,6 +1508,7 @@ for decoding and encoding files, process I/O, etc."
 (setq file-coding-system-alist
       (mapcar (lambda (arg) (cons (purecopy (car arg)) (cdr arg)))
       '(("\\.elc\\'" . utf-8-emacs)
+        ("\\.el\\'" . utf-8)
         ("\\.utf\\(-8\\)?\\'" . utf-8)
         ("\\.xml\\'" . xml-find-file-coding-system)
         ;; We use raw-text for reading loaddefs.el so that if it
diff --git a/lisp/isearch.el b/lisp/isearch.el
index 5bf2818fadc..d9f8b0891e4 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -198,7 +198,7 @@ skips this match and continues searching for the next match.
 When the list of predicates is empty, `run-hook-with-args-until-failure'
 returns non-nil that means that the found match is accepted.
 The property `isearch-message-prefix' put on the predicate's symbol
-specifies the prefix string displyed in the search message.")
+specifies the prefix string displayed in the search message.")
 (define-obsolete-variable-alias 'isearch-filter-predicate
                                 'isearch-filter-predicates
                                 "24.4")
@@ -514,6 +514,7 @@ This is like `describe-bindings', but displays only Isearch keys."
     (define-key map "\M-e" 'isearch-edit-string)
 
     (define-key map "\M-sc" 'isearch-toggle-case-fold)
+    (define-key map "\M-si" 'isearch-toggle-invisible)
     (define-key map "\M-sr" 'isearch-toggle-regexp)
     (define-key map "\M-sw" 'isearch-toggle-word)
     (define-key map "\M-s_" 'isearch-toggle-symbol)
@@ -602,6 +603,11 @@ Each set is a vector of the form:
 ;;   case in the search string is ignored.
 (defvar isearch-case-fold-search nil)
 
+;; search-invisible while searching.
+;;   either nil, t, or 'open.  'open means the same as t except that
+;;   opens hidden overlays.
+(defvar isearch-invisible search-invisible)
+
 (defvar isearch-last-case-fold-search nil)
 
 ;; Used to save default value while isearch is active
@@ -661,6 +667,7 @@ Each set is a vector of the form:
 (define-key esc-map "\C-r" 'isearch-backward-regexp)
 (define-key search-map "w" 'isearch-forward-word)
 (define-key search-map "_" 'isearch-forward-symbol)
+(define-key search-map "." 'isearch-forward-symbol-at-point)
 
 ;; Entry points to isearch-mode.
 
@@ -700,6 +707,7 @@ If you try to exit with the search string still empty, it invokes
  nonincremental search.
 
 Type \\[isearch-toggle-case-fold] to toggle search case-sensitivity.
+Type \\[isearch-toggle-invisible] to toggle search in invisible text.
 Type \\[isearch-toggle-regexp] to toggle regular-expression mode.
 Type \\[isearch-toggle-word] to toggle word mode.
 Type \\[isearch-toggle-symbol] to toggle symbol mode.
@@ -799,6 +807,25 @@ as a regexp.  See the command `isearch-forward' for more information."
   (interactive "P\np")
   (isearch-mode nil (null not-regexp) nil (not no-recursive-edit)))
 
+(defun isearch-forward-symbol-at-point ()
+  "Do incremental search forward for a symbol found near point.
+Like ordinary incremental search except that the symbol found at point
+is added to the search string initially as a regexp surrounded
+by symbol boundary constructs \\_< and \\_>.
+See the command `isearch-forward-symbol' for more information."
+  (interactive)
+  (isearch-forward-symbol nil 1)
+  (let ((bounds (find-tag-default-bounds)))
+    (cond
+     (bounds
+      (when (< (car bounds) (point))
+        (goto-char (car bounds)))
+      (isearch-yank-string
+       (buffer-substring-no-properties (car bounds) (cdr bounds))))
+     (t
+      (setq isearch-error "No symbol at point")
+      (isearch-update)))))
+
 
 ;; isearch-mode only sets up incremental search for the minor mode.
 ;; All the work is done by the isearch-mode commands.
@@ -836,6 +863,7 @@ convert the search string to a regexp used by regexp search functions."
         isearch-op-fun op-fun
         isearch-last-case-fold-search isearch-case-fold-search
         isearch-case-fold-search case-fold-search
+        isearch-invisible search-invisible
         isearch-string ""
         isearch-message ""
         isearch-cmds nil
@@ -1474,7 +1502,8 @@ value of the variable `isearch-regexp-lax-whitespace'."
   (isearch-update))
 
 (defun isearch-toggle-case-fold ()
-  "Toggle case folding in searching on or off."
+  "Toggle case folding in searching on or off.
+Toggles the value of the variable `isearch-case-fold-search'."
   (interactive)
   (setq isearch-case-fold-search
         (if isearch-case-fold-search nil 'yes))
@@ -1487,6 +1516,23 @@ value of the variable `isearch-regexp-lax-whitespace'."
   (sit-for 1)
   (isearch-update))
 
+(defun isearch-toggle-invisible ()
+  "Toggle searching in invisible text on or off.
+Toggles the variable `isearch-invisible' between values
+nil and a non-nil value of the option `search-invisible'
+\(or `open' if `search-invisible' is nil)."
+  (interactive)
+  (setq isearch-invisible
+        (if isearch-invisible nil (or search-invisible 'open)))
+  (let ((message-log-max nil))
+    (message "%s%s [match %svisible text]"
+             (isearch-message-prefix nil isearch-nonincremental)
+             isearch-message
+             (if isearch-invisible "in" "")))
+  (setq isearch-success t isearch-adjusted t)
+  (sit-for 1)
+  (isearch-update))
+
 
 ;; Word search
 
@@ -1622,6 +1668,7 @@ way to run word replacements from Isearch is `M-s w ... M-%'."
         ;; set `search-upper-case' to nil to not call
         ;; `isearch-no-upper-case-p' in `perform-replace'
         (search-upper-case nil)
+        (search-invisible isearch-invisible)
         (replace-lax-whitespace
          isearch-lax-whitespace)
         (replace-regexp-lax-whitespace
@@ -1725,7 +1772,10 @@ and reads its face argument using `hi-lock-read-face-name'."
     (isearch-done nil t)
     (isearch-clean-overlays))
   (require 'hi-lock nil t)
-  (let ((string (cond (isearch-regexp isearch-string)
+  (let ((regexp (cond ((functionp isearch-word)
+                       (funcall isearch-word isearch-string))
+                      (isearch-word (word-search-regexp isearch-string))
+                      (isearch-regexp isearch-string)
                       ((if (and (eq isearch-case-fold-search t)
                                 search-upper-case)
                            (isearch-no-upper-case-p
@@ -1741,7 +1791,7 @@ and reads its face argument using `hi-lock-read-face-name'."
                               (regexp-quote s))))
                         isearch-string ""))
                       (t (regexp-quote isearch-string)))))
-    (hi-lock-face-buffer string (hi-lock-read-face-name)))
+    (hi-lock-face-buffer regexp (hi-lock-read-face-name)))
   (and isearch-recursive-edit (exit-recursive-edit)))
 
 
@@ -2102,6 +2152,15 @@ If nil, scrolling commands will first cancel Isearch mode."
   :type 'boolean
   :group 'isearch)
 
+(defcustom isearch-allow-prefix t
+  "Whether prefix arguments are allowed during incremental search.
+If non-nil, entering a prefix argument will not terminate the
+search.  This option is ignored \(presumed t) when
+`isearch-allow-scroll' is set."
+  :version "24.4"
+  :type 'boolean
+  :group 'isearch)
+
 (defun isearch-string-out-of-window (isearch-point)
   "Test whether the search string is currently outside of the window.
 Return nil if it's completely visible, or if point is visible,
@@ -2254,12 +2313,19 @@ Isearch mode."
            (setq prefix-arg arg)
            (apply 'isearch-unread keylist)
            (isearch-edit-string))
-          ;; Handle a scrolling function.
-          ((and isearch-allow-scroll
-                (progn (setq key (isearch-reread-key-sequence-naturally keylist))
-                       (setq keylist (listify-key-sequence key))
-                       (setq main-event (aref key 0))
-                       (setq scroll-command (isearch-lookup-scroll-key key))))
+          ;; Handle a scrolling function or prefix argument.
+          ((progn
+             (setq key (isearch-reread-key-sequence-naturally keylist)
+                   keylist (listify-key-sequence key)
+                   main-event (aref key 0))
+             (or (and isearch-allow-scroll
+                      (setq scroll-command (isearch-lookup-scroll-key key)))
+                 (and isearch-allow-prefix
+                      (let (overriding-terminal-local-map)
+                        (setq scroll-command (key-binding key))
+                        (memq scroll-command
+                              '(universal-argument
+                                negative-argument digit-argument))))))
            ;; From this point onwards, KEY, KEYLIST and MAIN-EVENT hold a
            ;; complete key sequence, possibly as modified by function-key-map,
            ;; not merely the one or two event fragment which invoked
@@ -2638,9 +2704,10 @@ update the match data, and return point."
       (setq isearch-case-fold-search
             (isearch-no-upper-case-p isearch-string isearch-regexp)))
   (condition-case lossage
-      (let ((inhibit-point-motion-hooks search-invisible)
+      (let ((inhibit-point-motion-hooks isearch-invisible)
             (inhibit-quit nil)
             (case-fold-search isearch-case-fold-search)
+            (search-invisible isearch-invisible)
             (retry t))
         (setq isearch-error nil)
         (while retry
@@ -2836,7 +2903,7 @@ determined by `isearch-range-invisible' unless invisible text can be
 searched too when `search-invisible' is t."
   (or (eq search-invisible t)
       (not (isearch-range-invisible beg end))))
-(make-obsolete 'isearch-filter-visible 'search-invisible "24.4")
+(make-obsolete 'isearch-filter-visible 'isearch-invisible "24.4")
 
 
 ;; General utilities
diff --git a/lisp/ldefs-boot.el b/lisp/ldefs-boot.el
index d2b97986581..6cd20f9c8ca 100644
--- a/lisp/ldefs-boot.el
+++ b/lisp/ldefs-boot.el
@@ -68,7 +68,7 @@ should return a grid vector array that is the new solution.
 ;;;***
 
 ;;;### (autoloads (ada-mode ada-add-extensions) "ada-mode" "progmodes/ada-mode.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 62962 290468 0))
 ;;; Generated autoloads from progmodes/ada-mode.el
 
 (autoload 'ada-add-extensions "ada-mode" "\
@@ -474,7 +474,7 @@ A replacement function for `newline-and-indent', aligning as it goes.
 
 ;;;### (autoloads (outlineify-sticky allout-mode allout-mode-p allout-auto-activation
 ;;;;;;  allout-setup allout-auto-activation-helper) "allout" "allout.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20892 39729 858825 0))
 ;;; Generated autoloads from allout.el
 
 (autoload 'allout-auto-activation-helper "allout" "\
@@ -1245,8 +1245,8 @@ Entering array mode calls the function `array-mode-hook'.
 
 ;;;***
 
-;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (20777
-;;;;;;  63161 848428 0))
+;;;### (autoloads (artist-mode) "artist" "textmodes/artist.el" (20891
+;;;;;;  18859 893295 0))
 ;;; Generated autoloads from textmodes/artist.el
 
 (autoload 'artist-mode "artist" "\
@@ -1554,7 +1554,7 @@ This is similar to `autoarg-mode' but rebinds the keypad keys
 ;;;***
 
 ;;;### (autoloads (autoconf-mode) "autoconf" "progmodes/autoconf.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 62962 290468 0))
 ;;; Generated autoloads from progmodes/autoconf.el
 
 (autoload 'autoconf-mode "autoconf" "\
@@ -1605,7 +1605,7 @@ insert a template for the file depending on the mode of the buffer.
 
 ;;;### (autoloads (batch-update-autoloads update-directory-autoloads
 ;;;;;;  update-file-autoloads) "autoload" "emacs-lisp/autoload.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20879 27694 495748 0))
 ;;; Generated autoloads from emacs-lisp/autoload.el
 
 (put 'generated-autoload-file 'safe-local-variable 'stringp)
@@ -1656,7 +1656,7 @@ should be non-nil).
 
 ;;;### (autoloads (global-auto-revert-mode turn-on-auto-revert-tail-mode
 ;;;;;;  auto-revert-tail-mode turn-on-auto-revert-mode auto-revert-mode)
-;;;;;;  "autorevert" "autorevert.el" (20831 63016 738579 0))
+;;;;;;  "autorevert" "autorevert.el" (20893 60586 188550 0))
 ;;; Generated autoloads from autorevert.el
 
 (autoload 'auto-revert-mode "autorevert" "\
@@ -2112,7 +2112,7 @@ a reflection.
 ;;;;;;  bookmark-save bookmark-write bookmark-delete bookmark-insert
 ;;;;;;  bookmark-rename bookmark-insert-location bookmark-relocate
 ;;;;;;  bookmark-jump-other-window bookmark-jump bookmark-set) "bookmark"
-;;;;;;  "bookmark.el" (20849 6570 598687 0))
+;;;;;;  "bookmark.el" (20874 65006 176325 548000))
 ;;; Generated autoloads from bookmark.el
  (define-key ctl-x-r-map "b" 'bookmark-jump)
  (define-key ctl-x-r-map "m" 'bookmark-set)
@@ -2313,7 +2313,7 @@ Incremental search of bookmarks, hiding the non-matches as we go.
 ;;;;;;  browse-url-xdg-open browse-url-at-mouse browse-url-at-point
 ;;;;;;  browse-url browse-url-of-region browse-url-of-dired-file
 ;;;;;;  browse-url-of-buffer browse-url-of-file browse-url-browser-function)
-;;;;;;  "browse-url" "net/browse-url.el" (20709 26818 907104 0))
+;;;;;;  "browse-url" "net/browse-url.el" (20874 62962 290468 0))
 ;;; Generated autoloads from net/browse-url.el
 
 (defvar browse-url-browser-function 'browse-url-default-browser "\
@@ -2716,7 +2716,7 @@ Like `bug-reference-mode', but only buttonize in comments and strings.
 ;;;;;;  batch-byte-compile-if-not-done display-call-tree byte-compile
 ;;;;;;  compile-defun byte-compile-file byte-recompile-directory
 ;;;;;;  byte-force-recompile byte-compile-enable-warning byte-compile-disable-warning)
-;;;;;;  "bytecomp" "emacs-lisp/bytecomp.el" (20851 48294 960738 0))
+;;;;;;  "bytecomp" "emacs-lisp/bytecomp.el" (20900 33838 319219 0))
 ;;; Generated autoloads from emacs-lisp/bytecomp.el
 (put 'byte-compile-dynamic 'safe-local-variable 'booleanp)
 (put 'byte-compile-disable-print-circle 'safe-local-variable 'booleanp)
@@ -2971,8 +2971,8 @@ See Info node `(calc)Defining Functions'.
 
 ;;;***
 
-;;;### (autoloads (calculator) "calculator" "calculator.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (calculator) "calculator" "calculator.el" (20891
+;;;;;;  18859 893295 0))
 ;;; Generated autoloads from calculator.el
 
 (autoload 'calculator "calculator" "\
@@ -3206,7 +3206,7 @@ the absolute file name of the file if STYLE-NAME is nil.
 
 ;;;### (autoloads (awk-mode pike-mode idl-mode java-mode objc-mode
 ;;;;;;  c++-mode c-mode c-initialize-cc-mode) "cc-mode" "progmodes/cc-mode.el"
-;;;;;;  (20845 9511 656701 0))
+;;;;;;  (20903 56820 471502 429000))
 ;;; Generated autoloads from progmodes/cc-mode.el
 
 (autoload 'c-initialize-cc-mode "cc-mode" "\
@@ -3434,8 +3434,8 @@ and exists only for compatibility reasons.
 
 ;;;***
 
-;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads nil "cc-vars" "progmodes/cc-vars.el" (20904 30886
+;;;;;;  391458 0))
 ;;; Generated autoloads from progmodes/cc-vars.el
 (put 'c-basic-offset 'safe-local-variable 'integerp)
 (put 'c-backslash-column 'safe-local-variable 'integerp)
@@ -3445,7 +3445,7 @@ and exists only for compatibility reasons.
 
 ;;;### (autoloads (ccl-execute-with-args check-ccl-program define-ccl-program
 ;;;;;;  declare-ccl-program ccl-dump ccl-compile) "ccl" "international/ccl.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 412929 442000))
 ;;; Generated autoloads from international/ccl.el
 
 (autoload 'ccl-compile "ccl" "\
@@ -3776,7 +3776,7 @@ Returns non-nil if any false statements are found.
 ;;;;;;  checkdoc-comments checkdoc-continue checkdoc-start checkdoc-current-buffer
 ;;;;;;  checkdoc-eval-current-buffer checkdoc-message-interactive
 ;;;;;;  checkdoc-interactive checkdoc checkdoc-list-of-strings-p)
-;;;;;;  "checkdoc" "emacs-lisp/checkdoc.el" (20709 26818 907104 0))
+;;;;;;  "checkdoc" "emacs-lisp/checkdoc.el" (20893 60586 188550 0))
 ;;; Generated autoloads from emacs-lisp/checkdoc.el
 (put 'checkdoc-force-docstrings-flag 'safe-local-variable 'booleanp)
 (put 'checkdoc-force-history-flag 'safe-local-variable 'booleanp)
@@ -4050,7 +4050,7 @@ and runs the normal hook `command-history-hook'.
 ;;;***
 
 ;;;### (autoloads (common-lisp-indent-function) "cl-indent" "emacs-lisp/cl-indent.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20879 27694 495748 0))
 ;;; Generated autoloads from emacs-lisp/cl-indent.el
 
 (autoload 'common-lisp-indent-function "cl-indent" "\
@@ -4221,7 +4221,7 @@ If FRAME cannot display COLOR, return nil.
 ;;;### (autoloads (comint-redirect-results-list-from-process comint-redirect-results-list
 ;;;;;;  comint-redirect-send-command-to-process comint-redirect-send-command
 ;;;;;;  comint-run make-comint make-comint-in-buffer) "comint" "comint.el"
-;;;;;;  (20864 60326 774861 0))
+;;;;;;  (20896 36774 886399 0))
 ;;; Generated autoloads from comint.el
 
 (defvar comint-output-filter-functions '(ansi-color-process-output comint-postoutput-scroll-to-bottom comint-watch-for-password-prompt) "\
@@ -4321,7 +4321,7 @@ REGEXP-GROUP is the regular expression group in REGEXP to use.
 ;;;***
 
 ;;;### (autoloads (compare-windows) "compare-w" "vc/compare-w.el"
-;;;;;;  (20721 17977 14204 0))
+;;;;;;  (20871 33574 214287 0))
 ;;; Generated autoloads from vc/compare-w.el
 
 (autoload 'compare-windows "compare-w" "\
@@ -4539,7 +4539,7 @@ This is the value of `next-error-function' in Compilation buffers.
 ;;;***
 
 ;;;### (autoloads (dynamic-completion-mode) "completion" "completion.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 412929 442000))
 ;;; Generated autoloads from completion.el
 
 (defvar dynamic-completion-mode nil "\
@@ -4792,7 +4792,7 @@ If FIX is non-nil, run `copyright-fix-years' instead.
 ;;;***
 
 ;;;### (autoloads (cperl-perldoc-at-point cperl-perldoc cperl-mode)
-;;;;;;  "cperl-mode" "progmodes/cperl-mode.el" (20763 30266 231060
+;;;;;;  "cperl-mode" "progmodes/cperl-mode.el" (20901 54695 989166
 ;;;;;;  0))
 ;;; Generated autoloads from progmodes/cperl-mode.el
 (put 'cperl-indent-level 'safe-local-variable 'integerp)
@@ -4992,7 +4992,7 @@ Run a `perldoc' on the word around point.
 ;;;***
 
 ;;;### (autoloads (cpp-parse-edit cpp-highlight-buffer) "cpp" "progmodes/cpp.el"
-;;;;;;  (20762 9398 526093 0))
+;;;;;;  (20874 65006 672942 217000))
 ;;; Generated autoloads from progmodes/cpp.el
 
 (autoload 'cpp-highlight-buffer "cpp" "\
@@ -5145,7 +5145,7 @@ Enable CUA selection mode without the C-z/C-x/C-c/C-v bindings.
 ;;;;;;  customize-mode customize customize-push-and-save customize-save-variable
 ;;;;;;  customize-set-variable customize-set-value custom-menu-sort-alphabetically
 ;;;;;;  custom-buffer-sort-alphabetically custom-browse-sort-alphabetically)
-;;;;;;  "cus-edit" "cus-edit.el" (20841 12463 538770 0))
+;;;;;;  "cus-edit" "cus-edit.el" (20874 9766 437572 0))
 ;;; Generated autoloads from cus-edit.el
 
 (defvar custom-browse-sort-alphabetically nil "\
@@ -5634,8 +5634,8 @@ Create a new data-debug buffer with NAME.
 
 ;;;***
 
-;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (dbus-handle-event) "dbus" "net/dbus.el" (20900
+;;;;;;  33838 319219 0))
 ;;; Generated autoloads from net/dbus.el
 
 (autoload 'dbus-handle-event "dbus" "\
@@ -5905,7 +5905,7 @@ any selection.
 ;;;***
 
 ;;;### (autoloads (derived-mode-init-mode-variables define-derived-mode)
-;;;;;;  "derived" "emacs-lisp/derived.el" (20709 26818 907104 0))
+;;;;;;  "derived" "emacs-lisp/derived.el" (20900 33838 319219 0))
 ;;; Generated autoloads from emacs-lisp/derived.el
 
 (autoload 'define-derived-mode "derived" "\
@@ -5972,7 +5972,7 @@ the first time the mode is used.
 ;;;***
 
 ;;;### (autoloads (describe-char describe-text-properties) "descr-text"
-;;;;;;  "descr-text.el" (20764 51137 83502 0))
+;;;;;;  "descr-text.el" (20875 30633 412173 0))
 ;;; Generated autoloads from descr-text.el
 
 (autoload 'describe-text-properties "descr-text" "\
@@ -6009,7 +6009,7 @@ relevant to POS.
 ;;;### (autoloads (desktop-revert desktop-save-in-desktop-dir desktop-change-dir
 ;;;;;;  desktop-load-default desktop-read desktop-remove desktop-save
 ;;;;;;  desktop-clear desktop-locals-to-save desktop-save-mode) "desktop"
-;;;;;;  "desktop.el" (20860 63270 684173 0))
+;;;;;;  "desktop.el" (20866 42607 417304 513000))
 ;;; Generated autoloads from desktop.el
 
 (defvar desktop-save-mode nil "\
@@ -6232,7 +6232,7 @@ Deuglify broken Outlook (Express) articles and redisplay.
 ;;;***
 
 ;;;### (autoloads (diary-mode diary-mail-entries diary) "diary-lib"
-;;;;;;  "calendar/diary-lib.el" (20709 26818 907104 0))
+;;;;;;  "calendar/diary-lib.el" (20879 27694 495748 0))
 ;;; Generated autoloads from calendar/diary-lib.el
 
 (autoload 'diary "diary-lib" "\
@@ -6370,7 +6370,7 @@ Optional arguments are passed to `dig-invoke'.
 
 ;;;### (autoloads (dired-hide-details-mode dired-mode dired-noselect
 ;;;;;;  dired-other-frame dired-other-window dired dired-listing-switches)
-;;;;;;  "dired" "dired.el" (20784 36406 653593 0))
+;;;;;;  "dired" "dired.el" (20900 33838 319219 0))
 ;;; Generated autoloads from dired.el
 
 (defvar dired-listing-switches (purecopy "-al") "\
@@ -6730,8 +6730,8 @@ Locate SOA record and increment the serial field.
 ;;;***
 
 ;;;### (autoloads (doc-view-bookmark-jump doc-view-minor-mode doc-view-mode-maybe
-;;;;;;  doc-view-mode doc-view-mode-p) "doc-view" "doc-view.el" (20845
-;;;;;;  9511 656701 0))
+;;;;;;  doc-view-mode doc-view-mode-p) "doc-view" "doc-view.el" (20899
+;;;;;;  12965 791908 0))
 ;;; Generated autoloads from doc-view.el
 
 (autoload 'doc-view-mode-p "doc-view" "\
@@ -6805,8 +6805,8 @@ strings when pressed twice.  See `double-map' for details.
 
 ;;;***
 
-;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (dunnet) "dunnet" "play/dunnet.el" (20900 33838
+;;;;;;  319219 0))
 ;;; Generated autoloads from play/dunnet.el
 
 (autoload 'dunnet "dunnet" "\
@@ -6818,7 +6818,7 @@ Switch to *dungeon* buffer and start game.
 
 ;;;### (autoloads (easy-mmode-defsyntax easy-mmode-defmap easy-mmode-define-keymap
 ;;;;;;  define-globalized-minor-mode define-minor-mode) "easy-mmode"
-;;;;;;  "emacs-lisp/easy-mmode.el" (20780 39352 990623 0))
+;;;;;;  "emacs-lisp/easy-mmode.el" (20900 33838 319219 0))
 ;;; Generated autoloads from emacs-lisp/easy-mmode.el
 
 (defalias 'easy-mmode-define-minor-mode 'define-minor-mode)
@@ -7684,8 +7684,8 @@ Toggle edebugging of all forms.
 ;;;;;;  ediff-merge-directories-with-ancestor ediff-merge-directories
 ;;;;;;  ediff-directories3 ediff-directory-revisions ediff-directories
 ;;;;;;  ediff-buffers3 ediff-buffers ediff-backup ediff-current-file
-;;;;;;  ediff-files3 ediff-files) "ediff" "vc/ediff.el" (20709 26818
-;;;;;;  907104 0))
+;;;;;;  ediff-files3 ediff-files) "ediff" "vc/ediff.el" (20893 60586
+;;;;;;  188550 0))
 ;;; Generated autoloads from vc/ediff.el
 
 (autoload 'ediff-files "ediff" "\
@@ -7928,7 +7928,7 @@ With optional NODE, goes to that node.
 ;;;***
 
 ;;;### (autoloads (ediff-show-registry) "ediff-mult" "vc/ediff-mult.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20893 60586 188550 0))
 ;;; Generated autoloads from vc/ediff-mult.el
 
 (autoload 'ediff-show-registry "ediff-mult" "\
@@ -7941,7 +7941,7 @@ Display Ediff's registry.
 ;;;***
 
 ;;;### (autoloads (ediff-toggle-use-toolbar ediff-toggle-multiframe)
-;;;;;;  "ediff-util" "vc/ediff-util.el" (20777 63161 848428 0))
+;;;;;;  "ediff-util" "vc/ediff-util.el" (20893 60586 188550 0))
 ;;; Generated autoloads from vc/ediff-util.el
 
 (autoload 'ediff-toggle-multiframe "ediff-util" "\
@@ -8079,7 +8079,7 @@ Optional argument GROUP is the sub-group of slots to display.
 
 ;;;### (autoloads (eieio-describe-generic eieio-describe-constructor
 ;;;;;;  eieio-describe-class eieio-browse) "eieio-opt" "emacs-lisp/eieio-opt.el"
-;;;;;;  (20771 24374 643644 0))
+;;;;;;  (20892 39729 858825 0))
 ;;; Generated autoloads from emacs-lisp/eieio-opt.el
 
 (autoload 'eieio-browse "eieio-opt" "\
@@ -8474,8 +8474,8 @@ Commands:
 ;;;;;;  epa-sign-region epa-verify-cleartext-in-region epa-verify-region
 ;;;;;;  epa-decrypt-armor-in-region epa-decrypt-region epa-encrypt-file
 ;;;;;;  epa-sign-file epa-verify-file epa-decrypt-file epa-select-keys
-;;;;;;  epa-list-secret-keys epa-list-keys) "epa" "epa.el" (20762
-;;;;;;  9398 526093 0))
+;;;;;;  epa-list-secret-keys epa-list-keys) "epa" "epa.el" (20879
+;;;;;;  27694 495748 0))
 ;;; Generated autoloads from epa.el
 
 (autoload 'epa-list-keys "epa" "\
@@ -8499,9 +8499,9 @@ If SECRET is non-nil, list secret keys instead of public keys.
 \(fn CONTEXT PROMPT &optional NAMES SECRET)" nil nil)
 
 (autoload 'epa-decrypt-file "epa" "\
-Decrypt FILE.
+Decrypt DECRYPT-FILE into PLAIN-FILE.
 
-\(fn FILE)" t nil)
+\(fn DECRYPT-FILE PLAIN-FILE)" t nil)
 
 (autoload 'epa-verify-file "epa" "\
 Verify FILE.
@@ -8805,7 +8805,7 @@ Look at CONFIG and try to expand GROUP.
 ;;;***
 
 ;;;### (autoloads (erc-handle-irc-url erc-tls erc erc-select-read-args)
-;;;;;;  "erc" "erc/erc.el" (20709 26818 907104 0))
+;;;;;;  "erc" "erc/erc.el" (20891 18859 893295 0))
 ;;; Generated autoloads from erc/erc.el
 
 (autoload 'erc-select-read-args "erc" "\
@@ -8912,7 +8912,7 @@ that subcommand.
 ;;;***
 
 ;;;### (autoloads nil "erc-desktop-notifications" "erc/erc-desktop-notifications.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 65006 176325 548000))
 ;;; Generated autoloads from erc/erc-desktop-notifications.el
 (autoload 'erc-notifications-mode "erc-desktop-notifications" "" t)
 
@@ -9037,15 +9037,15 @@ system.
 
 ;;;***
 
-;;;### (autoloads nil "erc-list" "erc/erc-list.el" (20709 26818 907104
-;;;;;;  0))
+;;;### (autoloads nil "erc-list" "erc/erc-list.el" (20884 7264 412929
+;;;;;;  442000))
 ;;; Generated autoloads from erc/erc-list.el
  (autoload 'erc-list-mode "erc-list")
 
 ;;;***
 
 ;;;### (autoloads (erc-save-buffer-in-logs erc-logging-enabled) "erc-log"
-;;;;;;  "erc/erc-log.el" (20709 26818 907104 0))
+;;;;;;  "erc/erc-log.el" (20891 18859 893295 0))
 ;;; Generated autoloads from erc/erc-log.el
  (autoload 'erc-log-mode "erc-log" nil t)
 
@@ -9123,8 +9123,8 @@ Delete dangerous-host interactively to `erc-dangerous-hosts'.
 
 ;;;***
 
-;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (20709 26818 907104
-;;;;;;  0))
+;;;### (autoloads nil "erc-menu" "erc/erc-menu.el" (20884 7264 412929
+;;;;;;  442000))
 ;;; Generated autoloads from erc/erc-menu.el
  (autoload 'erc-menu-mode "erc-menu" nil t)
 
@@ -9161,7 +9161,7 @@ Interactively select a server to connect to using `erc-server-alist'.
 ;;;***
 
 ;;;### (autoloads (pcomplete/erc-mode/NOTIFY erc-cmd-NOTIFY) "erc-notify"
-;;;;;;  "erc/erc-notify.el" (20709 26818 907104 0))
+;;;;;;  "erc/erc-notify.el" (20891 18859 893295 0))
 ;;; Generated autoloads from erc/erc-notify.el
  (autoload 'erc-notify-mode "erc-notify" nil t)
 
@@ -9200,8 +9200,8 @@ with args, toggle notify status of people.
 
 ;;;***
 
-;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (20709 26818 907104
-;;;;;;  0))
+;;;### (autoloads nil "erc-ring" "erc/erc-ring.el" (20884 7264 412929
+;;;;;;  442000))
 ;;; Generated autoloads from erc/erc-ring.el
  (autoload 'erc-ring-mode "erc-ring" nil t)
 
@@ -9398,8 +9398,8 @@ Kill all test buffers that are still live.
 
 ;;;***
 
-;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (eshell-mode) "esh-mode" "eshell/esh-mode.el" (20893
+;;;;;;  60586 188550 0))
 ;;; Generated autoloads from eshell/esh-mode.el
 
 (autoload 'eshell-mode "esh-mode" "\
@@ -9412,7 +9412,7 @@ Emacs shell interactive mode.
 ;;;***
 
 ;;;### (autoloads (eshell-command-result eshell-command eshell) "eshell"
-;;;;;;  "eshell/eshell.el" (20709 26818 907104 0))
+;;;;;;  "eshell/eshell.el" (20893 60586 188550 0))
 ;;; Generated autoloads from eshell/eshell.el
 
 (autoload 'eshell "eshell" "\
@@ -10030,7 +10030,7 @@ Display a button for the JPEG DATA.
 ;;;***
 
 ;;;### (autoloads (eudc-try-bbdb-insert eudc-insert-record-at-point-into-bbdb)
-;;;;;;  "eudc-export" "net/eudc-export.el" (20791 9657 561026 0))
+;;;;;;  "eudc-export" "net/eudc-export.el" (20871 33574 214287 0))
 ;;; Generated autoloads from net/eudc-export.el
 
 (autoload 'eudc-insert-record-at-point-into-bbdb "eudc-export" "\
@@ -10179,8 +10179,8 @@ This is used only in conjunction with `expand-add-abbrevs'.
 
 ;;;***
 
-;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (f90-mode) "f90" "progmodes/f90.el" (20886 939
+;;;;;;  575794 0))
 ;;; Generated autoloads from progmodes/f90.el
 
 (autoload 'f90-mode "f90" "\
@@ -10232,11 +10232,11 @@ Variables controlling indentation style and extra features:
   Automatic insertion of & at beginning of continuation lines (default t).
 `f90-smart-end'
   From an END statement, check and fill the end using matching block start.
-  Allowed values are 'blink, 'no-blink, and nil, which determine
-  whether to blink the matching beginning (default 'blink).
+  Allowed values are `blink', `no-blink', and nil, which determine
+  whether to blink the matching beginning (default `blink').
 `f90-auto-keyword-case'
   Automatic change of case of keywords (default nil).
-  The possibilities are 'downcase-word, 'upcase-word, 'capitalize-word.
+  The possibilities are `downcase-word', `upcase-word', `capitalize-word'.
 `f90-leave-line-no'
   Do not left-justify line numbers (default nil).
 
@@ -10414,8 +10414,8 @@ Besides the choice of face, it is the same as `buffer-face-mode'.
 
 ;;;### (autoloads (feedmail-queue-reminder feedmail-run-the-queue
 ;;;;;;  feedmail-run-the-queue-global-prompt feedmail-run-the-queue-no-prompts
-;;;;;;  feedmail-send-it) "feedmail" "mail/feedmail.el" (20759 33211
-;;;;;;  414988 0))
+;;;;;;  feedmail-send-it) "feedmail" "mail/feedmail.el" (20891 18859
+;;;;;;  893295 0))
 ;;; Generated autoloads from mail/feedmail.el
 
 (autoload 'feedmail-send-it "feedmail" "\
@@ -10736,7 +10736,7 @@ use in place of \"-ls\" as the final argument.
 
 ;;;### (autoloads (ff-mouse-find-other-file-other-window ff-mouse-find-other-file
 ;;;;;;  ff-find-other-file ff-get-other-file ff-special-constructs)
-;;;;;;  "find-file" "find-file.el" (20709 26818 907104 0))
+;;;;;;  "find-file" "find-file.el" (20872 54440 171355 0))
 ;;; Generated autoloads from find-file.el
 
 (defvar ff-special-constructs `((,(purecopy "^#\\s *\\(include\\|import\\)\\s +[<\"]\\(.*\\)[>\"]") lambda nil (buffer-substring (match-beginning 2) (match-end 2)))) "\
@@ -11073,8 +11073,8 @@ to get the effect of a C-q.
 ;;;***
 
 ;;;### (autoloads (flymake-find-file-hook flymake-mode-off flymake-mode-on
-;;;;;;  flymake-mode) "flymake" "progmodes/flymake.el" (20717 20920
-;;;;;;  410005 0))
+;;;;;;  flymake-mode) "flymake" "progmodes/flymake.el" (20896 36774
+;;;;;;  886399 0))
 ;;; Generated autoloads from progmodes/flymake.el
 
 (autoload 'flymake-mode "flymake" "\
@@ -11429,7 +11429,7 @@ and choose the directory as the fortune-file.
 ;;;***
 
 ;;;### (autoloads (gdb gdb-enable-debug) "gdb-mi" "progmodes/gdb-mi.el"
-;;;;;;  (20851 48294 960738 0))
+;;;;;;  (20903 57728 956434 133000))
 ;;; Generated autoloads from progmodes/gdb-mi.el
 
 (defvar gdb-enable-debug nil "\
@@ -11658,8 +11658,8 @@ DEFAULT-MAP specifies the default key map for ICON-LIST.
 ;;;***
 
 ;;;### (autoloads (gnus gnus-other-frame gnus-slave gnus-no-server
-;;;;;;  gnus-slave-no-server) "gnus" "gnus/gnus.el" (20860 63270
-;;;;;;  684173 0))
+;;;;;;  gnus-slave-no-server) "gnus" "gnus/gnus.el" (20901 54695
+;;;;;;  989166 0))
 ;;; Generated autoloads from gnus/gnus.el
 (when (fboundp 'custom-autoload)
  (custom-autoload 'gnus-select-method "gnus"))
@@ -11804,7 +11804,7 @@ If CLEAN, obsolete (ignore).
 ;;;***
 
 ;;;### (autoloads (gnus-article-prepare-display) "gnus-art" "gnus/gnus-art.el"
-;;;;;;  (20763 30266 231060 0))
+;;;;;;  (20874 65006 176325 548000))
 ;;; Generated autoloads from gnus/gnus-art.el
 
 (autoload 'gnus-article-prepare-display "gnus-art" "\
@@ -12005,8 +12005,8 @@ FILE should be a PNG file that's 48x48 and smaller than or equal to
 ;;;***
 
 ;;;### (autoloads (gnus-treat-mail-gravatar gnus-treat-from-gravatar)
-;;;;;;  "gnus-gravatar" "gnus/gnus-gravatar.el" (20709 26818 907104
-;;;;;;  0))
+;;;;;;  "gnus-gravatar" "gnus/gnus-gravatar.el" (20874 65006 176325
+;;;;;;  548000))
 ;;; Generated autoloads from gnus/gnus-gravatar.el
 
 (autoload 'gnus-treat-from-gravatar "gnus-gravatar" "\
@@ -12024,7 +12024,7 @@ If gravatars are already displayed, remove them.
 ;;;***
 
 ;;;### (autoloads (gnus-fetch-group-other-frame gnus-fetch-group)
-;;;;;;  "gnus-group" "gnus/gnus-group.el" (20763 30266 231060 0))
+;;;;;;  "gnus-group" "gnus/gnus-group.el" (20901 54695 989166 0))
 ;;; Generated autoloads from gnus/gnus-group.el
 
 (autoload 'gnus-fetch-group "gnus-group" "\
@@ -12042,7 +12042,7 @@ Pop up a frame and enter GROUP.
 ;;;***
 
 ;;;### (autoloads (gnus-html-prefetch-images gnus-article-html) "gnus-html"
-;;;;;;  "gnus/gnus-html.el" (20709 26818 907104 0))
+;;;;;;  "gnus/gnus-html.el" (20874 65006 672942 217000))
 ;;; Generated autoloads from gnus/gnus-html.el
 
 (autoload 'gnus-article-html "gnus-html" "\
@@ -12226,7 +12226,7 @@ Like `message-reply'.
 ;;;***
 
 ;;;### (autoloads (gnus-notifications) "gnus-notifications" "gnus/gnus-notifications.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20886 939 575794 0))
 ;;; Generated autoloads from gnus/gnus-notifications.el
 
 (autoload 'gnus-notifications "gnus-notifications" "\
@@ -12244,7 +12244,7 @@ This is typically a function to add in
 
 ;;;### (autoloads (gnus-treat-newsgroups-picon gnus-treat-mail-picon
 ;;;;;;  gnus-treat-from-picon) "gnus-picon" "gnus/gnus-picon.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 65006 672942 217000))
 ;;; Generated autoloads from gnus/gnus-picon.el
 
 (autoload 'gnus-treat-from-picon "gnus-picon" "\
@@ -12385,7 +12385,7 @@ See the documentation for these variables and functions for details.
 ;;;***
 
 ;;;### (autoloads (gnus-update-format) "gnus-spec" "gnus/gnus-spec.el"
-;;;;;;  (20791 9657 561026 0))
+;;;;;;  (20893 60586 188550 0))
 ;;; Generated autoloads from gnus/gnus-spec.el
 
 (autoload 'gnus-update-format "gnus-spec" "\
@@ -12407,7 +12407,7 @@ Declare back end NAME with ABILITIES as a Gnus back end.
 ;;;***
 
 ;;;### (autoloads (gnus-summary-bookmark-jump) "gnus-sum" "gnus/gnus-sum.el"
-;;;;;;  (20856 32301 830403 0))
+;;;;;;  (20901 54695 989166 0))
 ;;; Generated autoloads from gnus/gnus-sum.el
 
 (autoload 'gnus-summary-bookmark-jump "gnus-sum" "\
@@ -12533,7 +12533,7 @@ Like `goto-address-mode', but only for comments and strings.
 ;;;***
 
 ;;;### (autoloads (gravatar-retrieve-synchronously gravatar-retrieve)
-;;;;;;  "gravatar" "gnus/gravatar.el" (20709 26818 907104 0))
+;;;;;;  "gravatar" "gnus/gravatar.el" (20901 54695 989166 0))
 ;;; Generated autoloads from gnus/gravatar.el
 
 (autoload 'gravatar-retrieve "gravatar" "\
@@ -12551,8 +12551,8 @@ Retrieve MAIL-ADDRESS gravatar and returns it.
 
 ;;;### (autoloads (zrgrep rgrep lgrep grep-find grep grep-mode grep-compute-defaults
 ;;;;;;  grep-process-setup grep-setup-hook grep-find-command grep-command
-;;;;;;  grep-window-height) "grep" "progmodes/grep.el" (20762 9398
-;;;;;;  526093 0))
+;;;;;;  grep-window-height) "grep" "progmodes/grep.el" (20896 36774
+;;;;;;  886399 0))
 ;;; Generated autoloads from progmodes/grep.el
 
 (defvar grep-window-height nil "\
@@ -12730,8 +12730,8 @@ the form \"WINDOW-ID PIXMAP-ID\".  Value is non-nil if successful.
 ;;;***
 
 ;;;### (autoloads (gud-tooltip-mode gdb-script-mode jdb pdb perldb
-;;;;;;  xdb dbx sdb gud-gdb) "gud" "progmodes/gud.el" (20851 48294
-;;;;;;  960738 0))
+;;;;;;  xdb dbx sdb gud-gdb) "gud" "progmodes/gud.el" (20895 15912
+;;;;;;  444844 0))
 ;;; Generated autoloads from progmodes/gud.el
 
 (autoload 'gud-gdb "gud" "\
@@ -14402,7 +14402,7 @@ See also the variable `idlwave-shell-prompt-pattern'.
 ;;;***
 
 ;;;### (autoloads (idlwave-mode) "idlwave" "progmodes/idlwave.el"
-;;;;;;  (20799 169 640767 0))
+;;;;;;  (20901 54695 989166 0))
 ;;; Generated autoloads from progmodes/idlwave.el
 
 (autoload 'idlwave-mode "idlwave" "\
@@ -14536,8 +14536,8 @@ The main features of this mode are
 ;;;;;;  ido-find-alternate-file ido-find-file-other-window ido-find-file
 ;;;;;;  ido-find-file-in-dir ido-switch-buffer-other-frame ido-insert-buffer
 ;;;;;;  ido-kill-buffer ido-display-buffer ido-switch-buffer-other-window
-;;;;;;  ido-switch-buffer ido-mode ido-mode) "ido" "ido.el" (20831
-;;;;;;  63016 738579 0))
+;;;;;;  ido-switch-buffer ido-mode ido-mode) "ido" "ido.el" (20886
+;;;;;;  939 575794 0))
 ;;; Generated autoloads from ido.el
 
 (defvar ido-mode nil "\
@@ -14796,7 +14796,7 @@ DEF, if non-nil, is the default value.
 
 ;;;***
 
-;;;### (autoloads (ielm) "ielm" "ielm.el" (20709 26818 907104 0))
+;;;### (autoloads (ielm) "ielm" "ielm.el" (20903 10024 645978 0))
 ;;; Generated autoloads from ielm.el
 
 (autoload 'ielm "ielm" "\
@@ -14829,7 +14829,7 @@ the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
 ;;;;;;  create-image image-type-auto-detected-p image-type-available-p
 ;;;;;;  image-type image-type-from-file-name image-type-from-file-header
 ;;;;;;  image-type-from-buffer image-type-from-data) "image" "image.el"
-;;;;;;  (20772 45239 494620 0))
+;;;;;;  (20903 10024 645978 0))
 ;;; Generated autoloads from image.el
 
 (autoload 'image-type-from-data "image" "\
@@ -15230,8 +15230,8 @@ An image file is one whose name has an extension in
 ;;;***
 
 ;;;### (autoloads (image-bookmark-jump image-mode-as-text image-minor-mode
-;;;;;;  image-mode) "image-mode" "image-mode.el" (20774 51931 214714
-;;;;;;  829000))
+;;;;;;  image-mode) "image-mode" "image-mode.el" (20899 12965 791908
+;;;;;;  0))
 ;;; Generated autoloads from image-mode.el
 
 (autoload 'image-mode "image-mode" "\
@@ -15470,7 +15470,7 @@ of `inferior-lisp-program').  Runs the hooks from
 ;;;;;;  Info-goto-emacs-key-command-node Info-goto-emacs-command-node
 ;;;;;;  Info-mode info-finder info-apropos Info-index Info-directory
 ;;;;;;  Info-on-current-buffer info-standalone info-emacs-bug info-emacs-manual
-;;;;;;  info info-other-window) "info" "info.el" (20841 12463 538770
+;;;;;;  info info-other-window) "info" "info.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from info.el
 
@@ -16379,7 +16379,7 @@ by `jka-compr-installed'.
 
 ;;;***
 
-;;;### (autoloads (js-mode) "js" "progmodes/js.el" (20793 51383 764318
+;;;### (autoloads (js-mode) "js" "progmodes/js.el" (20895 15912 444844
 ;;;;;;  0))
 ;;; Generated autoloads from progmodes/js.el
 
@@ -16770,7 +16770,7 @@ use either \\[customize] or the function `latin1-display'.")
 ;;;***
 
 ;;;### (autoloads (ld-script-mode) "ld-script" "progmodes/ld-script.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 62962 290468 0))
 ;;; Generated autoloads from progmodes/ld-script.el
 
 (autoload 'ld-script-mode "ld-script" "\
@@ -16960,8 +16960,8 @@ Major mode for browsing CVS log output.
 ;;;***
 
 ;;;### (autoloads (print-region lpr-region print-buffer lpr-buffer
-;;;;;;  lpr-command lpr-switches printer-name) "lpr" "lpr.el" (20709
-;;;;;;  26818 907104 0))
+;;;;;;  lpr-command lpr-switches printer-name) "lpr" "lpr.el" (20878
+;;;;;;  6823 881439 0))
 ;;; Generated autoloads from lpr.el
 
 (defvar lpr-windows-system (memq system-type '(ms-dos windows-nt)) "\
@@ -17057,7 +17057,7 @@ for further customization of the printer command.
 ;;;***
 
 ;;;### (autoloads (ls-lisp-support-shell-wildcards) "ls-lisp" "ls-lisp.el"
-;;;;;;  (20860 63270 684173 0))
+;;;;;;  (20870 12718 549931 0))
 ;;; Generated autoloads from ls-lisp.el
 
 (defvar ls-lisp-support-shell-wildcards t "\
@@ -17083,8 +17083,8 @@ This function is suitable for execution in an init file.
 
 ;;;***
 
-;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (m4-mode) "m4-mode" "progmodes/m4-mode.el" (20874
+;;;;;;  62962 290468 0))
 ;;; Generated autoloads from progmodes/m4-mode.el
 
 (autoload 'm4-mode "m4-mode" "\
@@ -17249,7 +17249,7 @@ This function normally would be called when the message is sent.
 ;;;### (autoloads (mail-fetch-field mail-unquote-printable-region
 ;;;;;;  mail-unquote-printable mail-quote-printable-region mail-quote-printable
 ;;;;;;  mail-file-babyl-p mail-dont-reply-to-names mail-use-rfc822)
-;;;;;;  "mail-utils" "mail/mail-utils.el" (20709 26818 907104 0))
+;;;;;;  "mail-utils" "mail/mail-utils.el" (20891 18859 893295 0))
 ;;; Generated autoloads from mail/mail-utils.el
 
 (defvar mail-use-rfc822 nil "\
@@ -17444,8 +17444,8 @@ The mail client is taken to be the handler of mailto URLs.
 
 ;;;### (autoloads (makefile-imake-mode makefile-bsdmake-mode makefile-makepp-mode
 ;;;;;;  makefile-gmake-mode makefile-automake-mode makefile-mode)
-;;;;;;  "make-mode" "progmodes/make-mode.el" (20748 62911 684442
-;;;;;;  0))
+;;;;;;  "make-mode" "progmodes/make-mode.el" (20874 65006 672942
+;;;;;;  217000))
 ;;; Generated autoloads from progmodes/make-mode.el
 
 (autoload 'makefile-mode "make-mode" "\
@@ -17575,7 +17575,7 @@ Previous contents of that buffer are killed first.
 ;;;***
 
 ;;;### (autoloads (Man-bookmark-jump man-follow man) "man" "man.el"
-;;;;;;  (20762 9398 526093 0))
+;;;;;;  (20888 42662 256824 0))
 ;;; Generated autoloads from man.el
 
 (defalias 'manual-entry 'man)
@@ -17629,8 +17629,8 @@ Default bookmark handler for Man buffers.
 
 ;;;***
 
-;;;### (autoloads (master-mode) "master" "master.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (master-mode) "master" "master.el" (20884 7264
+;;;;;;  912957 506000))
 ;;; Generated autoloads from master.el
 
 (autoload 'master-mode "master" "\
@@ -17686,7 +17686,7 @@ recursion depth in the minibuffer prompt.  This is only useful if
 ;;;;;;  message-forward-make-body message-forward message-recover
 ;;;;;;  message-supersede message-cancel-news message-followup message-wide-reply
 ;;;;;;  message-reply message-news message-mail message-mode) "message"
-;;;;;;  "gnus/message.el" (20858 21542 723007 0))
+;;;;;;  "gnus/message.el" (20889 63525 775294 0))
 ;;; Generated autoloads from gnus/message.el
 
 (define-mail-user-agent 'message-user-agent 'message-mail 'message-send-and-exit 'message-kill-buffer 'message-send-hook)
@@ -17852,7 +17852,7 @@ which specify the range to operate on.
 ;;;***
 
 ;;;### (autoloads (metapost-mode metafont-mode) "meta-mode" "progmodes/meta-mode.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20874 62962 290468 0))
 ;;; Generated autoloads from progmodes/meta-mode.el
 
 (autoload 'metafont-mode "meta-mode" "\
@@ -17914,7 +17914,7 @@ redisplayed as output is inserted.
 
 ;;;### (autoloads (mh-fully-kill-draft mh-send-letter mh-user-agent-compose
 ;;;;;;  mh-smail-batch mh-smail-other-window mh-smail) "mh-comp"
-;;;;;;  "mh-e/mh-comp.el" (20787 12616 976036 0))
+;;;;;;  "mh-e/mh-comp.el" (20890 54503 125088 852000))
 ;;; Generated autoloads from mh-e/mh-comp.el
 
 (autoload 'mh-smail "mh-comp" "\
@@ -18004,8 +18004,8 @@ delete the draft message.
 
 ;;;***
 
-;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (20787 12616
-;;;;;;  976036 0))
+;;;### (autoloads (mh-version) "mh-e" "mh-e/mh-e.el" (20874 65006
+;;;;;;  672942 217000))
 ;;; Generated autoloads from mh-e/mh-e.el
 
 (put 'mh-progs 'risky-local-variable t)
@@ -18391,7 +18391,7 @@ body) or \"attachment\" (separate from the body).
 ;;;***
 
 ;;;### (autoloads (mml1991-sign mml1991-encrypt) "mml1991" "gnus/mml1991.el"
-;;;;;;  (20791 9657 561026 0))
+;;;;;;  (20875 30633 412173 0))
 ;;; Generated autoloads from gnus/mml1991.el
 
 (autoload 'mml1991-encrypt "mml1991" "\
@@ -18408,7 +18408,7 @@ body) or \"attachment\" (separate from the body).
 
 ;;;### (autoloads (mml2015-self-encrypt mml2015-sign mml2015-encrypt
 ;;;;;;  mml2015-verify-test mml2015-verify mml2015-decrypt-test mml2015-decrypt)
-;;;;;;  "mml2015" "gnus/mml2015.el" (20780 39352 990623 0))
+;;;;;;  "mml2015" "gnus/mml2015.el" (20893 60586 188550 0))
 ;;; Generated autoloads from gnus/mml2015.el
 
 (autoload 'mml2015-decrypt "mml2015" "\
@@ -18615,7 +18615,7 @@ different buffer menu using the function `msb'.
 ;;;;;;  describe-current-coding-system describe-current-coding-system-briefly
 ;;;;;;  describe-coding-system describe-character-set list-charset-chars
 ;;;;;;  read-charset list-character-sets) "mule-diag" "international/mule-diag.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20891 18859 893295 0))
 ;;; Generated autoloads from international/mule-diag.el
 
 (autoload 'list-character-sets "mule-diag" "\
@@ -18885,7 +18885,7 @@ per-character basis, this may not be accurate.
 
 ;;;### (autoloads (advice-member-p advice-remove advice-add remove-function
 ;;;;;;  advice--add-function add-function advice--buffer-local advice--remove-function)
-;;;;;;  "nadvice" "emacs-lisp/nadvice.el" (20851 48294 960738 0))
+;;;;;;  "nadvice" "emacs-lisp/nadvice.el" (20872 54440 171355 0))
 ;;; Generated autoloads from emacs-lisp/nadvice.el
 
 (autoload 'advice--remove-function "nadvice" "\
@@ -18973,8 +18973,8 @@ of the piece of advice.
 ;;;### (autoloads (network-connection network-connection-to-service
 ;;;;;;  whois-reverse-lookup whois finger ftp run-dig dns-lookup-host
 ;;;;;;  nslookup nslookup-host ping traceroute route arp netstat
-;;;;;;  iwconfig ifconfig) "net-utils" "net/net-utils.el" (20799
-;;;;;;  169 640767 0))
+;;;;;;  iwconfig ifconfig) "net-utils" "net/net-utils.el" (20903
+;;;;;;  10024 645978 0))
 ;;; Generated autoloads from net/net-utils.el
 
 (autoload 'ifconfig "net-utils" "\
@@ -19359,8 +19359,8 @@ Return nil if the face cannot display a glyph for N.
 
 ;;;***
 
-;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (20813
-;;;;;;  33065 721081 0))
+;;;### (autoloads (nxml-mode) "nxml-mode" "nxml/nxml-mode.el" (20884
+;;;;;;  6711 386198 0))
 ;;; Generated autoloads from nxml/nxml-mode.el
 
 (autoload 'nxml-mode "nxml-mode" "\
@@ -19435,7 +19435,7 @@ the variable `nxml-enabled-unicode-blocks'.
 ;;;***
 
 ;;;### (autoloads (inferior-octave octave-mode) "octave" "progmodes/octave.el"
-;;;;;;  (20864 60326 774861 0))
+;;;;;;  (20905 51752 865679 0))
 ;;; Generated autoloads from progmodes/octave.el
 
 (autoload 'octave-mode "octave" "\
@@ -20203,7 +20203,7 @@ See the command `outline-mode' for more information on this mode.
 ;;;### (autoloads (list-packages describe-package package-initialize
 ;;;;;;  package-refresh-contents package-install-file package-install-from-buffer
 ;;;;;;  package-install package-enable-at-startup) "package" "emacs-lisp/package.el"
-;;;;;;  (20860 63270 684173 0))
+;;;;;;  (20882 3877 904124 0))
 ;;; Generated autoloads from emacs-lisp/package.el
 
 (defvar package-enable-at-startup t "\
@@ -20273,8 +20273,8 @@ The list is displayed in a buffer named `*Packages*'.
 
 ;;;***
 
-;;;### (autoloads (show-paren-mode) "paren" "paren.el" (20738 27061
-;;;;;;  124069 0))
+;;;### (autoloads (show-paren-mode) "paren" "paren.el" (20903 56815
+;;;;;;  695483 0))
 ;;; Generated autoloads from paren.el
 
 (defvar show-paren-mode nil "\
@@ -20314,8 +20314,8 @@ unknown are returned as nil.
 
 ;;;***
 
-;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (20746
-;;;;;;  21181 635406 0))
+;;;### (autoloads (pascal-mode) "pascal" "progmodes/pascal.el" (20870
+;;;;;;  12718 549931 0))
 ;;; Generated autoloads from progmodes/pascal.el
 
 (autoload 'pascal-mode "pascal" "\
@@ -20492,7 +20492,7 @@ Completion for the GNU tar utility.
 ;;;***
 
 ;;;### (autoloads (pcomplete/mount pcomplete/umount pcomplete/kill)
-;;;;;;  "pcmpl-linux" "pcmpl-linux.el" (20709 26818 907104 0))
+;;;;;;  "pcmpl-linux" "pcmpl-linux.el" (20884 7264 912957 506000))
 ;;; Generated autoloads from pcmpl-linux.el
 
 (autoload 'pcomplete/kill "pcmpl-linux" "\
@@ -20748,7 +20748,7 @@ Global menu used by PCL-CVS.")
 ;;;***
 
 ;;;### (autoloads (perl-mode) "perl-mode" "progmodes/perl-mode.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20873 17019 382960 343000))
 ;;; Generated autoloads from progmodes/perl-mode.el
 (put 'perl-indent-level 'safe-local-variable 'integerp)
 (put 'perl-continued-statement-offset 'safe-local-variable 'integerp)
@@ -21017,7 +21017,7 @@ Ignores leading comment characters.
 ;;;;;;  pr-ps-buffer-print pr-ps-buffer-using-ghostscript pr-ps-buffer-preview
 ;;;;;;  pr-ps-directory-ps-print pr-ps-directory-print pr-ps-directory-using-ghostscript
 ;;;;;;  pr-ps-directory-preview pr-interface) "printing" "printing.el"
-;;;;;;  (20721 17977 14204 0))
+;;;;;;  (20891 44219 680764 0))
 ;;; Generated autoloads from printing.el
 
 (autoload 'pr-interface "printing" "\
@@ -21654,7 +21654,7 @@ Open profile FILENAME.
 ;;;***
 
 ;;;### (autoloads (run-prolog mercury-mode prolog-mode) "prolog"
-;;;;;;  "progmodes/prolog.el" (20851 48294 960738 0))
+;;;;;;  "progmodes/prolog.el" (20891 18859 893295 0))
 ;;; Generated autoloads from progmodes/prolog.el
 
 (autoload 'prolog-mode "prolog" "\
@@ -21753,8 +21753,8 @@ Typing \\<ps-run-mode-map>\\[ps-run-goto-error] when the cursor is at the number
 ;;;;;;  ps-spool-region ps-spool-buffer-with-faces ps-spool-buffer
 ;;;;;;  ps-print-region-with-faces ps-print-region ps-print-buffer-with-faces
 ;;;;;;  ps-print-buffer ps-print-customize ps-print-color-p ps-paper-type
-;;;;;;  ps-page-dimensions-database) "ps-print" "ps-print.el" (20721
-;;;;;;  17977 14204 0))
+;;;;;;  ps-page-dimensions-database) "ps-print" "ps-print.el" (20874
+;;;;;;  65006 672942 217000))
 ;;; Generated autoloads from ps-print.el
 
 (defvar ps-page-dimensions-database (purecopy (list (list 'a4 (/ (* 72 21.0) 2.54) (/ (* 72 29.7) 2.54) "A4") (list 'a3 (/ (* 72 29.7) 2.54) (/ (* 72 42.0) 2.54) "A3") (list 'letter (* 72 8.5) (* 72 11.0) "Letter") (list 'legal (* 72 8.5) (* 72 14.0) "Legal") (list 'letter-small (* 72 7.68) (* 72 10.16) "LetterSmall") (list 'tabloid (* 72 11.0) (* 72 17.0) "Tabloid") (list 'ledger (* 72 17.0) (* 72 11.0) "Ledger") (list 'statement (* 72 5.5) (* 72 8.5) "Statement") (list 'executive (* 72 7.5) (* 72 10.0) "Executive") (list 'a4small (* 72 7.47) (* 72 10.85) "A4Small") (list 'b4 (* 72 10.125) (* 72 14.33) "B4") (list 'b5 (* 72 7.16) (* 72 10.125) "B5") '(addresslarge 236.0 99.0 "AddressLarge") '(addresssmall 236.0 68.0 "AddressSmall") '(cuthanging13 90.0 222.0 "CutHanging13") '(cuthanging15 90.0 114.0 "CutHanging15") '(diskette 181.0 136.0 "Diskette") '(eurofilefolder 139.0 112.0 "EuropeanFilefolder") '(eurofoldernarrow 526.0 107.0 "EuroFolderNarrow") '(eurofolderwide 526.0 136.0 "EuroFolderWide") '(euronamebadge 189.0 108.0 "EuroNameBadge") '(euronamebadgelarge 223.0 136.0 "EuroNameBadgeLarge") '(filefolder 230.0 37.0 "FileFolder") '(jewelry 76.0 136.0 "Jewelry") '(mediabadge 180.0 136.0 "MediaBadge") '(multipurpose 126.0 68.0 "MultiPurpose") '(retaillabel 90.0 104.0 "RetailLabel") '(shipping 271.0 136.0 "Shipping") '(slide35mm 26.0 104.0 "Slide35mm") '(spine8mm 187.0 26.0 "Spine8mm") '(topcoated 425.19685 136.0 "TopCoatedPaper") '(topcoatedpaper 396.0 136.0 "TopcoatedPaper150") '(vhsface 205.0 127.0 "VHSFace") '(vhsspine 400.0 50.0 "VHSSpine") '(zipdisk 156.0 136.0 "ZipDisk"))) "\
@@ -21951,7 +21951,7 @@ If EXTENSION is any other symbol, it is ignored.
 ;;;***
 
 ;;;### (autoloads (python-mode run-python) "python" "progmodes/python.el"
-;;;;;;  (20850 27430 515630 0))
+;;;;;;  (20874 65006 672942 217000))
 ;;; Generated autoloads from progmodes/python.el
 
 (add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'") 'python-mode))
@@ -22383,8 +22383,8 @@ matching parts of the target buffer will be highlighted.
 
 ;;;***
 
-;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (20799 169
-;;;;;;  640767 0))
+;;;### (autoloads (recentf-mode) "recentf" "recentf.el" (20871 33574
+;;;;;;  214287 0))
 ;;; Generated autoloads from recentf.el
 
 (defvar recentf-mode nil "\
@@ -22548,8 +22548,8 @@ with a prefix argument, prompt for START-AT and FORMAT.
 
 ;;;***
 
-;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (refill-mode) "refill" "textmodes/refill.el" (20884
+;;;;;;  7264 912957 506000))
 ;;; Generated autoloads from textmodes/refill.el
 
 (autoload 'refill-mode "refill" "\
@@ -22570,8 +22570,8 @@ For true \"word wrap\" behavior, use `visual-line-mode' instead.
 ;;;***
 
 ;;;### (autoloads (reftex-reset-scanning-information reftex-mode
-;;;;;;  turn-on-reftex) "reftex" "textmodes/reftex.el" (20843 54187
-;;;;;;  671468 0))
+;;;;;;  turn-on-reftex) "reftex" "textmodes/reftex.el" (20895 15912
+;;;;;;  444844 0))
 ;;; Generated autoloads from textmodes/reftex.el
 
 (autoload 'turn-on-reftex "reftex" "\
@@ -22701,7 +22701,7 @@ Here are all local bindings.
 ;;;***
 
 ;;;### (autoloads (reftex-all-document-files) "reftex-parse" "textmodes/reftex-parse.el"
-;;;;;;  (20858 21542 723007 0))
+;;;;;;  (20895 15912 444844 0))
 ;;; Generated autoloads from textmodes/reftex-parse.el
 
 (autoload 'reftex-all-document-files "reftex-parse" "\
@@ -22713,8 +22713,8 @@ of master file.
 
 ;;;***
 
-;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (20858
-;;;;;;  21542 723007 0))
+;;;### (autoloads nil "reftex-vars" "textmodes/reftex-vars.el" (20895
+;;;;;;  15912 444844 0))
 ;;; Generated autoloads from textmodes/reftex-vars.el
 (put 'reftex-vref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
 (put 'reftex-fref-is-default 'safe-local-variable (lambda (x) (or (stringp x) (symbolp x))))
@@ -22755,7 +22755,7 @@ This means the number of non-shy regexp grouping constructs
 
 ;;;### (autoloads (remember-diary-extract-entries remember-clipboard
 ;;;;;;  remember-other-frame remember) "remember" "textmodes/remember.el"
-;;;;;;  (20859 42406 744769 0))
+;;;;;;  (20874 65006 672942 217000))
 ;;; Generated autoloads from textmodes/remember.el
 
 (autoload 'remember "remember" "\
@@ -22919,8 +22919,8 @@ Make a ring that can contain SIZE elements.
 
 ;;;***
 
-;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (rlogin) "rlogin" "net/rlogin.el" (20903 10024
+;;;;;;  645978 0))
 ;;; Generated autoloads from net/rlogin.el
 
 (autoload 'rlogin "rlogin" "\
@@ -22969,7 +22969,7 @@ variable.
 ;;;;;;  rmail-secondary-file-directory rmail-primary-inbox-list rmail-highlighted-headers
 ;;;;;;  rmail-retry-ignored-headers rmail-displayed-headers rmail-ignored-headers
 ;;;;;;  rmail-user-mail-address-regexp rmail-movemail-variant-p rmail-spool-directory
-;;;;;;  rmail-file-name) "rmail" "mail/rmail.el" (20762 9398 526093
+;;;;;;  rmail-file-name) "rmail" "mail/rmail.el" (20892 39729 858825
 ;;;;;;  0))
 ;;; Generated autoloads from mail/rmail.el
 
@@ -23259,7 +23259,7 @@ Validation will be enabled if `rng-nxml-auto-validate-flag' is non-nil.
 ;;;***
 
 ;;;### (autoloads (rng-validate-mode) "rng-valid" "nxml/rng-valid.el"
-;;;;;;  (20814 53928 50501 0))
+;;;;;;  (20884 6711 386198 0))
 ;;; Generated autoloads from nxml/rng-valid.el
 
 (autoload 'rng-validate-mode "rng-valid" "\
@@ -23390,7 +23390,7 @@ Toggle the use of ROT13 encoding for the current window.
 ;;;***
 
 ;;;### (autoloads (rst-minor-mode rst-mode) "rst" "textmodes/rst.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 912957 506000))
 ;;; Generated autoloads from textmodes/rst.el
  (add-to-list 'auto-mode-alist (purecopy '("\\.re?st\\'" . rst-mode)))
 
@@ -23421,7 +23421,7 @@ for modes derived from Text mode, like Mail mode.
 ;;;***
 
 ;;;### (autoloads (ruby-mode) "ruby-mode" "progmodes/ruby-mode.el"
-;;;;;;  (20845 9511 656701 0))
+;;;;;;  (20905 51752 865679 0))
 ;;; Generated autoloads from progmodes/ruby-mode.el
 
 (autoload 'ruby-mode "ruby-mode" "\
@@ -23973,7 +23973,7 @@ Semantic mode.
 ;;;***
 
 ;;;### (autoloads (bovine-grammar-mode) "semantic/bovine/grammar"
-;;;;;;  "cedet/semantic/bovine/grammar.el" (20709 26818 907104 0))
+;;;;;;  "cedet/semantic/bovine/grammar.el" (20895 15912 444844 0))
 ;;; Generated autoloads from cedet/semantic/bovine/grammar.el
 
 (autoload 'bovine-grammar-mode "semantic/bovine/grammar" "\
@@ -23984,7 +23984,7 @@ Major mode for editing Bovine grammars.
 ;;;***
 
 ;;;### (autoloads (wisent-grammar-mode) "semantic/wisent/grammar"
-;;;;;;  "cedet/semantic/wisent/grammar.el" (20709 26818 907104 0))
+;;;;;;  "cedet/semantic/wisent/grammar.el" (20879 27694 495748 0))
 ;;; Generated autoloads from cedet/semantic/wisent/grammar.el
 
 (autoload 'wisent-grammar-mode "semantic/wisent/grammar" "\
@@ -24591,7 +24591,7 @@ Set up file shadowing.
 ;;;***
 
 ;;;### (autoloads (shell shell-dumb-shell-regexp) "shell" "shell.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 912957 506000))
 ;;; Generated autoloads from shell.el
 
 (defvar shell-dumb-shell-regexp (purecopy "cmd\\(proxy\\)?\\.exe") "\
@@ -24639,8 +24639,8 @@ Otherwise, one argument `-i' is passed to the shell.
 
 ;;;***
 
-;;;### (autoloads (shr-insert-document) "shr" "gnus/shr.el" (20845
-;;;;;;  9511 656701 0))
+;;;### (autoloads (shr-insert-document) "shr" "gnus/shr.el" (20903
+;;;;;;  10024 645978 0))
 ;;; Generated autoloads from gnus/shr.el
 
 (autoload 'shr-insert-document "shr" "\
@@ -24653,7 +24653,7 @@ DOM should be a parse tree as generated by
 ;;;***
 
 ;;;### (autoloads (sieve-upload-and-kill sieve-upload-and-bury sieve-upload
-;;;;;;  sieve-manage) "sieve" "gnus/sieve.el" (20709 26818 907104
+;;;;;;  sieve-manage) "sieve" "gnus/sieve.el" (20896 36774 886399
 ;;;;;;  0))
 ;;; Generated autoloads from gnus/sieve.el
 
@@ -24885,6 +24885,30 @@ If no conflict maker is found, turn off `smerge-mode'.
 
 ;;;***
 
+;;;### (autoloads (smie-highlight-matching-block-mode) "smie" "emacs-lisp/smie.el"
+;;;;;;  (20901 54695 989166 0))
+;;; Generated autoloads from emacs-lisp/smie.el
+
+(defvar smie-highlight-matching-block-mode nil "\
+Non-nil if Smie-Highlight-Matching-Block mode is enabled.
+See the command `smie-highlight-matching-block-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `smie-highlight-matching-block-mode'.")
+
+(custom-autoload 'smie-highlight-matching-block-mode "smie" nil)
+
+(autoload 'smie-highlight-matching-block-mode "smie" "\
+Toggle Smie-Highlight-Matching-Block mode on or off.
+With a prefix argument ARG, enable Smie-Highlight-Matching-Block mode if ARG is
+positive, and disable it otherwise.  If called from Lisp, enable
+the mode if ARG is omitted or nil, and toggle it if ARG is `toggle'.
+\\{smie-highlight-matching-block-mode-map}
+
+\(fn &optional ARG)" t nil)
+
+;;;***
+
 ;;;### (autoloads (smiley-buffer smiley-region) "smiley" "gnus/smiley.el"
 ;;;;;;  (20726 5184 974741 509000))
 ;;; Generated autoloads from gnus/smiley.el
@@ -24944,7 +24968,7 @@ Snake mode keybindings:
 ;;;***
 
 ;;;### (autoloads (snmpv2-mode snmp-mode) "snmp-mode" "net/snmp-mode.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20891 18859 893295 0))
 ;;; Generated autoloads from net/snmp-mode.el
 
 (autoload 'snmp-mode "snmp-mode" "\
@@ -25067,8 +25091,8 @@ Pick your favorite shortcuts:
 
 ;;;### (autoloads (delete-duplicate-lines reverse-region sort-columns
 ;;;;;;  sort-regexp-fields sort-fields sort-numeric-fields sort-pages
-;;;;;;  sort-paragraphs sort-lines sort-subr) "sort" "sort.el" (20709
-;;;;;;  26818 907104 0))
+;;;;;;  sort-paragraphs sort-lines sort-subr) "sort" "sort.el" (20896
+;;;;;;  36774 886399 0))
 ;;; Generated autoloads from sort.el
 (put 'sort-fold-case 'safe-local-variable 'booleanp)
 
@@ -25234,16 +25258,19 @@ delete repeated lines only if they are adjacent.  It works like the utility
 this is more efficient in performance and memory usage than when ADJACENT
 is nil that uses additional memory to remember previous lines.
 
+If KEEP-BLANKS is non-nil (when called interactively with three C-u prefixes),
+duplicate blank lines are preserved.
+
 When called from Lisp and INTERACTIVE is omitted or nil, return the number
 of deleted duplicate lines, do not print it; if INTERACTIVE is t, the
 function behaves in all respects as if it had been called interactively.
 
-\(fn BEG END &optional REVERSE ADJACENT INTERACTIVE)" t nil)
+\(fn BEG END &optional REVERSE ADJACENT KEEP-BLANKS INTERACTIVE)" t nil)
 
 ;;;***
 
-;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (spam-initialize) "spam" "gnus/spam.el" (20901
+;;;;;;  54695 989166 0))
 ;;; Generated autoloads from gnus/spam.el
 
 (autoload 'spam-initialize "spam" "\
@@ -25259,7 +25286,7 @@ installed through `spam-necessary-extra-headers'.
 
 ;;;### (autoloads (spam-report-deagentize spam-report-agentize spam-report-url-to-file
 ;;;;;;  spam-report-url-ping-mm-url spam-report-process-queue) "spam-report"
-;;;;;;  "gnus/spam-report.el" (20709 26818 907104 0))
+;;;;;;  "gnus/spam-report.el" (20874 65006 672942 217000))
 ;;; Generated autoloads from gnus/spam-report.el
 
 (autoload 'spam-report-process-queue "spam-report" "\
@@ -25302,7 +25329,7 @@ Spam reports will be queued with the method used when
 ;;;***
 
 ;;;### (autoloads (speedbar-get-focus speedbar-frame-mode) "speedbar"
-;;;;;;  "speedbar.el" (20709 26818 907104 0))
+;;;;;;  "speedbar.el" (20892 39729 858825 0))
 ;;; Generated autoloads from speedbar.el
 
 (defalias 'speedbar 'speedbar-frame-mode)
@@ -25346,7 +25373,7 @@ Return a vector containing the lines from `spook-phrases-file'.
 ;;;;;;  sql-ms sql-ingres sql-solid sql-mysql sql-sqlite sql-informix
 ;;;;;;  sql-sybase sql-oracle sql-product-interactive sql-connect
 ;;;;;;  sql-mode sql-add-product-keywords) "sql" "progmodes/sql.el"
-;;;;;;  (20797 44848 327754 0))
+;;;;;;  (20878 6823 881439 0))
 ;;; Generated autoloads from progmodes/sql.el
 
 (autoload 'sql-add-product-keywords "sql" "\
@@ -25985,8 +26012,8 @@ Studlify-case the current buffer.
 ;;;***
 
 ;;;### (autoloads (global-superword-mode superword-mode global-subword-mode
-;;;;;;  subword-mode) "subword" "progmodes/subword.el" (20822 48073
-;;;;;;  524485 0))
+;;;;;;  subword-mode) "subword" "progmodes/subword.el" (20886 47777
+;;;;;;  83668 440000))
 ;;; Generated autoloads from progmodes/subword.el
 
 (autoload 'subword-mode "subword" "\
@@ -26786,8 +26813,8 @@ Connect to the Emacs talk group from the current X display or tty frame.
 
 ;;;***
 
-;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (tar-mode) "tar-mode" "tar-mode.el" (20874 65222
+;;;;;;  672942 464000))
 ;;; Generated autoloads from tar-mode.el
 
 (autoload 'tar-mode "tar-mode" "\
@@ -26811,7 +26838,7 @@ See also: variables `tar-update-datestamp' and `tar-anal-blocksize'.
 ;;;***
 
 ;;;### (autoloads (tcl-help-on-word inferior-tcl tcl-mode) "tcl"
-;;;;;;  "progmodes/tcl.el" (20774 53405 704746 172000))
+;;;;;;  "progmodes/tcl.el" (20903 10024 645978 0))
 ;;; Generated autoloads from progmodes/tcl.el
 
 (autoload 'tcl-mode "tcl" "\
@@ -26886,7 +26913,7 @@ Normally input is edited in Emacs and sent a line at a time.
 ;;;***
 
 ;;;### (autoloads (serial-term ansi-term term make-term) "term" "term.el"
-;;;;;;  (20712 3008 596088 0))
+;;;;;;  (20878 6823 881439 0))
 ;;; Generated autoloads from term.el
 
 (autoload 'make-term "term" "\
@@ -26929,7 +26956,7 @@ use in that buffer.
 ;;;***
 
 ;;;### (autoloads (testcover-this-defun) "testcover" "emacs-lisp/testcover.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20878 6823 881439 0))
 ;;; Generated autoloads from emacs-lisp/testcover.el
 
 (autoload 'testcover-this-defun "testcover" "\
@@ -26939,8 +26966,8 @@ Start coverage on function under point.
 
 ;;;***
 
-;;;### (autoloads (tetris) "tetris" "play/tetris.el" (20709 26818
-;;;;;;  907104 0))
+;;;### (autoloads (tetris) "tetris" "play/tetris.el" (20874 65006
+;;;;;;  672942 217000))
 ;;; Generated autoloads from play/tetris.el
 
 (autoload 'tetris "tetris" "\
@@ -27428,7 +27455,7 @@ Compose Thai characters in the current buffer.
 
 ;;;### (autoloads (list-at-point number-at-point symbol-at-point
 ;;;;;;  sexp-at-point thing-at-point bounds-of-thing-at-point forward-thing)
-;;;;;;  "thingatpt" "thingatpt.el" (20822 48073 524485 0))
+;;;;;;  "thingatpt" "thingatpt.el" (20874 62962 290468 0))
 ;;; Generated autoloads from thingatpt.el
 
 (autoload 'forward-thing "thingatpt" "\
@@ -27462,10 +27489,13 @@ Possibilities include `symbol', `list', `sexp', `defun',
 `filename', `url', `email', `word', `sentence', `whitespace',
 `line', `number', and `page'.
 
+When the optional argument NO-PROPERTIES is non-nil,
+strip text properties from the return value.
+
 See the file `thingatpt.el' for documentation on how to define
 a symbol as a valid THING.
 
-\(fn THING)" nil nil)
+\(fn THING &optional NO-PROPERTIES)" nil nil)
 
 (autoload 'sexp-at-point "thingatpt" "\
 Return the sexp at point, or nil if none is found.
@@ -28145,7 +28175,7 @@ holds a keymap.
 ;;;***
 
 ;;;### (autoloads (tpu-edt-on tpu-edt-mode) "tpu-edt" "emulation/tpu-edt.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 412929 442000))
 ;;; Generated autoloads from emulation/tpu-edt.el
 
 (defvar tpu-edt-mode nil "\
@@ -28225,7 +28255,7 @@ to a tcp server on another machine.
 
 ;;;### (autoloads (trace-function-background trace-function-foreground
 ;;;;;;  trace-values trace-buffer) "trace" "emacs-lisp/trace.el"
-;;;;;;  (20842 33318 816618 0))
+;;;;;;  (20903 10024 645978 0))
 ;;; Generated autoloads from emacs-lisp/trace.el
 
 (defvar trace-buffer "*trace-output*" "\
@@ -28495,7 +28525,7 @@ First column's text    sSs  Second column's text
 
 ;;;### (autoloads (type-break-guesstimate-keystroke-threshold type-break-statistics
 ;;;;;;  type-break type-break-mode) "type-break" "type-break.el"
-;;;;;;  (20799 169 640767 0))
+;;;;;;  (20884 7264 912957 506000))
 ;;; Generated autoloads from type-break.el
 
 (defvar type-break-mode nil "\
@@ -28733,7 +28763,7 @@ which specify the range to operate on.
 ;;;***
 
 ;;;### (autoloads (unrmail batch-unrmail) "unrmail" "mail/unrmail.el"
-;;;;;;  (20731 53823 676680 0))
+;;;;;;  (20895 15912 444844 0))
 ;;; Generated autoloads from mail/unrmail.el
 
 (autoload 'batch-unrmail "unrmail" "\
@@ -28767,7 +28797,7 @@ UNSAFEP-VARS is a list of symbols with local bindings.
 ;;;***
 
 ;;;### (autoloads (url-retrieve-synchronously url-retrieve) "url"
-;;;;;;  "url/url.el" (20709 26818 907104 0))
+;;;;;;  "url/url.el" (20893 60586 188550 0))
 ;;; Generated autoloads from url/url.el
 
 (autoload 'url-retrieve "url" "\
@@ -28890,7 +28920,7 @@ Extract FNAM from the local disk cache.
 ;;;***
 
 ;;;### (autoloads (url-dav-vc-registered url-dav-request url-dav-supported-p)
-;;;;;;  "url-dav" "url/url-dav.el" (20709 26818 907104 0))
+;;;;;;  "url-dav" "url/url-dav.el" (20891 18859 893295 0))
 ;;; Generated autoloads from url/url-dav.el
 
 (autoload 'url-dav-supported-p "url-dav" "\
@@ -28956,7 +28986,7 @@ Might do a non-blocking connection; use `process-status' to check.
 
 ;;;### (autoloads (url-insert-file-contents url-file-local-copy url-copy-file
 ;;;;;;  url-file-handler url-handler-mode) "url-handlers" "url/url-handlers.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20892 39729 858825 0))
 ;;; Generated autoloads from url/url-handlers.el
 
 (defvar url-handler-mode nil "\
@@ -29098,7 +29128,7 @@ Fetch a data URL (RFC 2397).
 ;;;***
 
 ;;;### (autoloads (url-snews url-news) "url-news" "url/url-news.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20884 7264 912957 506000))
 ;;; Generated autoloads from url/url-news.el
 
 (autoload 'url-news "url-news" "\
@@ -29832,7 +29862,7 @@ mode-specific menu.  `vc-annotate-color-map' and
 
 ;;;***
 
-;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (20748 62911 684442
+;;;### (autoloads nil "vc-arch" "vc/vc-arch.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from vc/vc-arch.el
  (defun vc-arch-registered (file)
@@ -29843,8 +29873,8 @@ mode-specific menu.  `vc-annotate-color-map' and
 
 ;;;***
 
-;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (20856 32310 242920
-;;;;;;  705000))
+;;;### (autoloads nil "vc-bzr" "vc/vc-bzr.el" (20900 33838 319219
+;;;;;;  0))
 ;;; Generated autoloads from vc/vc-bzr.el
 
 (defconst vc-bzr-admin-dirname ".bzr" "\
@@ -29860,7 +29890,7 @@ Name of the format file in a .bzr directory.")
 
 ;;;***
 
-;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (20855 45357 683214
+;;;### (autoloads nil "vc-cvs" "vc/vc-cvs.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from vc/vc-cvs.el
 (defun vc-cvs-registered (f)
@@ -29872,49 +29902,10 @@ Name of the format file in a .bzr directory.")
 
 ;;;***
 
-;;;### (autoloads (vc-dir vc-dir-mode) "vc-dir" "vc/vc-dir.el" (20709
-;;;;;;  26818 907104 0))
+;;;### (autoloads (vc-dir) "vc-dir" "vc/vc-dir.el" (20900 33838 319219
+;;;;;;  0))
 ;;; Generated autoloads from vc/vc-dir.el
 
-(autoload 'vc-dir-mode "vc-dir" "\
-Major mode for VC directory buffers.
-Marking/Unmarking key bindings and actions:
-m - mark a file/directory
-  - if the region is active, mark all the files in region.
-    Restrictions: - a file cannot be marked if any parent directory is marked
-                  - a directory cannot be marked if any child file or
-                    directory is marked
-u - unmark a file/directory
-  - if the region is active, unmark all the files in region.
-M - if the cursor is on a file: mark all the files with the same state as
-      the current file
-  - if the cursor is on a directory: mark all child files
-  - with a prefix argument: mark all files
-U - if the cursor is on a file: unmark all the files with the same state
-      as the current file
-  - if the cursor is on a directory: unmark all child files
-  - with a prefix argument: unmark all files
-mouse-2  - toggles the mark state
-
-VC commands
-VC commands in the `C-x v' prefix can be used.
-VC commands act on the marked entries.  If nothing is marked, VC
-commands act on the current entry.
-
-Search & Replace
-S - searches the marked files
-Q - does a query replace on the marked files
-M-s a C-s - does an isearch on the marked files
-M-s a C-M-s - does a regexp isearch on the marked files
-If nothing is marked, these commands act on the current entry.
-When a directory is current or marked, the Search & Replace
-commands act on the child files of that directory that are displayed in
-the *vc-dir* buffer.
-
-\\{vc-dir-mode-map}
-
-\(fn)" t nil)
-
 (autoload 'vc-dir "vc-dir" "\
 Show the VC status for \"interesting\" files in and below DIR.
 This allows you to mark files and perform VC operations on them.
@@ -29960,7 +29951,7 @@ case, and the process object in the asynchronous case.
 
 ;;;***
 
-;;;### (autoloads nil "vc-git" "vc/vc-git.el" (20855 45357 683214
+;;;### (autoloads nil "vc-git" "vc/vc-git.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from vc/vc-git.el
  (defun vc-git-registered (file)
@@ -29972,7 +29963,7 @@ case, and the process object in the asynchronous case.
 
 ;;;***
 
-;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (20855 45357 683214 0))
+;;;### (autoloads nil "vc-hg" "vc/vc-hg.el" (20900 33838 319219 0))
 ;;; Generated autoloads from vc/vc-hg.el
  (defun vc-hg-registered (file)
   "Return non-nil if FILE is registered with hg."
@@ -29983,7 +29974,7 @@ case, and the process object in the asynchronous case.
 
 ;;;***
 
-;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (20855 45357 683214
+;;;### (autoloads nil "vc-mtn" "vc/vc-mtn.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from vc/vc-mtn.el
 
@@ -30001,7 +29992,7 @@ Name of the monotone directory's format file.")
 ;;;***
 
 ;;;### (autoloads (vc-rcs-master-templates) "vc-rcs" "vc/vc-rcs.el"
-;;;;;;  (20855 45357 683214 0))
+;;;;;;  (20900 33838 319219 0))
 ;;; Generated autoloads from vc/vc-rcs.el
 
 (defvar vc-rcs-master-templates (purecopy '("%sRCS/%s,v" "%s%s,v" "%sRCS/%s")) "\
@@ -30015,7 +30006,7 @@ For a description of possible values, see `vc-check-master-templates'.")
 ;;;***
 
 ;;;### (autoloads (vc-sccs-master-templates) "vc-sccs" "vc/vc-sccs.el"
-;;;;;;  (20855 45357 683214 0))
+;;;;;;  (20900 33838 319219 0))
 ;;; Generated autoloads from vc/vc-sccs.el
 
 (defvar vc-sccs-master-templates (purecopy '("%sSCCS/s.%s" "%ss.%s" vc-sccs-search-project-dir)) "\
@@ -30033,7 +30024,7 @@ find any project directory." (let ((project-dir (getenv "PROJECTDIR")) dirs dir)
 
 ;;;***
 
-;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (20855 45357 683214
+;;;### (autoloads nil "vc-svn" "vc/vc-svn.el" (20900 33838 319219
 ;;;;;;  0))
 ;;; Generated autoloads from vc/vc-svn.el
  (defun vc-svn-registered (f)
@@ -30048,7 +30039,7 @@ find any project directory." (let ((project-dir (getenv "PROJECTDIR")) dirs dir)
 ;;;***
 
 ;;;### (autoloads (vera-mode) "vera-mode" "progmodes/vera-mode.el"
-;;;;;;  (20777 63161 848428 0))
+;;;;;;  (20893 60586 188550 0))
 ;;; Generated autoloads from progmodes/vera-mode.el
  (add-to-list 'auto-mode-alist (cons (purecopy "\\.vr[hi]?\\'")  'vera-mode))
 
@@ -30106,7 +30097,7 @@ Key bindings:
 ;;;***
 
 ;;;### (autoloads (verilog-mode) "verilog-mode" "progmodes/verilog-mode.el"
-;;;;;;  (20763 30266 231060 0))
+;;;;;;  (20885 2819 449152 0))
 ;;; Generated autoloads from progmodes/verilog-mode.el
 
 (autoload 'verilog-mode "verilog-mode" "\
@@ -30245,7 +30236,7 @@ Key bindings specific to `verilog-mode-map' are:
 ;;;***
 
 ;;;### (autoloads (vhdl-mode) "vhdl-mode" "progmodes/vhdl-mode.el"
-;;;;;;  (20709 26818 907104 0))
+;;;;;;  (20892 39729 858825 0))
 ;;; Generated autoloads from progmodes/vhdl-mode.el
 
 (autoload 'vhdl-mode "vhdl-mode" "\
@@ -30615,7 +30606,7 @@ Usage:
     option `vhdl-index-menu' to non-nil) or made accessible as a mouse menu
     (e.g. add \"(global-set-key '[S-down-mouse-3] 'imenu)\" to your start-up
     file) for browsing the file contents (is not populated if buffer is
-    larger than `font-lock-maximum-size').  Also, a source file menu can be
+    larger than 256000).  Also, a source file menu can be
     added (set option `vhdl-source-file-menu' to non-nil) for browsing the
     current directory for VHDL source files.
 
@@ -30742,7 +30733,7 @@ Usage:
     automatically recognized as VHDL source files.  To add an extension
     \".xxx\", add the following line to your Emacs start-up file (`.emacs'):
 
-      (setq auto-mode-alist (cons '(\"\\\\.xxx\\\\'\" . vhdl-mode) auto-mode-alist))
+      (push '(\"\\\\.xxx\\\\'\" . vhdl-mode) auto-mode-alist)
 
 
   HINTS:
@@ -31283,7 +31274,7 @@ this is equivalent to `display-warning', using
 ;;;***
 
 ;;;### (autoloads (wdired-change-to-wdired-mode) "wdired" "wdired.el"
-;;;;;;  (20791 9657 561026 0))
+;;;;;;  (20900 33838 319219 0))
 ;;; Generated autoloads from wdired.el
 
 (autoload 'wdired-change-to-wdired-mode "wdired" "\
@@ -31318,7 +31309,7 @@ Please submit bug reports and other feedback to the author, Neil W. Van Dyke
 ;;;***
 
 ;;;### (autoloads (which-function-mode) "which-func" "progmodes/which-func.el"
-;;;;;;  (20725 15032 264919 0))
+;;;;;;  (20895 15912 444844 0))
 ;;; Generated autoloads from progmodes/which-func.el
  (put 'which-func-format 'risky-local-variable t)
  (put 'which-func-current 'risky-local-variable t)
@@ -31351,8 +31342,8 @@ in certain major modes.
 ;;;### (autoloads (whitespace-report-region whitespace-report whitespace-cleanup-region
 ;;;;;;  whitespace-cleanup global-whitespace-toggle-options whitespace-toggle-options
 ;;;;;;  global-whitespace-newline-mode global-whitespace-mode whitespace-newline-mode
-;;;;;;  whitespace-mode) "whitespace" "whitespace.el" (20831 63016
-;;;;;;  738579 0))
+;;;;;;  whitespace-mode) "whitespace" "whitespace.el" (20874 65007
+;;;;;;  172950 7000))
 ;;; Generated autoloads from whitespace.el
 
 (autoload 'whitespace-mode "whitespace" "\
@@ -32065,26 +32056,6 @@ The key bindings are:
 
 ;;;***
 
-;;;### (autoloads (xesam-search) "xesam" "net/xesam.el" (20709 26818
-;;;;;;  907104 0))
-;;; Generated autoloads from net/xesam.el
-
-(autoload 'xesam-search "xesam" "\
-Perform an interactive search.
-ENGINE is the Xesam search engine to be applied, it must be one of the
-entries of `xesam-search-engines'.  QUERY is the search string in the
-Xesam user query language.  If the search engine does not support
-the Xesam user query language, a Xesam fulltext search is applied.
-
-The default search engine is the first entry in `xesam-search-engines'.
-Example:
-
-  (xesam-search (car (xesam-search-engines)) \"emacs\")
-
-\(fn ENGINE QUERY)" t nil)
-
-;;;***
-
 ;;;### (autoloads (xml-parse-region xml-parse-file) "xml" "xml.el"
 ;;;;;;  (20766 6456 368550 0))
 ;;; Generated autoloads from xml.el
@@ -32143,7 +32114,7 @@ Both features can be combined by providing a cons cell
 ;;;***
 
 ;;;### (autoloads (xmltok-get-declared-encoding-position) "xmltok"
-;;;;;;  "nxml/xmltok.el" (20709 26818 907104 0))
+;;;;;;  "nxml/xmltok.el" (20884 6711 386198 0))
 ;;; Generated autoloads from nxml/xmltok.el
 
 (autoload 'xmltok-get-declared-encoding-position "xmltok" "\
@@ -32300,46 +32271,46 @@ Zone out, completely.
 ;;;;;;  "emacs-lisp/eieio-base.el" "emacs-lisp/eieio-datadebug.el"
 ;;;;;;  "emacs-lisp/eieio-speedbar.el" "emacs-lisp/eieio.el" "emacs-lisp/find-gc.el"
 ;;;;;;  "emacs-lisp/gulp.el" "emacs-lisp/lisp-mnt.el" "emacs-lisp/package-x.el"
-;;;;;;  "emacs-lisp/regi.el" "emacs-lisp/smie.el" "emacs-lisp/tcover-ses.el"
-;;;;;;  "emacs-lisp/tcover-unsafep.el" "emulation/cua-gmrk.el" "emulation/cua-rect.el"
-;;;;;;  "emulation/edt-lk201.el" "emulation/edt-mapper.el" "emulation/edt-pc.el"
-;;;;;;  "emulation/edt-vt100.el" "emulation/tpu-extras.el" "emulation/viper-cmd.el"
-;;;;;;  "emulation/viper-ex.el" "emulation/viper-init.el" "emulation/viper-keym.el"
-;;;;;;  "emulation/viper-macs.el" "emulation/viper-mous.el" "emulation/viper-util.el"
-;;;;;;  "erc/erc-backend.el" "erc/erc-goodies.el" "erc/erc-ibuffer.el"
-;;;;;;  "erc/erc-lang.el" "eshell/em-alias.el" "eshell/em-banner.el"
-;;;;;;  "eshell/em-basic.el" "eshell/em-cmpl.el" "eshell/em-dirs.el"
-;;;;;;  "eshell/em-glob.el" "eshell/em-hist.el" "eshell/em-ls.el"
-;;;;;;  "eshell/em-pred.el" "eshell/em-prompt.el" "eshell/em-rebind.el"
-;;;;;;  "eshell/em-script.el" "eshell/em-smart.el" "eshell/em-term.el"
-;;;;;;  "eshell/em-tramp.el" "eshell/em-unix.el" "eshell/em-xtra.el"
-;;;;;;  "eshell/esh-arg.el" "eshell/esh-cmd.el" "eshell/esh-ext.el"
-;;;;;;  "eshell/esh-groups.el" "eshell/esh-io.el" "eshell/esh-module.el"
-;;;;;;  "eshell/esh-opt.el" "eshell/esh-proc.el" "eshell/esh-util.el"
-;;;;;;  "eshell/esh-var.el" "ezimage.el" "foldout.el" "format-spec.el"
-;;;;;;  "fringe.el" "generic-x.el" "gnus/compface.el" "gnus/gnus-async.el"
-;;;;;;  "gnus/gnus-bcklg.el" "gnus/gnus-cite.el" "gnus/gnus-cus.el"
-;;;;;;  "gnus/gnus-demon.el" "gnus/gnus-dup.el" "gnus/gnus-eform.el"
-;;;;;;  "gnus/gnus-ems.el" "gnus/gnus-int.el" "gnus/gnus-logic.el"
-;;;;;;  "gnus/gnus-mh.el" "gnus/gnus-salt.el" "gnus/gnus-score.el"
-;;;;;;  "gnus/gnus-setup.el" "gnus/gnus-srvr.el" "gnus/gnus-topic.el"
-;;;;;;  "gnus/gnus-undo.el" "gnus/gnus-util.el" "gnus/gnus-uu.el"
-;;;;;;  "gnus/gnus-vm.el" "gnus/gssapi.el" "gnus/ietf-drums.el" "gnus/legacy-gnus-agent.el"
-;;;;;;  "gnus/mail-parse.el" "gnus/mail-prsvr.el" "gnus/mail-source.el"
-;;;;;;  "gnus/mailcap.el" "gnus/messcompat.el" "gnus/mm-archive.el"
-;;;;;;  "gnus/mm-bodies.el" "gnus/mm-decode.el" "gnus/mm-util.el"
-;;;;;;  "gnus/mm-view.el" "gnus/mml-sec.el" "gnus/mml-smime.el" "gnus/nnagent.el"
-;;;;;;  "gnus/nnbabyl.el" "gnus/nndir.el" "gnus/nndraft.el" "gnus/nneething.el"
-;;;;;;  "gnus/nngateway.el" "gnus/nnheader.el" "gnus/nnimap.el" "gnus/nnir.el"
-;;;;;;  "gnus/nnmail.el" "gnus/nnmaildir.el" "gnus/nnmairix.el" "gnus/nnmbox.el"
-;;;;;;  "gnus/nnmh.el" "gnus/nnnil.el" "gnus/nnoo.el" "gnus/nnregistry.el"
-;;;;;;  "gnus/nnrss.el" "gnus/nnspool.el" "gnus/nntp.el" "gnus/nnvirtual.el"
-;;;;;;  "gnus/nnweb.el" "gnus/registry.el" "gnus/rfc1843.el" "gnus/rfc2045.el"
-;;;;;;  "gnus/rfc2047.el" "gnus/rfc2104.el" "gnus/rfc2231.el" "gnus/rtree.el"
-;;;;;;  "gnus/shr-color.el" "gnus/sieve-manage.el" "gnus/smime.el"
-;;;;;;  "gnus/spam-stat.el" "gnus/spam-wash.el" "hex-util.el" "hfy-cmap.el"
-;;;;;;  "ibuf-ext.el" "international/cp51932.el" "international/eucjp-ms.el"
-;;;;;;  "international/fontset.el" "international/iso-ascii.el" "international/ja-dic-cnv.el"
+;;;;;;  "emacs-lisp/regi.el" "emacs-lisp/tcover-ses.el" "emacs-lisp/tcover-unsafep.el"
+;;;;;;  "emulation/cua-gmrk.el" "emulation/cua-rect.el" "emulation/edt-lk201.el"
+;;;;;;  "emulation/edt-mapper.el" "emulation/edt-pc.el" "emulation/edt-vt100.el"
+;;;;;;  "emulation/tpu-extras.el" "emulation/viper-cmd.el" "emulation/viper-ex.el"
+;;;;;;  "emulation/viper-init.el" "emulation/viper-keym.el" "emulation/viper-macs.el"
+;;;;;;  "emulation/viper-mous.el" "emulation/viper-util.el" "erc/erc-backend.el"
+;;;;;;  "erc/erc-goodies.el" "erc/erc-ibuffer.el" "erc/erc-lang.el"
+;;;;;;  "eshell/em-alias.el" "eshell/em-banner.el" "eshell/em-basic.el"
+;;;;;;  "eshell/em-cmpl.el" "eshell/em-dirs.el" "eshell/em-glob.el"
+;;;;;;  "eshell/em-hist.el" "eshell/em-ls.el" "eshell/em-pred.el"
+;;;;;;  "eshell/em-prompt.el" "eshell/em-rebind.el" "eshell/em-script.el"
+;;;;;;  "eshell/em-smart.el" "eshell/em-term.el" "eshell/em-tramp.el"
+;;;;;;  "eshell/em-unix.el" "eshell/em-xtra.el" "eshell/esh-arg.el"
+;;;;;;  "eshell/esh-cmd.el" "eshell/esh-ext.el" "eshell/esh-groups.el"
+;;;;;;  "eshell/esh-io.el" "eshell/esh-module.el" "eshell/esh-opt.el"
+;;;;;;  "eshell/esh-proc.el" "eshell/esh-util.el" "eshell/esh-var.el"
+;;;;;;  "ezimage.el" "foldout.el" "format-spec.el" "fringe.el" "generic-x.el"
+;;;;;;  "gnus/compface.el" "gnus/gnus-async.el" "gnus/gnus-bcklg.el"
+;;;;;;  "gnus/gnus-cite.el" "gnus/gnus-cus.el" "gnus/gnus-demon.el"
+;;;;;;  "gnus/gnus-dup.el" "gnus/gnus-eform.el" "gnus/gnus-ems.el"
+;;;;;;  "gnus/gnus-int.el" "gnus/gnus-logic.el" "gnus/gnus-mh.el"
+;;;;;;  "gnus/gnus-salt.el" "gnus/gnus-score.el" "gnus/gnus-setup.el"
+;;;;;;  "gnus/gnus-srvr.el" "gnus/gnus-topic.el" "gnus/gnus-undo.el"
+;;;;;;  "gnus/gnus-util.el" "gnus/gnus-uu.el" "gnus/gnus-vm.el" "gnus/gssapi.el"
+;;;;;;  "gnus/ietf-drums.el" "gnus/legacy-gnus-agent.el" "gnus/mail-parse.el"
+;;;;;;  "gnus/mail-prsvr.el" "gnus/mail-source.el" "gnus/mailcap.el"
+;;;;;;  "gnus/messcompat.el" "gnus/mm-archive.el" "gnus/mm-bodies.el"
+;;;;;;  "gnus/mm-decode.el" "gnus/mm-util.el" "gnus/mm-view.el" "gnus/mml-sec.el"
+;;;;;;  "gnus/mml-smime.el" "gnus/nnagent.el" "gnus/nnbabyl.el" "gnus/nndir.el"
+;;;;;;  "gnus/nndraft.el" "gnus/nneething.el" "gnus/nngateway.el"
+;;;;;;  "gnus/nnheader.el" "gnus/nnimap.el" "gnus/nnir.el" "gnus/nnmail.el"
+;;;;;;  "gnus/nnmaildir.el" "gnus/nnmairix.el" "gnus/nnmbox.el" "gnus/nnmh.el"
+;;;;;;  "gnus/nnnil.el" "gnus/nnoo.el" "gnus/nnregistry.el" "gnus/nnrss.el"
+;;;;;;  "gnus/nnspool.el" "gnus/nntp.el" "gnus/nnvirtual.el" "gnus/nnweb.el"
+;;;;;;  "gnus/registry.el" "gnus/rfc1843.el" "gnus/rfc2045.el" "gnus/rfc2047.el"
+;;;;;;  "gnus/rfc2104.el" "gnus/rfc2231.el" "gnus/rtree.el" "gnus/shr-color.el"
+;;;;;;  "gnus/sieve-manage.el" "gnus/smime.el" "gnus/spam-stat.el"
+;;;;;;  "gnus/spam-wash.el" "hex-util.el" "hfy-cmap.el" "ibuf-ext.el"
+;;;;;;  "international/cp51932.el" "international/eucjp-ms.el" "international/fontset.el"
+;;;;;;  "international/iso-ascii.el" "international/ja-dic-cnv.el"
 ;;;;;;  "international/ja-dic-utl.el" "international/ogonek.el" "international/uni-bidi.el"
 ;;;;;;  "international/uni-category.el" "international/uni-combining.el"
 ;;;;;;  "international/uni-comment.el" "international/uni-decimal.el"
@@ -32427,8 +32398,8 @@ Zone out, completely.
 ;;;;;;  "vc/ediff-ptch.el" "vc/ediff-vers.el" "vc/ediff-wind.el"
 ;;;;;;  "vc/pcvs-info.el" "vc/pcvs-parse.el" "vc/pcvs-util.el" "vc/vc-dav.el"
 ;;;;;;  "vcursor.el" "vt-control.el" "vt100-led.el" "w32-common-fns.el"
-;;;;;;  "w32-fns.el" "w32-vars.el" "x-dnd.el") (20864 60345 274595
-;;;;;;  113000))
+;;;;;;  "w32-fns.el" "w32-vars.el" "x-dnd.el") (20905 51795 339257
+;;;;;;  114000))
 
 ;;;***
 
diff --git a/lisp/loadup.el b/lisp/loadup.el
index 5764cdec7eb..7fb9526b360 100644
--- a/lisp/loadup.el
+++ b/lisp/loadup.el
@@ -210,6 +210,7 @@
 (load "textmodes/page")
 (load "register")
 (load "textmodes/paragraphs")
+(load "progmodes/prog-mode")
 (load "emacs-lisp/lisp-mode")
 (load "textmodes/text-mode")
 (load "textmodes/fill")
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index a5d79a415f6..8bcf3afae05 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -1796,6 +1796,14 @@ exit."
   (cl-assert (<= start (point)) (<= (point) end))
   (funcall completion-in-region-function start end collection predicate))
 
+(defcustom read-file-name-completion-ignore-case
+  (if (memq system-type '(ms-dos windows-nt darwin cygwin))
+      t nil)
+  "Non-nil means when reading a file name completion ignores case."
+  :group 'minibuffer
+  :type 'boolean
+  :version "22.1")
+
 (defun completion--in-region (start end collection &optional predicate)
   (with-wrapper-hook
       ;; FIXME: Maybe we should use this hook to provide a "display
@@ -2268,14 +2276,6 @@ except that it passes the file name through `substitute-in-file-name'.")
   "The function called by `read-file-name' to do its work.
 It should accept the same arguments as `read-file-name'.")
 
-(defcustom read-file-name-completion-ignore-case
-  (if (memq system-type '(ms-dos windows-nt darwin cygwin))
-      t nil)
-  "Non-nil means when reading a file name completion ignores case."
-  :group 'minibuffer
-  :type 'boolean
-  :version "22.1")
-
 (defcustom insert-default-directory t
   "Non-nil means when reading a filename start with default dir in minibuffer.
 
diff --git a/lisp/net/net-utils.el b/lisp/net/net-utils.el
index 9a6c7b124c7..810d8963ce2 100644
--- a/lisp/net/net-utils.el
+++ b/lisp/net/net-utils.el
@@ -497,7 +497,7 @@ If your system's ping continues until interrupted, you can try setting
 
 (defvar nslookup-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\t" 'completion-at-point)
     map))
 
 ;; Using a derived mode gives us keymaps, hooks, etc.
@@ -567,7 +567,7 @@ If your system's ping continues until interrupted, you can try setting
 (defvar ftp-mode-map
   (let ((map (make-sparse-keymap)))
     ;; Occasionally useful
-    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\t" 'completion-at-point)
     map))
 
 (define-derived-mode ftp-mode comint-mode "FTP"
diff --git a/lisp/net/rlogin.el b/lisp/net/rlogin.el
index 9ad79d694f8..e8d13254557 100644
--- a/lisp/net/rlogin.el
+++ b/lisp/net/rlogin.el
@@ -36,6 +36,11 @@
 
 ;;; Code:
 
+;; FIXME?
+;; Maybe this file should be obsolete.
+;; http://lists.gnu.org/archive/html/emacs-devel/2013-02/msg00517.html
+;; It only adds rlogin-directory-tracking-mode.  Is that useful?
+
 (require 'comint)
 (require 'shell)
 
@@ -44,13 +49,15 @@
   :group 'processes
   :group 'unix)
 
-(defcustom rlogin-program "rlogin"
-  "Name of program to invoke rlogin"
+(defcustom rlogin-program "ssh"
+  "Name of program to invoke remote login."
+  :version "24.4"                       ; rlogin -> ssh
   :type 'string
   :group 'rlogin)
 
-(defcustom rlogin-explicit-args nil
-  "List of arguments to pass to rlogin on the command line."
+(defcustom rlogin-explicit-args '("-t" "-t")
+  "List of arguments to pass to `rlogin-program' on the command line."
+  :version "24.4"                       ; nil -> -t -t
   :type '(repeat (string :tag "Argument"))
   :group 'rlogin)
 
@@ -62,13 +69,15 @@
 (defcustom rlogin-process-connection-type
   ;; Solaris 2.x `rlogin' will spew a bunch of ioctl error messages if
   ;; stdin isn't a tty.
-  (and (string-match-p "-solaris2" system-configuration) t)
+  (and (string-match "rlogin" rlogin-program)
+       (string-match-p "-solaris2" system-configuration) t)
   "If non-nil, use a pty for the local rlogin process.
 If nil, use a pipe (if pipes are supported on the local system).
 
 Generally it is better not to waste ptys on systems which have a static
 number of them.  On the other hand, some implementations of `rlogin' assume
 a pty is being used, and errors will result from using a pipe instead."
+  :set-after '(rlogin-program)
   :type '(choice (const :tag "pipes" nil)
                  (other :tag "ptys" t))
   :group 'rlogin)
@@ -98,7 +107,7 @@ re-synching of directories."
 (make-variable-buffer-local 'rlogin-directory-tracking-mode)
 
 (defcustom rlogin-host nil
-  "The name of the remote host.  This variable is buffer-local."
+  "The name of the default remote host.  This variable is buffer-local."
   :type '(choice (const nil) string)
   :group 'rlogin)
 
@@ -165,7 +174,9 @@ If you wish to change directory tracking styles during a session, use the
 function `rlogin-directory-tracking-mode' rather than simply setting the
 variable."
   (interactive (list
-                (read-from-minibuffer "rlogin arguments (hostname first): "
+                (read-from-minibuffer (format
+                                       "Arguments for `%s' (hostname first): "
+                                       (file-name-nondirectory rlogin-program))
                                       nil nil nil 'rlogin-history)
                 current-prefix-arg))
   (let* ((process-connection-type rlogin-process-connection-type)
@@ -297,7 +308,7 @@ local one share the same directories (e.g. through NFS)."
   "Complete file name if doing directory tracking, or just insert TAB."
   (interactive)
   (if rlogin-directory-tracking-mode
-      (comint-dynamic-complete)
+      (completion-at-point)
     (insert "\C-i")))
 
 (provide 'rlogin)
diff --git a/lisp/net/tls.el b/lisp/net/tls.el
index 7fc314ef088..3d8d8decf47 100644
--- a/lisp/net/tls.el
+++ b/lisp/net/tls.el
@@ -286,7 +286,10 @@ NOT trusted. Accept anyway? " host)))))
                              (format "Host name in certificate doesn't \
 match `%s'. Connect anyway? " host))))))
         (setq done nil)
-        (delete-process process)))
+        (delete-process process))
+      ;; Delete all the informational messages that could confuse
+      ;; future uses of `buffer'.
+      (delete-region (point-min) (point)))
     (message "Opening TLS connection to `%s'...%s"
              host (if done "done" "failed"))
     (when use-temp-buffer
diff --git a/lisp/newcomment.el b/lisp/newcomment.el
index e10b96f97f9..bcb5f721ae8 100644
--- a/lisp/newcomment.el
+++ b/lisp/newcomment.el
@@ -485,29 +485,27 @@ and raises an error or returns nil if NOERROR is non-nil."
 Moves point to inside the comment and returns the position of the
 comment-starter.  If no comment is found, moves point to LIMIT
 and raises an error or returns nil if NOERROR is non-nil."
-  (let (found end)
-    (while (and (not found)
-                (re-search-backward comment-start-skip limit t))
-      (setq end (match-end 0))
-      (unless (and comment-use-syntax
-                   (nth 8 (syntax-ppss (or (match-end 1)
-                                           (match-beginning 0)))))
-        (setq found t)))
-    (if (not found)
-        (unless noerror (error "No comment"))
-      (beginning-of-line)
-      (let ((cs (comment-search-forward end t))
-            (pt (point)))
-        (if (not cs)
-            (progn (beginning-of-line)
-                   (comment-search-backward limit noerror))
-          (while (progn (goto-char cs)
-                        (comment-forward)
-                        (and (< (point) end)
-                             (setq cs (comment-search-forward end t))))
-            (setq pt (point)))
-          (goto-char pt)
-          cs)))))
+  ;; FIXME: If a comment-start appears inside a comment, we may erroneously
+  ;; stop there.  This can be rather bad in general, but since
+  ;; comment-search-backward is only used to find the comment-column (in
+  ;; comment-set-column) and to find the comment-start string (via
+  ;; comment-beginning) in indent-new-comment-line, it should be harmless.
+  (if (not (re-search-backward comment-start-skip limit t))
+      (unless noerror (error "No comment"))
+    (beginning-of-line)
+    (let* ((end (match-end 0))
+           (cs (comment-search-forward end t))
+           (pt (point)))
+      (if (not cs)
+          (progn (beginning-of-line)
+                 (comment-search-backward limit noerror))
+        (while (progn (goto-char cs)
+                      (comment-forward)
+                      (and (< (point) end)
+                           (setq cs (comment-search-forward end t))))
+          (setq pt (point)))
+        (goto-char pt)
+        cs))))
 
 (defun comment-beginning ()
   "Find the beginning of the enclosing comment.
diff --git a/lisp/obsolete/sym-comp.el b/lisp/obsolete/sym-comp.el
index 4641ca68544..bd049b85aa2 100644
--- a/lisp/obsolete/sym-comp.el
+++ b/lisp/obsolete/sym-comp.el
@@ -139,12 +139,13 @@ to be set buffer-locally.  Variables `symbol-completion-symbol-function',
                                pattern))
          ;; In case the transform needs to access it.
          (symbol-completion-predicate predicate)
-         (completion-annotate-function
+         (completion-extra-properties
           (if (functionp symbol-completion-transform-function)
-              (lambda (str)
-                (car-safe (cdr-safe
-                           (funcall symbol-completion-transform-function
-                                    str)))))))
+              '(:annotation-function
+                (lambda (str)
+                  (car-safe (cdr-safe
+                             (funcall symbol-completion-transform-function
+                                      str))))))))
     (completion-in-region (- (point) (length pattern)) (point)
                           completions predicate)))
 
diff --git a/lisp/paren.el b/lisp/paren.el
index a9d3be60622..6f386573b01 100644
--- a/lisp/paren.el
+++ b/lisp/paren.el
@@ -37,11 +37,6 @@
   :prefix "show-paren-"
   :group 'paren-matching)
 
-;; This is the overlay used to highlight the matching paren.
-(defvar show-paren-overlay nil)
-;; This is the overlay used to highlight the closeparen right before point.
-(defvar show-paren-overlay-1 nil)
-
 (defcustom show-paren-style 'parenthesis
   "Style used when showing a matching paren.
 Valid styles are `parenthesis' (meaning show the matching paren),
@@ -107,7 +102,14 @@ active, you must toggle the mode off and on again for this to take effect."
 (defvar show-paren-highlight-openparen t
   "Non-nil turns on openparen highlighting when matching forward.")
 
-(defvar show-paren-idle-timer nil)
+(defvar show-paren--idle-timer nil)
+(defvar show-paren--overlay
+  (let ((ol (make-overlay (point) (point) nil t))) (delete-overlay ol) ol)
+  "Overlay used to highlight the matching paren.")
+(defvar show-paren--overlay-1
+  (let ((ol (make-overlay (point) (point) nil t))) (delete-overlay ol) ol)
+  "Overlay used to highlight the paren at point.")
+
 
 ;;;###autoload
 (define-minor-mode show-paren-mode
@@ -120,154 +122,148 @@ Show Paren mode is a global minor mode.  When enabled, any
 matching parenthesis is highlighted in `show-paren-style' after
 `show-paren-delay' seconds of Emacs idle time."
   :global t :group 'paren-showing
-    ;; Enable or disable the mechanism.
-    ;; First get rid of the old idle timer.
-    (if show-paren-idle-timer
-        (cancel-timer show-paren-idle-timer))
-    (setq show-paren-idle-timer nil)
-    ;; If show-paren-mode is enabled in some buffer now,
-    ;; set up a new timer.
-    (when (memq t (mapcar (lambda (buffer)
-                            (with-current-buffer buffer
-                              show-paren-mode))
-                          (buffer-list)))
-      (setq show-paren-idle-timer (run-with-idle-timer
-                                   show-paren-delay t
-                                   'show-paren-function)))
-    (unless show-paren-mode
-      (and show-paren-overlay
-           (eq (overlay-buffer show-paren-overlay) (current-buffer))
-           (delete-overlay show-paren-overlay))
-      (and show-paren-overlay-1
-           (eq (overlay-buffer show-paren-overlay-1) (current-buffer))
-           (delete-overlay show-paren-overlay-1))))
+  ;; Enable or disable the mechanism.
+  ;; First get rid of the old idle timer.
+  (when show-paren--idle-timer
+    (cancel-timer show-paren--idle-timer)
+    (setq show-paren--idle-timer nil))
+  (setq show-paren--idle-timer (run-with-idle-timer
+                                show-paren-delay t
+                                #'show-paren-function))
+  (unless show-paren-mode
+    (delete-overlay show-paren--overlay)
+    (delete-overlay show-paren--overlay-1)))
+
+(defvar show-paren-data-function #'show-paren--default
+  "Function to find the opener/closer at point and its match.
+The function is called with no argument and should return either nil
+if there's no opener/closer at point, or a list of the form
+\(HERE-BEG HERE-END THERE-BEG THERE-END MISMATCH)
+Where HERE-BEG..HERE-END is expected to be around point.")
+
+(defun show-paren--default ()
+  (let* ((oldpos (point))
+         (dir (cond ((eq (syntax-class (syntax-after (1- (point)))) 5) -1)
+                    ((eq (syntax-class (syntax-after (point)))      4) 1)))
+         (unescaped
+          (when dir
+            ;; Verify an even number of quoting characters precede the paren.
+            ;; Follow the same logic as in `blink-matching-open'.
+            (= (if (= dir -1) 1 0)
+               (logand 1 (- (point)
+                            (save-excursion
+                              (if (= dir -1) (forward-char -1))
+                              (skip-syntax-backward "/\\")
+                              (point)))))))
+         (here-beg (if (eq dir 1) (point) (1- (point))))
+         (here-end (if (eq dir 1) (1+ (point)) (point)))
+         pos mismatch)
+    ;;
+    ;; Find the other end of the sexp.
+    (when unescaped
+      (save-excursion
+        (save-restriction
+          ;; Determine the range within which to look for a match.
+          (when blink-matching-paren-distance
+            (narrow-to-region
+             (max (point-min) (- (point) blink-matching-paren-distance))
+             (min (point-max) (+ (point) blink-matching-paren-distance))))
+          ;; Scan across one sexp within that range.
+          ;; Errors or nil mean there is a mismatch.
+          (condition-case ()
+              (setq pos (scan-sexps (point) dir))
+            (error (setq pos t mismatch t)))
+          ;; Move back the other way and verify we get back to the
+          ;; starting point.  If not, these two parens don't really match.
+          ;; Maybe the one at point is escaped and doesn't really count,
+          ;; or one is inside a comment.
+          (when (integerp pos)
+            (unless (condition-case ()
+                        (eq (point) (scan-sexps pos (- dir)))
+                      (error nil))
+              (setq pos nil)))
+          ;; If found a "matching" paren, see if it is the right
+          ;; kind of paren to match the one we started at.
+          (if (not (integerp pos))
+              (if mismatch (list here-beg here-end nil nil t))
+            (let ((beg (min pos oldpos)) (end (max pos oldpos)))
+              (unless (eq (syntax-class (syntax-after beg)) 8)
+                (setq mismatch
+                      (not (or (eq (char-before end)
+                                   ;; This can give nil.
+                                   (cdr (syntax-after beg)))
+                               (eq (char-after beg)
+                                   ;; This can give nil.
+                                   (cdr (syntax-after (1- end))))
+                               ;; The cdr might hold a new paren-class
+                               ;; info rather than a matching-char info,
+                               ;; in which case the two CDRs should match.
+                               (eq (cdr (syntax-after (1- end)))
+                                   (cdr (syntax-after beg)))))))
+              (list here-beg here-end
+                    (if (= dir 1) (1- pos) pos)
+                    (if (= dir 1) pos (1+ pos))
+                    mismatch))))))))
 
 ;; Find the place to show, if there is one,
 ;; and show it until input arrives.
 (defun show-paren-function ()
-  (if show-paren-mode
-      (let* ((oldpos (point))
-             (dir (cond ((eq (syntax-class (syntax-after (1- (point)))) 5) -1)
-                        ((eq (syntax-class (syntax-after (point)))      4) 1)))
-             (unescaped
-              (when dir
-                ;; Verify an even number of quoting characters precede the paren.
-                ;; Follow the same logic as in `blink-matching-open'.
-                (= (if (= dir -1) 1 0)
-                   (logand 1 (- (point)
-                                (save-excursion
-                                  (if (= dir -1) (forward-char -1))
-                                  (skip-syntax-backward "/\\")
-                                  (point)))))))
-             pos mismatch face)
-        ;;
-        ;; Find the other end of the sexp.
-        (when unescaped
-          (save-excursion
-            (save-restriction
-              ;; Determine the range within which to look for a match.
-              (when blink-matching-paren-distance
-                (narrow-to-region
-                 (max (point-min) (- (point) blink-matching-paren-distance))
-                 (min (point-max) (+ (point) blink-matching-paren-distance))))
-              ;; Scan across one sexp within that range.
-              ;; Errors or nil mean there is a mismatch.
-              (condition-case ()
-                  (setq pos (scan-sexps (point) dir))
-                (error (setq pos t mismatch t)))
-              ;; Move back the other way and verify we get back to the
-              ;; starting point.  If not, these two parens don't really match.
-              ;; Maybe the one at point is escaped and doesn't really count.
-              (when (integerp pos)
-                (unless (condition-case ()
-                            (eq (point) (scan-sexps pos (- dir)))
-                          (error nil))
-                  (setq pos nil)))
-              ;; If found a "matching" paren, see if it is the right
-              ;; kind of paren to match the one we started at.
-              (when (integerp pos)
-                (let ((beg (min pos oldpos)) (end (max pos oldpos)))
-                  (unless (eq (syntax-class (syntax-after beg)) 8)
-                    (setq mismatch
-                          (not (or (eq (char-before end)
-                                       ;; This can give nil.
-                                       (cdr (syntax-after beg)))
-                                   (eq (char-after beg)
-                                       ;; This can give nil.
-                                       (cdr (syntax-after (1- end))))
-                                   ;; The cdr might hold a new paren-class
-                                   ;; info rather than a matching-char info,
-                                   ;; in which case the two CDRs should match.
-                                   (eq (cdr (syntax-after (1- end)))
-                                       (cdr (syntax-after beg))))))))))))
-        ;;
-        ;; Highlight the other end of the sexp, or unhighlight if none.
-        (if (not pos)
-            (progn
-              ;; If not at a paren that has a match,
-              ;; turn off any previous paren highlighting.
-              (and show-paren-overlay (overlay-buffer show-paren-overlay)
-                   (delete-overlay show-paren-overlay))
-              (and show-paren-overlay-1 (overlay-buffer show-paren-overlay-1)
-                   (delete-overlay show-paren-overlay-1)))
-          ;;
-          ;; Use the correct face.
-          (if mismatch
-              (progn
-                (if show-paren-ring-bell-on-mismatch
-                    (beep))
-                (setq face 'show-paren-mismatch))
-            (setq face 'show-paren-match))
-          ;;
-          ;; If matching backwards, highlight the closeparen
-          ;; before point as well as its matching open.
-          ;; If matching forward, and the openparen is unbalanced,
-          ;; highlight the paren at point to indicate misbalance.
-          ;; Otherwise, turn off any such highlighting.
-          (if (and (not show-paren-highlight-openparen) (= dir 1) (integerp pos))
-              (when (and show-paren-overlay-1
-                         (overlay-buffer show-paren-overlay-1))
-                (delete-overlay show-paren-overlay-1))
-            (let ((from (if (= dir 1)
-                            (point)
-                          (- (point) 1)))
-                  (to (if (= dir 1)
-                          (+ (point) 1)
-                        (point))))
-              (if show-paren-overlay-1
-                  (move-overlay show-paren-overlay-1 from to (current-buffer))
-                (setq show-paren-overlay-1 (make-overlay from to nil t)))
-              ;; Always set the overlay face, since it varies.
-              (overlay-put show-paren-overlay-1 'priority show-paren-priority)
-              (overlay-put show-paren-overlay-1 'face face)))
-          ;;
-          ;; Turn on highlighting for the matching paren, if found.
-          ;; If it's an unmatched paren, turn off any such highlighting.
-          (if (not (integerp pos))
-              (when show-paren-overlay (delete-overlay show-paren-overlay))
-            (let ((to (if (or (eq show-paren-style 'expression)
-                              (and (eq show-paren-style 'mixed)
-                                   (not (pos-visible-in-window-p pos))))
-                          (point)
-                        pos))
-                  (from (if (or (eq show-paren-style 'expression)
-                                (and (eq show-paren-style 'mixed)
-                                     (not (pos-visible-in-window-p pos))))
-                            pos
-                          (save-excursion
-                            (goto-char pos)
-                            (- (point) dir)))))
-              (if show-paren-overlay
-                  (move-overlay show-paren-overlay from to (current-buffer))
-                (setq show-paren-overlay (make-overlay from to nil t))))
-            ;; Always set the overlay face, since it varies.
-            (overlay-put show-paren-overlay 'priority show-paren-priority)
-            (overlay-put show-paren-overlay 'face face))))
-    ;; show-paren-mode is nil in this buffer.
-    (and show-paren-overlay
-         (delete-overlay show-paren-overlay))
-    (and show-paren-overlay-1
-         (delete-overlay show-paren-overlay-1))))
+  (let ((data (and show-paren-mode (funcall show-paren-data-function))))
+    (if (not data)
+        (progn
+          ;; If show-paren-mode is nil in this buffer or if not at a paren that
+          ;; has a match, turn off any previous paren highlighting.
+          (delete-overlay show-paren--overlay)
+          (delete-overlay show-paren--overlay-1))
+
+      ;; Found something to highlight.
+      (let* ((here-beg (nth 0 data))
+             (here-end (nth 1 data))
+             (there-beg (nth 2 data))
+             (there-end (nth 3 data))
+             (mismatch (nth 4 data))
+             (face
+              (if mismatch
+                  (progn
+                    (if show-paren-ring-bell-on-mismatch
+                        (beep))
+                    'show-paren-mismatch)
+                'show-paren-match)))
+        ;;
+        ;; If matching backwards, highlight the closeparen
+        ;; before point as well as its matching open.
+        ;; If matching forward, and the openparen is unbalanced,
+        ;; highlight the paren at point to indicate misbalance.
+        ;; Otherwise, turn off any such highlighting.
+        (if (or (not here-beg)
+                (and (not show-paren-highlight-openparen)
+                     (> here-end (point))
+                     (integerp there-beg)))
+            (delete-overlay show-paren--overlay-1)
+          (move-overlay show-paren--overlay-1
+                        here-beg here-end (current-buffer))
+          ;; Always set the overlay face, since it varies.
+          (overlay-put show-paren--overlay-1 'priority show-paren-priority)
+          (overlay-put show-paren--overlay-1 'face face))
+        ;;
+        ;; Turn on highlighting for the matching paren, if found.
+        ;; If it's an unmatched paren, turn off any such highlighting.
+        (if (not there-beg)
+            (delete-overlay show-paren--overlay)
+          (if (or (eq show-paren-style 'expression)
+                  (and (eq show-paren-style 'mixed)
+                       (let ((closest (if (< there-beg here-beg)
+                                          (1- there-end) (1+ there-beg))))
+                         (not (pos-visible-in-window-p closest)))))
+              (move-overlay show-paren--overlay
+                            (point)
+                            (if (< there-beg here-beg) there-beg there-end)
+                            (current-buffer))
+            (move-overlay show-paren--overlay
+                          there-beg there-end (current-buffer)))
+          ;; Always set the overlay face, since it varies.
+          (overlay-put show-paren--overlay 'priority show-paren-priority)
+          (overlay-put show-paren--overlay 'face face))))))
 
 (provide 'paren)
 
diff --git a/lisp/pcmpl-gnu.el b/lisp/pcmpl-gnu.el
index 91b146fdc78..fb31984facc 100644
--- a/lisp/pcmpl-gnu.el
+++ b/lisp/pcmpl-gnu.el
@@ -158,7 +158,8 @@
   "Completion for the GNU tar utility."
   ;; options that end in an equal sign will want further completion...
   (let (saw-option complete-within)
-    (let ((pcomplete-suffix-list (cons ?= pcomplete-suffix-list)))
+    (let ((pcomplete-suffix-list (if (boundp 'pcomplete-suffix-list)
+                                     (cons ?= pcomplete-suffix-list))))
       (while (pcomplete-match "^-" 0)
         (setq saw-option t)
         (if (pcomplete-match "^--" 0)
diff --git a/lisp/progmodes/cc-bytecomp.el b/lisp/progmodes/cc-bytecomp.el
index e41455f7883..337a5292417 100644
--- a/lisp/progmodes/cc-bytecomp.el
+++ b/lisp/progmodes/cc-bytecomp.el
@@ -232,6 +232,9 @@ perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere"))
           (cc-bytecomp-setup-environment)
           t))))
 
+(defvar cc-bytecomp-noruntime-functions nil
+  "Saved value of `byte-compile-noruntime-functions'.")
+
 (defmacro cc-require (cc-part)
   "Force loading of the corresponding .el file in the current directory
 during compilation, but compile in a `require'.  Don't use within
@@ -240,7 +243,16 @@ during compilation, but compile in a `require'.  Don't use within
 Having cyclic cc-require's will result in infinite recursion.  That's
 somewhat intentional."
   `(progn
-     (eval-when-compile (cc-bytecomp-load (symbol-name ,cc-part)))
+     (eval-when-compile
+       (setq cc-bytecomp-noruntime-functions byte-compile-noruntime-functions)
+       (cc-bytecomp-load (symbol-name ,cc-part)))
+     ;; Hack to suppress spurious "might not be defined at runtime" warnings.
+     ;; The basic issue is that
+     ;;   (eval-when-compile (require 'foo))
+     ;;   (require 'foo)
+     ;; produces bogus noruntime warnings about functions from foo.
+     (eval-when-compile
+       (setq byte-compile-noruntime-functions cc-bytecomp-noruntime-functions))
      (require ,cc-part)))
 
 (defmacro cc-provide (feature)
@@ -266,7 +278,7 @@ somewhat intentional."
 during compilation, but do a compile time `require' otherwise.  Don't
 use within `eval-when-compile'."
   `(eval-when-compile
-     (if (and (featurep 'cc-bytecomp)
+     (if (and (fboundp 'cc-bytecomp-is-compiling)
               (cc-bytecomp-is-compiling))
          (if (or (not load-in-progress)
                  (not (featurep ,cc-part)))
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 0bb804799dc..dc6ed1348d1 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -45,7 +45,6 @@
 (cc-require 'cc-engine)
 
 ;; Silence the compiler.
-(cc-bytecomp-defun delete-forward-p)    ; XEmacs
 (cc-bytecomp-defvar filladapt-mode)     ; c-fill-paragraph contains a kludge
                                         ; which looks at this.
 
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index e7f96767675..b90a01dcb3b 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -48,16 +48,12 @@
 
 ;; Silence the compiler.
 (cc-bytecomp-defvar c-enable-xemacs-performance-kludge-p) ; In cc-vars.el
-(cc-bytecomp-defun buffer-syntactic-context-depth) ; XEmacs
 (cc-bytecomp-defun region-active-p)     ; XEmacs
-(cc-bytecomp-defvar zmacs-region-stays) ; XEmacs
-(cc-bytecomp-defvar zmacs-regions)      ; XEmacs
 (cc-bytecomp-defvar mark-active)        ; Emacs
 (cc-bytecomp-defvar deactivate-mark)    ; Emacs
 (cc-bytecomp-defvar inhibit-point-motion-hooks) ; Emacs
 (cc-bytecomp-defvar parse-sexp-lookup-properties) ; Emacs
 (cc-bytecomp-defvar text-property-default-nonsticky) ; Emacs 21
-(cc-bytecomp-defvar lookup-syntax-properties) ; XEmacs
 (cc-bytecomp-defun string-to-syntax)    ; Emacs 21
 
 
@@ -334,6 +330,8 @@ to it is returned.  This function does not modify the point or the mark."
 (defmacro c-region-is-active-p ()
   ;; Return t when the region is active.  The determination of region
   ;; activeness is different in both Emacs and XEmacs.
+  ;; FIXME? Emacs has region-active-p since 23.1, so maybe this test
+  ;; should be updated.
   (if (cc-bytecomp-boundp 'mark-active)
       ;; Emacs.
       'mark-active
@@ -343,7 +341,7 @@ to it is returned.  This function does not modify the point or the mark."
 (defmacro c-set-region-active (activate)
   ;; Activate the region if ACTIVE is non-nil, deactivate it
   ;; otherwise.  Covers the differences between Emacs and XEmacs.
-  (if (cc-bytecomp-fboundp 'zmacs-activate-region)
+  (if (fboundp 'zmacs-activate-region)
       ;; XEmacs.
       `(if ,activate
            (zmacs-activate-region)
@@ -707,9 +705,9 @@ be after it."
   ;; `c-parse-state'.
 
   `(progn
-     (if (and ,(cc-bytecomp-fboundp 'buffer-syntactic-context-depth)
+     (if (and ,(fboundp 'buffer-syntactic-context-depth)
               c-enable-xemacs-performance-kludge-p)
-         ,(when (cc-bytecomp-fboundp 'buffer-syntactic-context-depth)
+         ,(when (fboundp 'buffer-syntactic-context-depth)
             ;; XEmacs only.  This can improve the performance of
             ;; c-parse-state to between 3 and 60 times faster when
             ;; braces are hung.  It can also degrade performance by
@@ -1606,7 +1604,7 @@ non-nil, a caret is prepended to invert the set."
     (let ((buf (generate-new-buffer " test"))
           parse-sexp-lookup-properties
           parse-sexp-ignore-comments
-          lookup-syntax-properties)
+          lookup-syntax-properties)     ; XEmacs
       (with-current-buffer buf
         (set-syntax-table (make-syntax-table))
 
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 6a23da1f2cd..9077bdbb513 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -147,9 +147,6 @@
 (cc-require-when-compile 'cc-langs)
 (cc-require 'cc-vars)
 
-;; Silence the compiler.
-(cc-bytecomp-defun buffer-syntactic-context) ; XEmacs
-
 
 ;; Make declarations for all the `c-lang-defvar' variables in cc-langs.
 
@@ -9358,10 +9355,6 @@ comment at the start of cc-engine.el for more info."
                           containing-sexp nil)))
               (setq lim (1+ containing-sexp))))
         (setq lim (point-min)))
-      (when (c-beginning-of-macro)
-        (goto-char indent-point)
-        (let ((lim1 (c-determine-limit 2000)))
-          (setq lim (max lim lim1))))
 
       ;; If we're in a parenthesis list then ',' delimits the
       ;; "statements" rather than being an operator (with the
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 83343b23014..6a4bfd9e875 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -176,7 +176,6 @@
       'font-lock-negation-char-face))
 
 (cc-bytecomp-defun face-inverse-video-p) ; Only in Emacs.
-(cc-bytecomp-defun face-property-instance) ; Only in XEmacs.
 
 (defun c-make-inverse-face (oldface newface)
   ;; Emacs and XEmacs have completely different face manipulation
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 746b75d962b..74818b7e1ea 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -86,8 +86,8 @@
     (load "cc-bytecomp" nil t)))
 
 (cc-require 'cc-defs)
-(cc-require-when-compile 'cc-langs)
 (cc-require 'cc-vars)
+(cc-require-when-compile 'cc-langs)
 (cc-require 'cc-engine)
 (cc-require 'cc-styles)
 (cc-require 'cc-cmds)
@@ -97,7 +97,6 @@
 
 ;; Silence the compiler.
 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
-(cc-bytecomp-defun set-keymap-parents)  ; XEmacs
 (cc-bytecomp-defun run-mode-hooks)      ; Emacs 21.1
 
 ;; We set these variables during mode init, yet we don't require
@@ -212,7 +211,7 @@ control).  See \"cc-mode.el\" for more info."
      ((cc-bytecomp-fboundp 'set-keymap-parent)
       (set-keymap-parent map c-mode-base-map))
      ;; XEmacs
-     ((cc-bytecomp-fboundp 'set-keymap-parents)
+     ((fboundp 'set-keymap-parents)
       (set-keymap-parents map c-mode-base-map))
      ;; incompatible
      (t (error "CC Mode is incompatible with this version of Emacs")))
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index f830cc7edc1..c89402c63a3 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -42,23 +42,25 @@
 
 (cc-require 'cc-defs)
 
-;; Silence the compiler.
-(cc-bytecomp-defun get-char-table)      ; XEmacs
-
 (cc-eval-when-compile
   (require 'custom)
   (require 'widget))
 
 ;;; Helpers
 
-;; This widget exists in newer versions of the Custom library
-(or (get 'other 'widget-type)
-    (define-widget 'other 'sexp
-      "Matches everything, but doesn't let the user edit the value.
+
+;; Emacs has 'other since at least version 21.1.
+;; FIXME this is probably broken, since the widget is defined
+;; in wid-edit, which this file does not load.  So we will always
+;; define the widget, even when we don't need to.
+(when (featurep 'xemacs)
+  (or (get 'other 'widget-type)
+      (define-widget 'other 'sexp
+        "Matches everything, but doesn't let the user edit the value.
 Useful as last item in a `choice' widget."
-      :tag "Other"
-      :format "%t%n"
-      :value 'other))
+        :tag "Other"
+        :format "%t%n"
+        :value 'other)))
 
 ;; The next defun will supersede c-const-symbol.
 (eval-and-compile
@@ -1645,6 +1647,7 @@ and is likely to disappear or change its form soon.")
   ;; `c-macro-with-semi-re' (or just copy it if it's already a re).
   (setq c-macro-with-semi-re
         (and
+         (boundp 'c-opt-cpp-macro-define)
          c-opt-cpp-macro-define
          (cond
           ((stringp c-macro-names-with-semicolon)
diff --git a/lisp/progmodes/cfengine.el b/lisp/progmodes/cfengine.el
index 11eb0eeaf49..01b5faef5b3 100644
--- a/lisp/progmodes/cfengine.el
+++ b/lisp/progmodes/cfengine.el
@@ -527,6 +527,11 @@ Intended as the value of `indent-line-function'."
   ;; Doze path separators.
   (modify-syntax-entry ?\\ "." table))
 
+(defconst cfengine3--prettify-symbols-alist
+  '(("->"  . ?→)
+    ("=>"  . ?⇒)
+    ("::" . ?∷)))
+
 ;;;###autoload
 (define-derived-mode cfengine3-mode prog-mode "CFE3"
   "Major mode for editing CFEngine3 input.
@@ -538,8 +543,11 @@ to the action header."
   (cfengine-common-syntax cfengine3-mode-syntax-table)
 
   (set (make-local-variable 'indent-line-function) #'cfengine3-indent-line)
+
   (setq font-lock-defaults
-        '(cfengine3-font-lock-keywords nil nil nil beginning-of-defun))
+        '(cfengine3-font-lock-keywords
+          nil nil nil beginning-of-defun))
+  (prog-prettify-install cfengine3--prettify-symbols-alist)
 
   ;; Use defuns as the essential syntax block.
   (set (make-local-variable 'beginning-of-defun-function)
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index d6f136ec92d..d9c482330cc 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -1002,7 +1002,7 @@ POS and RES.")
     (let ((win (get-buffer-window buffer 0)))
       (if win (set-window-point win pos)))
     (if compilation-auto-jump-to-first-error
-        (compile-goto-error))))
+        (compile-goto-error nil t))))
 
 ;; This function is the central driver, called when font-locking to gather
 ;; all information needed to later jump to corresponding source code.
@@ -2317,7 +2317,7 @@ Prefix arg N says how many files to move backwards (or forwards, if negative)."
 
 (defalias 'compile-mouse-goto-error 'compile-goto-error)
 
-(defun compile-goto-error (&optional event)
+(defun compile-goto-error (&optional event nomsg)
   "Visit the source for the error message at point.
 Use this command in a compilation log buffer.  Sets the mark at point there."
   (interactive (list last-input-event))
@@ -2328,7 +2328,7 @@ Use this command in a compilation log buffer.  Sets the mark at point there."
   (if (get-text-property (point) 'compilation-directory)
       (dired-other-window
        (car (get-text-property (point) 'compilation-directory)))
-    (push-mark)
+    (push-mark nil nomsg)
     (setq compilation-current-error (point))
     (next-error-internal)))
 
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index a6ad5736576..0b52302a98d 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -345,7 +345,7 @@ triggers in `gdb-handler-list'."
   `(run-with-timer
     0.5 nil
     '(lambda ()
-       (if (not (gdb-find-if (lambda (handler)
+       (if (not (cl-find-if (lambda (handler)
                                (gdb-handler-pending-trigger handler))
                              gdb-handler-list))
            (progn ,@body)
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
index bacd37b3d3c..b1936467274 100644
--- a/lisp/progmodes/octave.el
+++ b/lisp/progmodes/octave.el
@@ -89,7 +89,7 @@ Used in `octave-mode' and `inferior-octave-mode' buffers.")
 
 (defvar octave-function-header-regexp
   (concat "^\\s-*\\_<\\(function\\)\\_>"
-          "\\([^=;\n]*=[ \t]*\\|[ \t]*\\)\\(\\(?:\\w\\|\\s_\\)+\\)\\_>")
+          "\\([^=;(\n]*=[ \t]*\\|[ \t]*\\)\\(\\(?:\\w\\|\\s_\\)+\\)\\_>")
   "Regexp to match an Octave function header.
 The string `function' and its name are given by the first and third
 parenthetical grouping.")
@@ -153,10 +153,10 @@ parenthetical grouping.")
                                 'eldoc-mode))
      :style toggle :selected (or eldoc-post-insert-mode eldoc-mode)
      :help "Display function signatures after typing `SPC' or `('"]
-    ["Delimiter Matching"           smie-highlight-matching-block-mode
-     :style toggle :selected smie-highlight-matching-block-mode
+    ["Delimiter Matching"           show-paren-mode
+     :style toggle :selected show-paren-mode
      :help "Highlight matched pairs such as `if ... end'"
-     :visible (fboundp 'smie-highlight-matching-block-mode)]
+     :visible (fboundp 'smie--matching-block-data)]
     ["Auto Fill"                    auto-fill-mode
      :style toggle :selected auto-fill-function
      :help "Automatic line breaking"]
@@ -191,10 +191,9 @@ parenthetical grouping.")
     (modify-syntax-entry ?! "."   table)
     (modify-syntax-entry ?\\ "."  table)
     (modify-syntax-entry ?\' "."  table)
-    ;; Was "w" for abbrevs, but now that it's not necessary any more,
     (modify-syntax-entry ?\` "."  table)
+    (modify-syntax-entry ?. "."   table)
     (modify-syntax-entry ?\" "\"" table)
-    (modify-syntax-entry ?. "_"   table)
     (modify-syntax-entry ?_ "_"   table)
     ;; The "b" flag only applies to the second letter of the comstart
     ;; and the first letter of the comend, i.e. the "4b" below is ineffective.
@@ -541,6 +540,7 @@ definitions can also be stored in files and used in batch mode."
   ;; a ";" at those places where it's correct (i.e. outside of parens).
   (setq-local electric-layout-rules '((?\; . after)))
 
+  (setq-local comment-use-global-state t)
   (setq-local comment-start octave-comment-start)
   (setq-local comment-end "")
   (setq-local comment-start-skip octave-comment-start-skip)
@@ -564,6 +564,8 @@ definitions can also be stored in files and used in batch mode."
   (setq-local imenu-generic-expression octave-mode-imenu-generic-expression)
   (setq-local imenu-case-fold-search nil)
 
+  (setq-local add-log-current-defun-function #'octave-add-log-current-defun)
+
   (add-hook 'completion-at-point-functions 'octave-completion-at-point nil t)
   (add-hook 'before-save-hook 'octave-sync-function-file-names nil t)
   (setq-local beginning-of-defun-function 'octave-beginning-of-defun)
@@ -606,12 +608,13 @@ startup."
   :group 'octave
   :version "24.4")
 
-(defcustom inferior-octave-startup-args nil
+(defcustom inferior-octave-startup-args '("-i" "--no-line-editing")
   "List of command line arguments for the inferior Octave process.
 For example, for suppressing the startup message and using `traditional'
-mode, set this to (\"-q\" \"--traditional\")."
+mode, include \"-q\" and \"--traditional\"."
   :type '(repeat string)
-  :group 'octave)
+  :group 'octave
+  :version "24.4")
 
 (defcustom inferior-octave-mode-hook nil
   "Hook to be run when Inferior Octave mode is started."
@@ -665,6 +668,7 @@ in the Inferior Octave buffer.")
   :abbrev-table octave-abbrev-table
   (setq comint-prompt-regexp inferior-octave-prompt)
 
+  (setq-local comment-use-global-state t)
   (setq-local comment-start octave-comment-start)
   (setq-local comment-end "")
   (setq comment-column 32)
@@ -676,13 +680,16 @@ in the Inferior Octave buffer.")
   (setq-local eldoc-documentation-function 'octave-eldoc-function)
 
   (setq comint-input-ring-file-name
-        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
-        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
+        (or (getenv "OCTAVE_HISTFILE") "~/.octave_hist")
+        comint-input-ring-size (or (getenv "OCTAVE_HISTSIZE") 1024))
   (setq-local comint-dynamic-complete-functions
               inferior-octave-dynamic-complete-functions)
   (setq-local comint-prompt-read-only inferior-octave-prompt-read-only)
   (add-hook 'comint-input-filter-functions
             'inferior-octave-directory-tracker nil t)
+  ;; http://thread.gmane.org/gmane.comp.gnu.octave.general/48572
+  (add-hook 'window-configuration-change-hook
+            'inferior-octave-track-window-width-change nil t)
   (comint-read-input-ring t))
 
 ;;;###autoload
@@ -717,13 +724,13 @@ startup file, `~/.emacs-octave'."
                (substring inferior-octave-buffer 1 -1)
                inferior-octave-buffer
                inferior-octave-program
-               (append (list "-i" "--no-line-editing")
-                       ;; --no-gui is introduced in Octave > 3.7
-                       (when (zerop (process-file inferior-octave-program
-                                                  nil nil nil
-                                                  "--no-gui" "--help"))
-                         (list "--no-gui"))
-                       inferior-octave-startup-args))))
+               (append
+                inferior-octave-startup-args
+                ;; --no-gui is introduced in Octave > 3.7
+                (and (not (member "--no-gui" inferior-octave-startup-args))
+                     (zerop (process-file inferior-octave-program
+                                          nil nil nil "--no-gui" "--help"))
+                     '("--no-gui"))))))
     (set-process-filter proc 'inferior-octave-output-digest)
     (setq inferior-octave-process proc
           inferior-octave-output-list nil
@@ -753,10 +760,10 @@ startup file, `~/.emacs-octave'."
     (inferior-octave-send-list-and-digest (list "PS2\n"))
     (when (string-match "\\(PS2\\|ans\\) = *$"
                         (car inferior-octave-output-list))
-      (inferior-octave-send-list-and-digest (list "PS2 (\"> \");\n")))
+      (inferior-octave-send-list-and-digest (list "PS2 ('> ');\n")))
 
     (inferior-octave-send-list-and-digest
-     (list "disp(getenv(\"OCTAVE_SRCDIR\"))\n"))
+     (list "disp (getenv ('OCTAVE_SRCDIR'))\n"))
     (process-put proc 'octave-srcdir
                  (unless (equal (car inferior-octave-output-list) "")
                    (car inferior-octave-output-list)))
@@ -765,19 +772,19 @@ startup file, `~/.emacs-octave'."
     (inferior-octave-send-list-and-digest
      (list "more off;\n"
            (unless (equal inferior-octave-output-string ">> ")
-             "PS1 (\"\\\\s> \");\n")
+             "PS1 ('\\s> ');\n")
            (when (and inferior-octave-startup-file
                       (file-exists-p inferior-octave-startup-file))
-             (format "source (\"%s\");\n" inferior-octave-startup-file))))
+             (format "source ('%s');\n" inferior-octave-startup-file))))
     (when inferior-octave-output-list
       (insert-before-markers
        (mapconcat 'identity inferior-octave-output-list "\n")))
 
     ;; And finally, everything is back to normal.
     (set-process-filter proc 'comint-output-filter)
-    ;; Just in case, to be sure a cd in the startup file
-    ;; won't have detrimental effects.
-    (inferior-octave-resync-dirs)
+    ;; Just in case, to be sure a cd in the startup file won't have
+    ;; detrimental effects.
+    (with-demoted-errors (inferior-octave-resync-dirs))
     ;; Generate a proper prompt, which is critical to
     ;; `comint-history-isearch-backward-regexp'.  Bug#14433.
     (comint-send-string proc "\n")))
@@ -793,7 +800,7 @@ startup file, `~/.emacs-octave'."
        (unless (and (equal (car cache) command)
                     (< (float-time) (+ 5 (cadr cache))))
          (inferior-octave-send-list-and-digest
-          (list (concat "completion_matches (\"" command "\");\n")))
+          (list (format "completion_matches ('%s');\n" command)))
          (setq cache (list command (float-time)
                            (delete-consecutive-dups
                             (sort inferior-octave-output-list 'string-lessp)))))
@@ -892,8 +899,8 @@ output is passed to the filter `inferior-octave-output-digest'."
   "Tracks `cd' commands issued to the inferior Octave process.
 Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
   (when inferior-octave-directory-tracker-resync
-    (setq inferior-octave-directory-tracker-resync nil)
-    (inferior-octave-resync-dirs))
+    (or (inferior-octave-resync-dirs 'noerror)
+        (setq inferior-octave-directory-tracker-resync nil)))
   (cond
    ((string-match "^[ \t]*cd[ \t;]*$" string)
     (cd "~"))
@@ -905,13 +912,35 @@ Use \\[inferior-octave-resync-dirs] to resync if Emacs gets confused."
                       (error-message-string err)
                       (match-string 1 string)))))))
 
-(defun inferior-octave-resync-dirs ()
+(defun inferior-octave-resync-dirs (&optional noerror)
   "Resync the buffer's idea of the current directory.
 This command queries the inferior Octave process about its current
 directory and makes this the current buffer's default directory."
   (interactive)
   (inferior-octave-send-list-and-digest '("disp (pwd ())\n"))
-  (cd (car inferior-octave-output-list)))
+  (condition-case err
+      (progn
+        (cd (car inferior-octave-output-list))
+        t)
+    (error (unless noerror (signal (car err) (cdr err))))))
+
+(defcustom inferior-octave-minimal-columns 80
+  "The minimal column width for the inferior Octave process."
+  :type 'integer
+  :group 'octave
+  :version "24.4")
+
+(defvar inferior-octave-last-column-width nil)
+
+(defun inferior-octave-track-window-width-change ()
+  ;; http://thread.gmane.org/gmane.comp.gnu.octave.general/48572
+  (let ((width (max inferior-octave-minimal-columns (window-width))))
+    (unless (eq inferior-octave-last-column-width width)
+      (setq-local inferior-octave-last-column-width width)
+      (when (and inferior-octave-process
+                 (process-live-p inferior-octave-process))
+        (inferior-octave-send-list-and-digest
+         (list (format "putenv ('COLUMNS', '%s');\n" width)))))))
 
 
 ;;; Miscellaneous useful functions
@@ -955,16 +984,17 @@ directory and makes this the current buffer's default directory."
 
 (defun octave-goto-function-definition (fn)
   "Go to the function definition of FN in current buffer."
-  (goto-char (point-min))
   (let ((search
          (lambda (re sub)
-           (let (done)
-             (while (and (not done) (re-search-forward re nil t))
+           (let ((orig (point)) found)
+             (goto-char (point-min))
+             (while (and (not found) (re-search-forward re nil t))
                (when (and (equal (match-string sub) fn)
                           (not (nth 8 (syntax-ppss))))
-                 (setq done t)))
-             (or done (goto-char (point-min)))))))
-    (pcase (file-name-extension (buffer-file-name))
+                 (setq found t)))
+             (unless found (goto-char orig))
+             found))))
+    (pcase (and buffer-file-name (file-name-extension buffer-file-name))
       (`"cc" (funcall search
                       "\\_<DEFUN\\(?:_DLD\\)?\\s-*(\\s-*\\(\\(?:\\sw\\|\\s_\\)+\\)" 1))
       (t (funcall search octave-function-header-regexp 3)))))
@@ -1325,8 +1355,6 @@ The block marked is the one that contains point or follows point."
               (forward-line 1))))
       t)))
 
-;;; Completions
-
 (defun octave-completion-at-point ()
   "Find the text to complete and the corresponding table."
   (let* ((beg (save-excursion (skip-syntax-backward "w_") (point)))
@@ -1343,6 +1371,16 @@ The block marked is the one that contains point or follows point."
 
 (define-obsolete-function-alias 'octave-complete-symbol
   'completion-at-point "24.1")
+
+(defun octave-add-log-current-defun ()
+  "A function for `add-log-current-defun-function' (which see)."
+  (save-excursion
+    (end-of-line)
+    (and (beginning-of-defun)
+         (re-search-forward octave-function-header-regexp
+                            (line-end-position) t)
+         (match-string 3))))
+
 
 ;;; Electric characters && friends
 (define-skeleton octave-insert-defun
@@ -1367,7 +1405,7 @@ entered without parens)."
   "function " > str \n
   _ \n
   "endfunction" > \n)
-
+
 ;;; Communication with the inferior Octave process
 (defun octave-kill-process ()
   "Kill inferior Octave process and its buffer."
@@ -1486,9 +1524,7 @@ code line."
 (defun octave-eldoc-function-signatures (fn)
   (unless (equal fn (car octave-eldoc-cache))
     (inferior-octave-send-list-and-digest
-     (list (format "\
-if ismember(exist(\"%s\"), [2 3 5 103]) print_usage(\"%s\") endif\n"
-                   fn fn)))
+     (list (format "print_usage ('%s');\n" fn)))
     (let (result)
       (dolist (line inferior-octave-output-list)
         (when (string-match
@@ -1585,20 +1621,11 @@ if ismember(exist(\"%s\"), [2 3 5 103]) print_usage(\"%s\") endif\n"
     (when (or help-xref-stack help-xref-forward-stack)
       (insert "\n"))))
 
-(defvar octave-help-mode-finish-hook nil
-  "Octave specific hook for `temp-buffer-show-hook'.")
-
-(defun octave-help-mode-finish ()
-  (when (eq major-mode 'octave-help-mode)
-    (run-hooks 'octave-help-mode-finish-hook)))
-
-(add-hook 'temp-buffer-show-hook 'octave-help-mode-finish)
-
 (defun octave-help (fn)
   "Display the documentation of FN."
   (interactive (list (octave-completing-read)))
   (inferior-octave-send-list-and-digest
-   (list (format "help \"%s\"\n" fn)))
+   (list (format "help ('%s');\n" fn)))
   (let ((lines inferior-octave-output-list)
         (inhibit-read-only t))
     (when (string-match "error: \\(.*\\)$" (car lines))
@@ -1634,16 +1661,15 @@ if ismember(exist(\"%s\"), [2 3 5 103]) print_usage(\"%s\") endif\n"
             (help-insert-xref-button (file-relative-name file dir)
                                      'octave-help-file fn)
             (insert "'")))
-        ;; Make 'See also' clickable
+        ;; Make 'See also' clickable.
         (with-syntax-table octave-mode-syntax-table
           (when (re-search-forward "^\\s-*See also:" nil t)
             (let ((end (save-excursion (re-search-forward "^\\s-*$" nil t))))
-              (while (re-search-forward "\\_<\\(?:\\sw\\|\\s_\\)+\\_>" end t)
-                (make-text-button (match-beginning 0)
-                                  ;; If the match ends with . exclude it.
-                                  (if (eq (char-before (match-end 0)) ?.)
-                                      (1- (match-end 0))
-                                    (match-end 0))
+              (while (re-search-forward
+                      ;; Match operators and symbols.
+                      "\\(?1:\\s.+?\\)\\(?:$\\|[,;]\\|\\s-\\)\\|\\_<\\(?1:\\(?:\\sw\\|\\s_\\)+\\)\\_>"
+                      end t)
+                (make-text-button (match-beginning 1) (match-end 1)
                                   :type 'octave-help-function)))))
         (octave-help-mode)))))
 
@@ -1694,23 +1720,30 @@ If the environment variable OCTAVE_SRCDIR is set, it is searched first."
 Functions implemented in C++ can be found if
 `octave-source-directories' is set correctly."
   (interactive (list (octave-completing-read)))
-  (inferior-octave-send-list-and-digest
-   ;; help NAME is more verbose
-   (list (format "\
-if iskeyword(\"%s\") disp(\"`%s' is a keyword\") else which(\"%s\") endif\n"
-                 fn fn fn)))
-  (let* ((line (car inferior-octave-output-list))
-         (file (when (and line (string-match "from the file \\(.*\\)$" line))
-                 (match-string 1 line))))
-    (if (not file)
-        (user-error "%s" (or line (format "`%s' not found" fn)))
-      (require 'etags)
-      (ring-insert find-tag-marker-ring (point-marker))
-      (setq file (funcall octave-find-definition-filename-function file))
-      (when file
-        (find-file file)
-        (octave-goto-function-definition fn)))))
-
+  (require 'etags)
+  (let ((orig (point)))
+    (if (and (derived-mode-p 'octave-mode)
+             (octave-goto-function-definition fn))
+        (ring-insert find-tag-marker-ring (copy-marker orig))
+      (inferior-octave-send-list-and-digest
+       ;; help NAME is more verbose
+       (list (format "\
+if iskeyword('%s') disp('`%s'' is a keyword') else which('%s') endif\n"
+                     fn fn fn)))
+      (let (line file)
+        ;; Skip garbage lines such as
+        ;;     warning: fmincg.m: possible Matlab-style ....
+        (while (and (not file) (consp inferior-octave-output-list))
+          (setq line (pop inferior-octave-output-list))
+          (when (string-match "from the file \\(.*\\)$" line)
+            (setq file (match-string 1 line))))
+        (if (not file)
+            (user-error "%s" (or line (format "`%s' not found" fn)))
+          (ring-insert find-tag-marker-ring (point-marker))
+          (setq file (funcall octave-find-definition-filename-function file))
+          (when file
+            (find-file file)
+            (octave-goto-function-definition fn)))))))
 
 (provide 'octave)
 ;;; octave.el ends here
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index 01ac8584e19..1d5052bede4 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -158,44 +158,10 @@
 ;; Regexps updated with help from Tom Tromey <tromey@cambric.colorado.edu> and
 ;; Jim Campbell <jec@murzim.ca.boeing.com>.
 
-(defcustom perl-prettify-symbols t
-  "If non-nil, some symbols will be displayed using Unicode chars."
-  :version "24.4"
-  :type 'boolean)
-
 (defconst perl--prettify-symbols-alist
-  '(;;("andalso" . ?∧) ("orelse"  . ?∨) ("as" . ?≡)("not" . ?¬)
-    ;;("div" . ?÷) ("*"   . ?×) ("o"   . ?○)
-    ("->"  . ?→)
+  '(("->"  . ?→)
     ("=>"  . ?⇒)
-    ;;("<-"  . ?←) ("<>"  . ?≠) (">="  . ?≥) ("<="  . ?≤) ("..." . ?⋯)
-    ("::" . ?∷)
-    ))
-
-(defun perl--font-lock-compose-symbol ()
-  "Compose a sequence of ascii chars into a symbol.
-Regexp match data 0 points to the chars."
-  ;; Check that the chars should really be composed into a symbol.
-  (let* ((start (match-beginning 0))
-         (end (match-end 0))
-         (syntaxes (if (eq (char-syntax (char-after start)) ?w)
-                       '(?w) '(?. ?\\))))
-    (if (or (memq (char-syntax (or (char-before start) ?\ )) syntaxes)
-            (memq (char-syntax (or (char-after end) ?\ )) syntaxes)
-            (nth 8 (syntax-ppss)))
-        ;; No composition for you.  Let's actually remove any composition
-        ;; we may have added earlier and which is now incorrect.
-        (remove-text-properties start end '(composition))
-      ;; That's a symbol alright, so add the composition.
-      (compose-region start end (cdr (assoc (match-string 0)
-                                            perl--prettify-symbols-alist)))))
-  ;; Return nil because we're not adding any face property.
-  nil)
-
-(defun perl--font-lock-symbols-keywords ()
-  (when perl-prettify-symbols
-    `((,(regexp-opt (mapcar 'car perl--prettify-symbols-alist) t)
-       (0 (perl--font-lock-compose-symbol))))))
+    ("::" . ?∷)))
 
 (defconst perl-font-lock-keywords-1
   '(;; What is this for?
@@ -243,8 +209,7 @@ Regexp match data 0 points to the chars."
      ;; Fontify keywords with/and labels as we do in `c++-font-lock-keywords'.
      ("\\<\\(continue\\|goto\\|last\\|next\\|redo\\)\\>[ \t]*\\(\\sw+\\)?"
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
-     ("^[ \t]*\\(\\sw+\\)[ \t]*:[^:]" 1 font-lock-constant-face)
-     ,@(perl--font-lock-symbols-keywords)))
+     ("^[ \t]*\\(\\sw+\\)[ \t]*:[^:]" 1 font-lock-constant-face)))
   "Gaudy level highlighting for Perl mode.")
 
 (defvar perl-font-lock-keywords perl-font-lock-keywords-1
@@ -685,13 +650,15 @@ Turning on Perl mode runs the normal hook `perl-mode-hook'."
   (setq-local comment-start-skip "\\(^\\|\\s-\\);?#+ *")
   (setq-local comment-indent-function #'perl-comment-indent)
   (setq-local parse-sexp-ignore-comments t)
+
   ;; Tell font-lock.el how to handle Perl.
   (setq font-lock-defaults '((perl-font-lock-keywords
-                              perl-font-lock-keywords-1
-                              perl-font-lock-keywords-2)
-                             nil nil ((?\_ . "w")) nil
+                              perl-font-lock-keywords-1
+                              perl-font-lock-keywords-2)
+                             nil nil ((?\_ . "w")) nil
                              (font-lock-syntactic-face-function
                               . perl-font-lock-syntactic-face-function)))
+  (prog-prettify-install perl--prettify-symbols-alist)
   (setq-local syntax-propertize-function #'perl-syntax-propertize-function)
   (add-hook 'syntax-propertize-extend-region-functions
             #'syntax-propertize-multiline 'append 'local)
diff --git a/lisp/progmodes/prog-mode.el b/lisp/progmodes/prog-mode.el
new file mode 100644
index 00000000000..e2700414636
--- /dev/null
+++ b/lisp/progmodes/prog-mode.el
@@ -0,0 +1,119 @@
+;;; prog-mode.el --- Generic major mode for programming  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013 Free Software Foundation, Inc.
+
+;; Maintainer: FSF
+;; Keywords: internal
+;; Package: emacs
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This major mode is mostly intended as a parent of other programming
+;; modes.  All major modes for programming languages should derive from this
+;; mode so that users can put generic customization on prog-mode-hook.
+
+;;; Code:
+
+(eval-when-compile (require 'cl-lib))
+
+(defgroup prog-mode nil
+  "Generic programming mode, from which others derive."
+  :group 'languages)
+
+(defvar prog-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map [?\C-\M-q] 'prog-indent-sexp)
+    map)
+  "Keymap used for programming modes.")
+
+(defun prog-indent-sexp (&optional defun)
+  "Indent the expression after point.
+When interactively called with prefix, indent the enclosing defun
+instead."
+  (interactive "P")
+  (save-excursion
+    (when defun
+      (end-of-line)
+      (beginning-of-defun))
+    (let ((start (point))
+          (end (progn (forward-sexp 1) (point))))
+      (indent-region start end nil))))
+
+(defvar prog-prettify-symbols-alist nil)
+
+(defcustom prog-prettify-symbols nil
+  "Whether symbols should be prettified.
+When set to an alist in the form `((STRING . CHARACTER)...)' it
+will augment the mode's native prettify alist."
+  :type '(choice
+          (const :tag "No thanks" nil)
+          (const :tag "Mode defaults" t)
+          (alist :tag "Mode defaults augmented with your own list"
+                 :key-type string :value-type character))
+  :version "24.4")
+
+(defun prog--prettify-font-lock-compose-symbol (alist)
+  "Compose a sequence of ascii chars into a symbol.
+Regexp match data 0 points to the chars."
+  ;; Check that the chars should really be composed into a symbol.
+  (let* ((start (match-beginning 0))
+         (end (match-end 0))
+         (syntaxes (if (eq (char-syntax (char-after start)) ?w)
+                       '(?w) '(?. ?\\))))
+    (if (or (memq (char-syntax (or (char-before start) ?\ )) syntaxes)
+            (memq (char-syntax (or (char-after end) ?\ )) syntaxes)
+            (nth 8 (syntax-ppss)))
+        ;; No composition for you.  Let's actually remove any composition
+        ;; we may have added earlier and which is now incorrect.
+        (remove-text-properties start end '(composition))
+      ;; That's a symbol alright, so add the composition.
+      (compose-region start end (cdr (assoc (match-string 0) alist)))))
+  ;; Return nil because we're not adding any face property.
+  nil)
+
+(defun prog-prettify-font-lock-symbols-keywords ()
+  (when prog-prettify-symbols
+    (let ((alist (append prog-prettify-symbols-alist
+                         (if (listp prog-prettify-symbols)
+                             prog-prettify-symbols
+                           nil))))
+      `((,(regexp-opt (mapcar 'car alist) t)
+         (0 (prog--prettify-font-lock-compose-symbol ',alist)))))))
+
+(defun prog-prettify-install (alist)
+"Install prog-mode support to prettify symbols according to ALIST.
+
+ALIST is in the format `((STRING . CHARACTER)...)' like
+`prog-prettify-symbols'.
+
+Internally, `font-lock-add-keywords' is called."
+  (setq-local prog-prettify-symbols-alist alist)
+  (let ((keywords (prog-prettify-font-lock-symbols-keywords)))
+    (if keywords (font-lock-add-keywords nil keywords))))
+
+;;;###autoload
+(define-derived-mode prog-mode fundamental-mode "Prog"
+  "Major mode for editing programming language source code."
+  (set (make-local-variable 'require-final-newline) mode-require-final-newline)
+  (set (make-local-variable 'parse-sexp-ignore-comments) t)
+  ;; Any programming language is always written left to right.
+  (setq bidi-paragraph-direction 'left-to-right))
+
+(provide 'prog-mode)
+
+;;; prog-mode.el ends here
diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el
index 63bd9258d69..0f3c1504ee9 100644
--- a/lisp/progmodes/prolog.el
+++ b/lisp/progmodes/prolog.el
@@ -1149,11 +1149,7 @@ VERSION is of the format (Major . Minor)"
   (set (make-local-variable 'comment-start) "%")
   (set (make-local-variable 'comment-end) "")
   (set (make-local-variable 'comment-add) 1)
-  (set (make-local-variable 'comment-start-skip)
-       ;; This complex regexp makes sure that comments cannot start
-       ;; inside quoted atoms or strings
-       (format "^\\(\\(%s\\|%s\\|[^\n\'\"%%]\\)*\\)\\(/\\*+ *\\|%%+ *\\)"
-               prolog-quoted-atom-regexp prolog-string-regexp))
+  (set (make-local-variable 'comment-start-skip) "\\(?:/\\*+ *\\|%%+ *\\)")
   (set (make-local-variable 'parens-require-spaces) nil)
   ;; Initialize Prolog system specific variables
   (dolist (var '(prolog-keywords prolog-types prolog-mode-specificators
@@ -1739,8 +1735,7 @@ This function must be called from the source code buffer."
          (real-file buffer-file-name)
          (command-string (prolog-build-prolog-command compilep file
                                                       real-file first-line))
-         (process (get-process "prolog"))
-         (old-filter (process-filter process)))
+         (process (get-process "prolog")))
     (with-current-buffer buffer
       (delete-region (point-min) (point-max))
       ;; FIXME: Wasn't this supposed to use prolog-inferior-mode?
@@ -1759,8 +1754,7 @@ This function must be called from the source code buffer."
                'prolog-parse-sicstus-compilation-errors))
       (setq buffer-read-only nil)
       (insert command-string "\n"))
-    (save-selected-window
-      (pop-to-buffer buffer))
+    (display-buffer buffer)
     (setq prolog-process-flag t
           prolog-consult-compile-output ""
           prolog-consult-compile-first-line (if first-line (1- first-line) 0)
@@ -1954,20 +1948,6 @@ If COMPILEP is non-nil, compile, otherwise consult."
 ;;-------------------------------------------------------------------
 
 ;; Auxiliary functions
-(defun prolog-make-keywords-regexp (keywords &optional protect)
-  "Create regexp from the list of strings KEYWORDS.
-If PROTECT is non-nil, surround the result regexp by word breaks."
-  (let ((regexp
-         (if (fboundp 'regexp-opt)
-             ;; Emacs 20
-             ;; Avoid compile warnings under earlier versions by using eval
-             (eval '(regexp-opt keywords))
-           ;; Older Emacsen
-           (concat (mapconcat 'regexp-quote keywords "\\|")))
-         ))
-    (if protect
-        (concat "\\<\\(" regexp "\\)\\>")
-      regexp)))
 
 (defun prolog-font-lock-object-matcher (bound)
   "Find SICStus objects method name for font lock.
@@ -2084,20 +2064,16 @@ Argument BOUND is a buffer position limiting searching."
             (if (eq prolog-system 'mercury)
                 (concat
                  "\\<\\("
-                 (prolog-make-keywords-regexp prolog-keywords-i)
+                 (regexp-opt prolog-keywords-i)
                  "\\|"
-                 (prolog-make-keywords-regexp
+                 (regexp-opt
                   prolog-determinism-specificators-i)
                  "\\)\\>")
               (concat
                "^[?:]- *\\("
-               (prolog-make-keywords-regexp prolog-keywords-i)
+               (regexp-opt prolog-keywords-i)
                "\\)\\>"))
               1 prolog-builtin-face))
-          (quoted_atom (list prolog-quoted-atom-regexp
-                             2 'font-lock-string-face 'append))
-          (string (list prolog-string-regexp
-                        1 'font-lock-string-face 'append))
           ;; SICStus specific patterns
           (sicstus-object-methods
            (if (eq prolog-system 'sicstus)
@@ -2107,17 +2083,17 @@ Argument BOUND is a buffer position limiting searching."
           (types
            (if (eq prolog-system 'mercury)
                (list
-                (prolog-make-keywords-regexp prolog-types-i t)
+                (regexp-opt prolog-types-i 'words)
                 0 'font-lock-type-face)))
           (modes
            (if (eq prolog-system 'mercury)
                (list
-                (prolog-make-keywords-regexp prolog-mode-specificators-i t)
+                (regexp-opt prolog-mode-specificators-i 'words)
                 0 'font-lock-constant-face)))
           (directives
            (if (eq prolog-system 'mercury)
                (list
-                (prolog-make-keywords-regexp prolog-directives-i t)
+                (regexp-opt prolog-directives-i 'words)
                 0 'prolog-warning-face)))
           ;; Inferior mode specific patterns
           (prompt
@@ -2211,8 +2187,6 @@ Argument BOUND is a buffer position limiting searching."
          (list
           head-predicates
           head-predicates-1
-          quoted_atom
-          string
           variables
           important-elements
           important-elements-1
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 641563ae0ab..ccb2dcba42e 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -157,7 +157,7 @@
 
 ;; Skeletons: 6 skeletons are provided for simple inserting of class,
 ;; def, for, if, try and while.  These skeletons are integrated with
-;; dabbrev.  If you have `dabbrev-mode' activated and
+;; abbrev.  If you have `abbrev-mode' activated and
 ;; `python-skeleton-autoinsert' is set to t, then whenever you type
 ;; the name of any of those defined and hit SPC, they will be
 ;; automatically expanded.  As an alternative you can use the defined
@@ -642,7 +642,8 @@ It makes underscores and dots word constituent chars.")
 These make `python-indent-calculate-indentation' subtract the value of
 `python-indent-offset'.")
 
-(defvar python-indent-block-enders '("return" "pass")
+(defvar python-indent-block-enders
+  '("break" "continue" "pass" "raise" "return")
   "List of words that mark the end of a block.
 These make `python-indent-calculate-indentation' subtract the
 value of `python-indent-offset' when `python-indent-context' is
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index a96ee64a229..fa4efe49b7b 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -1349,6 +1349,7 @@ If the result is do-end block, it will always be multiline."
 (declare-function ruby-syntax-propertize-percent-literal "ruby-mode" (limit))
 ;; Unusual code layout confuses the byte-compiler.
 (declare-function ruby-syntax-propertize-expansion "ruby-mode" ())
+(declare-function ruby-syntax-expansion-allowed-p "ruby-mode" (parse-state))
 
 (if (eval-when-compile (fboundp #'syntax-propertize-rules))
     ;; New code that works independently from font-lock.
@@ -1380,51 +1381,52 @@ It will be properly highlighted even when the call omits parens.")
 
       (defun ruby-syntax-propertize-function (start end)
         "Syntactic keywords for Ruby mode.  See `syntax-propertize-function'."
-        (goto-char start)
-        (remove-text-properties start end '(ruby-expansion-match-data))
-        (ruby-syntax-propertize-heredoc end)
-        (ruby-syntax-enclosing-percent-literal end)
-        (funcall
-         (syntax-propertize-rules
-          ;; $' $" $` .... are variables.
-          ;; ?' ?" ?` are ascii codes.
-          ("\\([?$]\\)[#\"'`]"
-           (1 (unless (save-excursion
-                        ;; Not within a string.
-                        (nth 3 (syntax-ppss (match-beginning 0))))
-                (string-to-syntax "\\"))))
-          ;; Regular expressions.  Start with matching unescaped slash.
-          ("\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(/\\)"
-           (1 (let ((state (save-excursion (syntax-ppss (match-beginning 1)))))
-                (when (or
-                       ;; Beginning of a regexp.
-                       (and (null (nth 8 state))
-                            (save-excursion
-                              (forward-char -1)
-                              (looking-back ruby-syntax-before-regexp-re
-                                            (point-at-bol))))
-                       ;; End of regexp.  We don't match the whole
-                       ;; regexp at once because it can have
-                       ;; string interpolation inside, or span
-                       ;; several lines.
-                       (eq ?/ (nth 3 state)))
-                  (string-to-syntax "\"/")))))
-          ;; Expression expansions in strings.  We're handling them
-          ;; here, so that the regexp rule never matches inside them.
-          (ruby-expression-expansion-re
-           (0 (ignore (ruby-syntax-propertize-expansion))))
-          ("^=en\\(d\\)\\_>" (1 "!"))
-          ("^\\(=\\)begin\\_>" (1 "!"))
-          ;; Handle here documents.
-          ((concat ruby-here-doc-beg-re ".*\\(\n\\)")
-           (7 (unless (ruby-singleton-class-p (match-beginning 0))
-                (put-text-property (match-beginning 7) (match-end 7)
-                                   'syntax-table (string-to-syntax "\""))
-                (ruby-syntax-propertize-heredoc end))))
-          ;; Handle percent literals: %w(), %q{}, etc.
-          ((concat "\\(?:^\\|[[ \t\n<+(,=]\\)" ruby-percent-literal-beg-re)
-           (1 (prog1 "|" (ruby-syntax-propertize-percent-literal end)))))
-         (point) end))
+        (let (case-fold-search)
+          (goto-char start)
+          (remove-text-properties start end '(ruby-expansion-match-data))
+          (ruby-syntax-propertize-heredoc end)
+          (ruby-syntax-enclosing-percent-literal end)
+          (funcall
+           (syntax-propertize-rules
+            ;; $' $" $` .... are variables.
+            ;; ?' ?" ?` are ascii codes.
+            ("\\([?$]\\)[#\"'`]"
+             (1 (unless (save-excursion
+                          ;; Not within a string.
+                          (nth 3 (syntax-ppss (match-beginning 0))))
+                  (string-to-syntax "\\"))))
+            ;; Regular expressions.  Start with matching unescaped slash.
+            ("\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(/\\)"
+             (1 (let ((state (save-excursion (syntax-ppss (match-beginning 1)))))
+                  (when (or
+                         ;; Beginning of a regexp.
+                         (and (null (nth 8 state))
+                              (save-excursion
+                                (forward-char -1)
+                                (looking-back ruby-syntax-before-regexp-re
+                                              (point-at-bol))))
+                         ;; End of regexp.  We don't match the whole
+                         ;; regexp at once because it can have
+                         ;; string interpolation inside, or span
+                         ;; several lines.
+                         (eq ?/ (nth 3 state)))
+                    (string-to-syntax "\"/")))))
+            ;; Expression expansions in strings.  We're handling them
+            ;; here, so that the regexp rule never matches inside them.
+            (ruby-expression-expansion-re
+             (0 (ignore (ruby-syntax-propertize-expansion))))
+            ("^=en\\(d\\)\\_>" (1 "!"))
+            ("^\\(=\\)begin\\_>" (1 "!"))
+            ;; Handle here documents.
+            ((concat ruby-here-doc-beg-re ".*\\(\n\\)")
+             (7 (unless (ruby-singleton-class-p (match-beginning 0))
+                  (put-text-property (match-beginning 7) (match-end 7)
+                                     'syntax-table (string-to-syntax "\""))
+                  (ruby-syntax-propertize-heredoc end))))
+            ;; Handle percent literals: %w(), %q{}, etc.
+            ((concat "\\(?:^\\|[[ \t\n<+(,=]\\)" ruby-percent-literal-beg-re)
+             (1 (prog1 "|" (ruby-syntax-propertize-percent-literal end)))))
+           (point) end)))
 
       (defun ruby-syntax-propertize-heredoc (limit)
         (let ((ppss (syntax-ppss))
@@ -1496,9 +1498,10 @@ It will be properly highlighted even when the call omits parens.")
       (defun ruby-syntax-propertize-expansion ()
         ;; Save the match data to a text property, for font-locking later.
         ;; Set the syntax of all double quotes and backticks to punctuation.
-        (let ((beg (match-beginning 2))
-              (end (match-end 2)))
-          (when (and beg (save-excursion (nth 3 (syntax-ppss beg))))
+        (let* ((beg (match-beginning 2))
+               (end (match-end 2))
+               (state (and beg (save-excursion (syntax-ppss beg)))))
+          (when (ruby-syntax-expansion-allowed-p state)
             (put-text-property beg (1+ beg) 'ruby-expansion-match-data
                                (match-data))
             (goto-char beg)
@@ -1506,6 +1509,17 @@ It will be properly highlighted even when the call omits parens.")
               (put-text-property (match-beginning 0) (match-end 0)
                                  'syntax-table (string-to-syntax "."))))))
 
+      (defun ruby-syntax-expansion-allowed-p (parse-state)
+        "Return non-nil if expression expansion is allowed."
+        (let ((term (nth 3 parse-state)))
+          (cond
+           ((memq term '(?\" ?` ?\n ?/)))
+           ((eq term t)
+            (save-match-data
+              (save-excursion
+                (goto-char (nth 8 parse-state))
+                (looking-at "%\\(?:[QWrx]\\|\\W\\)")))))))
+
       (defun ruby-syntax-propertize-expansions (start end)
         (save-excursion
           (goto-char start)
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 9169a433015..3e91aeba9a1 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -266,7 +266,7 @@ quoted for Tcl."
   ;; Maybe someone has a better set?
   (let ((map (make-sparse-keymap)))
     ;; Will inherit from `comint-mode-map' thanks to define-derived-mode.
-    (define-key map "\t" 'comint-dynamic-complete)
+    (define-key map "\t" 'completion-at-point)
     (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
     (define-key map "\177" 'backward-delete-char-untabify)
     (define-key map "\M-\C-x" 'tcl-eval-defun)
diff --git a/lisp/replace.el b/lisp/replace.el
index 86956a614cd..24cfccf60fd 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -246,10 +246,14 @@ Matching is independent of case if `case-fold-search' is non-nil and
 FROM-STRING has no uppercase letters.  Replacement transfers the case
 pattern of the old text to the new text, if `case-replace' and
 `case-fold-search' are non-nil and FROM-STRING has no uppercase
-letters.  \(Transferring the case pattern means that if the old text
+letters.  (Transferring the case pattern means that if the old text
 matched is all caps, or capitalized, then its replacement is upcased
 or capitalized.)
 
+Ignore read-only matches if `query-replace-skip-read-only' is non-nil,
+ignore hidden matches if `search-invisible' is nil, and ignore more
+matches using a non-nil `isearch-filter-predicates'.
+
 If `replace-lax-whitespace' is non-nil, a space or spaces in the string
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
@@ -300,6 +304,10 @@ pattern of the old text to the new text, if `case-replace' and
 all caps, or capitalized, then its replacement is upcased or
 capitalized.)
 
+Ignore read-only matches if `query-replace-skip-read-only' is non-nil,
+ignore hidden matches if `search-invisible' is nil, and ignore more
+matches using a non-nil `isearch-filter-predicates'.
+
 If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
@@ -380,6 +388,10 @@ that reads REGEXP.
 Preserves case in each replacement if `case-replace' and `case-fold-search'
 are non-nil and REGEXP has no uppercase letters.
 
+Ignore read-only matches if `query-replace-skip-read-only' is non-nil,
+ignore hidden matches if `search-invisible' is nil, and ignore more
+matches using a non-nil `isearch-filter-predicates'.
+
 If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
@@ -470,6 +482,10 @@ are non-nil and FROM-STRING has no uppercase letters.
 \(Preserving case means that if the string matched is all caps, or capitalized,
 then its replacement is upcased or capitalized.)
 
+Ignore read-only matches if `query-replace-skip-read-only' is non-nil,
+ignore hidden matches if `search-invisible' is nil, and ignore more
+matches using a non-nil `isearch-filter-predicates'.
+
 If `replace-lax-whitespace' is non-nil, a space or spaces in the string
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
@@ -512,6 +528,10 @@ and TO-STRING is also null.)"
 Preserve case in each match if `case-replace' and `case-fold-search'
 are non-nil and REGEXP has no uppercase letters.
 
+Ignore read-only matches if `query-replace-skip-read-only' is non-nil,
+ignore hidden matches if `search-invisible' is nil, and ignore more
+matches using a non-nil `isearch-filter-predicates'.
+
 If `replace-regexp-lax-whitespace' is non-nil, a space or spaces in the regexp
 to be replaced will match a sequence of whitespace chars defined by the
 regexp in `search-whitespace-regexp'.
@@ -1155,8 +1175,8 @@ is called only during interactive use.
 
 For example, to check for occurrence of symbol at point use
 
-    \(setq occur-read-regexp-defaults-function
-          'find-tag-default-as-regexp\).")
+    (setq occur-read-regexp-defaults-function
+          'find-tag-default-as-regexp).")
 
 (defun occur-read-regexp-defaults ()
   "Return the latest regexp from `regexp-history'.
@@ -1369,16 +1389,18 @@ See also `multi-occur'."
 (defun occur-engine (regexp buffers out-buf nlines case-fold
                             title-face prefix-face match-face keep-props)
   (with-current-buffer out-buf
-    (let ((globalcount 0)
+    (let ((global-lines 0)    ;; total count of matching lines
+          (global-matches 0)  ;; total count of matches
           (coding nil)
           (case-fold-search case-fold))
       ;; Map over all the buffers
       (dolist (buf buffers)
         (when (buffer-live-p buf)
-          (let ((matches 0)     ;; count of matched lines
-                (lines 1)       ;; line count
-                (prev-after-lines nil)  ;; context lines of prev match
-                (prev-lines nil)        ;; line number of prev match endpt
+          (let ((lines 0)               ;; count of matching lines
+                (matches 0)             ;; count of matches
+                (curr-line 1)           ;; line count
+                (prev-line nil)         ;; line number of prev match endpt
+                (prev-after-lines nil)  ;; context lines of prev match
                 (matchbeg 0)
                 (origpt nil)
                 (begpt nil)
@@ -1399,7 +1421,7 @@ See also `multi-occur'."
                 (while (not (eobp))
                   (setq origpt (point))
                   (when (setq endpt (re-search-forward regexp nil t))
-                    (setq matches (1+ matches)) ;; increment match count
+                    (setq lines (1+ lines)) ;; increment matching lines count
                     (setq matchbeg (match-beginning 0))
                     ;; Get beginning of first match line and end of the last.
                     (save-excursion
@@ -1408,7 +1430,7 @@ See also `multi-occur'."
                       (goto-char endpt)
                       (setq endpt (line-end-position)))
                     ;; Sum line numbers up to the first match line.
-                    (setq lines (+ lines (count-lines origpt begpt)))
+                    (setq curr-line (+ curr-line (count-lines origpt begpt)))
                     (setq marker (make-marker))
                     (set-marker marker matchbeg)
                     (setq curstring (occur-engine-line begpt endpt keep-props))
@@ -1417,6 +1439,7 @@ See also `multi-occur'."
                           (start 0))
                       (while (and (< start len)
                                   (string-match regexp curstring start))
+                        (setq matches (1+ matches))
                         (add-text-properties
                          (match-beginning 0) (match-end 0)
                          (append
@@ -1430,7 +1453,7 @@ See also `multi-occur'."
                     ;; Generate the string to insert for this match
                     (let* ((match-prefix
                             ;; Using 7 digits aligns tabs properly.
-                            (apply #'propertize (format "%7d:" lines)
+                            (apply #'propertize (format "%7d:" curr-line)
                                    (append
                                     (when prefix-face
                                       `(font-lock-face ,prefix-face))
@@ -1470,7 +1493,7 @@ 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
+                                         curr-line prev-line prev-after-lines
                                          prefix-face))
                               ;; Set first elem of the returned list to `data',
                               ;; and the second elem to `prev-after-lines'.
@@ -1483,28 +1506,34 @@ See also `multi-occur'."
                   (if endpt
                       (progn
                         ;; Sum line numbers between first and last match lines.
-                        (setq lines (+ lines (count-lines begpt endpt)
-                                       ;; Add 1 for empty last match line since
-                                       ;; count-lines returns 1 line less.
-                                       (if (and (bolp) (eolp)) 1 0)))
+                        (setq curr-line (+ curr-line (count-lines begpt endpt)
+                                           ;; Add 1 for empty last match line since
+                                           ;; count-lines returns 1 line less.
+                                           (if (and (bolp) (eolp)) 1 0)))
                         ;; On to the next match...
                         (forward-line 1))
                     (goto-char (point-max)))
-                  (setq prev-lines (1- lines)))
+                  (setq prev-line (1- curr-line)))
                 ;; Flush remaining context after-lines.
                 (when prev-after-lines
                   (with-current-buffer out-buf
                     (insert (apply #'concat (occur-engine-add-prefix
                                              prev-after-lines prefix-face)))))))
-            (when (not (zerop matches)) ;; is the count zero?
-              (setq globalcount (+ globalcount matches))
+            (when (not (zerop lines)) ;; is the count zero?
+              (setq global-lines (+ global-lines lines)
+                    global-matches (+ global-matches matches))
               (with-current-buffer out-buf
                 (goto-char headerpt)
                 (let ((beg (point))
                       end)
                   (insert (propertize
-                           (format "%d match%s%s in buffer: %s\n"
+                           (format "%d match%s%s%s in buffer: %s\n"
                                    matches (if (= matches 1) "" "es")
+                                   ;; Don't display the same number of lines
+                                   ;; and matches in case of 1 match per line.
+                                   (if (= lines matches)
+                                       "" (format " in %d line%s"
+                                                  lines (if (= lines 1) "" "s")))
                                    ;; Don't display regexp for multi-buffer.
                                    (if (> (length buffers) 1)
                                        "" (format " for \"%s\""
@@ -1519,12 +1548,17 @@ See also `multi-occur'."
                                         `(occur-title ,buf))))
                 (goto-char (point-min)))))))
       ;; Display total match count and regexp for multi-buffer.
-      (when (and (not (zerop globalcount)) (> (length buffers) 1))
+      (when (and (not (zerop global-lines)) (> (length buffers) 1))
         (goto-char (point-min))
         (let ((beg (point))
               end)
-          (insert (format "%d match%s total for \"%s\":\n"
-                          globalcount (if (= globalcount 1) "" "es")
+          (insert (format "%d match%s%s total for \"%s\":\n"
+                          global-matches (if (= global-matches 1) "" "es")
+                          ;; Don't display the same number of lines
+                          ;; and matches in case of 1 match per line.
+                          (if (= global-lines global-matches)
+                              "" (format " in %d line%s"
+                                         global-lines (if (= global-lines 1) "" "s")))
                           (query-replace-descr regexp)))
           (setq end (point))
           (add-text-properties beg end (when title-face
@@ -1536,7 +1570,7 @@ See also `multi-occur'."
           ;; buffer.
           (set-buffer-file-coding-system coding))
       ;; Return the number of matches
-      globalcount)))
+      global-matches)))
 
 (defun occur-engine-line (beg end &optional keep-props)
   (if (and keep-props (if (boundp 'jit-lock-mode) jit-lock-mode)
@@ -1579,13 +1613,13 @@ See also `multi-occur'."
 ;; Generate context display for occur.
 ;; OUT-LINE is the line where the match is.
 ;; NLINES and KEEP-PROPS are args to occur-engine.
-;; LINES is line count of the current match,
-;; PREV-LINES is line count of the previous match,
+;; CURR-LINE is line count of the current match,
+;; PREV-LINE is line count of the previous match,
 ;; PREV-AFTER-LINES is a list of after-context lines of the previous match.
 ;; 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
+                                     curr-line prev-line prev-after-lines
                                      &optional prefix-face)
   ;; Find after- and before-context lines of the current match.
   (let ((before-lines
@@ -1601,22 +1635,22 @@ See also `multi-occur'."
 
     (when prev-after-lines
       ;; Don't overlap prev after-lines with current before-lines.
-      (if (>= (+ prev-lines (length prev-after-lines))
-              (- lines      (length before-lines)))
+      (if (>= (+ prev-line (length prev-after-lines))
+              (- curr-line      (length before-lines)))
           (setq prev-after-lines
                 (butlast prev-after-lines
                          (- (length prev-after-lines)
-                            (- lines prev-lines (length before-lines) 1))))
+                            (- curr-line prev-line (length before-lines) 1))))
         ;; Separate non-overlapping context lines with a dashed line.
         (setq separator "-------\n")))
 
-    (when prev-lines
+    (when prev-line
       ;; Don't overlap current before-lines with previous match line.
-      (if (<= (- lines (length before-lines))
-              prev-lines)
+      (if (<= (- curr-line (length before-lines))
+              prev-line)
           (setq before-lines
                 (nthcdr (- (length before-lines)
-                           (- lines prev-lines 1))
+                           (- curr-line prev-line 1))
                         before-lines))
         ;; Separate non-overlapping before-context lines.
         (unless (> nlines 0)
@@ -1840,7 +1874,7 @@ It is called with three arguments, as if it were
 
 (defun replace-search (search-string limit regexp-flag delimited-flag
                                      case-fold-search)
-  "Search for the next occurence of SEARCH-STRING to replace."
+  "Search for the next occurrence of SEARCH-STRING to replace."
   ;; Let-bind global isearch-* variables to values used
   ;; to search the next replacement.  These let-bindings
   ;; should be effective both at the time of calling
@@ -1934,6 +1968,9 @@ make, or the user didn't cancel the call."
          (keep-going t)
          (stack nil)
          (replace-count 0)
+         (skip-read-only-count 0)
+         (skip-filtered-count 0)
+         (skip-invisible-count 0)
          (nonempty-match nil)
          (multi-buffer nil)
          (recenter-last-op nil) ; Start cycling order with initial position.
@@ -2042,20 +2079,27 @@ make, or the user didn't cancel the call."
                                 (and (/= (nth 0 match) (nth 1 match))
                                      match))))))
 
-          ;; Optionally ignore matches that have a read-only property.
-          (when (and (or (not query-replace-skip-read-only)
-                         (not (text-property-not-all
-                               (nth 0 real-match-data) (nth 1 real-match-data)
-                               'read-only nil)))
-                     ;; Optionally filter out matches.
-                     (run-hook-with-args-until-failure
-                      'isearch-filter-predicates
-                      (nth 0 real-match-data) (nth 1 real-match-data))
-                     ;; Optionally ignore invisible matches.
-                     (or (eq search-invisible t)
-                         (not (isearch-range-invisible
-                               (nth 0 real-match-data) (nth 1 real-match-data)))))
-
+          (cond
+           ;; Optionally ignore matches that have a read-only property.
+           ((not (or (not query-replace-skip-read-only)
+                     (not (text-property-not-all
+                           (nth 0 real-match-data) (nth 1 real-match-data)
+                           'read-only nil))))
+            (setq skip-read-only-count (1+ skip-read-only-count)))
+           ;; Optionally filter out matches.
+           ((not (run-hook-with-args-until-failure
+                  'isearch-filter-predicates
+                  (nth 0 real-match-data) (nth 1 real-match-data)))
+            (setq skip-filtered-count (1+ skip-filtered-count)))
+           ;; Optionally ignore invisible matches.
+           ((not (or (eq search-invisible t)
+                     ;; Don't open overlays for automatic replacements.
+                     (and (not query-flag) search-invisible)
+                     ;; Open hidden overlays for interactive replacements.
+                     (not (isearch-range-invisible
+                           (nth 0 real-match-data) (nth 1 real-match-data)))))
+            (setq skip-invisible-count (1+ skip-invisible-count)))
+           (t
             ;; Calculate the replacement string, if necessary.
             (when replacements
               (set-match-data real-match-data)
@@ -2260,13 +2304,31 @@ make, or the user didn't cancel the call."
                                  (match-end 0)
                                  (current-buffer))
                               (match-data t)))
-                      stack)))))
+                      stack))))))
 
       (replace-dehighlight))
     (or unread-command-events
-        (message "Replaced %d occurrence%s"
+        (message "Replaced %d occurrence%s%s"
                  replace-count
-                 (if (= replace-count 1) "" "s")))
+                 (if (= replace-count 1) "" "s")
+                 (if (> (+ skip-read-only-count
+                           skip-filtered-count
+                           skip-invisible-count) 0)
+                     (format " (skipped %s)"
+                             (mapconcat
+                              'identity
+                              (delq nil (list
+                                         (if (> skip-read-only-count 0)
+                                             (format "%s read-only"
+                                                     skip-read-only-count))
+                                         (if (> skip-invisible-count 0)
+                                             (format "%s invisible"
+                                                     skip-invisible-count))
+                                         (if (> skip-filtered-count 0)
+                                             (format "%s filtered out"
+                                                     skip-filtered-count))))
+                              ", "))
+                   "")))
     (or (and keep-going stack) multi-buffer)))
 
 ;;; replace.el ends here
diff --git a/lisp/simple.el b/lisp/simple.el
index 18a360faa61..15bf8779f56 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -372,34 +372,6 @@ Other major modes are defined by comparison with this one."
   "Parent major mode from which special major modes should inherit."
   (setq buffer-read-only t))
 
-;; Major mode meant to be the parent of programming modes.
-
-(defvar prog-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map [?\C-\M-q] 'prog-indent-sexp)
-    map)
-  "Keymap used for programming modes.")
-
-(defun prog-indent-sexp (&optional defun)
-  "Indent the expression after point.
-When interactively called with prefix, indent the enclosing defun
-instead."
-  (interactive "P")
-  (save-excursion
-    (when defun
-      (end-of-line)
-      (beginning-of-defun))
-    (let ((start (point))
-          (end (progn (forward-sexp 1) (point))))
-      (indent-region start end nil))))
-
-(define-derived-mode prog-mode fundamental-mode "Prog"
-  "Major mode for editing programming language source code."
-  (set (make-local-variable 'require-final-newline) mode-require-final-newline)
-  (set (make-local-variable 'parse-sexp-ignore-comments) t)
-  ;; Any programming language is always written left to right.
-  (setq bidi-paragraph-direction 'left-to-right))
-
 ;; Making and deleting lines.
 
 (defvar hard-newline (propertize "\n" 'hard t 'rear-nonsticky '(hard))
diff --git a/lisp/skeleton.el b/lisp/skeleton.el
index 01288b89132..a7eae7464e2 100644
--- a/lisp/skeleton.el
+++ b/lisp/skeleton.el
@@ -31,6 +31,8 @@
 
 ;;; Code:
 
+(eval-when-compile (require 'cl-lib))
+
 ;; page 1:      statement skeleton language definition & interpreter
 ;; page 2:      paired insertion
 ;; page 3:      mirror-mode, an example for setting up paired insertion
@@ -84,13 +86,11 @@ The variables `v1' and `v2' are still set when calling this.")
   "When non-nil, indent rigidly under current line for element `\\n'.
 Else use mode's `indent-line-function'.")
 
-(defvar skeleton-further-elements ()
+(defvar-local skeleton-further-elements ()
   "A buffer-local varlist (see `let') of mode specific skeleton elements.
 These variables are bound while interpreting a skeleton.  Their value may
 in turn be any valid skeleton element if they are themselves to be used as
 skeleton elements.")
-(make-variable-buffer-local 'skeleton-further-elements)
-
 
 (defvar skeleton-subprompt
   (substitute-command-keys
@@ -260,8 +260,10 @@ When done with skeleton, but before going back to `_'-point call
           skeleton-modified skeleton-point resume: help input v1 v2)
       (setq skeleton-positions nil)
       (unwind-protect
-          (eval `(let ,skeleton-further-elements
-                   (skeleton-internal-list skeleton str)))
+          (cl-progv
+              (mapcar #'car skeleton-further-elements)
+              (mapcar (lambda (x) (eval (cadr x))) skeleton-further-elements)
+            (skeleton-internal-list skeleton str))
         (run-hooks 'skeleton-end-hook)
         (sit-for 0)
         (or (pos-visible-in-window-p beg)
diff --git a/lisp/subr.el b/lisp/subr.el
index 23684f02b87..8f290f356da 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1,4 +1,4 @@
-;;; subr.el --- basic lisp subroutines for Emacs  -*- coding: utf-8 -*-
+;;; subr.el --- basic lisp subroutines for Emacs  -*- coding: utf-8; lexical-binding:t -*-
 
 ;; Copyright (C) 1985-1986, 1992, 1994-1995, 1999-2013 Free Software
 ;; Foundation, Inc.
@@ -39,13 +39,13 @@ Each element of this list holds the arguments to one call to `defcustom'.")
   (setq custom-declare-variable-list
         (cons arguments custom-declare-variable-list)))
 
-(defmacro declare-function (fn file &optional arglist fileonly)
+(defmacro declare-function (_fn _file &optional _arglist _fileonly)
   "Tell the byte-compiler that function FN is defined, in FILE.
-Optional ARGLIST is the argument list used by the function.  The
-FILE argument is not used by the byte-compiler, but by the
+Optional ARGLIST is the argument list used by the function.
+The FILE argument is not used by the byte-compiler, but by the
 `check-declare' package, which checks that FILE contains a
-definition for FN.  ARGLIST is used by both the byte-compiler and
-`check-declare' to check for consistency.
+definition for FN.  ARGLIST is used by both the byte-compiler
+and `check-declare' to check for consistency.
 
 FILE can be either a Lisp file (in which case the \".el\"
 extension is optional), or a C file.  C files are expanded
@@ -396,9 +396,9 @@ non-nil."
 (defun number-sequence (from &optional to inc)
   "Return a sequence of numbers from FROM to TO (both inclusive) as a list.
 INC is the increment used between numbers in the sequence and defaults to 1.
-So, the Nth element of the list is \(+ FROM \(* N INC)) where N counts from
+So, the Nth element of the list is (+ FROM (* N INC)) where N counts from
 zero.  TO is only included if there is an N for which TO = FROM + N * INC.
-If TO is nil or numerically equal to FROM, return \(FROM).
+If TO is nil or numerically equal to FROM, return (FROM).
 If INC is positive and TO is less than FROM, or INC is negative
 and TO is larger than FROM, return nil.
 If INC is zero and TO is neither nil nor numerically equal to
@@ -408,11 +408,11 @@ This function is primarily designed for integer arguments.
 Nevertheless, FROM, TO and INC can be integer or float.  However,
 floating point arithmetic is inexact.  For instance, depending on
 the machine, it may quite well happen that
-\(number-sequence 0.4 0.6 0.2) returns the one element list \(0.4),
-whereas \(number-sequence 0.4 0.8 0.2) returns a list with three
+\(number-sequence 0.4 0.6 0.2) returns the one element list (0.4),
+whereas (number-sequence 0.4 0.8 0.2) returns a list with three
 elements.  Thus, if some of the arguments are floats and one wants
 to make sure that TO is included, one may have to explicitly write
-TO as \(+ FROM \(* N INC)) or use a variable whose value was
+TO as (+ FROM (* N INC)) or use a variable whose value was
 computed with this exact expression.  Alternatively, you can,
 of course, also replace TO with a slightly larger value
 \(or a slightly more negative value if INC is negative)."
@@ -784,8 +784,8 @@ KEY is a key sequence; noninteractively, it is a string or vector
 of characters or event types, and non-ASCII characters with codes
 above 127 (such as ISO Latin-1) can be included if you use a vector.
 
-The binding goes in the current buffer's local map,
-which in most cases is shared with all other buffers in the same major mode."
+The binding goes in the current buffer's local map, which in most
+cases is shared with all other buffers in the same major mode."
   (interactive "KSet key locally: \nCSet key %s locally to command: ")
   (let ((map (current-local-map)))
     (or map
@@ -821,7 +821,7 @@ in KEYMAP as NEWDEF those keys which are defined as OLDDEF in OLDMAP.
 
 If you don't specify OLDMAP, you can usually get the same results
 in a cleaner way with command remapping, like this:
-  \(define-key KEYMAP [remap OLDDEF] NEWDEF)
+  (define-key KEYMAP [remap OLDDEF] NEWDEF)
 \n(fn OLDDEF NEWDEF KEYMAP &optional OLDMAP)"
   ;; Don't document PREFIX in the doc string because we don't want to
   ;; advertise it.  It's meant for recursive calls only.  Here's its
@@ -1478,11 +1478,48 @@ ELEMENT is added at the end.
 
 The return value is the new value of LIST-VAR.
 
+This is handy to add some elements to configuration variables,
+but please do not abuse it in Elisp code, where you are usually better off
+using `push' or `cl-pushnew'.
+
 If you want to use `add-to-list' on a variable that is not defined
 until a certain package is loaded, you should put the call to `add-to-list'
 into a hook function that will be run only after loading the package.
 `eval-after-load' provides one way to do this.  In some cases
 other hooks, such as major mode hooks, can do the job."
+  (declare
+   (compiler-macro
+    (lambda (exp)
+      ;; FIXME: Something like this could be used for `set' as well.
+      (if (or (not (eq 'quote (car-safe list-var)))
+              (special-variable-p (cadr list-var))
+              (and append compare-fn))
+          exp
+        (let* ((sym (cadr list-var))
+               (msg (format "`add-to-list' can't use lexical var `%s'; use `push' or `cl-pushnew'"
+                            sym))
+               ;; Big ugly hack so we only output a warning during
+               ;; byte-compilation, and so we can use
+               ;; byte-compile-not-lexical-var-p to silence the warning
+               ;; when a defvar has been seen but not yet executed.
+               (warnfun (lambda ()
+                          ;; FIXME: We should also emit a warning for let-bound
+                          ;; variables with dynamic binding.
+                          (when (assq sym byte-compile--lexical-environment)
+                            (byte-compile-log-warning msg t :error))))
+               (code
+                (if append
+                    (macroexp-let2 macroexp-copyable-p x element
+                    `(unless (member ,x ,sym)
+                       (setq ,sym (append ,sym (list ,x)))))
+                  (require 'cl-lib)
+                  `(cl-pushnew ,element ,sym
+                               :test ,(or compare-fn '#'equal)))))
+          (if (not (macroexp--compiling-p))
+              code
+            `(progn
+               (macroexp--funcall-if-compiled ',warnfun)
+               ,code)))))))
   (if (cond
        ((null compare-fn)
         (member element (symbol-value list-var)))
@@ -1710,7 +1747,7 @@ If TOGGLE has a `:menu-tag', that is used for the menu item's label."
                 (nconc found (list (cons toggle keymap)) rest))
             (push (cons toggle keymap) minor-mode-map-alist)))))))
 
-;;; Load history
+;;;; Load history
 
 (defsubst autoloadp (object)
   "Non-nil if OBJECT is an autoload."
@@ -1793,173 +1830,6 @@ and the file name is displayed in the echo area."
     file))
 
 
-;;;; Specifying things to do later.
-
-(defun load-history-regexp (file)
-  "Form a regexp to find FILE in `load-history'.
-FILE, a string, is described in the function `eval-after-load'."
-  (if (file-name-absolute-p file)
-      (setq file (file-truename file)))
-  (concat (if (file-name-absolute-p file) "\\`" "\\(\\`\\|/\\)")
-          (regexp-quote file)
-          (if (file-name-extension file)
-              ""
-            ;; Note: regexp-opt can't be used here, since we need to call
-            ;; this before Emacs has been fully started.  2006-05-21
-            (concat "\\(" (mapconcat 'regexp-quote load-suffixes "\\|") "\\)?"))
-          "\\(" (mapconcat 'regexp-quote jka-compr-load-suffixes "\\|")
-          "\\)?\\'"))
-
-(defun load-history-filename-element (file-regexp)
-  "Get the first elt of `load-history' whose car matches FILE-REGEXP.
-Return nil if there isn't one."
-  (let* ((loads load-history)
-         (load-elt (and loads (car loads))))
-    (save-match-data
-      (while (and loads
-                  (or (null (car load-elt))
-                      (not (string-match file-regexp (car load-elt)))))
-        (setq loads (cdr loads)
-              load-elt (and loads (car loads)))))
-    load-elt))
-
-(put 'eval-after-load 'lisp-indent-function 1)
-(defun eval-after-load (file form)
-  "Arrange that if FILE is loaded, FORM will be run immediately afterwards.
-If FILE is already loaded, evaluate FORM right now.
-
-If a matching file is loaded again, FORM will be evaluated again.
-
-If FILE is a string, it may be either an absolute or a relative file
-name, and may have an extension \(e.g. \".el\") or may lack one, and
-additionally may or may not have an extension denoting a compressed
-format \(e.g. \".gz\").
-
-When FILE is absolute, this first converts it to a true name by chasing
-symbolic links.  Only a file of this name \(see next paragraph regarding
-extensions) will trigger the evaluation of FORM.  When FILE is relative,
-a file whose absolute true name ends in FILE will trigger evaluation.
-
-When FILE lacks an extension, a file name with any extension will trigger
-evaluation.  Otherwise, its extension must match FILE's.  A further
-extension for a compressed format \(e.g. \".gz\") on FILE will not affect
-this name matching.
-
-Alternatively, FILE can be a feature (i.e. a symbol), in which case FORM
-is evaluated at the end of any file that `provide's this feature.
-If the feature is provided when evaluating code not associated with a
-file, FORM is evaluated immediately after the provide statement.
-
-Usually FILE is just a library name like \"font-lock\" or a feature name
-like 'font-lock.
-
-This function makes or adds to an entry on `after-load-alist'."
-  ;; Add this FORM into after-load-alist (regardless of whether we'll be
-  ;; evaluating it now).
-  (let* ((regexp-or-feature
-          (if (stringp file)
-              (setq file (purecopy (load-history-regexp file)))
-            file))
-         (elt (assoc regexp-or-feature after-load-alist)))
-    (unless elt
-      (setq elt (list regexp-or-feature))
-      (push elt after-load-alist))
-    ;; Make sure `form' is evalled in the current lexical/dynamic code.
-    (setq form `(funcall ',(eval `(lambda () ,form) lexical-binding)))
-    ;; Is there an already loaded file whose name (or `provide' name)
-    ;; matches FILE?
-    (prog1 (if (if (stringp file)
-                   (load-history-filename-element regexp-or-feature)
-                 (featurep file))
-               (eval form))
-      (when (symbolp regexp-or-feature)
-        ;; For features, the after-load-alist elements get run when `provide' is
-        ;; called rather than at the end of the file.  So add an indirection to
-        ;; make sure that `form' is really run "after-load" in case the provide
-        ;; call happens early.
-        (setq form
-              `(if load-file-name
-                   (let ((fun (make-symbol "eval-after-load-helper")))
-                     (fset fun `(lambda (file)
-                                  (if (not (equal file ',load-file-name))
-                                      nil
-                                    (remove-hook 'after-load-functions ',fun)
-                                    ,',form)))
-                     (add-hook 'after-load-functions fun))
-                 ;; Not being provided from a file, run form right now.
-                 ,form)))
-      ;; Add FORM to the element unless it's already there.
-      (unless (member form (cdr elt))
-        (nconc elt (list form))))))
-
-(defvar after-load-functions nil
-  "Special hook run after loading a file.
-Each function there is called with a single argument, the absolute
-name of the file just loaded.")
-
-(defun do-after-load-evaluation (abs-file)
-  "Evaluate all `eval-after-load' forms, if any, for ABS-FILE.
-ABS-FILE, a string, should be the absolute true name of a file just loaded.
-This function is called directly from the C code."
-  ;; Run the relevant eval-after-load forms.
-  (mapc #'(lambda (a-l-element)
-            (when (and (stringp (car a-l-element))
-                       (string-match-p (car a-l-element) abs-file))
-              ;; discard the file name regexp
-              (mapc #'eval (cdr a-l-element))))
-        after-load-alist)
-  ;; Complain when the user uses obsolete files.
-  (when (string-match-p "/obsolete/[^/]*\\'" abs-file)
-    (run-with-timer 0 nil
-                    (lambda (file)
-                      (message "Package %s is obsolete!"
-                               (substring file 0
-                                          (string-match "\\.elc?\\>" file))))
-                    (file-name-nondirectory abs-file)))
-  ;; Finally, run any other hook.
-  (run-hook-with-args 'after-load-functions abs-file))
-
-(defun eval-next-after-load (file)
-  "Read the following input sexp, and run it whenever FILE is loaded.
-This makes or adds to an entry on `after-load-alist'.
-FILE should be the name of a library, with no directory name."
-  (declare (obsolete eval-after-load "23.2"))
-  (eval-after-load file (read)))
-
-(defun display-delayed-warnings ()
-  "Display delayed warnings from `delayed-warnings-list'.
-Used from `delayed-warnings-hook' (which see)."
-  (dolist (warning (nreverse delayed-warnings-list))
-    (apply 'display-warning warning))
-  (setq delayed-warnings-list nil))
-
-(defun collapse-delayed-warnings ()
-  "Remove duplicates from `delayed-warnings-list'.
-Collapse identical adjacent warnings into one (plus count).
-Used from `delayed-warnings-hook' (which see)."
-  (let ((count 1)
-        collapsed warning)
-    (while delayed-warnings-list
-      (setq warning (pop delayed-warnings-list))
-      (if (equal warning (car delayed-warnings-list))
-          (setq count (1+ count))
-        (when (> count 1)
-          (setcdr warning (cons (format "%s [%d times]" (cadr warning) count)
-                                (cddr warning)))
-          (setq count 1))
-        (push warning collapsed)))
-    (setq delayed-warnings-list (nreverse collapsed))))
-
-;; At present this is only used for Emacs internals.
-;; Ref http://lists.gnu.org/archive/html/emacs-devel/2012-02/msg00085.html
-(defvar delayed-warnings-hook '(collapse-delayed-warnings
-                                display-delayed-warnings)
-  "Normal hook run to process and display delayed warnings.
-By default, this hook contains functions to consolidate the
-warnings listed in `delayed-warnings-list', display them, and set
-`delayed-warnings-list' back to nil.")
-
-
 ;;;; Process stuff.
 
 (defun process-lines (program &rest args)
@@ -2054,8 +1924,8 @@ some sort of escape sequence, the ambiguity is resolved via `read-key-delay'."
   ;; disable quail's input methods, so although read-key-sequence
   ;; always inherits the input method, in practice read-key does not
   ;; inherit the input method (at least not if it's based on quail).
-  (let ((overriding-terminal-local-map read-key-empty-map)
-        (overriding-local-map nil)
+  (let ((overriding-terminal-local-map nil)
+        (overriding-local-map read-key-empty-map)
         (echo-keystrokes 0)
         (old-global-map (current-global-map))
         (timer (run-with-idle-timer
@@ -2670,7 +2540,7 @@ Set this to nil at your own risk..."
 (defun locate-user-emacs-file (new-name &optional old-name)
   "Return an absolute per-user Emacs-specific file name.
 If NEW-NAME exists in `user-emacs-directory', return it.
-Else If OLD-NAME is non-nil and ~/OLD-NAME exists, return ~/OLD-NAME.
+Else if OLD-NAME is non-nil and ~/OLD-NAME exists, return ~/OLD-NAME.
 Else return NEW-NAME in `user-emacs-directory', creating the
 directory if it does not exist."
   (convert-standard-filename
@@ -2717,8 +2587,9 @@ customize the variable `user-emacs-directory-warning'."
   "Return non-nil if the current buffer is narrowed."
   (/= (- (point-max) (point-min)) (buffer-size)))
 
-(defun find-tag-default ()
-  "Determine default tag to search for, based on text at point.
+(defun find-tag-default-bounds ()
+  "Determine the boundaries of the default tag, based on text at point.
+Return a cons cell with the beginning and end of the found tag.
 If there is no plausible default, return nil."
   (let (from to bound)
     (when (or (progn
@@ -2742,7 +2613,14 @@ If there is no plausible default, return nil."
                      (< (setq from (point)) bound)
                      (skip-syntax-forward "w_")
                      (setq to (point)))))
-      (buffer-substring-no-properties from to))))
+      (cons from to))))
+
+(defun find-tag-default ()
+  "Determine default tag to search for, based on text at point.
+If there is no plausible default, return nil."
+  (let ((bounds (find-tag-default-bounds)))
+    (when bounds
+      (buffer-substring-no-properties (car bounds) (cdr bounds)))))
 
 (defun find-tag-default-as-regexp ()
   "Return regexp that matches the default tag at point.
@@ -3353,7 +3231,7 @@ than cosmetic ones, undo data may become corrupted.
 
 This macro will run BODY normally, but doesn't count its buffer
 modifications as being buffer modifications.  This affects things
-like buffer-modified-p, checking whether the file is locked by
+like `buffer-modified-p', checking whether the file is locked by
 someone else, running buffer modification hooks, and other things
 of that nature.
 
@@ -3658,7 +3536,7 @@ which separates, but is not part of, the substrings.  If nil it defaults to
 `split-string-default-separators', normally \"[ \\f\\t\\n\\r\\v]+\", and
 OMIT-NULLS is forced to t.
 
-If OMIT-NULLS is t, zero-length substrings are omitted from the list \(so
+If OMIT-NULLS is t, zero-length substrings are omitted from the list (so
 that for the default value of SEPARATORS leading and trailing whitespace
 are effectively trimmed).  If nil, all zero-length substrings are retained,
 which correctly parses CSV format, for example.
@@ -3817,6 +3695,173 @@ consisting of STR followed by an invisible left-to-right mark
       (concat str (propertize (string ?\x200e) 'invisible t))
     str))
 
+;;;; Specifying things to do later.
+
+(defun load-history-regexp (file)
+  "Form a regexp to find FILE in `load-history'.
+FILE, a string, is described in the function `eval-after-load'."
+  (if (file-name-absolute-p file)
+      (setq file (file-truename file)))
+  (concat (if (file-name-absolute-p file) "\\`" "\\(\\`\\|/\\)")
+          (regexp-quote file)
+          (if (file-name-extension file)
+              ""
+            ;; Note: regexp-opt can't be used here, since we need to call
+            ;; this before Emacs has been fully started.  2006-05-21
+            (concat "\\(" (mapconcat 'regexp-quote load-suffixes "\\|") "\\)?"))
+          "\\(" (mapconcat 'regexp-quote jka-compr-load-suffixes "\\|")
+          "\\)?\\'"))
+
+(defun load-history-filename-element (file-regexp)
+  "Get the first elt of `load-history' whose car matches FILE-REGEXP.
+Return nil if there isn't one."
+  (let* ((loads load-history)
+         (load-elt (and loads (car loads))))
+    (save-match-data
+      (while (and loads
+                  (or (null (car load-elt))
+                      (not (string-match file-regexp (car load-elt)))))
+        (setq loads (cdr loads)
+              load-elt (and loads (car loads)))))
+    load-elt))
+
+(put 'eval-after-load 'lisp-indent-function 1)
+(defun eval-after-load (file form)
+  "Arrange that if FILE is loaded, FORM will be run immediately afterwards.
+If FILE is already loaded, evaluate FORM right now.
+
+If a matching file is loaded again, FORM will be evaluated again.
+
+If FILE is a string, it may be either an absolute or a relative file
+name, and may have an extension (e.g. \".el\") or may lack one, and
+additionally may or may not have an extension denoting a compressed
+format (e.g. \".gz\").
+
+When FILE is absolute, this first converts it to a true name by chasing
+symbolic links.  Only a file of this name (see next paragraph regarding
+extensions) will trigger the evaluation of FORM.  When FILE is relative,
+a file whose absolute true name ends in FILE will trigger evaluation.
+
+When FILE lacks an extension, a file name with any extension will trigger
+evaluation.  Otherwise, its extension must match FILE's.  A further
+extension for a compressed format (e.g. \".gz\") on FILE will not affect
+this name matching.
+
+Alternatively, FILE can be a feature (i.e. a symbol), in which case FORM
+is evaluated at the end of any file that `provide's this feature.
+If the feature is provided when evaluating code not associated with a
+file, FORM is evaluated immediately after the provide statement.
+
+Usually FILE is just a library name like \"font-lock\" or a feature name
+like 'font-lock.
+
+This function makes or adds to an entry on `after-load-alist'."
+  ;; Add this FORM into after-load-alist (regardless of whether we'll be
+  ;; evaluating it now).
+  (let* ((regexp-or-feature
+          (if (stringp file)
+              (setq file (purecopy (load-history-regexp file)))
+            file))
+         (elt (assoc regexp-or-feature after-load-alist)))
+    (unless elt
+      (setq elt (list regexp-or-feature))
+      (push elt after-load-alist))
+    ;; Make sure `form' is evalled in the current lexical/dynamic code.
+    (setq form `(funcall ',(eval `(lambda () ,form) lexical-binding)))
+    ;; Is there an already loaded file whose name (or `provide' name)
+    ;; matches FILE?
+    (prog1 (if (if (stringp file)
+                   (load-history-filename-element regexp-or-feature)
+                 (featurep file))
+               (eval form))
+      (when (symbolp regexp-or-feature)
+        ;; For features, the after-load-alist elements get run when `provide' is
+        ;; called rather than at the end of the file.  So add an indirection to
+        ;; make sure that `form' is really run "after-load" in case the provide
+        ;; call happens early.
+        (setq form
+              `(if load-file-name
+                   (let ((fun (make-symbol "eval-after-load-helper")))
+                     (fset fun `(lambda (file)
+                                  (if (not (equal file ',load-file-name))
+                                      nil
+                                    (remove-hook 'after-load-functions ',fun)
+                                    ,',form)))
+                     (add-hook 'after-load-functions fun))
+                 ;; Not being provided from a file, run form right now.
+                 ,form)))
+      ;; Add FORM to the element unless it's already there.
+      (unless (member form (cdr elt))
+        (nconc elt (list form))))))
+
+(defvar after-load-functions nil
+  "Special hook run after loading a file.
+Each function there is called with a single argument, the absolute
+name of the file just loaded.")
+
+(defun do-after-load-evaluation (abs-file)
+  "Evaluate all `eval-after-load' forms, if any, for ABS-FILE.
+ABS-FILE, a string, should be the absolute true name of a file just loaded.
+This function is called directly from the C code."
+  ;; Run the relevant eval-after-load forms.
+  (mapc #'(lambda (a-l-element)
+            (when (and (stringp (car a-l-element))
+                       (string-match-p (car a-l-element) abs-file))
+              ;; discard the file name regexp
+              (mapc #'eval (cdr a-l-element))))
+        after-load-alist)
+  ;; Complain when the user uses obsolete files.
+  (when (string-match-p "/obsolete/[^/]*\\'" abs-file)
+    (run-with-timer 0 nil
+                    (lambda (file)
+                      (message "Package %s is obsolete!"
+                               (substring file 0
+                                          (string-match "\\.elc?\\>" file))))
+                    (file-name-nondirectory abs-file)))
+  ;; Finally, run any other hook.
+  (run-hook-with-args 'after-load-functions abs-file))
+
+(defun eval-next-after-load (file)
+  "Read the following input sexp, and run it whenever FILE is loaded.
+This makes or adds to an entry on `after-load-alist'.
+FILE should be the name of a library, with no directory name."
+  (declare (obsolete eval-after-load "23.2"))
+  (eval-after-load file (read)))
+
+(defun display-delayed-warnings ()
+  "Display delayed warnings from `delayed-warnings-list'.
+Used from `delayed-warnings-hook' (which see)."
+  (dolist (warning (nreverse delayed-warnings-list))
+    (apply 'display-warning warning))
+  (setq delayed-warnings-list nil))
+
+(defun collapse-delayed-warnings ()
+  "Remove duplicates from `delayed-warnings-list'.
+Collapse identical adjacent warnings into one (plus count).
+Used from `delayed-warnings-hook' (which see)."
+  (let ((count 1)
+        collapsed warning)
+    (while delayed-warnings-list
+      (setq warning (pop delayed-warnings-list))
+      (if (equal warning (car delayed-warnings-list))
+          (setq count (1+ count))
+        (when (> count 1)
+          (setcdr warning (cons (format "%s [%d times]" (cadr warning) count)
+                                (cddr warning)))
+          (setq count 1))
+        (push warning collapsed)))
+    (setq delayed-warnings-list (nreverse collapsed))))
+
+;; At present this is only used for Emacs internals.
+;; Ref http://lists.gnu.org/archive/html/emacs-devel/2012-02/msg00085.html
+(defvar delayed-warnings-hook '(collapse-delayed-warnings
+                                display-delayed-warnings)
+  "Normal hook run to process and display delayed warnings.
+By default, this hook contains functions to consolidate the
+warnings listed in `delayed-warnings-list', display them, and set
+`delayed-warnings-list' back to nil.")
+
+
 ;;;; invisibility specs
 
 (defun add-to-invisibility-spec (element)
@@ -4189,32 +4234,6 @@ use `called-interactively-p'."
   (declare (obsolete called-interactively-p "23.2"))
   (called-interactively-p 'interactive))
 
-(defun function-arity (f &optional num)
-  "Return the (MIN . MAX) arity of F.
-If the maximum arity is infinite, MAX is `many'.
-F can be a function or a macro.
-If NUM is non-nil, return non-nil iff F can be called with NUM args."
-  (if (symbolp f) (setq f (indirect-function f)))
-  (if (eq (car-safe f) 'macro) (setq f (cdr f)))
-  (let ((res
-         (if (subrp f)
-             (let ((x (subr-arity f)))
-               (if (eq (cdr x) 'unevalled) (cons (car x) 'many)))
-           (let* ((args (if (consp f) (cadr f) (aref f 0)))
-                  (max (length args))
-                  (opt (memq '&optional args))
-                  (rest (memq '&rest args))
-                  (min (- max (length opt))))
-             (if opt
-                 (cons min (if rest 'many (1- max)))
-               (if rest
-                   (cons (- max (length rest)) 'many)
-                 (cons min max)))))))
-    (if (not num)
-        res
-      (and (>= num (car res))
-           (or (eq 'many (cdr res)) (<= num (cdr res)))))))
-
 (defun set-temporary-overlay-map (map &optional keep-pred)
   "Set MAP as a temporary keymap taking precedence over most other keymaps.
 Note that this does NOT take precedence over the \"overriding\" maps
@@ -4432,32 +4451,16 @@ convenience wrapper around `make-progress-reporter' and friends.
 
 ;;;; Support for watching filesystem events.
 
-(defun inotify-event-p (event)
-  "Check if EVENT is an inotify event."
-  (and (listp event)
-       (>= (length event) 3)
-       (eq (car event) 'file-inotify)))
-
-;;;###autoload
-(defun inotify-handle-event (event)
-  "Handle inotify file system monitoring event.
-If EVENT is an inotify filewatch event, call its callback.
-Otherwise, signal a `filewatch-error'."
-  (interactive "e")
-  (unless (inotify-event-p event)
-    (signal 'filewatch-error (cons "Not a valid inotify event" event)))
-  (funcall (nth 2 event) (nth 1 event)))
-
-(defun w32notify-handle-event (event)
-  "Handle MS-Windows file system monitoring event.
-If EVENT is an MS-Windows filewatch event, call its callback.
+(defun file-notify-handle-event (event)
+  "Handle file system monitoring event.
+If EVENT is a filewatch event, call its callback.
 Otherwise, signal a `filewatch-error'."
   (interactive "e")
-  (if (and (eq (car event) 'file-w32notify)
-           (= (length event) 3))
+  (if (and (eq (car event) 'file-notify)
+           (>= (length event) 3))
       (funcall (nth 2 event) (nth 1 event))
     (signal 'filewatch-error
-            (cons "Not a valid MS-Windows file-notify event" event))))
+            (cons "Not a valid file-notify event" event))))
 
 
 ;;;; Comparing version strings.
diff --git a/lisp/term/ns-win.el b/lisp/term/ns-win.el
index 0d4d3aaa26b..0298ad81a34 100644
--- a/lisp/term/ns-win.el
+++ b/lisp/term/ns-win.el
@@ -558,6 +558,11 @@ unless the current buffer is a scratch buffer."
   (other-frame -1))
 
 ;; If no position specified, make new frame offset by 25 from current.
+;; You'd think this was a window manager's job, but apparently without
+;; this, new frames open exactly on top of old ones (?).
+;; http://lists.gnu.org/archive/html/emacs-devel/2010-10/msg00988.html
+;; Note that AFAICS it is not documented that functions on
+;; before-make-frame-hook can access PARAMETERS.
 (defvar parameters)                  ; dynamically bound in make-frame
 (add-hook 'before-make-frame-hook
           (lambda ()
diff --git a/lisp/vc/log-view.el b/lisp/vc/log-view.el
index b633b7be403..de103c0cdb6 100644
--- a/lisp/vc/log-view.el
+++ b/lisp/vc/log-view.el
@@ -1,9 +1,9 @@
-;;; log-view.el --- Major mode for browsing RCS/CVS/SCCS log output -*- lexical-binding: t -*-
+;;; log-view.el --- Major mode for browsing revision log histories -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1999-2013 Free Software Foundation, Inc.
 
 ;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
-;; Keywords: rcs, sccs, cvs, log, vc, tools
+;; Keywords: tools, vc
 
 ;; This file is part of GNU Emacs.
 
@@ -24,10 +24,12 @@
 
 ;; Major mode to browse revision log histories.
 ;; Currently supports the format output by:
-;;  RCS, SCCS, CVS, Subversion, and DaRCS.
+;; SCCS, RCS, CVS, Subversion, DaRCS, and Mercurial.
 
 ;; Examples of log output:
 
+;;;; SCCS:
+
 ;;;; RCS/CVS:
 
 ;; ----------------------------
@@ -43,8 +45,6 @@
 ;; Change release version from 21.4 to 22.1 throughout.
 ;; Change development version from 21.3.50 to 22.0.50.
 
-;;;; SCCS:
-
 ;;;; Subversion:
 
 ;; ------------------------------------------------------------------------
@@ -117,18 +117,25 @@
 (defvar cvs-force-command)
 
 (defgroup log-view nil
-  "Major mode for browsing log output of RCS/CVS/SCCS."
+  "Major mode for browsing log output of revision log histories."
   :group 'pcl-cvs
   :prefix "log-view-")
 
 (easy-mmode-defmap log-view-mode-map
   '(
-    ;; FIXME: (copy-keymap special-mode-map) instead
-    ("z" . kill-this-buffer)
-    ("q" . quit-window)
-    ("g" . revert-buffer)
-    ("\C-m" . log-view-toggle-entry-display)
+    ("-"        .       negative-argument)
+    ("0"        .       digit-argument)
+    ("1"        .       digit-argument)
+    ("2"        .       digit-argument)
+    ("3"        .       digit-argument)
+    ("4"        .       digit-argument)
+    ("5"        .       digit-argument)
+    ("6"        .       digit-argument)
+    ("7"        .       digit-argument)
+    ("8"        .       digit-argument)
+    ("9"        .       digit-argument)
 
+    ("\C-m" . log-view-toggle-entry-display)
     ("m" . log-view-toggle-mark-entry)
     ("e" . log-view-modify-change-comment)
     ("d" . log-view-diff)
@@ -145,6 +152,7 @@
     ("\M-n" . log-view-file-next)
     ("\M-p" . log-view-file-prev))
   "Log-View's keymap."
+  :inherit special-mode-map
   :group 'log-view)
 
 (easy-menu-define log-view-mode-menu log-view-mode-map
@@ -275,6 +283,7 @@ The match group number 1 should match the revision number itself.")
 (easy-mmode-define-navigation log-view-file log-view-file-re "file")
 
 (defun log-view-goto-rev (rev)
+  "Go to revision REV."
   (goto-char (point-min))
   (ignore-errors
     (while (not (equal rev (log-view-current-tag)))
@@ -288,6 +297,7 @@ The match group number 1 should match the revision number itself.")
 (defconst log-view-dir-re "^cvs[.ex]* [a-z]+: Logging \\(.+\\)$")
 
 (defun log-view-current-file ()
+  "Return the current file."
   (save-excursion
     (forward-line 1)
     (or (re-search-backward log-view-file-re nil t)
@@ -340,7 +350,7 @@ if POS is omitted or nil, it defaults to point."
 
 (defun log-view-toggle-mark-entry ()
   "Toggle the marked state for the log entry at point.
-Individual log entries can be marked and unmarked. The marked
+Individual log entries can be marked and unmarked.  The marked
 entries are denoted by changing their background color.
 `log-view-get-marked' returns the list of tags for the marked
 log entries."
@@ -479,7 +489,8 @@ It assumes that a log entry starts with a line matching
       (funcall f))))
 
 (defun log-view-find-revision (pos)
-  "Visit the version at point."
+  "Visit the version at POS.
+If called interactively, visit the version at point."
   (interactive "d")
   (unless log-view-per-file-logs
     (when (> (length log-view-vc-fileset) 1)
@@ -521,7 +532,8 @@ It assumes that a log entry starts with a line matching
                             (log-view-extract-comment)))
 
 (defun log-view-annotate-version (pos)
-  "Annotate the version at point."
+  "Annotate the version at POS.
+If called interactively, annotate the version at point."
   (interactive "d")
   (unless log-view-per-file-logs
     (when (> (length log-view-vc-fileset) 1)
diff --git a/lisp/vc/vc.el b/lisp/vc/vc.el
index 5e1d27c0ea3..0308dd1ebd4 100644
--- a/lisp/vc/vc.el
+++ b/lisp/vc/vc.el
@@ -115,10 +115,10 @@
 ;;   Return non-nil if FILE is registered in this backend.  Both this
 ;;   function as well as `state' should be careful to fail gracefully
 ;;   in the event that the backend executable is absent.  It is
-;;   preferable that this function's body is autoloaded, that way only
+;;   preferable that this function's *body* is autoloaded, that way only
 ;;   calling vc-registered does not cause the backend to be loaded
 ;;   (all the vc-FOO-registered functions are called to try to find
-;;   the controlling backend for FILE.
+;;   the controlling backend for FILE).
 ;;
 ;; * state (file)
 ;;
@@ -233,6 +233,7 @@
 ;;   The implementation should pass the value of vc-register-switches
 ;;   to the backend command.  (Note: in older versions of VC, this
 ;;   command took a single file argument and not a list.)
+;;   The REV argument is a historical leftover and is never used.
 ;;
 ;; - init-revision (file)
 ;;
@@ -999,7 +1000,7 @@ current buffer."
                 nil)
         (list (vc-backend-for-registration (buffer-file-name))
               (list buffer-file-name))))
-     (t (error "No fileset is available here")))))
+     (t (error "File is not under version control")))))
 
 (defun vc-dired-deduce-fileset ()
   (let ((backend (vc-responsible-backend default-directory)))
@@ -1041,6 +1042,11 @@ current buffer."
    (eq p q)
    (and (member p '(edited added removed)) (member q '(edited added removed)))))
 
+(defun vc-read-backend (prompt)
+  (intern
+   (completing-read prompt (mapcar 'symbol-name vc-handled-backends)
+                    nil 'require-match)))
+
 ;; Here's the major entry point.
 
 ;;;###autoload
@@ -1099,8 +1105,9 @@ For old-style locking-based version control systems, like RCS:
      ((or (eq state 'up-to-date) (and verbose (eq state 'needs-update)))
       (cond
        (verbose
-        ;; go to a different revision
+        ;; Go to a different revision.
         (let* ((revision
+                ;; FIXME: Provide completion.
                 (read-string "Branch, revision, or backend to move to: "))
                (revision-downcase (downcase revision)))
           (if (member
@@ -1161,15 +1168,10 @@ For old-style locking-based version control systems, like RCS:
             (message "No files remain to be committed")
           (if (not verbose)
               (vc-checkin ready-for-commit backend)
-            (let* ((revision (read-string "New revision or backend: "))
-                   (revision-downcase (downcase revision)))
-              (if (member
-                   revision-downcase
-                   (mapcar (lambda (arg) (downcase (symbol-name arg)))
-                           vc-handled-backends))
-                  (let ((vsym (intern revision-downcase)))
-                    (dolist (file files) (vc-transfer-file file vsym)))
-                (vc-checkin ready-for-commit backend revision)))))))
+            (let ((new-backend (vc-read-backend "New backend: ")))
+              (if new-backend
+                  (dolist (file files)
+                    (vc-transfer-file file new-backend))))))))
      ;; locked by somebody else (locking VCSes only)
      ((stringp state)
       ;; In the old days, we computed the revision once and used it on