Merge from trunk

176 files changed, 3292 insertions, 1882 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 62d3097cca..d56e0e88f9 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,599 @@
+2012-09-17  Richard Stallman  <[email protected]>
+
+	* epa-mail.el (epa-mail-encrypt): Fix bug when a name has no key.
+
+2012-09-17  Chong Yidong  <[email protected]>
+
+	* shell.el (shell-file-name-chars, shell-file-name-quote-list)
+	(shell-dynamic-complete-functions): Convert to defcustom.
+	(shell-prompt-pattern, shell-completion-fignore): Doc fix.
+
+	* bookmark.el (bookmark-bmenu-toggle-filenames): Doc fixes.
+	* comint.el (comint-prompt-read-only):
+	* custom.el (defcustom):
+	* hi-lock.el (hi-lock-mode):
+	* ibuffer.el (ibuffer-formats):
+	* ielm.el (ielm-prompt-read-only):
+	* novice.el (disable-command):
+	* saveplace.el (toggle-save-place):
+	* speedbar.el (speedbar-supported-extension-expressions):
+	* startup.el (auto-save-list-file-prefix, init-file-user)
+	(after-init-hook, inhibit-startup-echo-area-message):
+	* strokes.el (strokes-help):
+	* time-stamp.el (time-stamp):
+	* calendar/calendar.el (calendar, diary-file):
+	* calendar/diary-lib.el (diary-mail-entries, diary)
+	(diary-list-entries-hook):
+	* calendar/holidays.el (holidays, calendar-holidays):
+	* calendar/lunar.el (lunar-phases):
+	* calendar/solar.el (sunrise-sunset):
+	* emulation/edt.el (edt-load-keys):
+	* emulation/viper.el (viper-mode):
+	* eshell/em-alias.el (eshell-command-aliases-list):
+	* eshell/esh-util.el (eshell-convert-numeric-arguments):
+	* international/ogonek.el (ogonek-information):
+	* net/tramp-cmds.el (tramp-bug):
+	* net/quickurl.el (quickurl-reread-hook-postfix):
+	* play/decipher.el (decipher-font-lock-keywords):
+	* progmodes/cc-styles.el (c-set-style):
+	* progmodes/idlw-shell.el (idlwave-shell-prompt-pattern):
+	* progmodes/inf-lisp.el (inferior-lisp-prompt):
+	* progmodes/octave-mod.el (octave-mode):
+	* progmodes/sql.el (sql-mode, sql-interactive-mode, sql-password):
+	* progmodes/verilog-mode.el (verilog-read-defines):
+	* textmodes/two-column.el (2C-mode): Likewise.
+
+2012-09-16  Katsumi Yamaoka  <[email protected]>
+
+	* mail/mailabbrev.el (mail-abbrev-expand-hook): Work for a mail aliasee
+	that holds many addresses.
+
+2012-09-16  Chong Yidong  <[email protected]>
+
+	* align.el (align-areas): Call the indication function with
+	positions instead of markers for arguments (Bug#12343).
+
+	* files.el (parse-colon-path): Use split-string (Bug#12351).
+
+	* window.el (special-display-popup-frame): Doc fix (Bug#8853).
+	(display-buffer-function): Mark as obsolete.
+
+	* progmodes/compile.el (compilation-parse-errors): Accept list
+	values similar to font-lock-keywords (Bug#12136).  Suggested by
+	Oleksandr Manzyuk.
+	(compilation-error-regexp-alist): Doc fix.
+
+2012-09-15  Glenn Morris  <[email protected]>
+
+	* version.el (emacs-bzr-version-bzr): New function.
+	(emacs-bzr-get-version): Add optional EXTERNAL argument.
+
+	* vc/vc-bzr.el (vc-bzr-working-revision): For lightweight local
+	checkouts, check the parent dirstate matches the branch.
+	Add "--tree" to "bzr revno" arguments.  Don't try to shorten the
+	empty string.
+
+	* version.el (emacs-bzr-version): Doc fix.
+	(emacs-bzr-version-dirstate): New function.
+	(emacs-bzr-get-version): For lightweight checkouts, if the parent
+	is local try and check that it matches the branch.  If not, just
+	use dirstate information.  (Bug#12441)
+
+2012-09-14  Juri Linkov  <[email protected]>
+
+	* dired-aux.el (dired-do-chmod): Use `eq' to detect empty input.
+	(Bug#12399)
+
+2012-09-14  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/advice.el (ad-prognify): Remove, use macroexp-progn.
+
+	* emacs-lisp/edebug.el: Miscellaneous cleanup.
+	Remove obsolete byte-compiler hack that tried to silence some warnings.
+	(edebug-submit-bug-report): Remove.
+	(edebug-get-buffer-window, edebug-sit-for, edebug-input-pending-p):
+	Remove aliases, use the un-prefixed name instead.
+	(edebug-pop-to-buffer): Consider other frames.
+	(edebug-original-read):: Make it more obvious that it's always defined.
+	(edebug--make-form-data-entry, edebug--form-data-name)
+	(edebug--form-data-begin, edebug--form-data-end): Rename from the
+	single-dashed name, and implement with cl-defstruct.
+	(edebug-set-form-data-entry): Use the standard accessors.
+	(edebug-make-top-form-data-entry): Use push.
+	(edebug-no-match): Drop useless `funcall'.
+	(mapcar, mapconcat, mapatoms, apply, funcall): Don't add debug specs
+	to functions.
+	(defsubst, dont-compile, eval-when-compile, eval-and-compile)
+	(delay-mode-hooks, with-temp-file, with-temp-message, ad-dolist)
+	(with-syntax-table, push, pop, 1value, noreturn, defadvice)
+	(easy-menu-define, with-custom-print): Remove redundant specs.
+	(edebug-outside-overriding-local-map)
+	(edebug-outside-overriding-terminal-local-map): Remove, unused.
+	(edebug--display): Bind unread-command-events directly to nil rather
+	than binding it to unread-command-events and later setting it to nil.
+	(edebug--display): Kill edebug-eval-buffer here...
+	(edebug--recursive-edit): ...rather than here.
+	Bind standard-output and standard-input.
+	(edebug-eval): Check cl-macroexpand-all is fboundp.
+	(edebug-temp-display-freq-count): Fix last change.
+
+	* emacs-lisp/easymenu.el (easy-menu-define): Add `debug' spec.
+	* subr.el (noreturn, 1value): Add `debug' spec.
+	* emacs-lisp/advice.el: Require cl-lib.
+	(ad-copy-tree): Remove, use copy-tree instead.
+	(ad-dolist): Remove use dolist or cl-dolist instead.
+	(ad-do-return): Remove, use cl-return instead.
+	(defadvice): Add `debug' spec.
+
+2012-09-13  Juri Linkov  <[email protected]>
+
+	* dired-aux.el (dired-do-chxxx): Use `eq' to detect empty input.
+	(Bug#12399)
+
+2012-09-13  Glenn Morris  <[email protected]>
+
+	* calc/calc.el (math-compose-expr):
+	* calc/calc-ext.el (math-compose-expr):
+	* progmodes/cc-defs.el (cl-macroexpand-all):
+	* progmodes/cc-langs.el (delete-duplicates, mapcan)
+	(cl-macroexpand-all): Update declarations.
+
+	* vc/vc.el: No need to require ediff.
+	(ediff-load-version-control): Declare.
+	(ediff-vc-internal): Fix declaration.
+	(vc-version-ediff): Require ediff.
+
+2012-09-13  Paul Eggert  <[email protected]>
+
+	Use a more backwards-compatible timer format (Bug#12430).
+	* emacs-lisp/timer.el (timer): PSECS is now at the end, rather than
+	being right after USECS, as that better supports old code that
+	inadvisedly looked directly at the timer vector.
+
+2012-09-13  Kenichi Handa  <[email protected]>
+
+	* language/chinese.el ("Chinese-GB", "Chinese-BIG5")
+	("Chinese-CNS", "Chinese-EUC-TW"): Add chinese-gbk to
+	`coding-priority' property of these language environment.
+
+2012-09-13  Paul Eggert  <[email protected]>
+
+	Fix glitches caused by addition of psec to timers (Bug#12430).
+	* image.el (image-animate-timer):
+	* time.el (display-time-world-timer):
+	Use timer--function and timer--args rather than raw access to
+	timer vector.
+
+2012-09-13  Glenn Morris  <[email protected]>
+
+	* emacs-lisp/bytecomp.el (byte-compile-warning-prefix):
+	If not compiling a file, try using load-file-name.
+
+2012-09-13  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/edebug.el (edebug-outside-unread-command-events):
+	Fix last change.
+	(edebug-update-eval-list): Use `push'.
+
+	* emacs-lisp/edebug.el: Use lexical-binding.
+	Remove the "edebug-" prefix from non-dynamically-scoped variables.
+	Mark unused args with underscore.
+	(edebug-save-restriction, edebug-outside-excursion): Use `declare'.
+	(edebug-form-data): Use defvar-local.
+	(edebug-make-before-and-after-form, edebug-make-after-form):
+	Use backquote.
+	(edebug-args, edebug-value, edebug-after-index, edebug-arg-mode):
+	Not dynamically scoped any more.
+	(edebug--enter-trace): Add arguments `function' and `args'.
+	Rename from edebug-enter-trace.
+	(edebug-enter): Call it accordingly.  Bind edebug-function explicitly.
+	(edebug--update-coverage): Add `after-index' and `value' args.
+	Rename from edebug-update-coverage.
+	(edebug-slow-after): Call it accordingly.
+	(edebug--recursive-edit): Add arg `arg-mode'.  Rename from
+	edebug-recursive-edit.
+	(edebug--display): Call it accordingly.  Add args `value',
+	`offset-index', and `arg-mode'.  Rename from edebug-display.
+	(edebug-debugger, edebug): Call it accordingly.
+	(edebug-eval-display-list): Use dolist.
+
+2012-09-12  Juri Linkov  <[email protected]>
+
+	* info.el (Info-search): Don't check for isearch-mode and
+	isearch-regexp before let-binding search-spaces-regexp to
+	Info-search-whitespace-regexp.
+	(Info-isearch-search): Let-bind Info-search-whitespace-regexp to
+	search-whitespace-regexp if isearch-lax-whitespace or
+	isearch-regexp-lax-whitespace is non-nil.
+	(Info-mode): Don't set local variable search-whitespace-regexp.
+	http://lists.gnu.org/archive/html/emacs-devel/2012-08/msg00811.html
+
+2012-09-12  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/debug.el (debugger-outer-unread-command-char, debug)
+	(debugger-env-macro): Remove support for unread-command-char.
+
+	* subr.el (set-temporary-overlay-map): Minimize slightly the impact of
+	the temporary map re-appearing on emulation-mode-map-alists.
+
+	* emacs-lisp/edebug.el (def-edebug-form-spec): Remove, it's been broken
+	since 22.1.
+
+	* ehelp.el (with-electric-help): Accept functions in
+	electric-help-form-to-execute.
+	(electric-help-execute-extended, electric-help-ctrl-x-prefix): Use it.
+	And replace unread-command-char -> unread-command-events.
+
+2012-09-12  Michael Albinus  <[email protected]>
+
+	Sync with Tramp 2.2.6.
+
+	* net/tramp.el (tramp-accept-process-output): Don't use
+	JUST-THIS-ONE in the XEmacs case.
+
+	* net/trampver.el: Update release number.
+
+2012-09-12  Martin Rudalics  <[email protected]>
+
+	* emacs-lisp/debug.el (debugger-previous-window-height):
+	New variable.
+	(debug): When debugger-jumping-flag is non-nil try to restore
+	height of debugger window.  (Bug#8789)
+
+2012-09-12  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/edebug.el (edebug-enter): Don't mess with
+	overriding-local-map and pre/post-command-hook here.
+	(edebug-recursive-edit): Do it here instead (bug#12345).
+	(edebug-outside-unread-command-char): Remove all uses of
+	unread-command-char.
+
+	* emacs-lisp/debug.el (debug): Don't bind debug-on-error since
+	inhibit-debugger is bound instead.
+
+2012-09-11  Bastien Guerry  <[email protected]>
+
+	* subr.el (set-temporary-overlay-map): Add a docstring.
+	(Bug#12346)
+
+2012-09-11  Bastien Guerry  <[email protected]>
+
+	* minibuffer.el (completion-table-subvert): Fix docstring.
+	(Bug#12347)
+
+2012-09-11  Bastien Guerry  <[email protected]>
+
+	* help-fns.el (describe-variable): Fix typo.  (Bug#12346)
+
+2012-09-10  Michael R. Mauger  <[email protected]>
+
+	* progmodes/sql.el: Version 3.1
+	(sql-db2-escape-newlines): New variable.
+	(sql-escape-newlines-filter): Use it.
+
+2012-09-10  Juanma Barranquero  <[email protected]>
+
+	* custom.el (custom-theme-load-confirm): Remove unneeded assignment.
+
+2012-09-10  Dan Nicolaescu  <[email protected]>
+
+	* vc/diff-mode.el (diff-mode-menu):
+	Bind diff-remove-trailing-whitespace.
+
+2012-09-10  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/lisp-mode.el (emacs-list-byte-code-comment-re): New var.
+	(emacs-lisp-byte-code-comment, emacs-lisp-byte-code-syntax-propertize)
+	(emacs-lisp-byte-code-mode): New functions.
+	(eval-sexp-add-defvars): Don't skip defvars in column >0.
+	(eval-defun-2): Remove bogus interactive spec.
+	(lisp-indent-line): Remove redundant whole-exp code, now done in
+	indent-according-to-mode.
+	(save-match-data): Remove redundant indent data.
+
+	* emacs-lisp/benchmark.el (benchmark-run, benchmark-run-compiled):
+	Use `declare'.
+
+2012-09-09  Juri Linkov  <[email protected]>
+
+	* replace.el (replace-regexp-lax-whitespace): New defcustom.
+	(replace-lax-whitespace, query-replace-regexp)
+	(query-replace-regexp-eval, replace-regexp): Doc fix.
+	(perform-replace, replace-highlight): Let-bind
+	isearch-lax-whitespace to replace-lax-whitespace and
+	isearch-regexp-lax-whitespace to replace-regexp-lax-whitespace.
+
+	* isearch.el (isearch-query-replace): Let-bind
+	replace-lax-whitespace to isearch-lax-whitespace and
+	replace-regexp-lax-whitespace to
+	isearch-regexp-lax-whitespace.  (Bug#10885)
+
+2012-09-09  Stefan Monnier  <[email protected]>
+
+	* eshell/em-unix.el (eshell/sudo): Explicitly drop return value.
+
+2012-09-09  Alan Mackenzie  <[email protected]>
+
+	* progmodes/cc-engine.el (c-state-cache-init):
+	Initialise c-state-semi-nonlit-pos-cache\(-limit\)? properly.
+	(c-record-parse-state-state):
+	Record c-state-semi-nonlit-pos-cache\(-limit\)?.
+
+2012-09-09  Andreas Schwab  <[email protected]>
+
+	* register.el (register-separator): Rename from
+	separator-register.  All uses changed.  Doc fix.
+	(register): Fix version.
+
+2012-09-09  Chong Yidong  <[email protected]>
+
+	* replace.el (query-replace-map): Bind four new symbols for
+	requesting window scrolling.
+
+	* subr.el (y-or-n-p): Handle the window-scrolling bindings in
+	query-replace-map (Bug#8948).
+
+	* custom.el (custom-theme-load-confirm): Use y-or-n-p.
+
+	* emacs-lisp/map-ynp.el (map-y-or-n-p): Don't bind scrolling keys
+	since they are now in query-replace-map.
+
+	* window.el (scroll-other-window-down): Make the arg optional.
+
+2012-09-09  Chong Yidong  <[email protected]>
+
+	* files.el (hack-local-variables-confirm): Use quit-window to kill
+	the *Local Variables* buffer.
+
+2012-09-08  Dmitry Gutov  <[email protected]>
+
+	* progmodes/ruby-mode.el (ruby-toggle-block): Guess the current block,
+	not just expect to be at its beginning.  Adjust callees.
+	Succeed when do-end block has no space before the pipe character.
+	(ruby-brace-to-do-end): When the original block is one-liner,
+	convert to multiline.  Reindent the result.
+
+2012-09-08  Jambunathan K  <[email protected]>
+
+	* register.el (register): New group.
+	(register-separator): New user option.
+	(increment-register): Route it to `append-to-register', if
+	register contains text.  Implication is that `C-x r +' can now be
+	used for appending to a text register (bug#12217).
+	(append-to-register, prepend-to-register): Add separator based on
+	`register-separator.
+
+2012-09-08  Alan Mackenzie  <[email protected]>
+
+	AWK Mode: make auto-newline work when there's "==" in the pattern.
+	* progmodes/cc-cmds.el (c-point-syntax): Handle virtual semicolons
+	correctly.
+	* progmodes/cc-engine.el (c-guess-basic-syntax CASE 5A.3):
+	Test more rigorously for "=" token.
+
+2012-09-08  Dmitry Gutov  <[email protected]>
+
+	* progmodes/ruby-mode.el (ruby-match-expression-expansion):
+	Only fail when reached LIMIT.
+
+2012-09-08  Chong Yidong  <[email protected]>
+
+	* dired.el (dired-mode-map): Don't bind M-=.
+
+	* dired-aux.el (dired-diff): Use backup file as default.
+
+2012-09-08  Drew Adams  <[email protected]>
+
+	* subr.el (add-to-history): Fix delete usage (Bug#12314).
+
+2012-09-08  Chong Yidong  <[email protected]>
+
+	* subr.el (syntax-after, syntax-class): Doc fix.
+
+2012-09-08  Martin Rudalics  <[email protected]>
+
+	* window.el (display-buffer-in-previous-window): New buffer
+	display action function.
+
+	* emacs-lisp/debug.el (debugger-bury-or-kill): New option.
+	(debugger-previous-window): New variable.
+	(debug): Rewrite using display-buffer-in-previous-window,
+	quit-restore-window and debugger-bury-or-kill.  (Bug#8789)
+
+2012-09-07  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/byte-run.el (defun): Tweak message.  Simplify code.
+
+2012-09-07  Matt McClure  <[email protected]>  (tiny change)
+
+	* progmodes/python.el (python-shell-send-string):
+	When default-directory is remote, create temp file on remote
+	filesystem.
+	(python-shell-send-file): When file is remote, pass local view of
+	file paths to remote Python interpreter.  (Bug#12340)
+
+2012-09-07  Chong Yidong  <[email protected]>
+
+	* window.el (switch-to-buffer): Doc fix (Bug#12181).
+
+	* files.el (after-find-file): Don't fail on a read-only buffer if
+	require-final-newline is `visit' or `visit-save' (Bug#11156).
+
+	* subr.el (read-char-choice): Allow quitting via ESC ESC.
+
+	* userlock.el (ask-user-about-supersession-threat):
+	Use read-char-choice (Bug#12093).
+
+2012-09-07  Chong Yidong  <[email protected]>
+
+	* subr.el (buffer-narrowed-p): New function.
+
+	* ses.el (ses-widen):
+	* simple.el (count-words--buffer-message):
+	* net/browse-url.el (browse-url-of-buffer): Use it
+
+	* simple.el (count-words-region): Don't signal an error if there
+	is a non-nil prefix arg and the mark is not set.
+
+	* help.el (describe-key-briefly): Allow the message to be seen
+	when invoked from the minibuffer (Bug#7014).
+
+2012-09-07  Dmitry Gutov  <[email protected]>
+
+	* progmodes/ruby-mode.el (ruby-end-of-defun)
+	(ruby-beginning-of-defun): Simplify, allow indentation before
+	block beginning and end keywords.
+	(ruby-beginning-of-defun): Only consider 3 keywords defun beginners.
+	(ruby-end-of-defun): Expect that the point is at the beginning of
+	the defun.
+
+2012-09-06  Stefan Monnier  <[email protected]>
+
+	* emacs-lisp/cl-macs.el (cl--do-arglist): Understand _ on &key args
+	(bug#12367).
+	(cl--make-usage-args): Strip _ from argument names.
+
+2012-09-06  Rüdiger Sonderfeld  <[email protected]>
+
+	* progmodes/vhdl-mode.el (vhdl-speedbar-initialize): Don't use
+	obsolete alias speedbar-key-map.
+	(vhdl-doc-variable, vhdl-doc-mode): Use called-interactively-p.
+	(vhdl-index-menu-init): Don't use obsolete variable
+	font-lock-maximum-size.
+
+2012-09-06  Chong Yidong  <[email protected]>
+
+	* frame.el (window-system-version): Mark as obsolete.
+
+	* speedbar.el (speedbar-update-flag, speedbar-mode): Remove uses
+	of obsolete variable speedbar-key-map.
+
+2012-09-06  Juri Linkov  <[email protected]>
+
+	* replace.el (replace-lax-whitespace): New defcustom.
+	(query-replace, query-replace-regexp, query-replace-regexp-eval)
+	(replace-string, replace-regexp): Mention it in docstrings.
+	(perform-replace, replace-highlight): Let-bind
+	isearch-lax-whitespace and isearch-regexp-lax-whitespace according
+	to the values of replace-lax-whitespace and regexp-flag.
+	Don't let-bind search-whitespace-regexp.  (Bug#10885)
+
+	* isearch.el (isearch-query-replace): Let-bind
+	replace-lax-whitespace instead of let-binding
+	replace-search-function and replace-re-search-function.
+	(isearch-lazy-highlight-search): Let-bind isearch-lax-whitespace
+	and isearch-regexp-lax-whitespace to lazy-highlight variables.
+	(isearch-toggle-symbol): Set isearch-regexp to nil
+	in isearch-word mode (like in isearch-toggle-word).
+
+2012-09-06  Juri Linkov  <[email protected]>
+
+	* replace.el (replace-search-function)
+	(replace-re-search-function): Set default values to nil.
+	(perform-replace): Let-bind isearch-related variables based on
+	replace-related values, call `isearch-search-fun' and let-bind
+	the result to `search-function'.  Remove code that sets
+	`search-function' and `search-string' separately for
+	`delimited-flag'.
+	(replace-highlight): Add new argument `delimited-flag' and
+	rename other arguments to the names used in `perform-replace'.
+	Let-bind `isearch-word' to the argument `delimited-flag'.
+	(Bug#10885, bug#10887)
+
+2012-09-07  Dmitry Gutov  <[email protected]>
+
+	* progmodes/ruby-mode.el (ruby-indent-beg-re): Add pieces from
+	ruby-beginning-of-indent, simplify, allow all keywords to have
+	indentation before them.
+	(ruby-beginning-of-indent): Adjust for above.  Search until the
+	found point is not inside a string or comment.
+	(ruby-font-lock-keywords): Allow symbols to start with "@"
+	character, give them higher priority than variables.
+	(ruby-syntax-propertize-function)
+	(ruby-font-lock-syntactic-keywords): Remove the "not comments"
+	matchers.  Expression expansions are not comments when inside a
+	string, and there comment syntax status is irrelevant.
+	(ruby-match-expression-expansion): New function.  Check that
+	expression expansion is inside a string, and it's not escaped.
+	(ruby-font-lock-keywords): Use it.
+
+2012-09-05  Martin Rudalics  <[email protected]>
+
+	* help.el (temp-buffer-max-height): New default value.
+	(temp-buffer-resize-frames): New option.
+	(resize-temp-buffer-window): Optionally resize frame.
+
+	* window.el (fit-frame-to-buffer-bottom-margin): New option.
+	(fit-frame-to-buffer): New function.
+
+2012-09-05  Glenn Morris  <[email protected]>
+
+	* emulation/cua-rect.el (cua--init-rectangles):
+	* textmodes/picture.el (picture-mode-map):
+	* play/blackbox.el (blackbox-mode-map): Remap right-char and left-char
+	like forward-char and backward-char.  (Bug#12317)
+
+2012-09-05  Leo Liu  <[email protected]>
+
+	* progmodes/flymake.el (flymake-warning-re): New variable.
+	(flymake-parse-line): Use it.
+
+2012-09-05  Glenn Morris  <[email protected]>
+
+	* calendar/holidays.el (holiday-christian-holidays):
+	Rename an entry.  (Bug#12289)
+
+2012-09-05  Stefan Monnier  <[email protected]>
+
+	* progmodes/sh-script.el (sh-font-lock-paren): Don't burp at BOB
+	(bug#12222).
+
+2012-09-04  Stefan Monnier  <[email protected]>
+
+	* loadup.el: Load macroexp.  Remove hack.
+	* emacs-lisp/macroexp.el (macroexp--eval-if-compile): New function.
+	(macroexp--expand-all): Use it to get better warnings.
+	(macroexp--backtrace, macroexp--trim-backtrace-frame)
+	(internal-macroexpand-for-load): New functions.
+	(macroexp--pending-eager-loads): New var.
+	(emacs-startup-hook): New hack to replace one in loadup.el.
+	* emacs-lisp/cl-macs.el (cl--compiler-macro-list*)
+	(cl--compiler-macro-cXXr): Move to top, before they can be used.
+	(cl-psetf): Simplify.
+	(cl-defstruct): Add indent rule.
+
+2012-09-04  Lars Ingebrigtsen  <[email protected]>
+
+	* mail/smtpmail.el (smtpmail-send-it): Prefer the From: header
+	over `user-mail-address' for the SMTP MAIL FROM envelope.
+	(smtpmail-via-smtp): Ditto.
+
+2012-09-04  Dmitry Gutov  <[email protected]>
+
+	* progmodes/ruby-mode.el: Clean up keybindings.
+	(ruby-mode-map): Don't bind ruby-electric-brace,
+	ruby-beginning-of-defun, ruby-end-of-defun, ruby-mark-defun,
+	backward-kill-word, reindent-then-newline-and-indent.
+	(ruby-mark-defun): Remove.
+	(ruby-electric-brace): Remove.  Obsoleted by electric-indent-chars.
+	(ruby-mode): Set local beginning-of-defun-function and
+	end-of-defun-function values.
+
+2012-09-03  Martin Rudalics  <[email protected]>
+
+	* window.el (temp-buffer-window-setup-hook)
+	(temp-buffer-window-show-hook): New hooks.
+	(temp-buffer-window-setup, temp-buffer-window-show)
+	(with-temp-buffer-window): New functions.
+	(fit-window-to-buffer): Remove unused optional argument OVERRIDE.
+	(special-display-popup-frame): Make sure the window used shows BUFFER.
+
+	* help.el (temp-buffer-resize-mode): Fix doc-string.
+	(resize-temp-buffer-window): New optional argument WINDOW.
+
+	* files.el (recover-file, save-buffers-kill-emacs):
+	* dired.el (dired-mark-pop-up): Use with-temp-buffer-window.
+
 2012-09-02  Michael Albinus  <[email protected]>
 
 	* eshell/em-unix.el (eshell/sudo): When we have an ad-hoc
@@ -132,8 +728,8 @@
 2012-08-29  Michael Albinus  <[email protected]>
 
 	* eshell/esh-ext.el (eshell-external-command): Do not examine
-	remote shell scripts.  See
-	<https://bugs.launchpad.net/ubuntu/+source/emacs23/+bug/1035790>.
+	remote shell scripts.
+	See <https://bugs.launchpad.net/ubuntu/+source/emacs23/+bug/1035790>.
 
 	* net/tramp-sh.el (tramp-remote-path): Add "/sbin" and
 	"/usr/local/sbin".
@@ -1175,7 +1771,7 @@
 	* calc-mode.el (calc-basic-simplification-mode): Rename from
 	`calc-limited-simplification-mode'.
 	(calc-alg-simplification-mode): New function.
-	(calc-set-simplify-mode):  Adjust message.
+	(calc-set-simplify-mode): Adjust message.
 
 	* calc.el (calc-set-mode-line): Adjust mode line display for
 	basic simplification mode.
@@ -1373,7 +1969,7 @@
 	* notifications.el (notifications-on-action-signal)
 	(notifications-on-closed-signal): Use also the bus address for the map.
 	(notifications-notify, notifications-close-notification)
-	(notifications-get-capabilities):  Add optional argument BUS.
+	(notifications-get-capabilities): Add optional argument BUS.
 
 2012-07-27  Tassilo Horn  <[email protected]>
 
@@ -1493,7 +2089,7 @@
 	ses-cell-set-formula or ses-set-cell to change the cell and handle
 	the undo at the same time, but rather use lower level new macros
 	`ses-cell-formula-aset' and `ses-cell-references-aset' and handle
-	the undo directly. Refresh the mode line.
+	the undo directly.  Refresh the mode line.
 
 2012-07-21  Leo Liu  <[email protected]>
 
@@ -4909,13 +5505,13 @@
 	* progmodes/verilog-mode.el (font-lock-keywords):
 	Fix mis-highligting auto.  Reported by Craig Barner.
 	(verilog-auto, verilog-auto-undef): Add AUTOUNDEF to remove
-	defines from global name space. Reported by Dan Dever.
+	defines from global name space.  Reported by Dan Dever.
 	(verilog-auto-reset, verilog-auto-reset-widths)
 	(verilog-auto-tieoff): Support using unbased numbers for
 	AUTORESET and AUTOTIEOFF.
 	(verilog-submit-bug-report): Update variable list.
 	(verilog-read-auto-params): Fix AUTOINPUT regexps containing
-	parenthesis from not matching. Reported by Michael Rytting.
+	parenthesis from not matching.  Reported by Michael Rytting.
 	(verilog-auto-template-lint): Fix hash error when linting modules
 	with no used templates.
 	(verilog-warn, verilog-warn-error)
@@ -4925,12 +5521,12 @@
 	(verilog-read-auto-template): Add `verilog-auto-template-warn-unused'
 	to report unused template errors.  Reported by Brad Dobbie.
 	(verilog-read-decls): Fix AUTOWIRE etc on supply0, supply1 type
-	nets, bug438. Reported by Vns Blore.
+	nets, bug438.  Reported by Vns Blore.
 	(verilog-auto-inout-module, verilog-auto-reg)
 	(verilog-read-decls, verilog-read-sub-decls-sig)
 	(verilog-signals-edit-wire-reg, verilog-signals-with):
 	Fix passing of Verilog data types in ANSI input/output ports
-	such as "output logic" into the AUTOs. Special case "wire" and
+	such as "output logic" into the AUTOs.  Special case "wire" and
 	"reg" for backwards compatibility presuming Verilog 2001.
 	(verilog-auto-ascii-enum): Add "auto enum" as alias.
 	(verilog-preprocess): Fix replication of preprocess output.
@@ -4951,7 +5547,7 @@
 	(verilog-read-decls): Fix 'parameter type' not appearing in
 	AUTOINSTPARAM, bug340.  Reported by Jonathan Greenlaw.
 	(verilog-auto-logic): Fix when AUTOLOGIC present to properly do
-	AUTOINPUTs, bug411. Reported by Jonathan Greenlaw.
+	AUTOINPUTs, bug411.  Reported by Jonathan Greenlaw.
 	(verilog-read-auto-lisp): Avoid syntax-ppss warning on AUTOLISP.
 	Reported by David Kravitz.
 
diff --git a/lisp/align.el b/lisp/align.el
index 4c82d7bea8..0af5e56c66 100644
--- a/lisp/align.el
+++ b/lisp/align.el
@@ -74,7 +74,7 @@
 ;; align-?-modes variables (for example, `align-dq-string-modes'), use
 ;; `add-to-list', or some similar function which checks first to see
 ;; if the value is already there.  Since the user may customize that
-;; mode list, and then write your mode name into their .emacs file,
+;; mode list, and then write your mode name into their init file,
 ;; causing the symbol already to be present the next time they load
 ;; your package.
 
@@ -1201,7 +1201,10 @@ have been aligned.  No changes will be made to the buffer."
 	      (gocol col) cur)
 	  (when area
 	    (if func
-		(funcall func (car area) (cdr area) change)
+		(funcall func
+			 (marker-position (car area))
+			 (marker-position (cdr area))
+			 change)
 	      (if (not (and justify
 			    (consp (cdr area))))
 		  (goto-char (cdr area))
diff --git a/lisp/autoinsert.el b/lisp/autoinsert.el
index fbf8c46658..21c35811ac 100644
--- a/lisp/autoinsert.el
+++ b/lisp/autoinsert.el
@@ -36,7 +36,7 @@
 ;;     setq auto-insert-directory to an appropriate slash-terminated value
 ;;
 ;;  You can also customize the variable `auto-insert-mode' to load the
-;;  package.  Alternatively, add the following to your .emacs file:
+;;  package.  Alternatively, add the following to your init file:
 ;;  (auto-insert-mode 1)
 ;;
 ;;  Author:  Charlie Martin
diff --git a/lisp/bookmark.el b/lisp/bookmark.el
index 75a8d9f59d..31bbc13acf 100644
--- a/lisp/bookmark.el
+++ b/lisp/bookmark.el
@@ -144,10 +144,7 @@ You can toggle whether files are shown with \\<bookmark-bmenu-mode-map>\\[bookma
 
 (defcustom bookmark-bmenu-toggle-filenames t
   "Non-nil means show filenames when listing bookmarks.
-This may result in truncated bookmark names.  To disable this, put the
-following in your `.emacs' file:
-
-\(setq bookmark-bmenu-toggle-filenames nil)"
+A non-nil value may result in truncated bookmark names."
   :type 'boolean
   :group 'bookmark)
 
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index 7089070df5..c7d93530fd 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -61,7 +61,7 @@
 (declare-function math-vector-is-string "calccomp" (a))
 (declare-function math-vector-to-string "calccomp" (a &optional quoted))
 (declare-function math-format-radix-float "calc-bin" (a prec))
-(declare-function math-compose-expr "calccomp" (a prec))
+(declare-function math-compose-expr "calccomp" (a prec &optional div))
 (declare-function math-abs "calc-arith" (a))
 (declare-function math-format-bignum-binary "calc-bin" (a))
 (declare-function math-format-bignum-octal "calc-bin" (a))
@@ -3483,7 +3483,7 @@ If X is not an error form, return 1."
 			(substring str i))))
     str))
 
-;;; Users can redefine this in their .emacs files.
+;;; Users can redefine this in their init files.
 (defvar calc-keypad-user-menu nil
   "If non-nil, this describes an additional menu for calc-keypad.
 It should contain a list of three rows.
diff --git a/lisp/calc/calc-forms.el b/lisp/calc/calc-forms.el
index dfc5dfc658..bd748158d6 100644
--- a/lisp/calc/calc-forms.el
+++ b/lisp/calc/calc-forms.el
@@ -494,7 +494,7 @@
 			      (car res))))))))
 
 
-;;; It is safe to redefine these in your .emacs file to use a different
+;;; It is safe to redefine these in your init file to use a different
 ;;; language.
 
 (defvar math-long-weekday-names '( "Sunday" "Monday" "Tuesday" "Wednesday"
diff --git a/lisp/calc/calc.el b/lisp/calc/calc.el
index 3e6ae1c740..17f0998d30 100644
--- a/lisp/calc/calc.el
+++ b/lisp/calc/calc.el
@@ -199,7 +199,7 @@
 (declare-function calc-div-fractions "calc-frac" (a b))
 (declare-function math-div-objects-fancy "calc-arith" (a b))
 (declare-function math-div-symb-fancy "calc-arith" (a b))
-(declare-function math-compose-expr "calccomp" (a prec))
+(declare-function math-compose-expr "calccomp" (a prec &optional div))
 (declare-function math-comp-width "calccomp" (c))
 (declare-function math-composition-to-string "calccomp" (c &optional width))
 (declare-function math-stack-value-offset-fancy "calccomp" ())
diff --git a/lisp/calendar/calendar.el b/lisp/calendar/calendar.el
index d5514d14a3..cdbf8d7aa8 100644
--- a/lisp/calendar/calendar.el
+++ b/lisp/calendar/calendar.el
@@ -593,7 +593,7 @@ You can customize `diary-date-forms' to your preferred format.
 Three default styles are provided: `diary-american-date-forms',
 `diary-european-date-forms', and `diary-iso-date-forms'.
 You can choose between these by setting `calendar-date-style' in your
-.emacs file, or by using `calendar-set-date-style' when in the calendar.
+init file, or by using `calendar-set-date-style' when in the calendar.
 
 A diary entry can be preceded by the character `diary-nonmarking-symbol'
 \(ordinarily `&') to make that entry nonmarking--that is, it will not be
@@ -1276,7 +1276,7 @@ Runs the following hooks:
    generating a calendar, if today's date is visible or not, respectively
 `calendar-initial-window-hook' - after first creating a calendar
 
-This function is suitable for execution in a .emacs file."
+This function is suitable for execution in an init file."
   (interactive "P")
   ;; Avoid loading cal-x unless it will be used.
   (if (and (memq calendar-setup '(one-frame two-frames calendar-only))
diff --git a/lisp/calendar/diary-lib.el b/lisp/calendar/diary-lib.el
index 8fa5b0ddb0..4bce8ec092 100644
--- a/lisp/calendar/diary-lib.el
+++ b/lisp/calendar/diary-lib.el
@@ -200,19 +200,21 @@ holidays), or hard copy output."
   'diary-list-entries-hook "23.1")
 
 (defcustom diary-list-entries-hook nil
-  "List of functions called after diary file is culled for relevant entries.
-You might wish to add `diary-include-other-diary-files', in which case
-you will probably also want to add `diary-mark-included-diary-files' to
-`diary-mark-entries-hook'.  For example, you could use
+  "Hook run after diary file is culled for relevant entries.
+
+If you add `diary-include-other-diary-files' to this hook, you
+will probably also want to add `diary-mark-included-diary-files'
+to `diary-mark-entries-hook'.  For example, to cause the fancy
+diary buffer to be displayed with diary entries from various
+included files, each day's entries sorted into lexicographic
+order, add the following to your init file:
 
      (setq diary-display-function 'diary-fancy-display)
      (add-hook 'diary-list-entries-hook 'diary-include-other-diary-files)
      (add-hook 'diary-list-entries-hook 'diary-sort-entries t)
 
-in your `.emacs' file to cause the fancy diary buffer to be displayed with
-diary entries from various included files, each day's entries sorted into
-lexicographic order.  Note how the sort function is placed last,
-so that it can sort the entries included from other files.
+Note how the sort function is placed last, so that it can sort
+the entries included from other files.
 
 This hook runs after `diary-nongregorian-listing-hook'.  These two hooks
 differ only if you are using included diary files.  In that case,
@@ -532,7 +534,7 @@ If so, return the expanded file name, otherwise signal an error."
   "Generate the diary window for ARG days starting with the current date.
 If no argument is provided, the number of days of diary entries is governed
 by the variable `diary-number-of-entries'.  A value of ARG less than 1
-does nothing.  This function is suitable for execution in a `.emacs' file."
+does nothing.  This function is suitable for execution in an init file."
   (interactive "P")
   (diary-check-diary-file)
   (diary-list-entries (calendar-current-date)
@@ -1230,8 +1232,8 @@ Mail is sent to the address specified by `diary-mail-addr'.
 
 Here is an example of a script to call `diary-mail-entries',
 suitable for regular scheduling using cron (or at).  Note that
-since `emacs -script' does not load your `.emacs' file, you
-should ensure that all relevant variables are set.
+since `emacs -script' does not load your init file, you should
+ensure that all relevant variables are set.
 
 #!/usr/bin/emacs -script
 ;; diary-rem.el - run the Emacs diary-reminder
diff --git a/lisp/calendar/holidays.el b/lisp/calendar/holidays.el
index 043d402f61..b94815f98e 100644
--- a/lisp/calendar/holidays.el
+++ b/lisp/calendar/holidays.el
@@ -250,7 +250,7 @@ See the documentation for `calendar-holidays' for details."
     (if calendar-christian-all-holidays-flag
         (append
          (holiday-fixed 1 6 "Epiphany")
-         (holiday-julian 12 25 "Eastern Orthodox Christmas")
+         (holiday-julian 12 25 "Christmas (Julian calendar)")
          (holiday-greek-orthodox-easter)
          (holiday-fixed 8 15 "Assumption")
          (holiday-advent 0 "Advent")))))
@@ -343,12 +343,12 @@ See the documentation for `calendar-holidays' for details."
   "List of notable days for the command \\[holidays].
 
 Additional holidays are easy to add to the list, just put them in the
-list `holiday-other-holidays' in your .emacs file.  Similarly, by setting
+list `holiday-other-holidays' in your init file.  Similarly, by setting
 any of `holiday-general-holidays', `holiday-local-holidays',
 `holiday-christian-holidays', `holiday-hebrew-holidays',
 `holiday-islamic-holidays', `holiday-bahai-holidays',
 `holiday-oriental-holidays', or `holiday-solar-holidays' to nil in your
-.emacs file, you can eliminate unwanted categories of holidays.
+init file, you can eliminate unwanted categories of holidays.
 
 The aforementioned variables control the holiday choices offered
 by the function `holiday-list' when it is called interactively.
@@ -523,7 +523,7 @@ use instead of point."
 (defun holidays (&optional arg)
   "Display the holidays for last month, this month, and next month.
 If called with an optional prefix argument ARG, prompts for month and year.
-This function is suitable for execution in a .emacs file."
+This function is suitable for execution in a init file."
   (interactive "P")
   (save-excursion
     (let* ((completion-ignore-case t)
diff --git a/lisp/calendar/lunar.el b/lisp/calendar/lunar.el
index 8f09d20f50..2761df0bdb 100644
--- a/lisp/calendar/lunar.el
+++ b/lisp/calendar/lunar.el
@@ -236,7 +236,7 @@ use instead of point."
 (defun lunar-phases (&optional arg)
   "Display the quarters of the moon for last month, this month, and next month.
 If called with an optional prefix argument ARG, prompts for month and year.
-This function is suitable for execution in a .emacs file."
+This function is suitable for execution in an init file."
   (interactive "P")
   (save-excursion
     (let* ((date (if arg (calendar-read-date t)
diff --git a/lisp/calendar/solar.el b/lisp/calendar/solar.el
index a8d7d44af3..3ccdf135fb 100644
--- a/lisp/calendar/solar.el
+++ b/lisp/calendar/solar.el
@@ -797,7 +797,7 @@ If called with an optional prefix argument ARG, prompt for date.
 If called with an optional double prefix argument, prompt for
 longitude, latitude, time zone, and date, and always use standard time.
 
-This function is suitable for execution in a .emacs file."
+This function is suitable for execution in an init file."
   (interactive "p")
   (or arg (setq arg 1))
   (if (and (< arg 16)
diff --git a/lisp/calendar/timeclock.el b/lisp/calendar/timeclock.el
index 2ebb8c7c3a..3151ce145d 100644
--- a/lisp/calendar/timeclock.el
+++ b/lisp/calendar/timeclock.el
@@ -49,7 +49,7 @@
 ;; If you want Emacs to display the amount of time "left" to your
 ;; workday in the mode-line, you can either set the value of
 ;; `timeclock-mode-line-display' to t using M-x customize, or you can
-;; add this code to your .emacs file:
+;; add this code to your init file:
 ;;
 ;;   (require 'timeclock)
 ;;   (timeclock-mode-line-display)
@@ -60,7 +60,7 @@
 ;; You may also want Emacs to ask you before exiting, if you are
 ;; currently working on a project.  This can be done either by setting
 ;; `timeclock-ask-before-exiting' to t using M-x customize (this is
-;; the default), or by adding the following to your .emacs file:
+;; the default), or by adding the following to your init file:
 ;;
 ;;   (add-hook 'kill-emacs-query-functions 'timeclock-query-out)
 
diff --git a/lisp/comint.el b/lisp/comint.el
index 5b0eb3027e..638ef73d53 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -181,7 +181,7 @@ override the read-only-ness of comint prompts is to call
 `comint-kill-whole-line' or `comint-kill-region' with no
 narrowing in effect.  This way you will be certain that none of
 the remaining prompts will be accidentally messed up.  You may
-wish to put something like the following in your `.emacs' file:
+wish to put something like the following in your init file:
 
 \(add-hook 'comint-mode-hook
 	  (lambda ()
diff --git a/lisp/custom.el b/lisp/custom.el
index fb166dd35f..01b0e6d165 100644
--- a/lisp/custom.el
+++ b/lisp/custom.el
@@ -237,7 +237,7 @@ The following keywords are meaningful:
 	is `default-value'.
 :require
 	VALUE should be a feature symbol.  If you save a value
-	for this option, then when your `.emacs' file loads the value,
+	for this option, then when your init file loads the value,
 	it does (require VALUE) first.
 :set-after VARIABLES
 	Specifies that SYMBOL should be set after the list of variables
@@ -1223,38 +1223,19 @@ Return t if THEME was successfully loaded, nil otherwise."
   "Query the user about loading a Custom theme that may not be safe.
 The theme should be in the current buffer.  If the user agrees,
 query also about adding HASH to `custom-safe-themes'."
-  (if noninteractive
-      nil
-    (let ((exit-chars '(?y ?n ?\s))
-	  window prompt char)
-      (save-window-excursion
-	(rename-buffer "*Custom Theme*" t)
-	(emacs-lisp-mode)
-	(setq window (display-buffer (current-buffer)))
-	(setq prompt
-	      (format "Loading a theme can run Lisp code.  Really load?%s"
-		      (if (and window
-			       (< (line-number-at-pos (point-max))
-				  (window-body-height)))
-			  " (y or n) "
-			(push ?\C-v exit-chars)
-			"\nType y or n, or C-v to scroll: ")))
-	(goto-char (point-min))
-	(while (null char)
-	  (setq char (read-char-choice prompt exit-chars))
-	  (when (eq char ?\C-v)
-	    (if window
-		(with-selected-window window
-		  (condition-case nil
-		      (scroll-up)
-		    (error (goto-char (point-min))))))
-	    (setq char nil)))
-	(when (memq char '(?\s ?y))
-	  ;; Offer to save to `custom-safe-themes'.
-	  (and (or custom-file user-init-file)
-	       (y-or-n-p "Treat this theme as safe in future sessions? ")
-	       (customize-push-and-save 'custom-safe-themes (list hash)))
-	  t)))))
+  (unless noninteractive
+    (save-window-excursion
+      (rename-buffer "*Custom Theme*" t)
+      (emacs-lisp-mode)
+      (pop-to-buffer (current-buffer))
+      (goto-char (point-min))
+      (prog1 (when (y-or-n-p "Loading a theme can run Lisp code.  Really load? ")
+	       ;; Offer to save to `custom-safe-themes'.
+	       (and (or custom-file user-init-file)
+		    (y-or-n-p "Treat this theme as safe in future sessions? ")
+		    (customize-push-and-save 'custom-safe-themes (list hash)))
+	       t)
+	(quit-window)))))
 
 (defun custom-theme-name-valid-p (name)
   "Return t if NAME is a valid name for a Custom theme, nil otherwise.
diff --git a/lisp/desktop.el b/lisp/desktop.el
index a873a6b63b..75deb58b4d 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -34,7 +34,7 @@
 ;;		- some local variables
 
 ;; To use this, use customize to turn on desktop-save-mode or add the
-;; following line somewhere in your .emacs file:
+;; following line somewhere in your init file:
 ;;
 ;;	(desktop-save-mode 1)
 ;;
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index 6186f762e0..e5ca463e8d 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -54,43 +54,30 @@ into this list; they also should call `dired-log' to log the errors.")
 ;;;###autoload
 (defun dired-diff (file &optional switches)
   "Compare file at point with file FILE using `diff'.
-FILE defaults to the file at the mark.  (That's the mark set by
-\\[set-mark-command], not by Dired's \\[dired-mark] command.)
-The prompted-for FILE is the first file given to `diff'.
+If called interactively, prompt for FILE; if the file at point
+has a backup file, use that as the default.
+
+FILE is the first file given to `diff'.
 With prefix arg, prompt for second argument SWITCHES,
 which is the string of command switches for `diff'."
   (interactive
    (let* ((current (dired-get-filename t))
-	  ;; Get the file at the mark.
-	  (file-at-mark (if (mark t)
-			    (save-excursion (goto-char (mark t))
-					    (dired-get-filename t t))))
-	  ;; Use it as default if it's not the same as the current file,
-	  ;; and the target dir is the current dir or the mark is active.
-	  (default (if (and (not (equal file-at-mark current))
-			    (or (equal (dired-dwim-target-directory)
-				       (dired-current-directory))
-				mark-active))
-		       file-at-mark))
-	  (target-dir (if default
-			  (dired-current-directory)
-			(dired-dwim-target-directory)))
-	  (defaults (dired-dwim-target-defaults (list current) target-dir)))
-     (require 'diff)
-     (list
-      (minibuffer-with-setup-hook
-	  (lambda ()
-	    (set (make-local-variable 'minibuffer-default-add-function) nil)
-	    (setq minibuffer-default defaults))
-	(read-file-name
-	 (format "Diff %s with%s: " current
-		 (if default (format " (default %s)" default) ""))
-	 target-dir default t))
-      (if current-prefix-arg
-	  (read-string "Options for diff: "
-		       (if (stringp diff-switches)
-			   diff-switches
-			 (mapconcat 'identity diff-switches " ")))))))
+	  (oldf (file-newest-backup current))
+	  (dir (if oldf (file-name-directory oldf))))
+     (list (read-file-name
+	    (format "Diff %s with%s: "
+		    (file-name-nondirectory current)
+		    (if oldf
+			(concat " (default "
+				(file-name-nondirectory oldf)
+				")")
+		      ""))
+	    dir oldf t)
+	   (if current-prefix-arg
+	       (read-string "Options for diff: "
+			    (if (stringp diff-switches)
+				diff-switches
+			      (mapconcat 'identity diff-switches " ")))))))
   (let ((current (dired-get-filename t)))
     (when (or (equal (expand-file-name file)
 		     (expand-file-name current))
@@ -257,7 +244,10 @@ List has a form of (file-name full-file-name (attribute-list))."
 			     (function dired-check-process)
 			     (append
 			      (list operation program)
-			      (unless (string-equal new-attribute "")
+			      (unless (or (string-equal new-attribute "")
+					  ;; Use `eq' instead of `equal'
+					  ;; to detect empty input (bug#12399).
+					  (eq new-attribute default))
 				(if (eq op-symbol 'touch)
 				    (list "-t" new-attribute)
 				  (list new-attribute)))
@@ -291,7 +281,10 @@ Symbolic modes like `g+w' are allowed."
 		 "Change mode of %s to: "
 		 nil 'chmod arg files default))
 	 num-modes)
-    (cond ((equal modes "")
+    (cond ((or (equal modes "")
+	       ;; Use `eq' instead of `equal'
+	       ;; to detect empty input (bug#12399).
+	       (eq modes default))
 	   ;; We used to treat empty input as DEFAULT, but that is not
 	   ;; such a good idea (Bug#9361).
 	   (error "No file mode specified"))
diff --git a/lisp/dired.el b/lisp/dired.el
index 5ae0e02617..54921a4ea6 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -1410,7 +1410,6 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "&" 'dired-do-async-shell-command)
     ;; Comparison commands
     (define-key map "=" 'dired-diff)
-    (define-key map "\M-=" 'dired-backup-diff)
     ;; Tree Dired commands
     (define-key map "\M-\C-?" 'dired-unmark-all-files)
     (define-key map "\M-\C-d" 'dired-tree-down)
@@ -2973,36 +2972,43 @@ If t, confirmation is never needed."
 		      (const shell) (const symlink) (const touch)
 		      (const uncompress))))
 
-(defun dired-mark-pop-up (bufname op-symbol files function &rest args)
+(defun dired-mark-pop-up (buffer-or-name op-symbol files function &rest args)
   "Return FUNCTION's result on ARGS after showing which files are marked.
-Displays the file names in a buffer named BUFNAME;
- nil gives \" *Marked Files*\".
-This uses function `dired-pop-to-buffer' to do that.
-
-FUNCTION should not manipulate files, just read input
- (an argument or confirmation).
-The window is not shown if there is just one file or
- OP-SYMBOL is a member of the list in `dired-no-confirm'.
+Displays the file names in a window showing a buffer named
+BUFFER-OR-NAME; the default name being \" *Marked Files*\".  The
+window is not shown if there is just one file, `dired-no-confirm'
+is t, or OP-SYMBOL is a member of the list in `dired-no-confirm'.
+
 FILES is the list of marked files.  It can also be (t FILENAME)
 in the case of one marked file, to distinguish that from using
-just the current file."
-  (or bufname (setq bufname  " *Marked Files*"))
+just the current file.
+
+FUNCTION should not manipulate files, just read input \(an
+argument or confirmation)."
   (if (or (eq dired-no-confirm t)
 	  (memq op-symbol dired-no-confirm)
 	  ;; If FILES defaulted to the current line's file.
 	  (= (length files) 1))
       (apply function args)
-    (with-current-buffer (get-buffer-create bufname)
-      (erase-buffer)
-      ;; Handle (t FILE) just like (FILE), here.
-      ;; That value is used (only in some cases), to mean
-      ;; just one file that was marked, rather than the current line file.
-      (dired-format-columns-of-files (if (eq (car files) t) (cdr files) files))
-      (remove-text-properties (point-min) (point-max)
-			      '(mouse-face nil help-echo nil)))
-    (save-window-excursion
-      (dired-pop-to-buffer bufname)
-      (apply function args))))
+    (let ((buffer (get-buffer-create (or buffer-or-name " *Marked Files*"))))
+      (with-current-buffer buffer
+	(let ((split-height-threshold 0))
+	  (with-temp-buffer-window
+	   buffer
+	   (cons 'display-buffer-below-selected nil)
+	   #'(lambda (window _value)
+	       (with-selected-window window
+		 (unwind-protect
+		     (apply function args)
+		   (when (window-live-p window)
+		     (quit-restore-window window 'kill)))))
+	   ;; Handle (t FILE) just like (FILE), here.  That value is
+	   ;; used (only in some cases), to mean just one file that was
+	   ;; marked, rather than the current line file.
+	   (dired-format-columns-of-files
+	    (if (eq (car files) t) (cdr files) files))
+	   (remove-text-properties (point-min) (point-max)
+				   '(mouse-face nil help-echo nil))))))))
 
 (defun dired-format-columns-of-files (files)
   (let ((beg (point)))
@@ -3738,14 +3744,15 @@ Ask means pop up a menu for the user to select one of copy, move or link."
 ;;;;;;  dired-run-shell-command dired-do-shell-command dired-do-async-shell-command
 ;;;;;;  dired-clean-directory dired-do-print dired-do-touch dired-do-chown
 ;;;;;;  dired-do-chgrp dired-do-chmod dired-compare-directories dired-backup-diff
-;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "9499f79f5853da0aa93d26465c7bf3a1")
+;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "3c768e470d5d053d0049e0286ce38da7")
 ;;; Generated autoloads from dired-aux.el
 
 (autoload 'dired-diff "dired-aux" "\
 Compare file at point with file FILE using `diff'.
-FILE defaults to the file at the mark.  (That's the mark set by
-\\[set-mark-command], not by Dired's \\[dired-mark] command.)
-The prompted-for FILE is the first file given to `diff'.
+If called interactively, prompt for FILE; if the file at point
+has a backup file, use that as the default.
+
+FILE is the first file given to `diff'.
 With prefix arg, prompt for second argument SWITCHES,
 which is the string of command switches for `diff'.
 
diff --git a/lisp/ehelp.el b/lisp/ehelp.el
index abb897f73f..281148d9cf 100644
--- a/lisp/ehelp.el
+++ b/lisp/ehelp.el
@@ -193,7 +193,9 @@ BUFFER is put back into its original major mode."
 	(replace-buffer-in-windows buffer)
 	;; must do this outside of save-window-excursion
 	(bury-buffer buffer))
-      (eval electric-help-form-to-execute))))
+      (if (functionp electric-help-form-to-execute)
+          (funcall electric-help-form-to-execute)
+        (eval electric-help-form-to-execute)))))
 
 (defun electric-help-command-loop ()
   (catch 'exit
@@ -349,14 +351,19 @@ will select it.)"
 ;; continues with execute-extended-command.
 (defun electric-help-execute-extended (_prefixarg)
   (interactive "p")
-  (setq electric-help-form-to-execute '(execute-extended-command nil))
+  (setq electric-help-form-to-execute
+        (lambda () (execute-extended-command nil)))
   (electric-help-retain))
 
 ;; This is to be buond to C-x in ehelp mode. Retains ehelp buffer and then
 ;; continues with ctrl-x prefix.
 (defun electric-help-ctrl-x-prefix (_prefixarg)
   (interactive "p")
-  (setq electric-help-form-to-execute '(progn (message nil) (setq unread-command-char ?\C-x)))
+  (setq electric-help-form-to-execute
+        (lambda ()
+          (message nil)
+          (setq unread-command-events
+                (append unread-command-events '(?\C-x)))))
   (electric-help-retain))
 
 
diff --git a/lisp/emacs-lisp/advice.el b/lisp/emacs-lisp/advice.el
index cac76d2bce..d96076d17a 100644
--- a/lisp/emacs-lisp/advice.el
+++ b/lisp/emacs-lisp/advice.el
@@ -1,4 +1,4 @@
-;;; advice.el --- an overloading mechanism for Emacs Lisp functions
+;;; advice.el --- An overloading mechanism for Emacs Lisp functions
 
 ;; Copyright (C) 1993-1994, 2000-2012 Free Software Foundation, Inc.
 
@@ -1746,7 +1746,8 @@
 (provide 'advice-preload)
 ;; During a normal load this is a noop:
 (require 'advice-preload "advice.el")
-
+(require 'macroexp)
+(eval-when-compile (require 'cl-lib))
 
 ;; @@ Variable definitions:
 ;; ========================
@@ -1812,54 +1813,6 @@ generates a copy of TREE."
          (funcall fUnCtIoN tReE))
         (t tReE)))
 
-;; this is just faster than `ad-substitute-tree':
-(defun ad-copy-tree (tree)
-  "Return a copy of the list structure of TREE."
-  (cond ((consp tree)
-	 (cons (ad-copy-tree (car tree))
-	       (ad-copy-tree (cdr tree))))
-	(t tree)))
-
-(defmacro ad-dolist (varform &rest body)
-  "A Common-Lisp-style dolist iterator with the following syntax:
-
-    (ad-dolist (VAR INIT-FORM [RESULT-FORM])
-       BODY-FORM...)
-
-which will iterate over the list yielded by INIT-FORM binding VAR to the
-current head at every iteration.  If RESULT-FORM is supplied its value will
-be returned at the end of the iteration, nil otherwise.  The iteration can be
-exited prematurely with `(ad-do-return [VALUE])'."
-  (let ((expansion
-         `(let ((ad-dO-vAr ,(car (cdr varform)))
-                ,(car varform))
-           (while ad-dO-vAr
-             (setq ,(car varform) (car ad-dO-vAr))
-             ,@body
-             ;;work around a backquote bug:
-             ;;(` ((,@ '(foo)) (bar))) => (append '(foo) '(((bar)))) wrong
-             ;;(` ((,@ '(foo)) (, '(bar)))) => (append '(foo) (list '(bar)))
-             ,'(setq ad-dO-vAr (cdr ad-dO-vAr)))
-           ,(car (cdr (cdr varform))))))
-    ;;ok, this wastes some cons cells but only during compilation:
-    (if (catch 'contains-return
-	  (ad-substitute-tree
-	   (function (lambda (subtree)
-             (cond ((eq (car-safe subtree) 'ad-dolist))
-                   ((eq (car-safe subtree) 'ad-do-return)
-                    (throw 'contains-return t)))))
-	   'identity body)
-	  nil)
-	`(catch 'ad-dO-eXiT ,expansion)
-        expansion)))
-
-(defmacro ad-do-return (value)
-  `(throw 'ad-dO-eXiT ,value))
-
-(if (not (get 'ad-dolist 'lisp-indent-hook))
-    (put 'ad-dolist 'lisp-indent-hook 1))
-
-
 ;; @@ Save real definitions of subrs used by Advice:
 ;; =================================================
 ;; Advice depends on the real, unmodified functionality of various subrs,
@@ -1924,16 +1877,16 @@ exited prematurely with `(ad-do-return [VALUE])'."
      ad-advised-functions)))
 
 (defmacro ad-do-advised-functions (varform &rest body)
-  "`ad-dolist'-style iterator that maps over `ad-advised-functions'.
+  "`dolist'-style iterator that maps over `ad-advised-functions'.
 \(ad-do-advised-functions (VAR [RESULT-FORM])
    BODY-FORM...)
 On each iteration VAR will be bound to the name of an advised function
 \(a symbol)."
-  `(ad-dolist (,(car varform)
+  `(cl-dolist (,(car varform)
                ad-advised-functions
                ,(car (cdr varform)))
-    (setq ,(car varform) (intern (car ,(car varform))))
-    ,@body))
+     (setq ,(car varform) (intern (car ,(car varform))))
+     ,@body))
 
 (if (not (get 'ad-do-advised-functions 'lisp-indent-hook))
     (put 'ad-do-advised-functions 'lisp-indent-hook 1))
@@ -1948,7 +1901,7 @@ On each iteration VAR will be bound to the name of an advised function
   `(put ,function 'ad-advice-info ,advice-info))
 
 (defmacro ad-copy-advice-info (function)
-  `(ad-copy-tree (get ,function 'ad-advice-info)))
+  `(copy-tree (get ,function 'ad-advice-info)))
 
 (defmacro ad-is-advised (function)
   "Return non-nil if FUNCTION has any advice info associated with it.
@@ -2022,8 +1975,8 @@ either t or nil, and DEFINITION should be a list of the form
 
 (defun ad-has-enabled-advice (function class)
   "True if at least one of FUNCTION's advices in CLASS is enabled."
-  (ad-dolist (advice (ad-get-advice-info-field function class))
-    (if (ad-advice-enabled advice) (ad-do-return t))))
+  (cl-dolist (advice (ad-get-advice-info-field function class))
+    (if (ad-advice-enabled advice) (cl-return t))))
 
 (defun ad-has-redefining-advice (function)
   "True if FUNCTION's advice info defines at least 1 redefining advice.
@@ -2036,14 +1989,14 @@ Redefining advices affect the construction of an advised definition."
 (defun ad-has-any-advice (function)
   "True if the advice info of FUNCTION defines at least one advice."
   (and (ad-is-advised function)
-       (ad-dolist (class ad-advice-classes nil)
+       (cl-dolist (class ad-advice-classes nil)
 	 (if (ad-get-advice-info-field function class)
-	     (ad-do-return t)))))
+	     (cl-return t)))))
 
 (defun ad-get-enabled-advices (function class)
   "Return the list of enabled advices of FUNCTION in CLASS."
   (let (enabled-advices)
-    (ad-dolist (advice (ad-get-advice-info-field function class))
+    (dolist (advice (ad-get-advice-info-field function class))
       (if (ad-advice-enabled advice)
 	  (push advice enabled-advices)))
     (reverse enabled-advices)))
@@ -2151,7 +2104,7 @@ function at point for which PREDICATE returns non-nil)."
 	    (ad-do-advised-functions (function)
 	      (if (or (null predicate)
 		      (funcall predicate function))
-		  (ad-do-return function)))
+		  (cl-return function)))
 	    (error "ad-read-advised-function: %s"
 		   "There are no qualifying advised functions")))
   (let* ((ad-pReDiCaTe predicate)
@@ -2184,9 +2137,9 @@ be returned on empty input (defaults to the first non-empty advice
 class of FUNCTION)."
   (setq default
 	(or default
-	    (ad-dolist (class ad-advice-classes)
+	    (cl-dolist (class ad-advice-classes)
 	      (if (ad-get-advice-info-field function class)
-		  (ad-do-return class)))
+		  (cl-return class)))
 	    (error "ad-read-advice-class: `%s' has no advices" function)))
   (let ((class (completing-read
 		(format "%s (default %s): " (or prompt "Class") default)
@@ -2255,18 +2208,18 @@ NAME can be a symbol or a regular expression matching part of an advice name.
 If CLASS is `any' all valid advice classes will be checked."
   (if (ad-is-advised function)
       (let (found-advice)
-	(ad-dolist (advice-class ad-advice-classes)
+	(cl-dolist (advice-class ad-advice-classes)
 	  (if (or (eq class 'any) (eq advice-class class))
 	      (setq found-advice
-		    (ad-dolist (advice (ad-get-advice-info-field
+		    (cl-dolist (advice (ad-get-advice-info-field
 					function advice-class))
 		      (if (or (and (stringp name)
 				   (string-match
 				    name (symbol-name
 					  (ad-advice-name advice))))
 			      (eq name (ad-advice-name advice)))
-			  (ad-do-return advice)))))
-	  (if found-advice (ad-do-return found-advice))))))
+			  (cl-return advice)))))
+	  (if found-advice (cl-return found-advice))))))
 
 (defun ad-enable-advice-internal (function class name flag)
   "Set enable FLAG of FUNCTION's advices in CLASS matching NAME.
@@ -2277,10 +2230,10 @@ considered.  The number of changed advices will be returned (or nil if
 FUNCTION was not advised)."
   (if (ad-is-advised function)
       (let ((matched-advices 0))
-	(ad-dolist (advice-class ad-advice-classes)
+	(dolist (advice-class ad-advice-classes)
 	  (if (or (eq class 'any) (eq advice-class class))
-	      (ad-dolist (advice (ad-get-advice-info-field
-				  function advice-class))
+	      (dolist (advice (ad-get-advice-info-field
+                               function advice-class))
 		(cond ((or (and (stringp name)
 				(string-match
 				 name (symbol-name (ad-advice-name advice))))
@@ -2586,11 +2539,6 @@ For that it has to be fbound with a non-autoload definition."
 	 (byte-compile symbol)
 	 (fset function (symbol-function symbol))))))
 
-(defun ad-prognify (forms)
-  (cond ((<= (length forms) 1)
-	 (car forms))
-	(t (cons 'progn forms))))
-
 ;; @@@ Accessing argument lists:
 ;; =============================
 
@@ -2868,8 +2816,8 @@ in any of these classes."
     (if origdoc (setq paragraphs (list origdoc)))
     (unless (eq style 'plain)
       (push (concat "This " origtype " is advised.") paragraphs))
-    (ad-dolist (class ad-advice-classes)
-      (ad-dolist (advice (ad-get-enabled-advices function class))
+    (dolist (class ad-advice-classes)
+      (dolist (advice (ad-get-enabled-advices function class))
 	(setq advice-docstring
 	      (ad-make-single-advice-docstring advice class style))
 	(if advice-docstring
@@ -2891,24 +2839,24 @@ in any of these classes."
 
 (defun ad-advised-arglist (function)
   "Find first defined arglist in FUNCTION's redefining advices."
-  (ad-dolist (advice (append (ad-get-enabled-advices function 'before)
+  (cl-dolist (advice (append (ad-get-enabled-advices function 'before)
 			     (ad-get-enabled-advices function 'around)
 			     (ad-get-enabled-advices function 'after)))
     (let ((arglist (ad-arglist (ad-advice-definition advice))))
       (if arglist
 	  ;; We found the first one, use it:
-	  (ad-do-return arglist)))))
+	  (cl-return arglist)))))
 
 (defun ad-advised-interactive-form (function)
   "Find first interactive form in FUNCTION's redefining advices."
-  (ad-dolist (advice (append (ad-get-enabled-advices function 'before)
+  (cl-dolist (advice (append (ad-get-enabled-advices function 'before)
 			     (ad-get-enabled-advices function 'around)
 			     (ad-get-enabled-advices function 'after)))
     (let ((interactive-form
 	   (ad-interactive-form (ad-advice-definition advice))))
       (if interactive-form
 	  ;; We found the first one, use it:
-	  (ad-do-return interactive-form)))))
+	  (cl-return interactive-form)))))
 
 ;; @@@ Putting it all together:
 ;; ============================
@@ -2997,47 +2945,47 @@ and BEFORES, AROUNDS and AFTERS are the lists of advices with which ORIG
 should be modified.  The assembled function will be returned."
 
   (let (before-forms around-form around-form-protected after-forms definition)
-    (ad-dolist (advice befores)
-               (cond ((and (ad-advice-protected advice)
-                           before-forms)
-                      (setq before-forms
-                            `((unwind-protect
-                                   ,(ad-prognify before-forms)
-                                ,@(ad-body-forms
-                                   (ad-advice-definition advice))))))
-                     (t (setq before-forms
-                              (append before-forms
-                                      (ad-body-forms (ad-advice-definition advice)))))))
+    (dolist (advice befores)
+      (cond ((and (ad-advice-protected advice)
+                  before-forms)
+             (setq before-forms
+                   `((unwind-protect
+                         ,(macroexp-progn before-forms)
+                       ,@(ad-body-forms
+                          (ad-advice-definition advice))))))
+            (t (setq before-forms
+                     (append before-forms
+                             (ad-body-forms (ad-advice-definition advice)))))))
 
     (setq around-form `(setq ad-return-value ,orig))
-    (ad-dolist (advice (reverse arounds))
-               ;; If any of the around advices is protected then we
-               ;; protect the complete around advice onion:
-               (if (ad-advice-protected advice)
-                   (setq around-form-protected t))
-               (setq around-form
-                     (ad-substitute-tree
-                      (function (lambda (form) (eq form 'ad-do-it)))
-                      (function (lambda (form) around-form))
-                      (ad-prognify (ad-body-forms (ad-advice-definition advice))))))
+    (dolist (advice (reverse arounds))
+      ;; If any of the around advices is protected then we
+      ;; protect the complete around advice onion:
+      (if (ad-advice-protected advice)
+          (setq around-form-protected t))
+      (setq around-form
+            (ad-substitute-tree
+             (function (lambda (form) (eq form 'ad-do-it)))
+             (function (lambda (form) around-form))
+             (macroexp-progn (ad-body-forms (ad-advice-definition advice))))))
 
     (setq after-forms
 	  (if (and around-form-protected before-forms)
 	      `((unwind-protect
-                     ,(ad-prognify before-forms)
+                     ,(macroexp-progn before-forms)
                   ,around-form))
               (append before-forms (list around-form))))
-    (ad-dolist (advice afters)
-               (cond ((and (ad-advice-protected advice)
-                           after-forms)
-                      (setq after-forms
-                            `((unwind-protect
-                                   ,(ad-prognify after-forms)
-                                ,@(ad-body-forms
-                                   (ad-advice-definition advice))))))
-                     (t (setq after-forms
-                              (append after-forms
-                                      (ad-body-forms (ad-advice-definition advice)))))))
+    (dolist (advice afters)
+      (cond ((and (ad-advice-protected advice)
+                  after-forms)
+             (setq after-forms
+                   `((unwind-protect
+                         ,(macroexp-progn after-forms)
+                       ,@(ad-body-forms
+                          (ad-advice-definition advice))))))
+            (t (setq after-forms
+                     (append after-forms
+                             (ad-body-forms (ad-advice-definition advice)))))))
 
     (setq definition
 	  `(,@(if (memq type '(macro special-form)) '(macro))
@@ -3061,7 +3009,7 @@ should be modified.  The assembled function will be returned."
 			     (ad-body-forms (ad-advice-definition advice))))
 		 (ad-get-enabled-advices function hook-name))))
     (if hook-forms
-	(ad-prognify (apply 'append hook-forms)))))
+	(macroexp-progn (apply 'append hook-forms)))))
 
 
 ;; @@ Caching:
@@ -3171,11 +3119,11 @@ advised definition from scratch."
 	(nth 2 cache-id)))))
 
 (defun ad-verify-cache-class-id (cache-class-id advices)
-  (ad-dolist (advice advices (null cache-class-id))
+  (cl-dolist (advice advices (null cache-class-id))
     (if (ad-advice-enabled advice)
 	(if (eq (car cache-class-id) (ad-advice-name advice))
 	    (setq cache-class-id (cdr cache-class-id))
-	  (ad-do-return nil)))))
+	  (cl-return nil)))))
 
 ;; There should be a way to monitor if and why a cache verification failed
 ;; in order to determine whether a certain preactivation could be used or
@@ -3670,7 +3618,16 @@ See Info node `(elisp)Advising Functions' for comprehensive documentation.
 usage: (defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
           [DOCSTRING] [INTERACTIVE-FORM]
           BODY...)"
-  (declare (doc-string 3))
+  (declare (doc-string 3)
+           (debug (&define name  ;; thing being advised.
+                           (name ;; class is [&or "before" "around" "after"
+                                 ;;               "activation" "deactivation"]
+                            name ;; name of advice
+                            &rest sexp ;; optional position and flags
+                            )
+                           [&optional stringp]
+                           [&optional ("interactive" interactive)]
+                           def-body)))
   (if (not (ad-name-p function))
       (error "defadvice: Invalid function name: %s" function))
   (let* ((class (car args))
diff --git a/lisp/emacs-lisp/benchmark.el b/lisp/emacs-lisp/benchmark.el
index 646be3e1b7..9029c81f27 100644
--- a/lisp/emacs-lisp/benchmark.el
+++ b/lisp/emacs-lisp/benchmark.el
@@ -53,6 +53,7 @@ FORMS once.
 Return a list of the total elapsed time for execution, the number of
 garbage collections that ran, and the time taken by garbage collection.
 See also `benchmark-run-compiled'."
+  (declare (indent 1) (debug t))
   (unless (natnump repetitions)
     (setq forms (cons repetitions forms)
 	  repetitions 1))
@@ -69,8 +70,6 @@ See also `benchmark-run-compiled'."
 		`(benchmark-elapse ,@forms))
 	     (- gcs-done ,gcs)
 	     (- gc-elapsed ,gc)))))
-(put 'benchmark-run 'edebug-form-spec t)
-(put 'benchmark-run 'lisp-indent-function 2)
 
 ;;;###autoload
 (defmacro benchmark-run-compiled (&optional repetitions &rest forms)
@@ -78,6 +77,7 @@ See also `benchmark-run-compiled'."
 This is like `benchmark-run', but what is timed is a funcall of the
 byte code obtained by wrapping FORMS in a `lambda' and compiling the
 result.  The overhead of the `lambda's is accounted for."
+  (declare (indent 1) (debug t))
   (unless (natnump repetitions)
     (setq forms (cons repetitions forms)
 	  repetitions 1))
@@ -96,8 +96,6 @@ result.  The overhead of the `lambda's is accounted for."
 					  (funcall ,lambda-code))))
 		`(benchmark-elapse (funcall ,code)))
 	     (- gcs-done ,gcs) (- gc-elapsed ,gc)))))
-(put 'benchmark-run-compiled 'edebug-form-spec t)
-(put 'benchmark-run-compiled 'lisp-indent-function 2)
 
 ;;;###autoload
 (defun benchmark (repetitions form)
diff --git a/lisp/emacs-lisp/byte-run.el b/lisp/emacs-lisp/byte-run.el
index 9b66c8ffd6..93e890a20c 100644
--- a/lisp/emacs-lisp/byte-run.el
+++ b/lisp/emacs-lisp/byte-run.el
@@ -185,11 +185,10 @@ The return value is undefined.
                    ((and (featurep 'cl)
                          (memq (car x)  ;C.f. cl-do-proclaim.
                                '(special inline notinline optimize warn)))
-                    (if (null (stringp docstring))
-                        (push (list 'declare x) body)
-                      (setcdr body (cons (list 'declare x) (cdr body))))
+                    (push (list 'declare x)
+                          (if (stringp docstring) (cdr body) body))
                     nil)
-                   (t (message "Warning: Unknown defun property %S in %S"
+                   (t (message "Warning: Unknown defun property `%S' in %S"
                                (car x) name)))))
                    decls))
           (def (list 'defalias
@@ -313,7 +312,7 @@ This uses `defvaralias' and `make-obsolete-variable' (which see).
 See the Info node `(elisp)Variable Aliases' for more details.
 
 If CURRENT-NAME is a defcustom (more generally, any variable
-where OBSOLETE-NAME may be set, e.g. in a .emacs file, before the
+where OBSOLETE-NAME may be set, e.g. in an init file, before the
 alias is defined), then the define-obsolete-variable-alias
 statement should be evaluated before the defcustom, if user
 customizations are to be respected.  The simplest way to achieve
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 10bc37c6dc..c42ae21aae 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -1016,6 +1016,10 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
 		     ((bufferp byte-compile-current-file)
 		      (format "Buffer %s:"
 			      (buffer-name byte-compile-current-file)))
+		     ;; We might be simply loading a file that
+		     ;; contains explicit calls to byte-compile functions.
+		     ((stringp load-file-name)
+		      (format "%s:" (file-relative-name load-file-name dir)))
 		     (t "")))
 	 (pos (if (and byte-compile-current-file
 		       (integerp byte-compile-read-position))
diff --git a/lisp/emacs-lisp/cl-lib.el b/lisp/emacs-lisp/cl-lib.el
index 532c81c502..5749ff91b4 100644
--- a/lisp/emacs-lisp/cl-lib.el
+++ b/lisp/emacs-lisp/cl-lib.el
@@ -121,7 +121,7 @@ a future Emacs interpreter will be able to use it.")
 
 ;;; Generalized variables.
 ;; These macros are defined here so that they
-;; can safely be used in .emacs files.
+;; can safely be used in init files.
 
 (defmacro cl-incf (place &optional x)
   "Increment PLACE by X (1 by default).
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index 470ca17d3a..c12e8ccacb 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -249,8 +249,7 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 
 ;;;***
 
-;;;### (autoloads (cl--compiler-macro-cXXr cl--compiler-macro-list*
-;;;;;;  cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand
+;;;### (autoloads (cl--compiler-macro-adjoin cl-defsubst cl-compiler-macroexpand
 ;;;;;;  cl-define-compiler-macro cl-assert cl-check-type cl-typep
 ;;;;;;  cl-deftype cl-defstruct cl-callf2 cl-callf cl-letf* cl-letf
 ;;;;;;  cl-rotatef cl-shiftf cl-remf cl-psetf cl-declare cl-the cl-locally
@@ -260,9 +259,20 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 ;;;;;;  cl-do cl-loop cl-return-from cl-return cl-block cl-etypecase
 ;;;;;;  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-macs" "cl-macs.el" "9676d5517e8b9246c09fe78984c68bef")
+;;;;;;  cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
+;;;;;;  "cl-macs" "cl-macs.el" "6d0676869af66e5b5a671f95ee069461")
 ;;; Generated autoloads from cl-macs.el
 
+(autoload 'cl--compiler-macro-list* "cl-macs" "\
+
+
+\(fn FORM ARG &rest OTHERS)" nil nil)
+
+(autoload 'cl--compiler-macro-cXXr "cl-macs" "\
+
+
+\(fn FORM X)" nil nil)
+
 (autoload 'cl-gensym "cl-macs" "\
 Generate a new uninterned symbol.
 The name is made by appending a number to PREFIX, default \"G\".
@@ -659,6 +669,8 @@ value, that slot cannot be set via `setf'.
 
 (put 'cl-defstruct 'doc-string-elt '2)
 
+(put 'cl-defstruct 'lisp-indent-function '1)
+
 (autoload 'cl-deftype "cl-macs" "\
 Define NAME as a new data type.
 The type name can then be used in `cl-typecase', `cl-check-type', etc.
@@ -722,16 +734,6 @@ surrounded by (cl-block NAME ...).
 
 \(fn FORM A LIST &rest KEYS)" nil nil)
 
-(autoload 'cl--compiler-macro-list* "cl-macs" "\
-
-
-\(fn FORM ARG &rest OTHERS)" nil nil)
-
-(autoload 'cl--compiler-macro-cXXr "cl-macs" "\
-
-
-\(fn FORM X)" nil nil)
-
 ;;;***
 
 ;;;### (autoloads (cl-tree-equal cl-nsublis cl-sublis cl-nsubst-if-not
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 9a59aa0c6d..16ac14f8fe 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -58,6 +58,33 @@
 
 ;;; Initialization.
 
+;; Place compiler macros at the beginning, otherwise uses of the corresponding
+;; functions can lead to recursive-loads that prevent the calls from
+;; being optimized.
+
+;;;###autoload
+(defun cl--compiler-macro-list* (_form arg &rest others)
+  (let* ((args (reverse (cons arg others)))
+	 (form (car args)))
+    (while (setq args (cdr args))
+      (setq form `(cons ,(car args) ,form)))
+    form))
+
+;;;###autoload
+(defun cl--compiler-macro-cXXr (form x)
+  (let* ((head (car form))
+         (n (symbol-name (car form)))
+         (i (- (length n) 2)))
+    (if (not (string-match "c[ad]+r\\'" n))
+        (if (and (fboundp head) (symbolp (symbol-function head)))
+            (cl--compiler-macro-cXXr (cons (symbol-function head) (cdr form))
+                                     x)
+          (error "Compiler macro for cXXr applied to non-cXXr form"))
+      (while (> i (match-beginning 0))
+        (setq x (list (if (eq (aref n i) ?a) 'car 'cdr) x))
+        (setq i (1- i)))
+      x)))
+
 ;;; Some predicates for analyzing Lisp forms.
 ;; These are used by various
 ;; macro expanders to optimize the results in certain common cases.
@@ -366,9 +393,14 @@ its argument list allows full Common Lisp conventions."
       (mapcar (lambda (x)
                 (cond
                  ((symbolp x)
-                  (if (eq ?\& (aref (symbol-name x) 0))
-                      (setq state x)
-                    (make-symbol (upcase (symbol-name x)))))
+                  (let ((first (aref (symbol-name x) 0)))
+                    (if (eq ?\& first)
+                        (setq state x)
+                      ;; Strip a leading underscore, since it only
+                      ;; means that this argument is unused.
+                      (make-symbol (upcase (if (eq ?_ first)
+                                               (substring (symbol-name x) 1)
+                                             (symbol-name x)))))))
                  ((not (consp x)) x)
                  ((memq state '(nil &rest)) (cl--make-usage-args x))
                  (t      ;(VAR INITFORM SVAR) or ((KEYWORD VAR) INITFORM SVAR).
@@ -452,7 +484,13 @@ its argument list allows full Common Lisp conventions."
 	  (let ((arg (pop args)))
 	    (or (consp arg) (setq arg (list arg)))
 	    (let* ((karg (if (consp (car arg)) (caar arg)
-			   (intern (format ":%s" (car arg)))))
+                           (let ((name (symbol-name (car arg))))
+                             ;; Strip a leading underscore, since it only
+                             ;; means that this argument is unused, but
+                             ;; shouldn't affect the key's name (bug#12367).
+                             (if (eq ?_ (aref name 0))
+                                 (setq name (substring name 1)))
+                             (intern (format ":%s" name)))))
 		   (varg (if (consp (car arg)) (cl-cadar arg) (car arg)))
 		   (def (if (cdr arg) (cadr arg)
 			  (or (car cl--bind-defs) (cadr (assq varg cl--bind-defs)))))
@@ -1425,8 +1463,15 @@ Valid clauses are:
 	  cl--loop-accum-var))))
 
 (defun cl--loop-build-ands (clauses)
+  "Return various representations of (and . CLAUSES).
+CLAUSES is a list of Elisp expressions, where clauses of the form
+\(progn E1 E2 E3 .. t) are the focus of particular optimizations.
+The return value has shape (COND BODY COMBO)
+such that COMBO is equivalent to (and . CLAUSES)."
   (let ((ands nil)
 	(body nil))
+    ;; Look through `clauses', trying to optimize (progn ,@A t) (progn ,@B) ,@C
+    ;; into (progn ,@A ,@B) ,@C.
     (while clauses
       (if (and (eq (car-safe (car clauses)) 'progn)
 	       (eq (car (last (car clauses))) t))
@@ -1437,6 +1482,7 @@ Valid clauses are:
 					     (cl-cdadr clauses)
 					   (list (cadr clauses))))
 				  (cddr clauses)))
+            ;; A final (progn ,@A t) is moved outside of the `and'.
 	    (setq body (cdr (butlast (pop clauses)))))
 	(push (pop clauses) ands)))
     (setq ands (or (nreverse ands) (list t)))
@@ -1905,8 +1951,6 @@ See Info node `(cl)Declarations' for details."
 	(cl-do-proclaim (pop specs) nil)))
   nil)
 
-
-
 ;;; The standard modify macros.
 
 ;; `setf' is now part of core Elisp, defined in gv.el.
@@ -1929,7 +1973,7 @@ before assigning any PLACEs to the corresponding values.
       (or p (error "Odd number of arguments to cl-psetf"))
       (pop p))
     (if simple
-	`(progn (setf ,@args) nil)
+	`(progn (setq ,@args) nil)
       (setq args (reverse args))
       (let ((expr `(setf ,(cadr args) ,(car args))))
 	(while (setq args (cddr args))
@@ -2119,7 +2163,7 @@ one keyword is supported, `:read-only'.  If this has a non-nil
 value, that slot cannot be set via `setf'.
 
 \(fn NAME SLOTS...)"
-  (declare (doc-string 2)
+  (declare (doc-string 2) (indent 1)
            (debug
             (&define                    ;Makes top-level form not be wrapped.
              [&or symbolp
@@ -2597,14 +2641,6 @@ surrounded by (cl-block NAME ...).
       `(if (cl-member ,a ,list ,@keys) ,list (cons ,a ,list))
     form))
 
-;;;###autoload
-(defun cl--compiler-macro-list* (_form arg &rest others)
-  (let* ((args (reverse (cons arg others)))
-	 (form (car args)))
-    (while (setq args (cdr args))
-      (setq form `(cons ,(car args) ,form)))
-    form))
-
 (defun cl--compiler-macro-get (_form sym prop &optional def)
   (if def
       `(cl-getf (symbol-plist ,sym) ,prop ,def)
@@ -2616,21 +2652,6 @@ surrounded by (cl-block NAME ...).
         (cl--make-type-test temp (cl--const-expr-val type)))
     form))
 
-;;;###autoload
-(defun cl--compiler-macro-cXXr (form x)
-  (let* ((head (car form))
-         (n (symbol-name (car form)))
-         (i (- (length n) 2)))
-    (if (not (string-match "c[ad]+r\\'" n))
-        (if (and (fboundp head) (symbolp (symbol-function head)))
-            (cl--compiler-macro-cXXr (cons (symbol-function head) (cdr form))
-                                     x)
-          (error "Compiler macro for cXXr applied to non-cXXr form"))
-      (while (> i (match-beginning 0))
-        (setq x (list (if (eq (aref n i) ?a) 'car 'cdr) x))
-        (setq i (1- i)))
-      x)))
-
 (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/debug.el b/lisp/emacs-lisp/debug.el
index 7bc93a19d1..774b4d3d60 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -48,6 +48,39 @@ the middle is discarded, and just the beginning and end are displayed."
   :group 'debugger
   :version "21.1")
 
+(defcustom debugger-bury-or-kill 'bury
+  "How to proceed with the debugger buffer when exiting `debug'.
+The value used here affects the behavior of operations on any
+window previously showing the debugger buffer.
+
+`nil' means that if its window is not deleted when exiting the
+  debugger, invoking `switch-to-prev-buffer' will usually show
+  the debugger buffer again.
+
+`append' means that if the window is not deleted, the debugger
+  buffer moves to the end of the window's previous buffers so
+  it's less likely that a future invocation of
+  `switch-to-prev-buffer' will switch to it.  Also, it moves the
+  buffer to the end of the frame's buffer list.
+
+`bury' means that if the window is not deleted, its buffer is
+  removed from the window's list of previous buffers.  Also, it
+  moves the buffer to the end of the frame's buffer list.  This
+  value provides the most reliable remedy to not have
+  `switch-to-prev-buffer' switch to the debugger buffer again
+  without killing the buffer.
+
+`kill' means to kill the debugger buffer.
+
+The value used here is passed to `quit-restore-window'."
+  :type '(choice
+	  (const :tag "Keep alive" nil)
+	  (const :tag "Append" 'append)
+	  (const :tag "Bury" 'bury)
+	  (const :tag "Kill" 'kill))
+  :group 'debugger
+  :version "24.2")
+
 (defvar debug-function-list nil
   "List of functions currently set for debug on entry.")
 
@@ -60,6 +93,12 @@ the middle is discarded, and just the beginning and end are displayed."
 (defvar debugger-old-buffer nil
   "This is the buffer that was current when the debugger was entered.")
 
+(defvar debugger-previous-window nil
+  "This is the window last showing the debugger buffer.")
+
+(defvar debugger-previous-window-height nil
+  "The last recorded height of `debugger-previous-window'.")
+
 (defvar debugger-previous-backtrace nil
   "The contents of the previous backtrace (including text properties).
 This is to optimize `debugger-make-xrefs'.")
@@ -71,10 +110,6 @@ This is to optimize `debugger-make-xrefs'.")
 (defvar debugger-outer-track-mouse)
 (defvar debugger-outer-last-command)
 (defvar debugger-outer-this-command)
-;; unread-command-char is obsolete,
-;; but we still save and restore it
-;; in case some user program still tries to set it.
-(defvar debugger-outer-unread-command-char)
 (defvar debugger-outer-unread-command-events)
 (defvar debugger-outer-unread-post-input-method-events)
 (defvar debugger-outer-last-input-event)
@@ -126,14 +161,12 @@ first will be printed into the backtrace buffer."
     (unless noninteractive
       (message "Entering debugger..."))
     (let (debugger-value
-	  (debug-on-error nil)
-	  (debug-on-quit nil)
 	  (debugger-previous-state
            (if (get-buffer "*Backtrace*")
                (with-current-buffer (get-buffer "*Backtrace*")
                  (list major-mode (buffer-string)))))
 	  (debugger-buffer (get-buffer-create "*Backtrace*"))
-	  (debugger-old-buffer (current-buffer))
+	  (debugger-window nil)
 	  (debugger-step-after-exit nil)
           (debugger-will-be-back nil)
 	  ;; Don't keep reading from an executing kbd macro!
@@ -148,8 +181,6 @@ first will be printed into the backtrace buffer."
 	  (debugger-outer-track-mouse track-mouse)
 	  (debugger-outer-last-command last-command)
 	  (debugger-outer-this-command this-command)
-	  (debugger-outer-unread-command-char
-	   (with-no-warnings unread-command-char))
 	  (debugger-outer-unread-command-events unread-command-events)
 	  (debugger-outer-unread-post-input-method-events
 	   unread-post-input-method-events)
@@ -184,78 +215,74 @@ first will be printed into the backtrace buffer."
 	    (cursor-in-echo-area nil))
 	(unwind-protect
 	    (save-excursion
-	      (save-window-excursion
-		(with-no-warnings
-		  (setq unread-command-char -1))
-		(when (eq (car debugger-args) 'debug)
-		  ;; Skip the frames for backtrace-debug, byte-code,
-		  ;; and implement-debug-on-entry.
-		  (backtrace-debug 4 t)
-		  ;; Place an extra debug-on-exit for macro's.
-		  (when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
-		    (backtrace-debug 5 t)))
-                (pop-to-buffer debugger-buffer)
-		(debugger-mode)
-		(debugger-setup-buffer debugger-args)
-		(when noninteractive
-		  ;; If the backtrace is long, save the beginning
-		  ;; and the end, but discard the middle.
-		  (when (> (count-lines (point-min) (point-max))
-			   debugger-batch-max-lines)
-		    (goto-char (point-min))
-		    (forward-line (/ 2 debugger-batch-max-lines))
-		    (let ((middlestart (point)))
-		      (goto-char (point-max))
-		      (forward-line (- (/ 2 debugger-batch-max-lines)
-				       debugger-batch-max-lines))
-		      (delete-region middlestart (point)))
-		    (insert "...\n"))
+	      (when (eq (car debugger-args) 'debug)
+		;; Skip the frames for backtrace-debug, byte-code,
+		;; and implement-debug-on-entry.
+		(backtrace-debug 4 t)
+		;; Place an extra debug-on-exit for macro's.
+		(when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
+		  (backtrace-debug 5 t)))
+	      (pop-to-buffer
+	       debugger-buffer
+	       `((display-buffer-reuse-window
+		  display-buffer-in-previous-window)
+		  . (,(when debugger-previous-window
+			`(previous-window . ,debugger-previous-window)))))
+	      (setq debugger-window (selected-window))
+	      (if (eq debugger-previous-window debugger-window)
+		  (when debugger-jumping-flag
+		    ;; Try to restore previous height of debugger
+		    ;; window.
+		    (condition-case nil
+			(window-resize
+			 debugger-window
+			 (- debugger-previous-window-height
+			    (window-total-size debugger-window)))
+		      (error nil)))
+		(setq debugger-previous-window debugger-window))
+	      (debugger-mode)
+	      (debugger-setup-buffer debugger-args)
+	      (when noninteractive
+		;; If the backtrace is long, save the beginning
+		;; and the end, but discard the middle.
+		(when (> (count-lines (point-min) (point-max))
+			 debugger-batch-max-lines)
 		  (goto-char (point-min))
-		  (message "%s" (buffer-string))
-		  (kill-emacs -1))
+		  (forward-line (/ 2 debugger-batch-max-lines))
+		  (let ((middlestart (point)))
+		    (goto-char (point-max))
+		    (forward-line (- (/ 2 debugger-batch-max-lines)
+				     debugger-batch-max-lines))
+		    (delete-region middlestart (point)))
+		  (insert "...\n"))
+		(goto-char (point-min))
+		(message "%s" (buffer-string))
+		(kill-emacs -1))
+	      (message "")
+	      (let ((standard-output nil)
+		    (buffer-read-only t))
 		(message "")
-		(let ((standard-output nil)
-		      (buffer-read-only t))
-		  (message "")
-		  ;; Make sure we unbind buffer-read-only in the right buffer.
-		  (save-excursion
-		    (recursive-edit)))))
-	  ;; Kill or at least neuter the backtrace buffer, so that users
-	  ;; don't try to execute debugger commands in an invalid context.
-	  (if (get-buffer-window debugger-buffer 0)
-	      ;; Still visible despite the save-window-excursion?  Maybe it
-	      ;; it's in a pop-up frame.  It would be annoying to delete and
-	      ;; recreate it every time the debugger stops, so instead we'll
-	      ;; erase it (and maybe hide it) but keep it alive.
-	      (with-current-buffer debugger-buffer
-		(with-selected-window (get-buffer-window debugger-buffer 0)
-                  (when (and (window-dedicated-p (selected-window))
-                             (not debugger-will-be-back))
-                    ;; If the window is not dedicated, burying the buffer
-                    ;; will mean that the frame created for it is left
-                    ;; around showing some random buffer, and next time we
-                    ;; pop to the debugger buffer we'll create yet
-                    ;; another frame.
-                    ;; If debugger-will-be-back is non-nil, the frame
-                    ;; would need to be de-iconified anyway immediately
-                    ;; after when we re-enter the debugger, so iconifying it
-                    ;; here would cause flashing.
-                    ;; Drew Adams is not happy with this: he wants to frame
-                    ;; to be left at the top-level, still working on how
-                    ;; best to do that.
-                    (bury-buffer))))
-            (unless debugger-previous-state
-              (kill-buffer debugger-buffer)))
-          ;; Restore the previous state of the debugger-buffer, in case we were
-          ;; in a recursive invocation of the debugger.
-          (when (buffer-live-p debugger-buffer)
-            (with-current-buffer debugger-buffer
-              (let ((inhibit-read-only t))
-                (erase-buffer)
-                (if (null debugger-previous-state)
-                    (fundamental-mode)
-                  (insert (nth 1 debugger-previous-state))
-                  (funcall (nth 0 debugger-previous-state))))))
+		;; Make sure we unbind buffer-read-only in the right buffer.
+		(save-excursion
+		  (recursive-edit))))
+	  (when (and (window-live-p debugger-window)
+		     (eq (window-buffer debugger-window) debugger-buffer))
+	    ;; Record height of debugger window.
+	    (setq debugger-previous-window-height
+		  (window-total-size debugger-window))
+	    ;; Unshow debugger-buffer.
+	    (quit-restore-window debugger-window debugger-bury-or-kill))
+          ;; Restore previous state of debugger-buffer in case we were
+          ;; in a recursive invocation of the debugger, otherwise just
+          ;; erase the buffer and put it into fundamental mode.
+	  (when (buffer-live-p debugger-buffer)
+	    (with-current-buffer debugger-buffer
+	      (let ((inhibit-read-only t))
+		(erase-buffer)
+		(if (null debugger-previous-state)
+		    (fundamental-mode)
+		  (insert (nth 1 debugger-previous-state))
+		  (funcall (nth 0 debugger-previous-state))))))
 	  (with-timeout-unsuspend debugger-with-timeout-suspend)
 	  (set-match-data debugger-outer-match-data)))
       ;; Put into effect the modified values of these variables
@@ -267,8 +294,6 @@ first will be printed into the backtrace buffer."
       (setq track-mouse debugger-outer-track-mouse)
       (setq last-command debugger-outer-last-command)
       (setq this-command debugger-outer-this-command)
-      (with-no-warnings
-	(setq unread-command-char debugger-outer-unread-command-char))
       (setq unread-command-events debugger-outer-unread-command-events)
       (setq unread-post-input-method-events
 	    debugger-outer-unread-post-input-method-events)
@@ -570,16 +595,7 @@ Applies to the frame whose line point is on in the backtrace."
           (cursor-in-echo-area debugger-outer-cursor-in-echo-area))
       (set-match-data debugger-outer-match-data)
       (prog1
-	  (let ((save-ucc (with-no-warnings unread-command-char)))
-	    (unwind-protect
-		(progn
-		  (with-no-warnings
-		    (setq unread-command-char debugger-outer-unread-command-char))
-		  (prog1 (progn ,@body)
-		    (with-no-warnings
-		      (setq debugger-outer-unread-command-char unread-command-char))))
-	      (with-no-warnings
-		(setq unread-command-char save-ucc))))
+          (progn ,@body)
         (setq debugger-outer-match-data (match-data))
         (setq debugger-outer-load-read-function load-read-function)
         (setq debugger-outer-overriding-terminal-local-map
diff --git a/lisp/emacs-lisp/easymenu.el b/lisp/emacs-lisp/easymenu.el
index 7f9f8a3363..939fab7894 100644
--- a/lisp/emacs-lisp/easymenu.el
+++ b/lisp/emacs-lisp/easymenu.el
@@ -148,7 +148,7 @@ unselectable text.  A string consisting solely of hyphens is displayed
 as a solid horizontal line.
 
 A menu item can be a list with the same format as MENU.  This is a submenu."
-  (declare (indent defun))
+  (declare (indent defun) (debug (symbolp body)))
   `(progn
      ,(if symbol `(defvar ,symbol nil ,doc))
      (easy-menu-do-define (quote ,symbol) ,maps ,doc ,menu)))
diff --git a/lisp/emacs-lisp/edebug.el b/lisp/emacs-lisp/edebug.el
index 7fcd339d6d..d656dcf952 100644
--- a/lisp/emacs-lisp/edebug.el
+++ b/lisp/emacs-lisp/edebug.el
@@ -1,4 +1,4 @@
-;;; edebug.el --- a source-level debugger for Emacs Lisp
+;;; edebug.el --- a source-level debugger for Emacs Lisp  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1988-1995, 1997, 1999-2012 Free Software Foundation, Inc.
 
@@ -52,10 +52,7 @@
 ;;; Code:
 
 (require 'macroexp)
-
-;;; Bug reporting
-
-(defalias 'edebug-submit-bug-report 'report-emacs-bug)
+(eval-when-compile (require 'cl-lib))
 
 ;;; Options
 
@@ -235,14 +232,9 @@ If the result is non-nil, then break.  Errors are ignored."
 
 ;;; Form spec utilities.
 
-(defmacro def-edebug-form-spec (symbol spec-form)
-  "For compatibility with old version."
-  (def-edebug-spec symbol (eval spec-form)))
-(make-obsolete 'def-edebug-form-spec 'def-edebug-spec "22.1")
-
 (defun get-edebug-spec (symbol)
   ;; Get the spec of symbol resolving all indirection.
-  (let ((edebug-form-spec nil)
+  (let ((spec nil)
 	(indirect symbol))
     (while
         (progn
@@ -250,9 +242,8 @@ If the result is non-nil, then break.  Errors are ignored."
                (setq indirect
                      (function-get indirect 'edebug-form-spec 'macro))))
       ;; (edebug-trace "indirection: %s" edebug-form-spec)
-      (setq edebug-form-spec indirect))
-    edebug-form-spec
-    ))
+      (setq spec indirect))
+    spec))
 
 ;;;###autoload
 (defun edebug-basic-spec (spec)
@@ -342,9 +333,7 @@ A lambda list keyword is a symbol that starts with `&'."
 	       (lambda (e1 e2)
 		 (funcall function (car e1) (car e2))))))
 
-;;(def-edebug-spec edebug-save-restriction t)
-
-;; Not used.  If it is used, def-edebug-spec must be defined before use.
+;; Not used.
 '(defmacro edebug-save-restriction (&rest body)
   "Evaluate BODY while saving the current buffers restriction.
 BODY may change buffer outside of current restriction, unlike
@@ -352,6 +341,7 @@ save-restriction.  BODY may change the current buffer,
 and the restriction will be restored to the original buffer,
 and the current buffer remains current.
 Return the result of the last expression in BODY."
+  (declare (debug t))
   `(let ((edebug:s-r-beg (point-min-marker))
 	 (edebug:s-r-end (point-max-marker)))
      (unwind-protect
@@ -369,6 +359,7 @@ Return the result of the last expression in BODY."
   ;; Select WINDOW if it is provided and still exists.  Otherwise,
   ;; if buffer is currently shown in several windows, choose one.
   ;; Otherwise, find a new window, possibly splitting one.
+  ;; FIXME: We should probably just be using `pop-to-buffer'.
   (setq window
 	(cond
 	 ((and (edebug-window-live-p window)
@@ -377,7 +368,7 @@ Return the result of the last expression in BODY."
 	 ((eq (window-buffer (selected-window)) buffer)
 	  ;; Selected window already displays BUFFER.
 	  (selected-window))
-	 ((edebug-get-buffer-window buffer))
+	 ((get-buffer-window buffer 0))
 	 ((one-window-p 'nomini)
 	  ;; When there's one window only, split it.
 	  (split-window))
@@ -450,18 +441,14 @@ Return the result of the last expression in BODY."
 	      window-info)
     (set-window-configuration window-info)))
 
-(defalias 'edebug-get-buffer-window 'get-buffer-window)
-(defalias 'edebug-sit-for 'sit-for)
-(defalias 'edebug-input-pending-p 'input-pending-p)
-
-
 ;;; Redefine read and eval functions
 ;; read is redefined to maybe instrument forms.
 ;; eval-defun is redefined to check edebug-all-forms and edebug-all-defs.
 
 ;; Save the original read function
-(or (fboundp 'edebug-original-read)
-    (defalias 'edebug-original-read  (symbol-function 'read)))
+(defalias 'edebug-original-read
+  (symbol-function (if (fboundp 'edebug-original-read)
+                       'edebug-original-read 'read)))
 
 (defun edebug-read (&optional stream)
   "Read one Lisp expression as text from STREAM, return as Lisp object.
@@ -626,36 +613,29 @@ already is one.)"
 ;; The internal data that is needed for edebugging is kept in the
 ;; buffer-local variable `edebug-form-data'.
 
-(make-variable-buffer-local 'edebug-form-data)
-
-(defvar edebug-form-data nil)
-;; A list of entries associating symbols with buffer regions.
-;; This is an automatic buffer local variable.  Each entry looks like:
-;; @code{(@var{symbol} @var{begin-marker} @var{end-marker}).  The markers
-;; are at the beginning and end of an entry level form and @var{symbol} is
-;; a symbol that holds all edebug related information for the form on its
-;; property list.
-
-;; In the future, the symbol will be irrelevant and edebug data will
-;; be stored in the definitions themselves rather than in the property
-;; list of a symbol.
-
-(defun edebug-make-form-data-entry (symbol begin end)
-  (list symbol begin end))
-
-(defsubst edebug-form-data-name (entry)
-  (car entry))
-
-(defsubst edebug-form-data-begin (entry)
-  (nth 1 entry))
-
-(defsubst edebug-form-data-end (entry)
-  (nth 2 entry))
+(defvar-local edebug-form-data nil
+  "A list of entries associating symbols with buffer regions.
+Each entry is an `edebug--form-data' struct with fields:
+SYMBOL, BEGIN-MARKER, and END-MARKER.  The markers
+are at the beginning and end of an entry level form and SYMBOL is
+a symbol that holds all edebug related information for the form on its
+property list.
+
+In the future (haha!), the symbol will be irrelevant and edebug data will
+be stored in the definitions themselves rather than in the property
+list of a symbol.")
+
+(cl-defstruct (edebug--form-data
+               ;; Some callers expect accessors to return nil when passed nil.
+               (:type list)
+               (:constructor edebug--make-form-data-entry (name begin end))
+               (:predicate nil) (:constructor nil) (:copier nil))
+  name begin end)
 
 (defsubst edebug-set-form-data-entry (entry name begin end)
-  (setcar entry name);; in case name is changed
-  (set-marker (nth 1 entry) begin)
-  (set-marker (nth 2 entry) end))
+  (setf (edebug--form-data-name entry) name) ;; In case name is changed.
+  (set-marker (edebug--form-data-begin entry) begin)
+  (set-marker (edebug--form-data-end entry) end))
 
 (defun edebug-get-form-data-entry (pnt &optional end-point)
   ;; Find the edebug form data entry which is closest to PNT.
@@ -663,17 +643,17 @@ already is one.)"
   ;; Return `nil' if none found.
   (let ((rest edebug-form-data)
 	closest-entry
-	(closest-dist 999999))  ;; need maxint here
+	(closest-dist 999999))  ;; Need maxint here.
     (while (and rest (< 0 closest-dist))
       (let* ((entry (car rest))
-	     (begin (edebug-form-data-begin entry))
+	     (begin (edebug--form-data-begin entry))
 	     (dist (- pnt begin)))
 	(setq rest (cdr rest))
 	(if (and (<= 0 dist)
 		 (< dist closest-dist)
 		 (or (not end-point)
-		     (= end-point (edebug-form-data-end entry)))
-		 (<= pnt (edebug-form-data-end entry)))
+		     (= end-point (edebug--form-data-end entry)))
+		 (<= pnt (edebug--form-data-end entry)))
 	    (setq closest-dist dist
 		  closest-entry entry))))
     closest-entry))
@@ -682,19 +662,19 @@ already is one.)"
 ;; and find an entry given a symbol, which should be just assq.
 
 (defun edebug-form-data-symbol ()
-;; Return the edebug data symbol of the form where point is in.
-;; If point is not inside a edebuggable form, cause error.
-  (or (edebug-form-data-name (edebug-get-form-data-entry (point)))
+  "Return the edebug data symbol of the form where point is in.
+If point is not inside a edebuggable form, cause error."
+  (or (edebug--form-data-name (edebug-get-form-data-entry (point)))
       (error "Not inside instrumented form")))
 
 (defun edebug-make-top-form-data-entry (new-entry)
   ;; Make NEW-ENTRY the first element in the `edebug-form-data' list.
   (edebug-clear-form-data-entry new-entry)
-  (setq edebug-form-data (cons new-entry edebug-form-data)))
+  (push new-entry edebug-form-data))
 
 (defun edebug-clear-form-data-entry (entry)
-;; If non-nil, clear ENTRY out of the form data.
-;; Maybe clear the markers and delete the symbol's edebug property?
+  "If non-nil, clear ENTRY out of the form data.
+Maybe clear the markers and delete the symbol's edebug property?"
   (if entry
       (progn
 	;; Instead of this, we could just find all contained forms.
@@ -1086,7 +1066,8 @@ already is one.)"
   ;; If it gets an error, make it nil.
   (let ((temp-hook edebug-setup-hook))
     (setq edebug-setup-hook nil)
-    (run-hooks 'temp-hook))
+    (if (functionp temp-hook) (funcall temp-hook)
+      (mapc #'funcall temp-hook)))
 
   (let (result
 	edebug-top-window-data
@@ -1223,8 +1204,8 @@ already is one.)"
 (defvar edebug-offset-list) ; the list of offset positions.
 
 (defun edebug-inc-offset (offset)
-  ;; modifies edebug-offset-index and edebug-offset-list
-  ;; accesses edebug-func-marc and buffer point
+  ;; Modifies edebug-offset-index and edebug-offset-list
+  ;; accesses edebug-func-marc and buffer point.
   (prog1
       edebug-offset-index
     (setq edebug-offset-list (cons (- offset edebug-form-begin-marker)
@@ -1237,13 +1218,11 @@ already is one.)"
   ;; given FORM.  Looks like:
   ;; (edebug-after (edebug-before BEFORE-INDEX) AFTER-INDEX FORM)
   ;; Also increment the offset index for subsequent use.
-  (list 'edebug-after
-	(list 'edebug-before before-index)
-	after-index form))
+  `(edebug-after (edebug-before ,before-index) ,after-index ,form))
 
 (defun edebug-make-after-form (form after-index)
   ;; Like edebug-make-before-and-after-form, but only after.
-  (list 'edebug-after 0 after-index form))
+  `(edebug-after 0 ,after-index ,form))
 
 
 (defun edebug-unwrap (sexp)
@@ -1293,7 +1272,7 @@ expressions; a `progn' form will be returned enclosing these forms."
 	 ;; Set this marker before parsing.
 	 (edebug-form-begin-marker
 	  (if form-data-entry
-	      (edebug-form-data-begin form-data-entry)
+	      (edebug--form-data-begin form-data-entry)
 	    ;; Buffer must be current-buffer for this to work:
 	    (set-marker (make-marker) form-begin))))
 
@@ -1303,7 +1282,7 @@ expressions; a `progn' form will be returned enclosing these forms."
 	  ;; For definitions.
 	  ;; (edebug-containing-def-name edebug-def-name)
 	  ;; Get name from form-data, if any.
-	  (edebug-old-def-name (edebug-form-data-name form-data-entry))
+	  (edebug-old-def-name (edebug--form-data-name form-data-entry))
 	  edebug-def-name
 	  edebug-def-args
 	  edebug-def-interactive
@@ -1333,7 +1312,7 @@ expressions; a `progn' form will be returned enclosing these forms."
       ;; In the latter case, pointers to the entry remain eq.
       (if (not form-data-entry)
 	  (setq form-data-entry
-		(edebug-make-form-data-entry
+		(edebug--make-form-data-entry
 		 edebug-def-name
 		 edebug-form-begin-marker
 		 ;; Buffer must be current-buffer.
@@ -1519,18 +1498,18 @@ expressions; a `progn' form will be returned enclosing these forms."
 ;; Otherwise it signals an error.  The place of the error is found
 ;; with the two before- and after-offset functions.
 
-(defun edebug-no-match (cursor &rest edebug-args)
+(defun edebug-no-match (cursor &rest args)
   ;; Throw a no-match, or signal an error immediately if gate is active.
   ;; Remember this point in case we need to report this error.
   (setq edebug-error-point (or edebug-error-point
 			       (edebug-before-offset cursor))
-	edebug-best-error (or edebug-best-error edebug-args))
+	edebug-best-error (or edebug-best-error args))
   (if (and edebug-gate (not edebug-&optional))
       (progn
 	(if edebug-error-point
 	    (goto-char edebug-error-point))
-	(apply 'edebug-syntax-error edebug-args))
-    (funcall 'throw 'no-match edebug-args)))
+	(apply 'edebug-syntax-error args))
+    (throw 'no-match args)))
 
 
 (defun edebug-match (cursor specs)
@@ -1757,7 +1736,7 @@ expressions; a `progn' form will be returned enclosing these forms."
 		 specs))))
 
 
-(defun edebug-match-gate (cursor)
+(defun edebug-match-gate (_cursor)
   ;; Simply set the gate to prevent backtracking at this level.
   (setq edebug-gate t)
   nil)
@@ -1846,7 +1825,7 @@ expressions; a `progn' form will be returned enclosing these forms."
     nil))
 
 
-(defun edebug-match-function (cursor)
+(defun edebug-match-function (_cursor)
   (error "Use function-form instead of function in edebug spec"))
 
 (defun edebug-match-&define (cursor specs)
@@ -1903,7 +1882,7 @@ expressions; a `progn' form will be returned enclosing these forms."
     (edebug-move-cursor cursor)
     (list name)))
 
-(defun edebug-match-colon-name (cursor spec)
+(defun edebug-match-colon-name (_cursor spec)
   ;; Set the edebug-def-name to the spec.
   (setq edebug-def-name
 	(if edebug-def-name
@@ -1988,6 +1967,8 @@ expressions; a `progn' form will be returned enclosing these forms."
 	   def-body))
 ;; FIXME? Isn't this missing the doc-string?  Cf defun.
 (def-edebug-spec defmacro
+  ;; FIXME: Improve `declare' so we can Edebug gv-expander and
+  ;; gv-setter declarations.
   (&define name lambda-list [&optional ("declare" &rest sexp)] def-body))
 
 (def-edebug-spec arglist lambda-list)  ;; deprecated - use lambda-list.
@@ -2018,11 +1999,6 @@ expressions; a `progn' form will be returned enclosing these forms."
 ;; (def-edebug-spec anonymous-form ((&or ["lambda" lambda] ["macro" macro])))
 
 ;; Standard functions that take function-forms arguments.
-(def-edebug-spec mapcar (function-form form))
-(def-edebug-spec mapconcat (function-form form form))
-(def-edebug-spec mapatoms (function-form &optional form))
-(def-edebug-spec apply (function-form &rest form))
-(def-edebug-spec funcall (function-form &rest form))
 
 ;; FIXME?  The manual uses this form (maybe that's just for illustration?):
 ;; (def-edebug-spec let
@@ -2088,49 +2064,12 @@ expressions; a `progn' form will be returned enclosing these forms."
 		     &or ("quote" edebug-\`) def-form))
 
 ;; New byte compiler.
-(def-edebug-spec defsubst defun)
-(def-edebug-spec dont-compile t)
-(def-edebug-spec eval-when-compile t)
-(def-edebug-spec eval-and-compile t)
 
 (def-edebug-spec save-selected-window t)
 (def-edebug-spec save-current-buffer t)
-(def-edebug-spec delay-mode-hooks t)
-(def-edebug-spec with-temp-file t)
-(def-edebug-spec with-temp-message t)
-(def-edebug-spec with-syntax-table t)
-(def-edebug-spec push (form sexp))
-(def-edebug-spec pop (sexp))
-
-(def-edebug-spec 1value (form))
-(def-edebug-spec noreturn (form))
-
 
 ;; Anything else?
 
-
-;; Some miscellaneous specs for macros in public packages.
-;; Send me yours.
-
-;; advice.el by Hans Chalupsky ([email protected])
-
-(def-edebug-spec ad-dolist ((symbolp form &optional form) body))
-(def-edebug-spec defadvice
-  (&define name   ;; thing being advised.
-	   (name  ;; class is [&or "before" "around" "after"
-	          ;;               "activation" "deactivation"]
-	    name  ;; name of advice
-	    &rest sexp  ;; optional position and flags
-	    )
-	   [&optional stringp]
-	   [&optional ("interactive" interactive)]
-	   def-body))
-
-(def-edebug-spec easy-menu-define (symbolp body))
-
-(def-edebug-spec with-custom-print body)
-
-
 ;;; The debugger itself
 
 (defvar edebug-active nil)  ;; Non-nil when edebug is active
@@ -2167,10 +2106,7 @@ expressions; a `progn' form will be returned enclosing these forms."
 
 ;; Dynamically bound variables, declared globally but left unbound.
 (defvar edebug-function) ; the function being executed. change name!!
-(defvar edebug-args) ; the arguments of the function
 (defvar edebug-data) ; the edebug data for the function
-(defvar edebug-value) ; the result of the expression
-(defvar edebug-after-index)
 (defvar edebug-def-mark) ; the mark for the definition
 (defvar edebug-freq-count) ; the count of expression visits.
 (defvar edebug-coverage) ; the coverage results of each expression of function.
@@ -2186,8 +2122,6 @@ expressions; a `progn' form will be returned enclosing these forms."
 (defvar edebug-outside-debug-on-error) ; the value of debug-on-error outside
 (defvar edebug-outside-debug-on-quit) ; the value of debug-on-quit outside
 
-(defvar edebug-outside-overriding-local-map)
-(defvar edebug-outside-overriding-terminal-local-map)
 
 (defvar edebug-outside-pre-command-hook)
 (defvar edebug-outside-post-command-hook)
@@ -2196,7 +2130,7 @@ expressions; a `progn' form will be returned enclosing these forms."
 
 ;;; Handling signals
 
-(defun edebug-signal (edebug-signal-name edebug-signal-data)
+(defun edebug-signal (signal-name signal-data)
   "Signal an error.  Args are SIGNAL-NAME, and associated DATA.
 A signal name is a symbol with an `error-conditions' property
 that is a list of condition names.
@@ -2210,19 +2144,18 @@ See `condition-case'.
 This is the Edebug replacement for the standard `signal'.  It should
 only be active while Edebug is.  It checks `debug-on-error' to see
 whether it should call the debugger.  When execution is resumed, the
-error is signaled again.
-\n(fn SIGNAL-NAME DATA)"
-  (if (and (listp debug-on-error) (memq edebug-signal-name debug-on-error))
-      (edebug 'error (cons edebug-signal-name edebug-signal-data)))
+error is signaled again."
+  (if (and (listp debug-on-error) (memq signal-name debug-on-error))
+      (edebug 'error (cons signal-name signal-data)))
   ;; If we reach here without another non-local exit, then send signal again.
   ;; i.e. the signal is not continuable, yet.
   ;; Avoid infinite recursion.
   (let ((signal-hook-function nil))
-    (signal edebug-signal-name edebug-signal-data)))
+    (signal signal-name signal-data)))
 
 ;;; Entering Edebug
 
-(defun edebug-enter (edebug-function edebug-args edebug-body)
+(defun edebug-enter (function args body)
   ;; Entering FUNC.  The arguments are ARGS, and the body is BODY.
   ;; Setup edebug variables and evaluate BODY.  This function is called
   ;; when a function evaluated with edebug-eval-top-level-form is entered.
@@ -2231,83 +2164,51 @@ error is signaled again.
   ;; Is this the first time we are entering edebug since
   ;; lower-level recursive-edit command?
   ;; More precisely, this tests whether Edebug is currently active.
-  (if (not edebug-entered)
-      (let ((edebug-entered t)
-	    ;; Binding max-lisp-eval-depth here is OK,
-	    ;; but not inside an unwind-protect.
-	    ;; Doing it here also keeps it from growing too large.
-	    (max-lisp-eval-depth (+ 100 max-lisp-eval-depth)) ; too much??
-	    (max-specpdl-size (+ 200 max-specpdl-size))
-
-	    (debugger edebug-debugger)  ; only while edebug is active.
-	    (edebug-outside-debug-on-error debug-on-error)
-	    (edebug-outside-debug-on-quit debug-on-quit)
-	    ;; Binding these may not be the right thing to do.
-	    ;; We want to allow the global values to be changed.
-	    (debug-on-error (or debug-on-error edebug-on-error))
-	    (debug-on-quit edebug-on-quit)
-
-	    ;; Lexical bindings must be uncompiled for this to work.
-	    (cl-lexical-debug t)
-
-	    (edebug-outside-overriding-local-map overriding-local-map)
-	    (edebug-outside-overriding-terminal-local-map
-	     overriding-terminal-local-map)
-
-	    ;; Save the outside value of executing macro.  (here??)
-	    (edebug-outside-executing-macro executing-kbd-macro)
-	    (edebug-outside-pre-command-hook
-	     (edebug-var-status 'pre-command-hook))
-	    (edebug-outside-post-command-hook
-	     (edebug-var-status 'post-command-hook)))
-	(unwind-protect
-	    (let (;; Don't keep reading from an executing kbd macro
-		  ;; within edebug unless edebug-continue-kbd-macro is
-		  ;; non-nil.  Again, local binding may not be best.
-		  (executing-kbd-macro
-		   (if edebug-continue-kbd-macro executing-kbd-macro))
-
-		  ;; Don't get confused by the user's keymap changes.
-		  (overriding-local-map nil)
-		  (overriding-terminal-local-map nil)
-
-		  (signal-hook-function 'edebug-signal)
-
-		  ;; Disable command hooks.  This is essential when
-		  ;; a hook function is instrumented - to avoid infinite loop.
-		  ;; This may be more than we need, however.
-		  (pre-command-hook nil)
-		  (post-command-hook nil))
-	      (setq edebug-execution-mode (or edebug-next-execution-mode
-					      edebug-initial-mode
-					      edebug-execution-mode)
-		    edebug-next-execution-mode nil)
-	      (edebug-enter edebug-function edebug-args edebug-body))
-	  ;; Reset global variables in case outside value was changed.
-	  (setq executing-kbd-macro edebug-outside-executing-macro)
-	  (edebug-restore-status
-	   'post-command-hook edebug-outside-post-command-hook)
-	  (edebug-restore-status
-	   'pre-command-hook edebug-outside-pre-command-hook)))
-
-    (let* ((edebug-data (get edebug-function 'edebug))
-	   (edebug-def-mark (car edebug-data)) ; mark at def start
-	   (edebug-freq-count (get edebug-function 'edebug-freq-count))
-	   (edebug-coverage (get edebug-function 'edebug-coverage))
-	   (edebug-buffer (marker-buffer edebug-def-mark))
-
-	   (edebug-stack (cons edebug-function edebug-stack))
-	   (edebug-offset-indices (cons 0 edebug-offset-indices))
-	   )
-      (if (get edebug-function 'edebug-on-entry)
-	  (progn
-	    (setq edebug-execution-mode 'step)
-	    (if (eq (get edebug-function 'edebug-on-entry) 'temp)
-		(put edebug-function 'edebug-on-entry nil))))
-      (if edebug-trace
-	  (edebug-enter-trace edebug-body)
-	(funcall edebug-body))
-      )))
+  (let ((edebug-function function))
+    (if (not edebug-entered)
+        (let ((edebug-entered t)
+              ;; Binding max-lisp-eval-depth here is OK,
+              ;; but not inside an unwind-protect.
+              ;; Doing it here also keeps it from growing too large.
+              (max-lisp-eval-depth (+ 100 max-lisp-eval-depth)) ; too much??
+              (max-specpdl-size (+ 200 max-specpdl-size))
+
+              (debugger edebug-debugger) ; only while edebug is active.
+              (edebug-outside-debug-on-error debug-on-error)
+              (edebug-outside-debug-on-quit debug-on-quit)
+              ;; Binding these may not be the right thing to do.
+              ;; We want to allow the global values to be changed.
+              (debug-on-error (or debug-on-error edebug-on-error))
+              (debug-on-quit edebug-on-quit)
+
+              ;; Lexical bindings must be uncompiled for this to work.
+              (cl-lexical-debug t))
+          (unwind-protect
+              (let ((signal-hook-function 'edebug-signal))
+                (setq edebug-execution-mode (or edebug-next-execution-mode
+                                                edebug-initial-mode
+                                                edebug-execution-mode)
+                      edebug-next-execution-mode nil)
+                (edebug-enter function args body))))
+
+      (let* ((edebug-data (get function 'edebug))
+             (edebug-def-mark (car edebug-data)) ; mark at def start
+             (edebug-freq-count (get function 'edebug-freq-count))
+             (edebug-coverage (get function 'edebug-coverage))
+             (edebug-buffer (marker-buffer edebug-def-mark))
+
+             (edebug-stack (cons function edebug-stack))
+             (edebug-offset-indices (cons 0 edebug-offset-indices))
+             )
+        (if (get function 'edebug-on-entry)
+            (progn
+              (setq edebug-execution-mode 'step)
+              (if (eq (get function 'edebug-on-entry) 'temp)
+                  (put function 'edebug-on-entry nil))))
+        (if edebug-trace
+            (edebug--enter-trace function args body)
+          (funcall body))
+        ))))
 
 (defun edebug-var-status (var)
   "Return a cons cell describing the status of VAR's current binding.
@@ -2334,14 +2235,14 @@ STATUS should be a list returned by `edebug-var-status'."
 	  (t
 	   (set var value)))))
 
-(defun edebug-enter-trace (edebug-body)
+(defun edebug--enter-trace (function args body)
   (let ((edebug-stack-depth (1+ edebug-stack-depth))
 	edebug-result)
     (edebug-print-trace-before
-     (format "%s args: %s" edebug-function edebug-args))
-    (prog1 (setq edebug-result (funcall edebug-body))
+     (format "%s args: %s" function args))
+    (prog1 (setq edebug-result (funcall body))
       (edebug-print-trace-after
-       (format "%s result: %s" edebug-function edebug-result)))))
+       (format "%s result: %s" function edebug-result)))))
 
 (def-edebug-spec edebug-tracing (form body))
 
@@ -2369,49 +2270,49 @@ MSG is printed after `::::} '."
 
 
 
-(defun edebug-slow-before (edebug-before-index)
+(defun edebug-slow-before (before-index)
   (unless edebug-active
     ;; Debug current function given BEFORE position.
     ;; Called from functions compiled with edebug-eval-top-level-form.
     ;; Return the before index.
-    (setcar edebug-offset-indices edebug-before-index)
+    (setcar edebug-offset-indices before-index)
 
     ;; Increment frequency count
-    (aset edebug-freq-count edebug-before-index
-	  (1+ (aref edebug-freq-count edebug-before-index)))
+    (aset edebug-freq-count before-index
+	  (1+ (aref edebug-freq-count before-index)))
 
     (if (or (not (memq edebug-execution-mode '(Go-nonstop next)))
-	    (edebug-input-pending-p))
-	(edebug-debugger edebug-before-index 'before nil)))
-  edebug-before-index)
+	    (input-pending-p))
+	(edebug-debugger before-index 'before nil)))
+  before-index)
 
-(defun edebug-fast-before (edebug-before-index)
+(defun edebug-fast-before (_before-index)
   ;; Do nothing.
   )
 
-(defun edebug-slow-after (edebug-before-index edebug-after-index edebug-value)
+(defun edebug-slow-after (_before-index after-index value)
   (if edebug-active
-      edebug-value
+      value
     ;; Debug current function given AFTER position and VALUE.
     ;; Called from functions compiled with edebug-eval-top-level-form.
     ;; Return VALUE.
-    (setcar edebug-offset-indices edebug-after-index)
+    (setcar edebug-offset-indices after-index)
 
     ;; Increment frequency count
-    (aset edebug-freq-count edebug-after-index
-	  (1+ (aref edebug-freq-count edebug-after-index)))
-    (if edebug-test-coverage (edebug-update-coverage))
+    (aset edebug-freq-count after-index
+	  (1+ (aref edebug-freq-count after-index)))
+    (if edebug-test-coverage (edebug--update-coverage after-index value))
 
     (if (and (eq edebug-execution-mode 'Go-nonstop)
-	     (not (edebug-input-pending-p)))
+	     (not (input-pending-p)))
 	;; Just return result.
-	edebug-value
-      (edebug-debugger edebug-after-index 'after edebug-value)
+	value
+      (edebug-debugger after-index 'after value)
       )))
 
-(defun edebug-fast-after (edebug-before-index edebug-after-index edebug-value)
+(defun edebug-fast-after (_before-index _after-index value)
   ;; Do nothing but return the value.
-  edebug-value)
+  value)
 
 (defun edebug-run-slow ()
   (defalias 'edebug-before 'edebug-slow-before)
@@ -2425,19 +2326,18 @@ MSG is printed after `::::} '."
 (edebug-run-slow)
 
 
-(defun edebug-update-coverage ()
-  (let ((old-result (aref edebug-coverage edebug-after-index)))
+(defun edebug--update-coverage (after-index value)
+  (let ((old-result (aref edebug-coverage after-index)))
     (cond
      ((eq 'ok-coverage old-result))
      ((eq 'unknown old-result)
-      (aset edebug-coverage edebug-after-index edebug-value))
+      (aset edebug-coverage after-index value))
      ;; Test if a different result.
-     ((not (eq edebug-value old-result))
-      (aset edebug-coverage edebug-after-index 'ok-coverage)))))
+     ((not (eq value old-result))
+      (aset edebug-coverage after-index 'ok-coverage)))))
 
 
 ;; Dynamically declared unbound variables.
-(defvar edebug-arg-mode)  ; the mode, either before, after, or error
 (defvar edebug-breakpoints)
 (defvar edebug-break-data) ; break data for current function.
 (defvar edebug-break) ; whether a break occurred.
@@ -2448,16 +2348,16 @@ MSG is printed after `::::} '."
 (defvar edebug-global-break-result nil)
 
 
-(defun edebug-debugger (edebug-offset-index edebug-arg-mode edebug-value)
+(defun edebug-debugger (offset-index arg-mode value)
   (if inhibit-redisplay
       ;; Don't really try to enter edebug within an eval from redisplay.
-      edebug-value
+      value
     ;; Check breakpoints and pending input.
-    ;; If edebug display should be updated, call edebug-display.
-    ;; Return edebug-value.
+    ;; If edebug display should be updated, call edebug--display.
+    ;; Return value.
     (let* ( ;; This needs to be here since breakpoints may be changed.
 	   (edebug-breakpoints (car (cdr edebug-data)))	; list of breakpoints
-	   (edebug-break-data (assq edebug-offset-index edebug-breakpoints))
+	   (edebug-break-data (assq offset-index edebug-breakpoints))
 	   (edebug-break-condition (car (cdr edebug-break-data)))
 	   (edebug-global-break
 	    (if edebug-global-break-condition
@@ -2468,7 +2368,7 @@ MSG is printed after `::::} '."
 		  (error nil))))
 	   (edebug-break))
 
-;;;    (edebug-trace "exp: %s" edebug-value)
+      ;;(edebug-trace "exp: %s" value)
       ;; Test whether we should break.
       (setq edebug-break
 	    (or edebug-global-break
@@ -2488,11 +2388,10 @@ MSG is printed after `::::} '."
       ;; or break, or input is pending,
       (if (or (not (memq edebug-execution-mode '(go continue Continue-fast)))
 	      edebug-break
-	      (edebug-input-pending-p))
-	  (edebug-display))		; <--------------- display
+	      (input-pending-p))
+	  (edebug--display value offset-index arg-mode)) ; <---------- display
 
-      edebug-value
-      )))
+      value)))
 
 
 ;; window-start now stored with each function.
@@ -2524,8 +2423,9 @@ MSG is printed after `::::} '."
 ;; Emacs 19 adds an arg to mark and mark-marker.
 (defalias 'edebug-mark-marker 'mark-marker)
 
+(defvar edebug-outside-unread-command-events)
 
-(defun edebug-display ()
+(defun edebug--display (value offset-index arg-mode)
   (unless (marker-position edebug-def-mark)
     ;; The buffer holding the source has been killed.
     ;; Let's at least show a backtrace so the user can figure out
@@ -2534,11 +2434,11 @@ MSG is printed after `::::} '."
   ;; Setup windows for edebug, determine mode, maybe enter recursive-edit.
   ;; Uses local variables of edebug-enter, edebug-before, edebug-after
   ;; and edebug-debugger.
-  (let ((edebug-active t)		; for minor mode alist
+  (let ((edebug-active t)		; For minor mode alist.
 	(edebug-with-timeout-suspend (with-timeout-suspend))
-	edebug-stop			; should we enter recursive-edit
+	edebug-stop			; Should we enter recursive-edit?
 	(edebug-point (+ edebug-def-mark
-			 (aref (nth 2 edebug-data) edebug-offset-index)))
+			 (aref (nth 2 edebug-data) offset-index)))
 	edebug-buffer-outside-point     ; current point in edebug-buffer
 	;; window displaying edebug-buffer
 	(edebug-window-data (nth 3 edebug-data))
@@ -2547,12 +2447,12 @@ MSG is printed after `::::} '."
 	(edebug-outside-point (point))
  	(edebug-outside-mark (edebug-mark))
 	(edebug-outside-unread-command-events unread-command-events)
-	edebug-outside-windows		; window or screen configuration
+	edebug-outside-windows		; Window or screen configuration.
 	edebug-buffer-points
 
-	edebug-eval-buffer		; declared here so we can kill it below
-	(edebug-eval-result-list (and edebug-eval-list
-				      (edebug-eval-result-list)))
+	edebug-eval-buffer             ; Declared here so we can kill it below.
+	(eval-result-list (and edebug-eval-list
+                               (edebug-eval-result-list)))
 	edebug-trace-window
 	edebug-trace-window-start
 
@@ -2565,7 +2465,7 @@ MSG is printed after `::::} '."
 	(let ((overlay-arrow-position overlay-arrow-position)
 	      (overlay-arrow-string overlay-arrow-string)
 	      (cursor-in-echo-area nil)
-	      (unread-command-events unread-command-events)
+	      (unread-command-events nil)
 	      ;; any others??
 	      )
           (setq-default cursor-in-non-selected-windows t)
@@ -2573,9 +2473,9 @@ MSG is printed after `::::} '."
 	      (let ((debug-on-error nil))
 		(error "Buffer defining %s not found" edebug-function)))
 
-	  (if (eq 'after edebug-arg-mode)
+	  (if (eq 'after arg-mode)
 	      ;; Compute result string now before windows are modified.
-	      (edebug-compute-previous-result edebug-value))
+	      (edebug-compute-previous-result value))
 
 	  (if edebug-save-windows
 	      ;; Save windows now before we modify them.
@@ -2599,7 +2499,7 @@ MSG is printed after `::::} '."
 	  ;; Now display eval list, if any.
 	  ;; This is done after the pop to edebug-buffer
 	  ;; so that buffer-window correspondence is correct after quitting.
-	  (edebug-eval-display edebug-eval-result-list)
+	  (edebug-eval-display eval-result-list)
 	  ;; The evaluation list better not have deleted edebug-window-data.
 	  (select-window (car edebug-window-data))
 	  (set-buffer edebug-buffer)
@@ -2607,7 +2507,7 @@ MSG is printed after `::::} '."
 	  (setq edebug-buffer-outside-point (point))
 	  (goto-char edebug-point)
 
-	  (if (eq 'before edebug-arg-mode)
+	  (if (eq 'before arg-mode)
 	      ;; Check whether positions are up-to-date.
 	      ;; This assumes point is never before symbol.
 	      (if (not (memq (following-char) '(?\( ?\# ?\` )))
@@ -2620,7 +2520,7 @@ MSG is printed after `::::} '."
 		  (edebug-adjust-window (cdr edebug-window-data)))
 
 	  ;; Test if there is input, not including keyboard macros.
-	  (if (edebug-input-pending-p)
+	  (if (input-pending-p)
 	      (progn
 		(setq edebug-execution-mode 'step
 		      edebug-stop t)
@@ -2631,14 +2531,14 @@ MSG is printed after `::::} '."
 	  (edebug-overlay-arrow)
 
 	  (cond
-	   ((eq 'error edebug-arg-mode)
+	   ((eq 'error arg-mode)
 	    ;; Display error message
 	    (setq edebug-execution-mode 'step)
 	    (edebug-overlay-arrow)
 	    (beep)
-	    (if (eq 'quit (car edebug-value))
+	    (if (eq 'quit (car value))
 		(message "Quit")
-	      (edebug-report-error edebug-value)))
+	      (edebug-report-error value)))
 	   (edebug-break
 	    (cond
 	     (edebug-global-break
@@ -2655,41 +2555,40 @@ MSG is printed after `::::} '."
 
 	   (t (message "")))
 
-	  (setq unread-command-events nil)
-	  (if (eq 'after edebug-arg-mode)
+	  (if (eq 'after arg-mode)
 	      (progn
 		;; Display result of previous evaluation.
 		(if (and edebug-break
 			 (not (eq edebug-execution-mode 'Continue-fast)))
-                    (edebug-sit-for edebug-sit-for-seconds)) ; Show message.
+                    (sit-for edebug-sit-for-seconds)) ; Show message.
 		(edebug-previous-result)))
 
 	  (cond
 	   (edebug-break
 	    (cond
 	     ((eq edebug-execution-mode 'continue)
-              (edebug-sit-for edebug-sit-for-seconds))
-	     ((eq edebug-execution-mode 'Continue-fast) (edebug-sit-for 0))
+              (sit-for edebug-sit-for-seconds))
+	     ((eq edebug-execution-mode 'Continue-fast) (sit-for 0))
 	     (t (setq edebug-stop t))))
 	   ;; not edebug-break
 	   ((eq edebug-execution-mode 'trace)
-	    (edebug-sit-for edebug-sit-for-seconds)) ; Force update and pause.
+	    (sit-for edebug-sit-for-seconds)) ; Force update and pause.
 	   ((eq edebug-execution-mode 'Trace-fast)
-	    (edebug-sit-for 0)))		; Force update and continue.
+	    (sit-for 0)))		; Force update and continue.
 
 	  (unwind-protect
 	      (if (or edebug-stop
 		      (memq edebug-execution-mode '(step next))
-		      (eq edebug-arg-mode 'error))
+		      (eq arg-mode 'error))
 		  (progn
 		    ;; (setq edebug-execution-mode 'step)
 		    ;; (edebug-overlay-arrow)	; This doesn't always show up.
-		    (edebug-recursive-edit))) ; <---------- Recursive edit
+		    (edebug--recursive-edit arg-mode))) ; <----- Recursive edit
 
 	    ;; Reset the edebug-window-data to whatever it is now.
 	    (let ((window (if (eq (window-buffer) edebug-buffer)
 			      (selected-window)
-			    (edebug-get-buffer-window edebug-buffer))))
+			    (get-buffer-window edebug-buffer))))
 	      ;; Remember window-start for edebug-buffer, if still displayed.
 	      (if window
 		  (progn
@@ -2767,6 +2666,8 @@ MSG is printed after `::::} '."
 	    (goto-char edebug-buffer-outside-point))
 	  ;; ... nothing more.
 	  )
+      ;; Could be an option to keep eval display up.
+      (if edebug-eval-buffer (kill-buffer edebug-eval-buffer))
       (with-timeout-unsuspend edebug-with-timeout-suspend)
       ;; Reset global variables to outside values in case they were changed.
       (setq
@@ -2804,26 +2705,15 @@ MSG is printed after `::::} '."
 ;; in versions where the variable is *not* built-in.
 
 ;; Emacs 18  FIXME
-(defvar edebug-outside-unread-command-char)
 
 ;; Emacs 19.
 (defvar edebug-outside-last-command-event)
-(defvar edebug-outside-unread-command-events)
 (defvar edebug-outside-last-input-event)
 (defvar edebug-outside-last-event-frame)
 (defvar edebug-outside-last-nonmenu-event)
 (defvar edebug-outside-track-mouse)
 
-;; Disable byte compiler warnings about unread-command-char and -event
-;; (maybe works with byte-compile-version 2.22 at least)
-(defvar edebug-unread-command-char-warning)
-(defvar edebug-unread-command-event-warning)
-(eval-when-compile			; FIXME
-  (setq edebug-unread-command-char-warning
-	(get 'unread-command-char 'byte-obsolete-variable))
-  (put 'unread-command-char 'byte-obsolete-variable nil))
-
-(defun edebug-recursive-edit ()
+(defun edebug--recursive-edit (arg-mode)
   ;; Start up a recursive edit inside of edebug.
   ;; The current buffer is the edebug-buffer, which is put into edebug-mode.
   ;; Assume that none of the variables below are buffer-local.
@@ -2844,14 +2734,20 @@ MSG is printed after `::::} '."
 
 	(edebug-outside-map (current-local-map))
 
-	(edebug-outside-standard-output standard-output)
+        ;; Save the outside value of executing macro.  (here??)
+        (edebug-outside-executing-macro executing-kbd-macro)
+        (edebug-outside-pre-command-hook
+         (edebug-var-status 'pre-command-hook))
+        (edebug-outside-post-command-hook
+         (edebug-var-status 'post-command-hook))
+
+        (edebug-outside-standard-output standard-output)
 	(edebug-outside-standard-input standard-input)
 	(edebug-outside-defining-kbd-macro defining-kbd-macro)
 
 	(edebug-outside-last-command last-command)
 	(edebug-outside-this-command this-command)
 
-	(edebug-outside-unread-command-char unread-command-char) ; FIXME
 	(edebug-outside-current-prefix-arg current-prefix-arg)
 
 	(edebug-outside-last-input-event last-input-event)
@@ -2867,9 +2763,6 @@ MSG is printed after `::::} '."
 	      ;; We could set these to the values for previous edebug call.
 	      (last-command last-command)
 	      (this-command this-command)
-
-	      ;; Assume no edebug command sets unread-command-char.
-	      (unread-command-char -1)
 	      (current-prefix-arg nil)
 
 	      ;; More for Emacs 19
@@ -2879,7 +2772,20 @@ MSG is printed after `::::} '."
 	      (last-nonmenu-event nil)
 	      (track-mouse nil)
 
-	      ;; Bind again to outside values.
+              (standard-output t)
+              (standard-input t)
+
+	      ;; Don't keep reading from an executing kbd macro
+              ;; within edebug unless edebug-continue-kbd-macro is
+              ;; non-nil.  Again, local binding may not be best.
+              (executing-kbd-macro
+               (if edebug-continue-kbd-macro executing-kbd-macro))
+
+              ;; Don't get confused by the user's keymap changes.
+              (overriding-local-map nil)
+              (overriding-terminal-local-map nil)
+
+		  ;; Bind again to outside values.
 	      (debug-on-error edebug-outside-debug-on-error)
 	      (debug-on-quit edebug-outside-debug-on-quit)
 
@@ -2887,11 +2793,17 @@ MSG is printed after `::::} '."
 	      (defining-kbd-macro
 		(if edebug-continue-kbd-macro defining-kbd-macro))
 
+	      ;; Disable command hooks.  This is essential when
+	      ;; a hook function is instrumented - to avoid infinite loop.
+	      ;; This may be more than we need, however.
+	      (pre-command-hook nil)
+	      (post-command-hook nil)
+
 	      ;; others??
 	      )
 
 	  (if (and (eq edebug-execution-mode 'go)
-		   (not (memq edebug-arg-mode '(after error))))
+		   (not (memq arg-mode '(after error))))
 	      (message "Break"))
 
 	  (setq buffer-read-only t)
@@ -2905,8 +2817,6 @@ MSG is printed after `::::} '."
 	    (setq signal-hook-function 'edebug-signal)
 	    (if edebug-backtrace-buffer
 		(kill-buffer edebug-backtrace-buffer))
-	    ;; Could be an option to keep eval display up.
-	    (if edebug-eval-buffer (kill-buffer edebug-eval-buffer))
 
 	    ;; Remember selected-window after recursive-edit.
 	    ;;      (setq edebug-inside-window (selected-window))
@@ -2933,7 +2843,6 @@ MSG is printed after `::::} '."
        last-command-event edebug-outside-last-command-event
        last-command edebug-outside-last-command
        this-command edebug-outside-this-command
-       unread-command-char edebug-outside-unread-command-char
        current-prefix-arg edebug-outside-current-prefix-arg
        last-input-event edebug-outside-last-input-event
        last-event-frame edebug-outside-last-event-frame
@@ -2942,17 +2851,21 @@ MSG is printed after `::::} '."
 
        standard-output edebug-outside-standard-output
        standard-input edebug-outside-standard-input
-       defining-kbd-macro edebug-outside-defining-kbd-macro
-       ))
-    ))
+       defining-kbd-macro edebug-outside-defining-kbd-macro)
+
+      (setq executing-kbd-macro edebug-outside-executing-macro)
+      (edebug-restore-status
+       'post-command-hook edebug-outside-post-command-hook)
+      (edebug-restore-status
+       'pre-command-hook edebug-outside-pre-command-hook))))
 
 
 ;;; Display related functions
 
 (defun edebug-adjust-window (old-start)
   ;; If pos is not visible, adjust current window to fit following context.
-;;;  (message "window: %s old-start: %s window-start: %s pos: %s"
-;;;	   (selected-window) old-start (window-start) (point)) (sit-for 5)
+  ;; (message "window: %s old-start: %s window-start: %s pos: %s"
+  ;;          (selected-window) old-start (window-start) (point)) (sit-for 5)
   (if (not (pos-visible-in-window-p))
       (progn
 	;; First try old-start
@@ -2960,7 +2873,7 @@ MSG is printed after `::::} '."
 	    (set-window-start (selected-window) old-start))
 	(if (not (pos-visible-in-window-p))
 	    (progn
-;;	(message "resetting window start") (sit-for 2)
+	;; (message "resetting window start") (sit-for 2)
 	(set-window-start
 	 (selected-window)
 	 (save-excursion
@@ -3099,12 +3012,12 @@ before returning.  The default is one second."
 	       (current-buffer) (point)
 	       (if (marker-buffer (edebug-mark-marker))
 		   (marker-position (edebug-mark-marker)) "<not set>"))
-      (edebug-sit-for arg)
+      (sit-for arg)
       (edebug-pop-to-buffer edebug-buffer (car edebug-window-data)))))
 
 
 ;; Joe Wells, here is a start at your idea of adding a buffer to the internal
-;; display list.  Still need to use this list in edebug-display.
+;; display list.  Still need to use this list in edebug--display.
 
 '(defvar edebug-display-buffer-list nil
   "List of buffers that edebug will display when it is active.")
@@ -3426,7 +3339,7 @@ function or macro is called, Edebug will be called there as well."
 	   (save-excursion
 	     (down-list 1)
 	     (if (looking-at "\(")
-		 (edebug-form-data-name
+		 (edebug--form-data-name
 		  (edebug-get-form-data-entry (point)))
 	       (edebug-original-read (current-buffer))))))
       (edebug-instrument-function func))))
@@ -3539,11 +3452,10 @@ edebug-mode."
 
 ;;; Evaluation of expressions
 
-(def-edebug-spec edebug-outside-excursion t)
-
 (defmacro edebug-outside-excursion (&rest body)
   "Evaluate an expression list in the outside context.
 Return the result of the last expression."
+  (declare (debug t))
   `(save-excursion			; of current-buffer
      (if edebug-save-windows
 	 (progn
@@ -3562,7 +3474,6 @@ Return the result of the last expression."
 	   (last-command-event edebug-outside-last-command-event)
 	   (last-command edebug-outside-last-command)
 	   (this-command edebug-outside-this-command)
-	   (unread-command-char edebug-outside-unread-command-char)
 	   (unread-command-events edebug-outside-unread-command-events)
 	   (current-prefix-arg edebug-outside-current-prefix-arg)
 	   (last-input-event edebug-outside-last-input-event)
@@ -3578,7 +3489,7 @@ Return the result of the last expression."
 	   (pre-command-hook (cdr edebug-outside-pre-command-hook))
 	   (post-command-hook (cdr edebug-outside-post-command-hook))
 
-	   ;; See edebug-display
+	   ;; See edebug-display.
 	   (overlay-arrow-position edebug-outside-o-a-p)
 	   (overlay-arrow-string edebug-outside-o-a-s)
 	   (cursor-in-echo-area edebug-outside-c-i-e-a)
@@ -3602,7 +3513,6 @@ Return the result of the last expression."
 	  edebug-outside-last-command-event last-command-event
 	  edebug-outside-last-command last-command
 	  edebug-outside-this-command this-command
-	  edebug-outside-unread-command-char unread-command-char
 	  edebug-outside-unread-command-events unread-command-events
 	  edebug-outside-current-prefix-arg current-prefix-arg
 	  edebug-outside-last-input-event last-input-event
@@ -3633,18 +3543,19 @@ Return the result of the last expression."
 
 (defvar cl-debug-env)  ; defined in cl; non-nil when lexical env used.
 
-(defun edebug-eval (edebug-expr)
+(defun edebug-eval (expr)
   ;; Are there cl lexical variables active?
-  (eval (if (bound-and-true-p cl-debug-env)
-            (cl-macroexpand-all edebug-expr cl-debug-env)
-          edebug-expr)
+  (eval (if (and (bound-and-true-p cl-debug-env)
+                 (fboundp 'cl-macroexpand-all))
+            (cl-macroexpand-all expr cl-debug-env)
+          expr)
         lexical-binding))
 
-(defun edebug-safe-eval (edebug-expr)
+(defun edebug-safe-eval (expr)
   ;; Evaluate EXPR safely.
   ;; If there is an error, a string is returned describing the error.
   (condition-case edebug-err
-      (edebug-eval edebug-expr)
+      (edebug-eval expr)
     (error (edebug-format "%s: %s"  ;; could
 			  (get (car edebug-err) 'error-message)
 			  (car (cdr edebug-err))))))
@@ -3652,17 +3563,17 @@ Return the result of the last expression."
 ;;; Printing
 
 
-(defun edebug-report-error (edebug-value)
+(defun edebug-report-error (value)
   ;; Print an error message like command level does.
   ;; This also prints the error name if it has no error-message.
   (message "%s: %s"
-	   (or (get (car edebug-value) 'error-message)
-	       (format "peculiar error (%s)" (car edebug-value)))
+	   (or (get (car value) 'error-message)
+	       (format "peculiar error (%s)" (car value)))
 	   (mapconcat (function (lambda (edebug-arg)
 				  ;; continuing after an error may
 				  ;; complain about edebug-arg. why??
 				  (prin1-to-string edebug-arg)))
-		      (cdr edebug-value) ", ")))
+		      (cdr value) ", ")))
 
 (defvar print-readably) ; defined by lemacs
 ;; Alternatively, we could change the definition of
@@ -3678,14 +3589,14 @@ Return the result of the last expression."
 	(edebug-prin1-to-string value)
       (error "#Apparently circular structure#"))))
 
-(defun edebug-compute-previous-result (edebug-previous-value)
+(defun edebug-compute-previous-result (previous-value)
   (if edebug-unwrap-results
-      (setq edebug-previous-value
-	    (edebug-unwrap* edebug-previous-value)))
+      (setq previous-value
+	    (edebug-unwrap* previous-value)))
   (setq edebug-previous-result
 	(concat "Result: "
-		(edebug-safe-prin1-to-string edebug-previous-value)
-		(eval-expression-print-format edebug-previous-value))))
+		(edebug-safe-prin1-to-string previous-value)
+		(eval-expression-print-format previous-value))))
 
 (defun edebug-previous-result ()
   "Print the previous result."
@@ -3700,7 +3611,7 @@ Return the result of the last expression."
 (defalias 'edebug-format 'format)
 (defalias 'edebug-message 'message)
 
-(defun edebug-eval-expression (edebug-expr)
+(defun edebug-eval-expression (expr)
   "Evaluate an expression in the outside environment.
 If interactive, prompt for the expression.
 Print result in minibuffer."
@@ -3709,7 +3620,7 @@ Print result in minibuffer."
 		      'read-expression-history)))
   (princ
    (edebug-outside-excursion
-    (setq values (cons (edebug-eval edebug-expr) values))
+    (setq values (cons (edebug-eval expr) values))
     (concat (edebug-safe-prin1-to-string (car values))
             (eval-expression-print-format (car values))))))
 
@@ -3723,14 +3634,14 @@ Print value in minibuffer."
   "Evaluate sexp before point in outside environment; insert value.
 This prints the value into current buffer."
   (interactive)
-  (let* ((edebug-form (edebug-last-sexp))
-	 (edebug-result-string
+  (let* ((form (edebug-last-sexp))
+	 (result-string
 	  (edebug-outside-excursion
-	   (edebug-safe-prin1-to-string (edebug-safe-eval edebug-form))))
+	   (edebug-safe-prin1-to-string (edebug-safe-eval form))))
 	 (standard-output (current-buffer)))
     (princ "\n")
     ;; princ the string to get rid of quotes.
-    (princ edebug-result-string)
+    (princ result-string)
     (princ "\n")
     ))
 
@@ -3922,44 +3833,38 @@ Options:
 	(edebug-trace nil))
     (mapcar 'edebug-safe-eval edebug-eval-list)))
 
-(defun edebug-eval-display-list (edebug-eval-result-list)
+(defun edebug-eval-display-list (eval-result-list)
   ;; Assumes edebug-eval-buffer exists.
-  (let ((edebug-eval-list-temp edebug-eval-list)
-	(standard-output edebug-eval-buffer)
+  (let ((standard-output edebug-eval-buffer)
 	(edebug-comment-line
 	 (format ";%s\n" (make-string (- (window-width) 2) ?-))))
     (set-buffer edebug-eval-buffer)
     (erase-buffer)
-    (while edebug-eval-list-temp
-      (prin1 (car edebug-eval-list-temp)) (terpri)
-      (prin1 (car edebug-eval-result-list)) (terpri)
-      (princ edebug-comment-line)
-      (setq edebug-eval-list-temp (cdr edebug-eval-list-temp))
-      (setq edebug-eval-result-list (cdr edebug-eval-result-list)))
+    (dolist (exp edebug-eval-list)
+      (prin1 exp) (terpri)
+      (prin1 (pop eval-result-list)) (terpri)
+      (princ edebug-comment-line))
     (edebug-pop-to-buffer edebug-eval-buffer)
     ))
 
 (defun edebug-create-eval-buffer ()
-  (if (not (and edebug-eval-buffer (buffer-name edebug-eval-buffer)))
-      (progn
-	(set-buffer (setq edebug-eval-buffer (get-buffer-create "*edebug*")))
-	(edebug-eval-mode))))
+  (unless (and edebug-eval-buffer (buffer-name edebug-eval-buffer))
+    (set-buffer (setq edebug-eval-buffer (get-buffer-create "*edebug*")))
+    (edebug-eval-mode)))
 
 ;; Should generalize this to be callable outside of edebug
 ;; with calls in user functions, e.g. (edebug-eval-display)
 
-(defun edebug-eval-display (edebug-eval-result-list)
-  "Display expressions and evaluations in EDEBUG-EVAL-RESULT-LIST.
+(defun edebug-eval-display (eval-result-list)
+  "Display expressions and evaluations in EVAL-RESULT-LIST.
 It modifies the context by popping up the eval display."
-  (if edebug-eval-result-list
-      (progn
-	(edebug-create-eval-buffer)
-	(edebug-eval-display-list edebug-eval-result-list)
-	)))
+  (when eval-result-list
+    (edebug-create-eval-buffer)
+    (edebug-eval-display-list eval-result-list)))
 
 (defun edebug-eval-redisplay ()
   "Redisplay eval list in outside environment.
-May only be called from within `edebug-recursive-edit'."
+May only be called from within `edebug--recursive-edit'."
   (edebug-create-eval-buffer)
   (edebug-outside-excursion
    (edebug-eval-display-list (edebug-eval-result-list))
@@ -3983,7 +3888,7 @@ May only be called from within `edebug-recursive-edit'."
     (if (not (eobp))
 	(progn
 	  (forward-sexp 1)
-	  (setq new-list (cons (edebug-last-sexp) new-list))))
+	  (push (edebug-last-sexp) new-list)))
 
     (while (re-search-forward "^;" nil t)
       (forward-line 1)
@@ -3992,7 +3897,7 @@ May only be called from within `edebug-recursive-edit'."
 	       (not (eobp)))
 	  (progn
 	    (forward-sexp 1)
-	    (setq new-list (cons (edebug-last-sexp) new-list)))))
+	    (push (edebug-last-sexp) new-list))))
 
     (setq edebug-eval-list (nreverse new-list))
     (edebug-eval-redisplay)
@@ -4021,8 +3926,8 @@ May only be called from within `edebug-recursive-edit'."
     (define-key map "\C-c\C-u" 'edebug-update-eval-list)
     (define-key map "\C-x\C-e" 'edebug-eval-last-sexp)
     (define-key map "\C-j" 'edebug-eval-print-last-sexp)
-  map)
-"Keymap for Edebug Eval mode.  Superset of Lisp Interaction mode.")
+    map)
+  "Keymap for Edebug Eval mode.  Superset of Lisp Interaction mode.")
 
 (put 'edebug-eval-mode 'mode-class 'special)
 
@@ -4049,32 +3954,32 @@ Global commands prefixed by `global-edebug-prefix':
 ;; since they depend on the backtrace looking a certain way.  But
 ;; edebug is not dependent on this, yet.
 
-(defun edebug (&optional edebug-arg-mode &rest debugger-args)
+(defun edebug (&optional arg-mode &rest args)
   "Replacement for `debug'.
 If we are running an edebugged function, show where we last were.
 Otherwise call `debug' normally."
-;;  (message "entered: %s  depth: %s  edebug-recursion-depth: %s"
-;;	   edebug-entered (recursion-depth) edebug-recursion-depth) (sit-for 1)
+  ;;(message "entered: %s  depth: %s  edebug-recursion-depth: %s"
+  ;;  edebug-entered (recursion-depth) edebug-recursion-depth) (sit-for 1)
   (if (and edebug-entered  ; anything active?
 	   (eq (recursion-depth) edebug-recursion-depth))
       (let (;; Where were we before the error occurred?
-	    (edebug-offset-index (car edebug-offset-indices))
-	    ;; Bind variables required by edebug-display
-	    (edebug-value (car debugger-args))
+	    (offset-index (car edebug-offset-indices))
+	    (value (car args))
+	    ;; Bind variables required by edebug--display.
 	    edebug-breakpoints
 	    edebug-break-data
 	    edebug-break-condition
 	    edebug-global-break
-	    (edebug-break (null edebug-arg-mode)) ;; if called explicitly
+	    (edebug-break (null arg-mode)) ;; If called explicitly.
 	    )
-	(edebug-display)
-	(if (eq edebug-arg-mode 'error)
+	(edebug--display value offset-index arg-mode)
+	(if (eq arg-mode 'error)
 	    nil
-	  edebug-value))
+	  value))
 
     ;; Otherwise call debug normally.
     ;; Still need to remove extraneous edebug calls from stack.
-    (apply 'debug edebug-arg-mode debugger-args)
+    (apply 'debug arg-mode args)
     ))
 
 
@@ -4085,7 +3990,7 @@ Otherwise call `debug' normally."
 	  (null (buffer-name edebug-backtrace-buffer)))
       (setq edebug-backtrace-buffer
 	    (generate-new-buffer "*Backtrace*"))
-    ;; else, could just display edebug-backtrace-buffer
+    ;; Else, could just display edebug-backtrace-buffer.
     )
   (with-output-to-temp-buffer (buffer-name edebug-backtrace-buffer)
     (setq edebug-backtrace-buffer standard-output)
@@ -4107,7 +4012,7 @@ Otherwise call `debug' normally."
 	(beginning-of-line)
 	(cond
 	 ((looking-at "^  \(edebug-after")
-	  ;; Previous lines may contain code, so just delete this line
+	  ;; Previous lines may contain code, so just delete this line.
 	  (setq last-ok-point (point))
 	  (forward-line 1)
 	  (delete-region last-ok-point (point)))
@@ -4125,15 +4030,15 @@ Otherwise call `debug' normally."
   "In buffer BUF-NAME, display FMT and ARGS at the end and make it visible.
 The buffer is created if it does not exist.
 You must include newlines in FMT to break lines, but one newline is appended."
-;; e.g.
-;;	 (edebug-trace-display "*trace-point*"
-;;	  "saving: point = %s  window-start = %s"
-;;	  (point) (window-start))
+  ;; e.g.
+  ;; (edebug-trace-display "*trace-point*"
+  ;;                       "saving: point = %s  window-start = %s"
+  ;;                       (point) (window-start))
   (let* ((oldbuf (current-buffer))
 	 (selected-window (selected-window))
 	 (buffer (get-buffer-create buf-name))
 	 buf-window)
-;;    (message "before pop-to-buffer") (sit-for 1)
+    ;; (message "before pop-to-buffer") (sit-for 1)
     (edebug-pop-to-buffer buffer)
     (setq truncate-lines t)
     (setq buf-window (selected-window))
@@ -4143,8 +4048,8 @@ You must include newlines in FMT to break lines, but one newline is appended."
     (vertical-motion (- 1 (window-height)))
     (set-window-start buf-window (point))
     (goto-char (point-max))
-;;    (set-window-point buf-window (point))
-;;    (edebug-sit-for 0)
+    ;; (set-window-point buf-window (point))
+    ;; (sit-for 0)
     (bury-buffer buffer)
     (select-window selected-window)
     (set-buffer oldbuf))
@@ -4207,8 +4112,8 @@ reinstrument it."
 	;; Insert all the indices for this line.
 	(forward-line 1)
 	(setq start-of-count-line (point)
-	      first-index i   ; really last index for line above this one.
-	      last-count -1)  ; cause first count to always appear.
+	      first-index i   ; Really, last index for line above this one.
+	      last-count -1)  ; Cause first count to always appear.
 	(insert ";#")
 	;; i == first-index still
 	(while (<= (setq i (1+ i)) last-index)
@@ -4240,7 +4145,8 @@ It is removed when you hit any char."
   (let ((buffer-read-only nil))
     (undo-boundary)
     (edebug-display-freq-count)
-    (setq unread-command-char (read-char))
+    (setq unread-command-events
+          (append unread-command-events (list (read-event))))
     ;; Yuck!  This doesn't seem to work at all for me.
     (undo)))
 
@@ -4352,87 +4258,6 @@ With prefix argument, make it a temporary breakpoint."
 
 (easy-menu-define edebug-menu edebug-mode-map "Edebug menus" edebug-mode-menus)
 
-;;; Byte-compiler
-
-;; Extension for bytecomp to resolve undefined function references.
-;; Requires new byte compiler.
-
-;; Reenable byte compiler warnings about unread-command-char and -event.
-;; Disabled before edebug-recursive-edit.
-(eval-when-compile
-  (if edebug-unread-command-char-warning
-      (put 'unread-command-char 'byte-obsolete-variable
-	   edebug-unread-command-char-warning)))
-
-(eval-when-compile
-  ;; The body of eval-when-compile seems to get evaluated with eval-defun.
-  ;; We only want to evaluate when actually byte compiling.
-  ;; But it is OK to evaluate as long as byte-compiler has been loaded.
-  (if (featurep 'byte-compile) (progn
-
-  (defun byte-compile-resolve-functions (funcs)
-    "Say it is OK for the named functions to be unresolved."
-    (mapc
-     (function
-      (lambda (func)
-	(setq byte-compile-unresolved-functions
-	      (delq (assq func byte-compile-unresolved-functions)
-		    byte-compile-unresolved-functions))))
-     funcs)
-    nil)
-
-  '(defun byte-compile-resolve-free-references (vars)
-     "Say it is OK for the named variables to be referenced."
-     (mapcar
-      (function
-       (lambda (var)
-	 (setq byte-compile-free-references
-	       (delq var byte-compile-free-references))))
-      vars)
-     nil)
-
-  '(defun byte-compile-resolve-free-assignments (vars)
-     "Say it is OK for the named variables to be assigned."
-     (mapcar
-      (function
-       (lambda (var)
-	 (setq byte-compile-free-assignments
-	       (delq var byte-compile-free-assignments))))
-      vars)
-     nil)
-
-  (byte-compile-resolve-functions
-   '(reporter-submit-bug-report
-     edebug-gensym ;; also in cl.el
-     ;; Interfaces to standard functions.
-     edebug-original-eval-defun
-     edebug-original-read
-     edebug-get-buffer-window
-     edebug-mark
-     edebug-mark-marker
-     edebug-input-pending-p
-     edebug-sit-for
-     edebug-prin1-to-string
-     edebug-format
-     ;; lemacs
-     zmacs-deactivate-region
-     popup-menu
-     ;; CL
-     cl-macroexpand-all
-     ;; And believe it or not, the byte compiler doesn't know about:
-     byte-compile-resolve-functions
-     ))
-
-  '(byte-compile-resolve-free-references
-    '(read-expression-history
-      read-expression-map))
-
-  '(byte-compile-resolve-free-assignments
-    '(read-expression-history))
-
-  )))
-
-
 ;;; Autoloading of Edebug accessories
 
 ;; edebug-cl-read and cl-read are available from [email protected]
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 666e31f690..64aac4b81d 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -431,6 +431,61 @@ if that value is non-nil."
   (add-hook 'completion-at-point-functions
             'lisp-completion-at-point nil 'local))
 
+;;; Emacs Lisp Byte-Code mode
+
+(eval-and-compile
+  (defconst emacs-list-byte-code-comment-re
+    (concat "\\(#\\)@\\([0-9]+\\) "
+            ;; Make sure it's a docstring and not a lazy-loaded byte-code.
+            "\\(?:[^(]\\|([^\"]\\)")))
+
+(defun emacs-lisp-byte-code-comment (end &optional _point)
+  "Try to syntactically mark the #@NNN ....^_ docstrings in byte-code files."
+  (let ((ppss (syntax-ppss)))
+    (when (and (nth 4 ppss)
+               (eq (char-after (nth 8 ppss)) ?#))
+      (let* ((n (save-excursion
+                  (goto-char (nth 8 ppss))
+                  (when (looking-at emacs-list-byte-code-comment-re)
+                    (string-to-number (match-string 2)))))
+             ;; `maxdiff' tries to make sure the loop below terminates.
+             (maxdiff n))
+        (when n
+          (let* ((bchar (match-end 2))
+                 (b (position-bytes bchar)))
+            (goto-char (+ b n))
+            (while (let ((diff (- (position-bytes (point)) b n)))
+                     (unless (zerop diff)
+                       (when (> diff maxdiff) (setq diff maxdiff))
+                       (forward-char (- diff))
+                       (setq maxdiff (if (> diff 0) diff
+                                       (max (1- maxdiff) 1)))
+                       t))))
+          (if (<= (point) end)
+              (put-text-property (1- (point)) (point)
+                                 'syntax-table
+                                 (string-to-syntax "> b"))
+            (goto-char end)))))))
+
+(defun emacs-lisp-byte-code-syntax-propertize (start end)
+  (emacs-lisp-byte-code-comment end (point))
+  (funcall
+   (syntax-propertize-rules
+    (emacs-list-byte-code-comment-re
+     (1 (prog1 "< b" (emacs-lisp-byte-code-comment end (point))))))
+   start end))
+
+(add-to-list 'auto-mode-alist '("\\.elc\\'" . emacs-lisp-byte-code-mode))
+(define-derived-mode emacs-lisp-byte-code-mode emacs-lisp-mode
+  "Elisp-Byte-Code"
+  "Major mode for *.elc files."
+  ;; TODO: Add way to disassemble byte-code under point.
+  (setq-local open-paren-in-column-0-is-defun-start nil)
+  (setq-local syntax-propertize-function
+              #'emacs-lisp-byte-code-syntax-propertize))
+
+;;; Generic Lisp mode.
+
 (defvar lisp-mode-map
   (let ((map (make-sparse-keymap))
 	(menu-map (make-sparse-keymap "Lisp")))
@@ -730,10 +785,12 @@ POS specifies the starting position where EXP was found and defaults to point."
       (let ((vars ()))
         (goto-char (point-min))
         (while (re-search-forward
-                "^(def\\(?:var\\|const\\|custom\\)[ \t\n]+\\([^; '()\n\t]+\\)"
+                "(def\\(?:var\\|const\\|custom\\)[ \t\n]+\\([^; '()\n\t]+\\)"
                 pos t)
           (let ((var (intern (match-string 1))))
-            (unless (special-variable-p var)
+            (and (not (special-variable-p var))
+                 (save-excursion
+                   (zerop (car (syntax-ppss (match-beginning 0)))))
               (push var vars))))
         `(progn ,@(mapcar (lambda (v) `(defvar ,v)) vars) ,exp)))))
 
@@ -820,7 +877,6 @@ if it already has a value.\)
 
 With argument, insert value in current buffer after the defun.
 Return the result of evaluation."
-  (interactive "P")
   ;; FIXME: the print-length/level bindings should only be applied while
   ;; printing, not while evaluating.
   (let ((debug-on-error eval-expression-debug-on-error)
@@ -925,6 +981,7 @@ rigidly along with this one."
     (if (or (null indent) (looking-at "\\s<\\s<\\s<"))
 	;; Don't alter indentation of a ;;; comment line
 	;; or a line that starts in a string.
+        ;; FIXME: inconsistency: comment-indent moves ;;; to column 0.
 	(goto-char (- (point-max) pos))
       (if (and (looking-at "\\s<") (not (looking-at "\\s<\\s<")))
 	  ;; Single-semicolon comment lines should be indented
@@ -939,18 +996,7 @@ rigidly along with this one."
       ;; If initial point was within line's indentation,
       ;; position after the indentation.  Else stay at same point in text.
       (if (> (- (point-max) pos) (point))
-	  (goto-char (- (point-max) pos)))
-      ;; If desired, shift remaining lines of expression the same amount.
-      (and whole-exp (not (zerop shift-amt))
-	   (save-excursion
-	     (goto-char beg)
-	     (forward-sexp 1)
-	     (setq end (point))
-	     (goto-char beg)
-	     (forward-line 1)
-	     (setq beg (point))
-	     (> end beg))
-	   (indent-code-rigidly beg end shift-amt)))))
+	  (goto-char (- (point-max) pos))))))
 
 (defvar calculate-lisp-indent-last-sexp)
 
@@ -1230,7 +1276,6 @@ Lisp function does not specify a special indentation."
 (put 'prog2 'lisp-indent-function 2)
 (put 'save-excursion 'lisp-indent-function 0)
 (put 'save-restriction 'lisp-indent-function 0)
-(put 'save-match-data 'lisp-indent-function 0)
 (put 'save-current-buffer 'lisp-indent-function 0)
 (put 'let 'lisp-indent-function 1)
 (put 'let* 'lisp-indent-function 1)
diff --git a/lisp/emacs-lisp/macroexp.el b/lisp/emacs-lisp/macroexp.el
index 70eab14983..394225d697 100644
--- a/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@ -100,6 +100,17 @@ each clause."
     (error (message "Compiler-macro error for %S: %S" (car form) err)
            form)))
 
+(defun macroexp--eval-if-compile (&rest _forms)
+  "Pseudo function used internally by macroexp to delay warnings.
+The purpose is to delay warnings to bytecomp.el, so they can use things
+like `byte-compile-log-warning' to get better file-and-line-number data
+and also to avoid outputting the warning during normal execution."
+  nil)
+(put 'macroexp--eval-if-compile 'byte-compile
+     (lambda (form)
+       (mapc (lambda (x) (funcall (eval x))) (cdr form))
+       (byte-compile-constant nil)))
+
 (defun macroexp--expand-all (form)
   "Expand all macros in FORM.
 This is an internal version of `macroexpand-all'.
@@ -112,14 +123,17 @@ Assumes the caller has bound `macroexpand-all-environment'."
       (macroexpand (macroexp--all-forms form 1)
 		   macroexpand-all-environment)
     ;; Normal form; get its expansion, and then expand arguments.
-    (let ((new-form (macroexpand form macroexpand-all-environment)))
-      (when (and (not (eq form new-form)) ;It was a macro call.
-                 (car-safe form)
-                 (symbolp (car form))
-                 (get (car form) 'byte-obsolete-info)
-                 (fboundp 'byte-compile-warn-obsolete))
-        (byte-compile-warn-obsolete (car form)))
-      (setq form new-form))
+    (let ((new-form
+           (macroexpand form macroexpand-all-environment)))
+      (setq form
+            (if (and (not (eq form new-form)) ;It was a macro call.
+                     (car-safe form)
+                     (symbolp (car form))
+                     (get (car form) 'byte-obsolete-info))
+                `(progn (macroexp--eval-if-compile
+                         (lambda () (byte-compile-warn-obsolete ',(car form))))
+                        ,new-form)
+              new-form)))
     (pcase form
       (`(cond . ,clauses)
        (macroexp--cons 'cond (macroexp--all-clauses clauses) form))
@@ -323,6 +337,86 @@ symbol itself."
   "Return non-nil if EXP can be copied without extra cost."
   (or (symbolp exp) (macroexp-const-p exp)))
 
+;;; Load-time macro-expansion.
+
+;; Because macro-expansion used to be more lazy, eager macro-expansion
+;; tends to bump into previously harmless/unnoticeable cyclic-dependencies.
+;; So, we have to delay macro-expansion like we used to when we detect
+;; such a cycle, and we also want to help coders resolve those cycles (since
+;; they can be non-obvious) by providing a usefully trimmed backtrace
+;; (hopefully) highlighting the problem.
+
+(defun macroexp--backtrace ()
+  "Return the Elisp backtrace, more recent frames first."
+  (let ((bt ())
+        (i 0))
+    (while
+        (let ((frame (backtrace-frame i)))
+          (when frame
+            (push frame bt)
+            (setq i (1+ i)))))
+    (nreverse bt)))
+
+(defun macroexp--trim-backtrace-frame (frame)
+  (pcase frame
+    (`(,_ macroexpand (,head . ,_) . ,_) `(macroexpand (,head …)))
+    (`(,_ internal-macroexpand-for-load (,head ,second . ,_) . ,_)
+     (if (or (symbolp second)
+             (and (eq 'quote (car-safe second))
+                  (symbolp (cadr second))))
+         `(macroexpand-all (,head ,second …))
+       '(macroexpand-all …)))
+    (`(,_ load-with-code-conversion ,name . ,_)
+     `(load ,(file-name-nondirectory name)))))
+
+(defvar macroexp--pending-eager-loads nil
+  "Stack of files currently undergoing eager macro-expansion.")
+
+(defun internal-macroexpand-for-load (form)
+  ;; Called from the eager-macroexpansion in readevalloop.
+  (cond
+   ;; Don't repeat the same warning for every top-level element.
+   ((eq 'skip (car macroexp--pending-eager-loads)) form)
+   ;; If we detect a cycle, skip macro-expansion for now, and output a warning
+   ;; with a trimmed backtrace.
+   ((and load-file-name (member load-file-name macroexp--pending-eager-loads))
+    (let* ((bt (delq nil
+                     (mapcar #'macroexp--trim-backtrace-frame
+                             (macroexp--backtrace))))
+           (elem `(load ,(file-name-nondirectory load-file-name)))
+           (tail (member elem (cdr (member elem bt)))))
+      (if tail (setcdr tail (list '…)))
+      (if (eq (car-safe (car bt)) 'macroexpand-all) (setq bt (cdr bt)))
+      (message "Warning: Eager macro-expansion skipped due to cycle:\n  %s"
+               (mapconcat #'prin1-to-string (nreverse bt) " => "))
+      (push 'skip macroexp--pending-eager-loads)
+      form))
+   (t
+    (condition-case err
+        (let ((macroexp--pending-eager-loads
+               (cons load-file-name macroexp--pending-eager-loads)))
+          (macroexpand-all form))
+      (error
+       ;; Hopefully this shouldn't happen thanks to the cycle detection,
+       ;; but in case it does happen, let's catch the error and give the
+       ;; code a chance to macro-expand later.
+       (message "Eager macro-expansion failure: %S" err)
+       form)))))
+
+;; ¡¡¡ Big Ugly Hack !!!
+;; src/bootstrap-emacs is mostly used to compile .el files, so it needs
+;; macroexp, bytecomp, cconv, and byte-opt to be fast.  Generally this is done
+;; by compiling those files first, but this only makes a difference if those
+;; files are not preloaded.  But macroexp.el is preloaded so we reload it if
+;; the current version is interpreted and there's a compiled version available.
+(eval-when-compile
+  (add-hook 'emacs-startup-hook
+            (lambda ()
+              (and (not (byte-code-function-p
+                         (symbol-function 'macroexpand-all)))
+                   (locate-library "macroexp.elc")
+                   (load "macroexp.elc")))))
+
 (provide 'macroexp)
 
 ;;; macroexp.el ends here
diff --git a/lisp/emacs-lisp/map-ynp.el b/lisp/emacs-lisp/map-ynp.el
index e7806440bf..289751f494 100644
--- a/lisp/emacs-lisp/map-ynp.el
+++ b/lisp/emacs-lisp/map-ynp.el
@@ -123,16 +123,6 @@ Returns the number of actions taken."
 	    map
             (let ((map (make-sparse-keymap)))
               (set-keymap-parent map query-replace-map)
-              (define-key map [?\C-\M-v] 'scroll-other-window)
-              (define-key map [M-next] 'scroll-other-window)
-              (define-key map [?\C-\M-\S-v] 'scroll-other-window-down)
-              (define-key map [M-prior] 'scroll-other-window-down)
-              ;; The above are rather inconvenient, so maybe we should
-              ;; provide the non-other keys for the other-scroll as well.
-              ;; (define-key map [?\C-v] 'scroll-other-window)
-              ;; (define-key map [next] 'scroll-other-window)
-              ;; (define-key map [?\M-v] 'scroll-other-window-down)
-              ;; (define-key map [prior] 'scroll-other-window-down)
               (dolist (elt action-alist)
                 (define-key map (vector (car elt)) (vector (nth 1 elt))))
               map)))
diff --git a/lisp/emacs-lisp/pcase.el b/lisp/emacs-lisp/pcase.el
index 4aeed7e4d0..09e47b69b9 100644
--- a/lisp/emacs-lisp/pcase.el
+++ b/lisp/emacs-lisp/pcase.el
@@ -60,6 +60,8 @@
 ;; is in a loop, the repeated macro-expansion becomes terribly costly, so we
 ;; memoize previous macro expansions to try and avoid recomputing them
 ;; over and over again.
+;; FIXME: Now that macroexpansion is also performed when loading an interpreted
+;; file, this is not a real problem any more.
 (defconst pcase--memoize (make-hash-table :weakness 'key :test 'eq))
 ;; (defconst pcase--memoize-1 (make-hash-table :test 'eq))
 ;; (defconst pcase--memoize-2 (make-hash-table :weakness 'key :test 'equal))
diff --git a/lisp/emacs-lisp/timer.el b/lisp/emacs-lisp/timer.el
index a66d5972d8..2248dde8c0 100644
--- a/lisp/emacs-lisp/timer.el
+++ b/lisp/emacs-lisp/timer.el
@@ -28,8 +28,8 @@
 ;;; Code:
 
 ;; Layout of a timer vector:
-;; [triggered-p high-seconds low-seconds usecs psecs repeat-delay
-;;  function args idle-delay]
+;; [triggered-p high-seconds low-seconds usecs repeat-delay
+;;  function args idle-delay psecs]
 ;; triggered-p is nil if the timer is active (waiting to be triggered),
 ;;  t if it is inactive ("already triggered", in theory)
 
@@ -42,7 +42,7 @@
             (:type vector)
             (:conc-name timer--))
   (triggered t)
-  high-seconds low-seconds usecs psecs repeat-delay function args idle-delay)
+  high-seconds low-seconds usecs repeat-delay function args idle-delay psecs)
 
 (defun timerp (object)
   "Return t if OBJECT is a timer."
diff --git a/lisp/emulation/cua-rect.el b/lisp/emulation/cua-rect.el
index 39ce590152..f63d79adf4 100644
--- a/lisp/emulation/cua-rect.el
+++ b/lisp/emulation/cua-rect.el
@@ -1423,7 +1423,9 @@ With prefix arg, indent to that column."
   (define-key cua--rectangle-keymap [remap set-mark-command]    'cua-toggle-rectangle-mark)
 
   (define-key cua--rectangle-keymap [remap forward-char]        'cua-resize-rectangle-right)
+  (define-key cua--rectangle-keymap [remap right-char]          'cua-resize-rectangle-right)
   (define-key cua--rectangle-keymap [remap backward-char]       'cua-resize-rectangle-left)
+  (define-key cua--rectangle-keymap [remap left-char]           'cua-resize-rectangle-left)
   (define-key cua--rectangle-keymap [remap next-line]           'cua-resize-rectangle-down)
   (define-key cua--rectangle-keymap [remap previous-line]       'cua-resize-rectangle-up)
   (define-key cua--rectangle-keymap [remap end-of-line]         'cua-resize-rectangle-eol)
diff --git a/lisp/emulation/edt-mapper.el b/lisp/emulation/edt-mapper.el
index 7fc24773b9..87b6bcf0aa 100644
--- a/lisp/emulation/edt-mapper.el
+++ b/lisp/emulation/edt-mapper.el
@@ -61,7 +61,7 @@
 
 ;;    emacs -q -l edt-mapper.el
 
-;;  The "-q" option prevents loading of your .emacs file (commands
+;;  The "-q" option prevents loading of your init file (commands
 ;;  therein might confuse this program).
 
 ;;  An instruction screen showing the typical LK-201 terminal
@@ -74,7 +74,7 @@
 ;;  and loaded automatically when the EDT emulation is started.  If
 ;;  you specify a different file name, you will need to set the
 ;;  variable "edt-keys-file" before starting the EDT emulation.
-;;  Here's how you might go about doing that in your .emacs file.
+;;  Here's how you might go about doing that in your init file:
 
 ;;    (setq edt-keys-file (expand-file-name "~/.my-emacs-keys"))
 
diff --git a/lisp/emulation/edt.el b/lisp/emulation/edt.el
index dbd13a01a8..3810dcccbb 100644
--- a/lisp/emulation/edt.el
+++ b/lisp/emulation/edt.el
@@ -48,7 +48,7 @@
 
 ;; You can have the EDT Emulation start up automatically, each time
 ;; you initiate a GNU Emacs session, by adding the following line to
-;; your .emacs file:
+;; your init file:
 ;;
 ;;    (add-hook term-setup-hook 'edt-emulation-on)
 
@@ -75,7 +75,7 @@
 ;;      default, this feature is enabled, with the top margin set to
 ;;      10% of the window and the bottom margin set to 15% of the
 ;;      window.  To change these settings, you can invoke the function
-;;      edt-set-scroll-margins in your .emacs file.  For example, the
+;;      edt-set-scroll-margins in your init file.  For example, the
 ;;      following line
 ;;
 ;;           (edt-set-scroll-margins "20%" "25%")
@@ -363,7 +363,7 @@ This means that an edt-user.el file was found in the user's `load-path'.")
 ;;;
 ;;;         (setq edt-keep-current-page-delimiter t)
 ;;;
-;;; in your .emacs file.
+;;; in your init file.
 
 (defun edt-page-forward (num)
   "Move forward to just after next page delimiter.
@@ -1961,14 +1961,14 @@ created."
      Ack!!  You're running the Enhanced EDT Emulation without loading an
      EDT key mapping file.  To create an EDT key mapping file, run the
      edt-mapper program.  It is safest to run it from an Emacs loaded
-     without any of your own customizations found in your .emacs file, etc.
+     without any of your own customizations found in your init file, etc.
      The reason for this is that some user customizations confuse edt-mapper.
      You can do this by quitting Emacs and then invoking Emacs again as
      follows:
 
           emacs -q -l edt-mapper
 
-     [NOTE:  If you do nothing out of the ordinary in your .emacs file, and
+     [NOTE:  If you do nothing out of the ordinary in your init file, and
      the search for edt-mapper is successful, you can try running it now.]
 
      The library edt-mapper includes these same directions on how to
diff --git a/lisp/emulation/tpu-edt.el b/lisp/emulation/tpu-edt.el
index b8d07e8b74..d375725af5 100644
--- a/lisp/emulation/tpu-edt.el
+++ b/lisp/emulation/tpu-edt.el
@@ -163,8 +163,8 @@
 ;;    and type `tpu-edt' followed by a carriage return.
 
 ;;    If you like TPU-edt and want to use it all the time, you can start
-;;    TPU-edt using the Emacs initialization file, .emacs.  Simply create
-;;    a .emacs file in your home directory containing the line:
+;;    TPU-edt using the Emacs initialization file, .emacs.  Simply add
+;;    the following line to your init file:
 
 ;;        (tpu-edt)
 
@@ -2440,7 +2440,7 @@ If FILE is nil, try to load a default file.  The default file names are
 
 
 ;;;### (autoloads (tpu-set-cursor-bound tpu-set-cursor-free tpu-set-scroll-margins
-;;;;;;  tpu-cursor-free-mode) "tpu-extras" "tpu-extras.el" "76f06905db4c5bfb3b86491a51512a0e")
+;;;;;;  tpu-cursor-free-mode) "tpu-extras" "tpu-extras.el" "bf5e7322f9a2c324a3bb306415813374")
 ;;; Generated autoloads from tpu-extras.el
 
 (autoload 'tpu-cursor-free-mode "tpu-extras" "\
diff --git a/lisp/emulation/tpu-extras.el b/lisp/emulation/tpu-extras.el
index 521b189e3b..4cf9eee037 100644
--- a/lisp/emulation/tpu-extras.el
+++ b/lisp/emulation/tpu-extras.el
@@ -26,7 +26,7 @@
 
 ;;  Use the functions defined here to customize TPU-edt to your tastes by
 ;;  setting scroll margins and/or turning on free cursor mode.  Here's an
-;;  example for your .emacs file.
+;;  example for your init file.
 
 ;;     (tpu-set-cursor-free)                   ; Set cursor free.
 ;;     (tpu-set-scroll-margins "10%" "15%")    ; Set scroll margins.
diff --git a/lisp/emulation/tpu-mapper.el b/lisp/emulation/tpu-mapper.el
index ef4e9b305f..9cced60816 100644
--- a/lisp/emulation/tpu-mapper.el
+++ b/lisp/emulation/tpu-mapper.el
@@ -81,7 +81,7 @@ Finally, you will be prompted for the name of the file to store the key
 definitions.  If you chose the default, TPU-edt will find it and load it
 automatically.  If you specify a different file name, you will need to
 set the variable ``tpu-xkeys-file'' before starting TPU-edt.  Here's how
-you might go about doing that in your .emacs file.
+you might go about doing that in your init file.
 
   (setq tpu-xkeys-file (expand-file-name \"~/.my-emacs-x-keys\"))
   (tpu-edt)
diff --git a/lisp/emulation/vi.el b/lisp/emulation/vi.el
index 9bf108c8c3..a59dd610c2 100644
--- a/lisp/emulation/vi.el
+++ b/lisp/emulation/vi.el
@@ -28,7 +28,7 @@
 ;;                               (if (not (or (eq major-mode 'Info-mode)
 ;; 	                                     (eq major-mode 'vi-mode)))
 ;;                                   (vi-mode))))))
-;; 3) In your .emacs file you can define the command "vi-mode" to be "autoload"
+;; 3) In your init file you can define the command "vi-mode" to be "autoload"
 ;;    or you can execute the "load" command to load "vi" directly.
 ;; 4) Read the comments for command "vi-mode" before you start using it.
 
diff --git a/lisp/emulation/viper.el b/lisp/emulation/viper.el
index 81fbfb0394..8de253d19b 100644
--- a/lisp/emulation/viper.el
+++ b/lisp/emulation/viper.el
@@ -351,7 +351,7 @@ user decide when to invoke Viper in a major mode."
 If t, viperize Emacs.  If nil -- don't.  If `ask', ask the user.
 This variable is used primarily when Viper is being loaded.
 
-Must be set in `~/.emacs' before Viper is loaded.
+Must be set in your init file before Viper is loaded.
 DO NOT set this variable interactively, unless you are using the customization
 widget."
   :type '(choice (const nil) (const t) (const ask))
@@ -1173,7 +1173,7 @@ If you wish to Viperize AND make this your way of life, please put
 	(setq viper-mode t)
 	(require 'viper)
 
-in your .emacs file (preferably, close to the top).
+in your init file (preferably, close to the top).
 These two lines must come in the order given.
 
 ** Viper users:
diff --git a/lisp/epa-mail.el b/lisp/epa-mail.el
index be5b849651..a16fa5abdd 100644
--- a/lisp/epa-mail.el
+++ b/lisp/epa-mail.el
@@ -170,24 +170,26 @@ Don't use this command in Lisp programs!"
 If no one is selected, symmetric encryption will be performed.  "
 		  recipients)
 	       (if recipients
-		   (mapcar
-		    (lambda (recipient)
-		      (setq recipient-key
-			    (epa-mail--find-usable-key
-			     (epg-list-keys
-			      (epg-make-context epa-protocol)
-			      (if (string-match "@" recipient)
-				  (concat "<" recipient ">")
-				recipient))
-			     'encrypt))
-		      (unless (or recipient-key
-				  (y-or-n-p
-				   (format
-				    "No public key for %s; skip it? "
-				    recipient)))
-			(error "No public key for %s" recipient))
-		      recipient-key)
-		    recipients)))
+		   (apply
+		    'nconc
+		    (mapcar
+		     (lambda (recipient)
+		       (setq recipient-key
+			     (epa-mail--find-usable-key
+			      (epg-list-keys
+			       (epg-make-context epa-protocol)
+			       (if (string-match "@" recipient)
+				   (concat "<" recipient ">")
+				 recipient))
+			      'encrypt))
+		       (unless (or recipient-key
+				   (y-or-n-p
+				    (format
+				     "No public key for %s; skip it? "
+				     recipient)))
+			 (error "No public key for %s" recipient))
+		       (if recipient-key (list recipient-key)))
+		     recipients))))
 	     (setq sign (if verbose (y-or-n-p "Sign? ")))
 	     (if sign
 		 (epa-select-keys context
diff --git a/lisp/erc/ChangeLog b/lisp/erc/ChangeLog
index 37e755e765..674a6c97ee 100644
--- a/lisp/erc/ChangeLog
+++ b/lisp/erc/ChangeLog
@@ -1,3 +1,9 @@
+2012-09-17  Chong Yidong  <[email protected]>
+
+	* erc-page.el (erc-page-function): 
+
+	* erc-stamp.el (erc-stamp): Doc fix.
+
 2012-08-21  Josh Feinstein <[email protected]>
 
 	* erc-join.el (erc-autojoin-timing): Fix defcustom type.
diff --git a/lisp/erc/erc-button.el b/lisp/erc/erc-button.el
index c8a7fec32b..a0593dcb74 100644
--- a/lisp/erc/erc-button.el
+++ b/lisp/erc/erc-button.el
@@ -25,7 +25,7 @@
 
 ;; Heavily borrowed from gnus-art.el. Thanks to the original authors.
 ;; This buttonizes nicks and other stuff to make it all clickable.
-;; To enable, add to your ~/.emacs:
+;; To enable, add to your init file:
 ;; (require 'erc-button)
 ;; (erc-button-mode 1)
 ;;
diff --git a/lisp/erc/erc-capab.el b/lisp/erc/erc-capab.el
index 4f6361ee92..c7103d6dc6 100644
--- a/lisp/erc/erc-capab.el
+++ b/lisp/erc/erc-capab.el
@@ -48,7 +48,7 @@
 
 ;;; Usage:
 
-;; Put the following in your ~/.emacs file.
+;; Put the following in your init file.
 
 ;; (require 'erc-capab)
 ;; (erc-capab-identify-mode 1)
diff --git a/lisp/erc/erc-match.el b/lisp/erc/erc-match.el
index cac042c029..de7f213719 100644
--- a/lisp/erc/erc-match.el
+++ b/lisp/erc/erc-match.el
@@ -29,7 +29,7 @@
 ;; customizable variables.
 
 ;; Usage:
-;; Put (erc-match-mode 1) into your ~/.emacs file.
+;; Put (erc-match-mode 1) into your init file.
 
 ;;; Code:
 
diff --git a/lisp/erc/erc-netsplit.el b/lisp/erc/erc-netsplit.el
index 44fbc9563d..355b345492 100644
--- a/lisp/erc/erc-netsplit.el
+++ b/lisp/erc/erc-netsplit.el
@@ -23,7 +23,7 @@
 ;;; Commentary:
 
 ;; This module hides quit/join messages if a netsplit occurs.
-;; To enable, add the following to your ~/.emacs:
+;; To enable, add the following to your init file:
 ;; (require 'erc-netsplit)
 ;; (erc-netsplit-mode 1)
 
diff --git a/lisp/erc/erc-page.el b/lisp/erc/erc-page.el
index e6b670c91b..51ddc33e1c 100644
--- a/lisp/erc/erc-page.el
+++ b/lisp/erc/erc-page.el
@@ -45,7 +45,7 @@ If nil, this prints the page message in the minibuffer and calls
 `beep'.  If non-nil, it must be a function that takes two arguments:
 SENDER and MSG, both strings.
 
-Example for your ~/.emacs file:
+Example for your init file:
 
 \(setq erc-page-function
       (lambda (sender msg)
diff --git a/lisp/erc/erc-replace.el b/lisp/erc/erc-replace.el
index 04c5885bc3..6c5804c62a 100644
--- a/lisp/erc/erc-replace.el
+++ b/lisp/erc/erc-replace.el
@@ -25,7 +25,7 @@
 
 ;; This module allows you to systematically replace text in incoming
 ;; messages.  Load erc-replace, and customize `erc-replace-alist'.
-;; Then add to your ~/.emacs:
+;; Then add to your init file:
 
 ;; (require 'erc-replace)
 ;; (erc-replace-mode 1)
diff --git a/lisp/erc/erc-stamp.el b/lisp/erc/erc-stamp.el
index 5831233aff..4ce2f18e04 100644
--- a/lisp/erc/erc-stamp.el
+++ b/lisp/erc/erc-stamp.el
@@ -43,7 +43,7 @@ group provides settings related to the format and display
 of timestamp information in `erc-mode' buffer.
 
 For timestamping to be activated, you just need to load `erc-stamp'
-in your .emacs file or interactively using `load-library'."
+in your init file or interactively using `load-library'."
   :group 'erc)
 
 (defcustom erc-timestamp-format "[%H:%M]"
diff --git a/lisp/erc/erc-track.el b/lisp/erc/erc-track.el
index 9c56c72422..88a3285730 100644
--- a/lisp/erc/erc-track.el
+++ b/lisp/erc/erc-track.el
@@ -24,7 +24,7 @@
 ;;; Commentary:
 
 ;; Highlights keywords and pals (friends), and hides or highlights fools
-;; (using a dark color).  Add to your ~/.emacs:
+;; (using a dark color).  Add to your init file:
 
 ;; (require 'erc-track)
 ;; (erc-track-mode 1)
diff --git a/lisp/eshell/em-alias.el b/lisp/eshell/em-alias.el
index 4b62fec95e..940056b643 100644
--- a/lisp/eshell/em-alias.el
+++ b/lisp/eshell/em-alias.el
@@ -133,10 +133,10 @@ Each element of this alias is a list of the form:
 Where NAME is the textual name of the alias, and DEFINITION is the
 command string to replace that command with.
 
-Note: this list should not be modified in your '.emacs' file.  Rather,
-any desired alias definitions should be declared using the `alias'
-command, which will automatically write them to the file named by
-`eshell-aliases-file'.")
+Note: this list should not be modified in your init file.
+Rather, any desired alias definitions should be declared using
+the `alias' command, which will automatically write them to the
+file named by `eshell-aliases-file'.")
 
 (put 'eshell-command-aliases-list 'risky-local-variable t)
 
diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el
index 58402e3750..d3ddab8af1 100644
--- a/lisp/eshell/em-unix.el
+++ b/lisp/eshell/em-unix.el
@@ -1111,7 +1111,7 @@ Execute a COMMAND as the superuser or another USER.")
 				  (substring prefix 0 -1) user host dir)
 			(format "/sudo:%s@%s:%s" user host dir))))
 		;; Ensure, that Tramp has connected to that construct already.
-		(file-exists-p default-directory)
+		(ignore (file-exists-p default-directory))
 		(eshell-named-command (car orig-args) (cdr orig-args))))))))
 
 (put 'eshell/sudo 'eshell-no-numeric-conversions t)
diff --git a/lisp/eshell/esh-util.el b/lisp/eshell/esh-util.el
index 8218e91ddc..fa0336232f 100644
--- a/lisp/eshell/esh-util.el
+++ b/lisp/eshell/esh-util.el
@@ -84,7 +84,7 @@ Numeric form is tested using the regular expression
 NOTE: If you find that numeric conversions are interfering with the
 specification of filenames (for example, in calling `find-file', or
 some other Lisp function that deals with files, not numbers), add the
-following in your .emacs file:
+following in your init file:
 
   (put 'find-file 'eshell-no-numeric-conversions t)
 
diff --git a/lisp/ffap.el b/lisp/ffap.el
index ebe8b6dee9..f3e8d4c194 100644
--- a/lisp/ffap.el
+++ b/lisp/ffap.el
@@ -34,7 +34,7 @@
 ;; README's, MANIFEST's, and so on.  Submit bugs or suggestions with
 ;; M-x ffap-bug.
 ;;
-;; For the default installation, add this line to your .emacs file:
+;; For the default installation, add this line to your init file:
 ;;
 ;; (ffap-bindings)                      ; do default key bindings
 ;;
@@ -206,7 +206,7 @@ Sensible values are nil, \"news\", or \"mailto\"."
 ;; those features interesting but not clear winners (a matter of
 ;; personal taste) I try to leave options to enable them.  Read
 ;; through this section for features that you like, put an appropriate
-;; enabler in your .emacs file.
+;; enabler in your init file.
 
 (defcustom ffap-dired-wildcards "[*?][^/]*\\'"
   "A regexp matching filename wildcard characters, or nil.
diff --git a/lisp/files.el b/lisp/files.el
index ef7f8e43a4..289f5c6b0b 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -658,22 +658,13 @@ Not actually set up until the first time you use it.")
 
 (defun parse-colon-path (search-path)
   "Explode a search path into a list of directory names.
-Directories are separated by occurrences of `path-separator'
-\(which is colon in GNU and GNU-like systems)."
-  ;; We could use split-string here.
-  (and search-path
-       (let (cd-list (cd-start 0) cd-colon)
-	 (setq search-path (concat search-path path-separator))
-	 (while (setq cd-colon (string-match path-separator search-path cd-start))
-	   (setq cd-list
-		 (nconc cd-list
-			(list (if (= cd-start cd-colon)
-				   nil
-				(substitute-in-file-name
-				 (file-name-as-directory
-				  (substring search-path cd-start cd-colon)))))))
-	   (setq cd-start (+ cd-colon 1)))
-	 cd-list)))
+Directories are separated by `path-separator' (which is colon in
+GNU and Unix systems).  Substitute environment variables into the
+resulting list of directory names."
+  (when (stringp search-path)
+    (mapcar (lambda (f)
+	      (substitute-in-file-name (file-name-as-directory f)))
+	    (split-string search-path path-separator t))))
 
 (defun cd-absolute (dir)
   "Change current directory to given absolute file name DIR."
@@ -2145,7 +2136,7 @@ unless NOMODES is non-nil."
 	 (not buffer-read-only)
 	 (save-excursion
 	   (goto-char (point-max))
-	   (insert "\n")))
+	   (ignore-errors (insert "\n"))))
     (when (and buffer-read-only
 	       view-read-only
 	       (not (eq (get major-mode 'mode-class) 'special)))
@@ -2951,20 +2942,16 @@ UNSAFE-VARS is the list of those that aren't marked as safe or risky.
 RISKY-VARS is the list of those that are marked as risky.
 If these settings come from directory-local variables, then
 DIR-NAME is the name of the associated directory.  Otherwise it is nil."
-  (if noninteractive
-      nil
-    (save-window-excursion
-      (let* ((name (or dir-name
-		       (if buffer-file-name
-			   (file-name-nondirectory buffer-file-name)
-			 (concat "buffer " (buffer-name)))))
-	     (offer-save (and (eq enable-local-variables t)
-			      unsafe-vars))
-	     (exit-chars
-	      (if offer-save '(?! ?y ?n ?\s ?\C-g) '(?y ?n ?\s ?\C-g)))
-	     (buf (pop-to-buffer "*Local Variables*"))
-	     prompt char)
-	(set (make-local-variable 'cursor-type) nil)
+  (unless noninteractive
+    (let ((name (cond (dir-name)
+		      (buffer-file-name
+		       (file-name-nondirectory buffer-file-name))
+		      ((concat "buffer " (buffer-name)))))
+	  (offer-save (and (eq enable-local-variables t)
+			   unsafe-vars))
+	  (buf (get-buffer-create "*Local Variables*")))
+      ;; Set up the contents of the *Local Variables* buffer.
+      (with-current-buffer buf
 	(erase-buffer)
 	(cond
 	 (unsafe-vars
@@ -2999,25 +2986,35 @@ n  -- to ignore the local variables list.")
 	  (let ((print-escape-newlines t))
 	    (prin1 (cdr elt) buf))
 	  (insert "\n"))
-	(setq prompt
-	      (format "Please type %s%s: "
-		      (if offer-save "y, n, or !" "y or n")
-		      (if (< (line-number-at-pos) (window-body-height))
-			  ""
-			(push ?\C-v exit-chars)
-			", or C-v to scroll")))
-	(goto-char (point-min))
-	(while (null char)
-	  (setq char (read-char-choice prompt exit-chars t))
-	  (when (eq char ?\C-v)
-	    (condition-case nil
-		(scroll-up)
-	      (error (goto-char (point-min))))
-	    (setq char nil)))
-	(kill-buffer buf)
-	(when (and offer-save (= char ?!) unsafe-vars)
-	  (customize-push-and-save 'safe-local-variable-values unsafe-vars))
-	(memq char '(?! ?\s ?y))))))
+	(set (make-local-variable 'cursor-type) nil)
+	(set-buffer-modified-p nil)
+	(goto-char (point-min)))
+
+      ;; Display the buffer and read a choice.
+      (save-window-excursion
+	(pop-to-buffer buf)
+	(let* ((exit-chars '(?y ?n ?\s ?\C-g ?\C-v))
+	       (prompt (format "Please type %s%s: "
+			       (if offer-save "y, n, or !" "y or n")
+			       (if (< (line-number-at-pos (point-max))
+				      (window-body-height))
+				   ""
+				 (push ?\C-v exit-chars)
+				 ", or C-v to scroll")))
+	       char)
+	  (if offer-save (push ?! exit-chars))
+	  (while (null char)
+	    (setq char (read-char-choice prompt exit-chars t))
+	    (when (eq char ?\C-v)
+	      (condition-case nil
+		  (scroll-up)
+		(error (goto-char (point-min))
+		       (recenter 1)))
+	      (setq char nil)))
+	  (when (and offer-save (= char ?!) unsafe-vars)
+	    (customize-push-and-save 'safe-local-variable-values unsafe-vars))
+	  (prog1 (memq char '(?! ?\s ?y))
+	    (quit-window t)))))))
 
 (defun hack-local-variables-prop-line (&optional mode-only)
   "Return local variables specified in the -*- line.
@@ -5350,23 +5347,26 @@ non-nil, it is called instead of rereading visited file contents."
 	     (not (file-exists-p file-name)))
 	   (error "Auto-save file %s not current"
 		  (abbreviate-file-name file-name)))
-	  ((save-window-excursion
-	     (with-output-to-temp-buffer "*Directory*"
-	       (buffer-disable-undo standard-output)
-	       (save-excursion
-		 (let ((switches dired-listing-switches))
-		   (if (file-symlink-p file)
-		       (setq switches (concat switches " -L")))
-		   (set-buffer standard-output)
-		   ;; Use insert-directory-safely, not insert-directory,
-		   ;; because these files might not exist.  In particular,
-		   ;; FILE might not exist if the auto-save file was for
-		   ;; a buffer that didn't visit a file, such as "*mail*".
-		   ;; The code in v20.x called `ls' directly, so we need
-		   ;; to emulate what `ls' did in that case.
-		   (insert-directory-safely file switches)
-		   (insert-directory-safely file-name switches))))
-	     (yes-or-no-p (format "Recover auto save file %s? " file-name)))
+	  ((with-temp-buffer-window
+	    "*Directory*" nil
+	    #'(lambda (window _value)
+		(with-selected-window window
+		  (unwind-protect
+		      (yes-or-no-p (format "Recover auto save file %s? " file-name))
+		    (when (window-live-p window)
+		      (quit-restore-window window 'kill)))))
+	    (with-current-buffer standard-output
+	      (let ((switches dired-listing-switches))
+		(if (file-symlink-p file)
+		    (setq switches (concat switches " -L")))
+		;; Use insert-directory-safely, not insert-directory,
+		;; because these files might not exist.  In particular,
+		;; FILE might not exist if the auto-save file was for
+		;; a buffer that didn't visit a file, such as "*mail*".
+		;; The code in v20.x called `ls' directly, so we need
+		;; to emulate what `ls' did in that case.
+		(insert-directory-safely file switches)
+		(insert-directory-safely file-name switches))))
 	   (switch-to-buffer (find-file-noselect file t))
 	   (let ((inhibit-read-only t)
 		 ;; Keep the current buffer-file-coding-system.
@@ -6327,8 +6327,15 @@ if any returns nil.  If `confirm-kill-emacs' is non-nil, calls it."
 		    (setq active t))
 	       (setq processes (cdr processes)))
 	     (or (not active)
-		 (progn (list-processes t)
-			(yes-or-no-p "Active processes exist; kill them and exit anyway? ")))))
+		 (with-temp-buffer-window
+		  (get-buffer-create "*Process List*") nil
+		  #'(lambda (window _value)
+		      (with-selected-window window
+			(unwind-protect
+			    (yes-or-no-p "Active processes exist; kill them and exit anyway? ")
+			  (when (window-live-p window)
+			    (quit-restore-window window 'kill)))))
+		  (list-processes t)))))
        ;; Query the user for other things, perhaps.
        (run-hook-with-args-until-failure 'kill-emacs-query-functions)
        (or (null confirm-kill-emacs)
diff --git a/lisp/filesets.el b/lisp/filesets.el
index 6c24a4f43d..a91d8cf0fc 100644
--- a/lisp/filesets.el
+++ b/lisp/filesets.el
@@ -35,7 +35,7 @@
 ;; inclusion group (i.e. a base file including other files).
 
 ;; Usage:
-;; 1. Put (require 'filesets) and (filesets-init) in your .emacs file.
+;; 1. Put (require 'filesets) and (filesets-init) in your init file.
 ;; 2. Type ;; M-x filesets-edit or choose "Edit Filesets" from the menu.
 ;; 3. Save your customizations.
 
diff --git a/lisp/flow-ctrl.el b/lisp/flow-ctrl.el
index 747a4ca018..b301886de5 100644
--- a/lisp/flow-ctrl.el
+++ b/lisp/flow-ctrl.el
@@ -31,7 +31,7 @@
 ;;
 ;; To invoke these adjustments, a user need only invoke the function
 ;; enable-flow-control-on with a list of terminal types in his/her own
-;; .emacs file.  As arguments, give it the names of one or more terminal
+;; init file.  As arguments, give it the names of one or more terminal
 ;; types in use by that user which require flow control adjustments.
 ;; Here's an example:
 ;;
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 77c21d2653..6404af7703 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -37,7 +37,7 @@
 ;; When this minor mode is on, the faces of the current line are updated with
 ;; every insertion or deletion.
 ;;
-;; To turn Font Lock mode on automatically, add this to your ~/.emacs file:
+;; To turn Font Lock mode on automatically, add this to your init file:
 ;;
 ;;  (add-hook 'emacs-lisp-mode-hook 'turn-on-font-lock)
 ;;
diff --git a/lisp/frame.el b/lisp/frame.el
index 1e8883eb98..b7b61bcc57 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -309,7 +309,7 @@ there (in decreasing order of priority)."
       ;; existing frame.  We need to explicitly include
       ;; default-frame-alist in the parameters of the screen we
       ;; create here, so that its new value, gleaned from the user's
-      ;; .emacs file, will be applied to the existing screen.
+      ;; init file, will be applied to the existing screen.
       (if (not (eq (cdr (or (assq 'minibuffer initial-frame-alist)
 			    (assq 'minibuffer window-system-frame-alist)
 			    (assq 'minibuffer default-frame-alist)
@@ -1668,6 +1668,10 @@ terminals, cursor blinking is controlled by the terminal."
 
 (make-variable-buffer-local 'show-trailing-whitespace)
 
+;; Defined in dispnew.c.
+(make-obsolete-variable
+ 'window-system-version "it does not give useful information." "24.3")
+
 (provide 'frame)
 
 ;;; frame.el ends here
diff --git a/lisp/generic-x.el b/lisp/generic-x.el
index cc7963b171..a97c5649c9 100644
--- a/lisp/generic-x.el
+++ b/lisp/generic-x.el
@@ -28,7 +28,7 @@
 ;;
 ;; INSTALLATION:
 ;;
-;; Add this line to your .emacs file:
+;; Add this line to your init file:
 ;;
 ;;   (require 'generic-x)
 ;;
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index a4e3d9bde2..69f0025b52 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,129 @@
+2012-09-13  Katsumi Yamaoka  <[email protected]>
+
+	* gnus-util.el (gnus-timer--function): New function.
+
+	* gnus-art.el (gnus-article-stop-animations): Use it.
+
+2012-09-13  Paul Eggert  <[email protected]>
+
+	Fix glitches caused by addition of psec to timers.
+	* gnus-art.el (gnus-article-stop-animations): Use timer--function
+	rather than raw access to timer vector.
+
+2012-09-11  Julien Danjou  <[email protected]>
+
+	* gnus-notifications.el (gnus-notifications): Check for nil values in
+	ignored addresses check.
+
+2012-09-10  Stefan Monnier  <[email protected]>
+
+	* qp.el (quoted-printable-decode-region): Inline+CSE+strength-reduction.
+
+2012-09-07  Chong Yidong  <[email protected]>
+
+	* gnus-util.el
+	(gnus-put-text-property-excluding-characters-with-faces): Restore.
+
+	* gnus-salt.el (gnus-tree-highlight-node):
+	* gnus-sum.el (gnus-summary-highlight-line):
+	* gnus-group.el (gnus-group-highlight-line): Revert use of add-face.
+
+2012-09-06  Lars Ingebrigtsen  <[email protected]>
+
+	* gnus-util.el: Fix compilation error on XEmacs 21.4.
+
+2012-09-06  Juri Linkov  <[email protected]>
+
+	* gnus-group.el (gnus-read-ephemeral-gmane-group): Change the naming
+	scheme for buffer names to be more consistent with other group and
+	article buffer names in Gnus.
+
+2012-09-06  Lars Ingebrigtsen  <[email protected]>
+
+	* gnus-util.el
+	(gnus-put-text-property-excluding-characters-with-faces): Remove.
+
+	* gnus-compat.el: Define compat function `add-face' from Wolfgang
+	Jenkner.
+
+	* gnus-group.el (gnus-group-highlight-line): Use combining faces.
+
+	* gnus-sum.el (gnus-summary-highlight-line): Ditto.
+
+	* gnus-salt.el (gnus-tree-highlight-node): Ditto.
+
+2012-09-06  Katsumi Yamaoka  <[email protected]>
+
+	* gnus-score.el (gnus-score-decode-text-parts): Use #' for
+	mm-text-parts used in labels macro to make it work with XEmacs 21.5.
+
+	* gnus-util.el (gnus-string-prefix-p): New function, an alias to
+	string-prefix-p in Emacs >=23.2.
+
+	* nnmaildir.el (nnmaildir--ensure-suffix, nnmaildir--add-flag)
+	(nnmaildir--remove-flag, nnmaildir--scan): Use gnus-string-match-p
+	instead of string-match-p.
+	(nnmaildir--scan): Use gnus-string-prefix-p instead of string-prefix-p.
+
+2012-09-06  Kenichi Handa  <[email protected]>
+
+	* qp.el (quoted-printable-decode-region): Fix previous change; handle
+	lowercase a..f.
+
+2012-09-05  Magnus Henoch  <[email protected]>
+
+	* nnmaildir.el (nnmaildir--article-set-flags): Fix compilation error.
+
+2012-09-05  Martin Stjernholm  <[email protected]>
+
+	* gnus-demon.el (gnus-demon-init): Fixed regression when IDLE is t and
+	TIME is set.
+
+2012-09-05  Juri Linkov  <[email protected]>
+
+	* gnus-group.el (gnus-read-ephemeral-bug-group): Allow opening more
+	than one group at a time (bug#11961).
+
+2012-09-05  Julien Danjou  <[email protected]>
+
+	* gnus-srvr.el (gnus-server-open-server): Don't message on failure:
+	this hide the real reason with a message giving absolutely no hint.
+
+2012-09-05  Lars Ingebrigtsen  <[email protected]>
+
+	* gnus-group.el (gnus-group-mark-article-read): Propagate the read mark
+	to the backend (bug#11804).
+
+	* message.el (message-insert-newsgroups): Don't insert newsgroup
+	duplicates (bug#12275).
+
+2012-09-05  John Wiegley  <[email protected]>
+
+	* gnus.el (gnus-expand-group-parameters): Allow regexp substitutions in
+	sieve rules.
+
+2012-09-05  Jan Tatarik  <[email protected]>
+
+	* gnus-score.el (gnus-score-decode-text-parts): Use #' for the local
+	function.
+
+	* gnus-logic.el (gnus-advanced-body): Allow scoring on decoded bodies.
+
+	* gnus-score.el (gnus-score-decode-text-parts): Ditto.
+
+2012-09-05  Magnus Henoch  <[email protected]>
+
+	* nnmaildir.el: Make nnmaildir understand and write maildir flags.
+	That is, rename files from "unique:2," to "unique:2,S" for "seen", etc.
+	This should make nnmaildir more usable with offlineimap.
+
+2012-09-03  Lars Ingebrigtsen  <[email protected]>
+
+	* gnus-notifications.el (gnus-notifications-notify): Use it.
+
+	* gnus-fun.el (gnus-funcall-no-warning): New function to silence
+	warnings on XEmacs.
+
 2012-09-01  Paul Eggert  <[email protected]>
 
 	Better seeds for (random).
@@ -2291,8 +2417,6 @@
 
 2011-06-30  Lars Magne Ingebrigtsen  <[email protected]>
 
-	* dgnushack.el: Autoload sha1 on XEmacs.
-
 	* gnus-group.el (gnus-read-ephemeral-emacs-bug-group): Take an optional
 	quit window configuration.
 
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index b9020a40b7..7dcbd61316 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -4554,7 +4554,7 @@ commands:
 (defun gnus-article-stop-animations ()
   (dolist (timer (and (boundp 'timer-list)
 		      timer-list))
-    (when (eq (elt timer 5) 'image-animate-timeout)
+    (when (eq (gnus-timer--function timer) 'image-animate-timeout)
       (cancel-timer timer))))
 
 (defun gnus-stop-downloads ()
diff --git a/lisp/gnus/gnus-demon.el b/lisp/gnus/gnus-demon.el
index 115c577744..671c566d09 100644
--- a/lisp/gnus/gnus-demon.el
+++ b/lisp/gnus/gnus-demon.el
@@ -144,9 +144,12 @@ marked with SPECIAL."
 			(* (gnus-demon-time-to-step time) gnus-demon-timestep))
                        (t
 			(* time gnus-demon-timestep))))
-           (idle (if (numberp idle)
-                     (* idle gnus-demon-timestep)
-                   idle))
+	   (idle (cond ((numberp idle)
+			(* idle gnus-demon-timestep))
+		       ((and (eq idle t) (numberp time))
+			time)
+		       (t
+			idle)))
 
            (timer
             (cond
diff --git a/lisp/gnus/gnus-fun.el b/lisp/gnus/gnus-fun.el
index f33eb910c6..f5e1c5ad69 100644
--- a/lisp/gnus/gnus-fun.el
+++ b/lisp/gnus/gnus-fun.el
@@ -278,6 +278,10 @@ colors of the displayed X-Faces."
 	  values))
   (mapconcat 'identity values " ")))
 
+(defun gnus-funcall-no-warning (function &rest args)
+  (when (fboundp function)
+    (apply function args)))
+
 (provide 'gnus-fun)
 
 ;;; gnus-fun.el ends here
diff --git a/lisp/gnus/gnus-group.el b/lisp/gnus/gnus-group.el
index 2f6fc0ccd1..8c7d016597 100644
--- a/lisp/gnus/gnus-group.el
+++ b/lisp/gnus/gnus-group.el
@@ -2388,7 +2388,7 @@ specified by `gnus-gmane-group-download-format'."
 	       group start (+ start range)))
       (write-region (point-min) (point-max) tmpfile)
       (gnus-group-read-ephemeral-group
-       (format "%s.start-%s.range-%s" group start range)
+       (format "nndoc+ephemeral:%s.start-%s.range-%s" group start range)
        `(nndoc ,tmpfile
 	       (nndoc-article-type mbox))))
     (delete-file tmpfile)))
@@ -2481,7 +2481,8 @@ the bug number, and browsing the URL must return mbox output."
 			 "/.*$" ""))))
       (write-region (point-min) (point-max) tmpfile)
       (gnus-group-read-ephemeral-group
-       "gnus-read-ephemeral-bug"
+       (format "nndoc+ephemeral:bug#%s"
+	       (mapconcat 'number-to-string ids ","))
        `(nndoc ,tmpfile
 	       (nndoc-article-type mbox))
        nil window-conf))
@@ -4670,6 +4671,8 @@ you the groups that have both dormant articles and cached articles."
 	      (setq mark gnus-expirable-mark))
 	    (setq mark (gnus-request-update-mark
 			group article mark))
+	    (gnus-request-set-mark
+	     group (list (list (list article) 'add '(read))))
 	    (gnus-mark-article-as-read article mark)
 	    (setq gnus-newsgroup-active (gnus-active group))
 	    (when active
diff --git a/lisp/gnus/gnus-logic.el b/lisp/gnus/gnus-logic.el
index 954295438c..a440b77993 100644
--- a/lisp/gnus/gnus-logic.el
+++ b/lisp/gnus/gnus-logic.el
@@ -180,46 +180,51 @@
     (setq header "article"))
   (with-current-buffer nntp-server-buffer
     (let* ((request-func (cond ((string= "head" header)
-				'gnus-request-head)
-			       ((string= "body" header)
-				'gnus-request-body)
-			       (t 'gnus-request-article)))
-	   ofunc article)
+                                'gnus-request-head)
+                               ;; We need to peek at the headers to detect the
+                               ;; content encoding
+                               ((string= "body" header)
+                                'gnus-request-article)
+                               (t 'gnus-request-article)))
+           ofunc article handles)
       ;; Not all backends support partial fetching.  In that case, we
       ;; just fetch the entire article.
       (unless (gnus-check-backend-function
-	       (intern (concat "request-" header))
-	       gnus-newsgroup-name)
-	(setq ofunc request-func)
-	(setq request-func 'gnus-request-article))
+               (intern (concat "request-" header))
+               gnus-newsgroup-name)
+        (setq ofunc request-func)
+        (setq request-func 'gnus-request-article))
       (setq article (mail-header-number gnus-advanced-headers))
       (gnus-message 7 "Scoring article %s..." article)
       (when (funcall request-func article gnus-newsgroup-name)
-	(goto-char (point-min))
-	;; If just parts of the article is to be searched and the
-	;; backend didn't support partial fetching, we just narrow to
-	;; the relevant parts.
-	(when ofunc
-	  (if (eq ofunc 'gnus-request-head)
-	      (narrow-to-region
-	       (point)
-	       (or (search-forward "\n\n" nil t) (point-max)))
-	    (narrow-to-region
-	     (or (search-forward "\n\n" nil t) (point))
-	     (point-max))))
-	(let* ((case-fold-search (not (eq (downcase (symbol-name type))
-					  (symbol-name type))))
-	       (search-func
-		(cond ((memq type '(r R regexp Regexp))
-		       're-search-forward)
-		      ((memq type '(s S string String))
-		       'search-forward)
-		      (t
-		       (error "Invalid match type: %s" type)))))
-	  (goto-char (point-min))
-	  (prog1
-	      (funcall search-func match nil t)
-	    (widen)))))))
+        (when (string= "body" header)
+          (setq handles (gnus-score-decode-text-parts)))
+        (goto-char (point-min))
+        ;; If just parts of the article is to be searched and the
+        ;; backend didn't support partial fetching, we just narrow to
+        ;; the relevant parts.
+        (when ofunc
+          (if (eq ofunc 'gnus-request-head)
+              (narrow-to-region
+               (point)
+               (or (search-forward "\n\n" nil t) (point-max)))
+            (narrow-to-region
+             (or (search-forward "\n\n" nil t) (point))
+             (point-max))))
+        (let* ((case-fold-search (not (eq (downcase (symbol-name type))
+                                          (symbol-name type))))
+               (search-func
+                (cond ((memq type '(r R regexp Regexp))
+                       're-search-forward)
+                      ((memq type '(s S string String))
+                       'search-forward)
+                      (t
+                       (error "Invalid match type: %s" type)))))
+          (goto-char (point-min))
+          (prog1
+              (funcall search-func match nil t)
+            (widen)))
+        (when handles (mm-destroy-parts handles))))))
 
 (provide 'gnus-logic)
 
diff --git a/lisp/gnus/gnus-notifications.el b/lisp/gnus/gnus-notifications.el
index c512995899..5104a56c6e 100644
--- a/lisp/gnus/gnus-notifications.el
+++ b/lisp/gnus/gnus-notifications.el
@@ -29,13 +29,16 @@
 
 ;;; Code:
 
-(require 'notifications nil t)
+(ignore-errors
+  (require 'notifications))
 (require 'gnus-sum)
 (require 'gnus-group)
 (require 'gnus-int)
 (require 'gnus-art)
 (require 'gnus-util)
-(require 'google-contacts nil t)        ; Optional
+(ignore-errors
+  (require 'google-contacts))        ; Optional
+(require 'gnus-fun)
 
 (defgroup gnus-notifications nil
   "Send notifications on new message in Gnus."
@@ -81,12 +84,14 @@ not get notifications."
   "Send a notification about a new mail.
 Return a notification id if any, or t on success."
   (if (fboundp 'notifications-notify)
-      (notifications-notify
+      (gnus-funcall-no-warning
+       'notifications-notify
        :title from
        :body subject
        :actions '("read" "Read")
        :on-action 'gnus-notifications-action
-       :app-icon (image-search-load-path "gnus/gnus.png")
+       :app-icon (gnus-funcall-no-warning
+		  'image-search-load-path "gnus/gnus.png")
        :app-name "Gnus"
        :category "email.arrived"
        :timeout gnus-notifications-timeout
@@ -100,7 +105,8 @@ Return a notification id if any, or t on success."
   (let ((google-photo (when (and gnus-notifications-use-google-contacts
                                  (fboundp 'google-contacts-get-photo))
                         (ignore-errors
-                          (google-contacts-get-photo mail-address)))))
+                          (gnus-funcall-no-warning
+			   'google-contacts-get-photo mail-address)))))
     (if google-photo
         google-photo
       (when gnus-notifications-use-gravatar
@@ -160,8 +166,10 @@ This is typically a function to add in
                                             (or (mail-fetch-field "From") "")))
                        (address (cadr address-components)))
                   ;; Ignore mails from ourselves
-                  (unless (gnus-string-match-p gnus-ignored-from-addresses
-                                               address)
+                  (unless (and gnus-ignored-from-addresses
+                               address
+                               (gnus-string-match-p gnus-ignored-from-addresses
+                                                    address))
                     (let* ((photo-file (gnus-notifications-get-photo-file address))
                            (notification-id (gnus-notifications-notify
                                              (or (car address-components) address)
diff --git a/lisp/gnus/gnus-score.el b/lisp/gnus/gnus-score.el
index f24d889216..f215b84551 100644
--- a/lisp/gnus/gnus-score.el
+++ b/lisp/gnus/gnus-score.el
@@ -1717,105 +1717,140 @@ score in `gnus-newsgroup-scored' by SCORE."
 	  (setq entries rest)))))
   nil)
 
+(defun gnus-score-decode-text-parts ()
+  (labels ((mm-text-parts (handle)
+                        (cond ((stringp (car handle))
+                               (let ((parts (mapcan #'mm-text-parts (cdr handle))))
+                                 (if (equal "multipart/alternative" (car handle))
+                                     ;; pick the first supported alternative
+                                     (list (car parts))
+                                   parts)))
+
+                              ((bufferp (car handle))
+                               (when (string-match "^text/" (mm-handle-media-type handle))
+                                 (list handle)))
+
+                              (t (mapcan #'mm-text-parts handle))))
+           (my-mm-display-part (handle)
+                               (when handle
+                                 (save-restriction
+                                   (narrow-to-region (point) (point))
+                                   (mm-display-inline handle)
+                                   (goto-char (point-max))))))
+
+    (let (;(mm-text-html-renderer 'w3m-standalone)
+          (handles (mm-dissect-buffer t)))
+      (save-excursion
+        (article-goto-body)
+        (delete-region (point) (point-max))
+        (mapc #'my-mm-display-part (mm-text-parts handles))
+        handles))))
+
 (defun gnus-score-body (scores header now expire &optional trace)
-  (if gnus-agent-fetching
-      nil
-    (save-excursion
-      (setq gnus-scores-articles
-	    (sort gnus-scores-articles
-		  (lambda (a1 a2)
-		    (< (mail-header-number (car a1))
-		       (mail-header-number (car a2))))))
-      (set-buffer nntp-server-buffer)
-      (save-restriction
-	(let* ((buffer-read-only nil)
-	       (articles gnus-scores-articles)
-	       (all-scores scores)
-	       (request-func (cond ((string= "head" header)
-				    'gnus-request-head)
-				   ((string= "body" header)
-				    'gnus-request-body)
-				   (t 'gnus-request-article)))
-	       entries alist ofunc article last)
-	  (when articles
-	    (setq last (mail-header-number (caar (last articles))))
-	  ;; Not all backends support partial fetching.  In that case,
-	    ;; we just fetch the entire article.
-	    (unless (gnus-check-backend-function
-		     (and (string-match "^gnus-" (symbol-name request-func))
-			  (intern (substring (symbol-name request-func)
-					     (match-end 0))))
-		     gnus-newsgroup-name)
-	      (setq ofunc request-func)
-	      (setq request-func 'gnus-request-article))
-	    (while articles
-	      (setq article (mail-header-number (caar articles)))
-	      (gnus-message 7 "Scoring article %s of %s..." article last)
-	      (widen)
-	      (when (funcall request-func article gnus-newsgroup-name)
-		(goto-char (point-min))
-	    ;; If just parts of the article is to be searched, but the
-	    ;; backend didn't support partial fetching, we just narrow
-		;; to the relevant parts.
-		(when ofunc
-		  (if (eq ofunc 'gnus-request-head)
-		      (narrow-to-region
-		       (point)
-		       (or (search-forward "\n\n" nil t) (point-max)))
-		    (narrow-to-region
-		     (or (search-forward "\n\n" nil t) (point))
-		     (point-max))))
-		(setq scores all-scores)
-		;; Find matches.
-		(while scores
-		  (setq alist (pop scores)
-			entries (assoc header alist))
-		  (while (cdr entries) ;First entry is the header index.
-		    (let* ((rest (cdr entries))
-			   (kill (car rest))
-			   (match (nth 0 kill))
-			   (type (or (nth 3 kill) 's))
-			   (score (or (nth 1 kill)
-				      gnus-score-interactive-default-score))
-			   (date (nth 2 kill))
-			   (found nil)
-			   (case-fold-search
-			    (not (or (eq type 'R) (eq type 'S)
-				     (eq type 'Regexp) (eq type 'String))))
-			   (search-func
-			    (cond ((or (eq type 'r) (eq type 'R)
-				       (eq type 'regexp) (eq type 'Regexp))
-				   're-search-forward)
-				  ((or (eq type 's) (eq type 'S)
-				       (eq type 'string) (eq type 'String))
-				   'search-forward)
-				  (t
-				   (error "Invalid match type: %s" type)))))
-		      (goto-char (point-min))
-		      (when (funcall search-func match nil t)
-			;; Found a match, update scores.
-			(setcdr (car articles) (+ score (cdar articles)))
-			(setq found t)
-			(when trace
-			  (push
-			   (cons (car-safe (rassq alist gnus-score-cache))
-				 kill)
-			   gnus-score-trace)))
-		      ;; Update expire date
-		      (unless trace
-			(cond
-			 ((null date))	;Permanent entry.
-			 ((and found gnus-update-score-entry-dates)
-			  ;; Match, update date.
-			  (gnus-score-set 'touched '(t) alist)
-			  (setcar (nthcdr 2 kill) now))
-			 ((and expire (< date expire)) ;Old entry, remove.
-			  (gnus-score-set 'touched '(t) alist)
-			  (setcdr entries (cdr rest))
-			  (setq rest entries))))
-		      (setq entries rest)))))
-	      (setq articles (cdr articles)))))))
-    nil))
+    (if gnus-agent-fetching
+       nil
+     (save-excursion
+       (setq gnus-scores-articles
+             (sort gnus-scores-articles
+                   (lambda (a1 a2)
+                     (< (mail-header-number (car a1))
+                        (mail-header-number (car a2))))))
+       (set-buffer nntp-server-buffer)
+       (save-restriction
+         (let* ((buffer-read-only nil)
+                (articles gnus-scores-articles)
+                (all-scores scores)
+                (request-func (cond ((string= "head" header)
+                                     'gnus-request-head)
+                                    ;; We need to peek at the headers to detect
+                                    ;; the content encoding
+                                    ((string= "body" header)
+                                     'gnus-request-article)
+                                    (t 'gnus-request-article)))
+                entries alist ofunc article last)
+           (when articles
+             (setq last (mail-header-number (caar (last articles))))
+             ;; Not all backends support partial fetching.  In that case,
+             ;; we just fetch the entire article.
+             (unless (gnus-check-backend-function
+                      (and (string-match "^gnus-" (symbol-name request-func))
+                           (intern (substring (symbol-name request-func)
+                                              (match-end 0))))
+                      gnus-newsgroup-name)
+               (setq ofunc request-func)
+               (setq request-func 'gnus-request-article))
+             (while articles
+               (setq article (mail-header-number (caar articles)))
+               (gnus-message 7 "Scoring article %s of %s..." article last)
+               (widen)
+               (let (handles)
+                 (when (funcall request-func article gnus-newsgroup-name)
+                  (when (string= "body" header)
+                    (setq handles (gnus-score-decode-text-parts)))
+                  (goto-char (point-min))
+                  ;; If just parts of the article is to be searched, but the
+                  ;; backend didn't support partial fetching, we just narrow
+                  ;; to the relevant parts.
+                  (when ofunc
+                    (if (eq ofunc 'gnus-request-head)
+                        (narrow-to-region
+                         (point)
+                         (or (search-forward "\n\n" nil t) (point-max)))
+                      (narrow-to-region
+                       (or (search-forward "\n\n" nil t) (point))
+                       (point-max))))
+                  (setq scores all-scores)
+                  ;; Find matches.
+                  (while scores
+                    (setq alist (pop scores)
+                          entries (assoc header alist))
+                    (while (cdr entries) ;First entry is the header index.
+                      (let* ((rest (cdr entries))
+                             (kill (car rest))
+                             (match (nth 0 kill))
+                             (type (or (nth 3 kill) 's))
+                             (score (or (nth 1 kill)
+                                        gnus-score-interactive-default-score))
+                             (date (nth 2 kill))
+                             (found nil)
+                             (case-fold-search
+                              (not (or (eq type 'R) (eq type 'S)
+                                       (eq type 'Regexp) (eq type 'String))))
+                             (search-func
+                              (cond ((or (eq type 'r) (eq type 'R)
+                                         (eq type 'regexp) (eq type 'Regexp))
+                                     're-search-forward)
+                                    ((or (eq type 's) (eq type 'S)
+                                         (eq type 'string) (eq type 'String))
+                                     'search-forward)
+                                    (t
+                                     (error "Invalid match type: %s" type)))))
+                        (goto-char (point-min))
+                        (when (funcall search-func match nil t)
+                          ;; Found a match, update scores.
+                          (setcdr (car articles) (+ score (cdar articles)))
+                          (setq found t)
+                          (when trace
+                            (push
+                             (cons (car-safe (rassq alist gnus-score-cache))
+                                   kill)
+                             gnus-score-trace)))
+                        ;; Update expire date
+                        (unless trace
+                          (cond
+                           ((null date)) ;Permanent entry.
+                           ((and found gnus-update-score-entry-dates)
+                            ;; Match, update date.
+                            (gnus-score-set 'touched '(t) alist)
+                            (setcar (nthcdr 2 kill) now))
+                           ((and expire (< date expire)) ;Old entry, remove.
+                            (gnus-score-set 'touched '(t) alist)
+                            (setcdr entries (cdr rest))
+                            (setq rest entries))))
+                        (setq entries rest))))
+                  (when handles (mm-destroy-parts handles))))
+               (setq articles (cdr articles)))))))
+     nil))
 
 (defun gnus-score-thread (scores header now expire &optional trace)
   (gnus-score-followup scores header now expire trace t))
diff --git a/lisp/gnus/gnus-srvr.el b/lisp/gnus/gnus-srvr.el
index 66509c939d..f58cb80311 100644
--- a/lisp/gnus/gnus-srvr.el
+++ b/lisp/gnus/gnus-srvr.el
@@ -490,8 +490,7 @@ The following commands are available:
       (error "No such server: %s" server))
     (gnus-server-set-status method 'ok)
     (prog1
-	(or (gnus-open-server method)
-	    (progn (message "Couldn't open %s" server) nil))
+	(gnus-open-server method)
       (gnus-server-update-server server)
       (gnus-server-position-point))))
 
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index 26178afa86..f5e1077f8c 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -1926,6 +1926,18 @@ Same as `string-match' except this function does not change the match data."
     (save-match-data
       (string-match regexp string start))))
 
+(if (fboundp 'string-prefix-p)
+    (defalias 'gnus-string-prefix-p 'string-prefix-p)
+  (defun gnus-string-prefix-p (str1 str2 &optional ignore-case)
+    "Return non-nil if STR1 is a prefix of STR2.
+If IGNORE-CASE is non-nil, the comparison is done without paying attention
+to case differences."
+    (and (<= (length str1) (length str2))
+	 (let ((prefix (substring str2 0 (length str1))))
+	   (if ignore-case
+	       (string-equal (downcase str1) (downcase prefix))
+	     (string-equal str1 prefix))))))
+
 (eval-and-compile
   (if (fboundp 'macroexpand-all)
       (defalias 'gnus-macroexpand-all 'macroexpand-all)
@@ -1952,6 +1964,11 @@ definitions to shadow the loaded ones for use in file byte-compilation."
 (defun gnus-bound-and-true-p (sym)
   (and (boundp sym) (symbol-value sym)))
 
+(if (fboundp 'timer--function)
+    (defalias 'gnus-timer--function 'timer--function)
+  (defun gnus-timer--function (timer)
+    (elt timer 5)))
+
 (provide 'gnus-util)
 
 ;;; gnus-util.el ends here
diff --git a/lisp/gnus/gnus.el b/lisp/gnus/gnus.el
index 5862e7807a..8fbde5c8ec 100644
--- a/lisp/gnus/gnus.el
+++ b/lisp/gnus/gnus.el
@@ -3824,12 +3824,28 @@ You should probably use `gnus-find-method-for-group' instead."
   "Go through PARAMETERS and expand them according to the match data."
   (let (new)
     (dolist (elem parameters)
-      (if (and (stringp (cdr elem))
-	       (string-match "\\\\[0-9&]" (cdr elem)))
-	  (push (cons (car elem)
-		      (gnus-expand-group-parameter match (cdr elem) group))
-		new)
-	(push elem new)))
+      (cond
+       ((and (stringp (cdr elem))
+             (string-match "\\\\[0-9&]" (cdr elem)))
+        (push (cons (car elem)
+                    (gnus-expand-group-parameter match (cdr elem) group))
+              new))
+       ;; For `sieve' group parameters, perform substitutions for every
+       ;; string within the match rule.  This allows for parameters such
+       ;; as:
+       ;;  ("list\\.\\(.*\\)"
+       ;;   (sieve header :is "list-id" "<\\1.domain.org>"))
+       ((eq 'sieve (car elem))
+        (push (mapcar (lambda (sieve-elem)
+                        (if (and (stringp sieve-elem)
+                                 (string-match "\\\\[0-9&]" sieve-elem))
+                            (gnus-expand-group-parameter match sieve-elem
+                                                         group)
+                          sieve-elem))
+                      (cdr elem))
+              new))
+       (t
+	(push elem new))))
     new))
 
 (defun gnus-group-fast-parameter (group symbol &optional allow-list)
@@ -3861,9 +3877,20 @@ The function `gnus-group-find-parameter' will do that for you."
 	      (when this-result
 		(setq result (car this-result))
 		;; Expand if necessary.
-		(if (and (stringp result) (string-match "\\\\[0-9&]" result))
-		    (setq result (gnus-expand-group-parameter
-				  (car head) result group)))))))
+		(cond
+                 ((and (stringp result) (string-match "\\\\[0-9&]" result))
+                  (setq result (gnus-expand-group-parameter
+                                (car head) result group)))
+                 ;; For `sieve' group parameters, perform substitutions
+                 ;; for every string within the match rule (see above).
+                 ((eq symbol 'sieve)
+                  (setq result
+                        (mapcar (lambda (elem)
+                                  (if (stringp elem)
+                                      (gnus-expand-group-parameter (car head)
+                                                                   elem group)
+                                    elem))
+                                result))))))))
 	;; Done.
 	result))))
 
diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index 18088423eb..42911ce064 100644
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -3292,11 +3292,33 @@ or in the synonym headers, defined by `message-header-synonyms'."
 (defun message-insert-newsgroups ()
   "Insert the Newsgroups header from the article being replied to."
   (interactive)
-  (when (and (message-position-on-field "Newsgroups")
-	     (mail-fetch-field "newsgroups")
-	     (not (string-match "\\` *\\'" (mail-fetch-field "newsgroups"))))
-    (insert ","))
-  (insert (or (message-fetch-reply-field "newsgroups") "")))
+  (let ((old-newsgroups (mail-fetch-field "newsgroups"))
+	(new-newsgroups (message-fetch-reply-field "newsgroups"))
+	(first t)
+	insert-newsgroups)
+    (message-position-on-field "Newsgroups")
+    (cond
+     ((not new-newsgroups)
+      (error "No Newsgroups to insert"))
+     ((not old-newsgroups)
+      (insert new-newsgroups))
+     (t
+      (setq new-newsgroups (split-string new-newsgroups "[, ]+")
+	    old-newsgroups (split-string old-newsgroups "[, ]+"))
+      (dolist (group new-newsgroups)
+	(unless (member group old-newsgroups)
+	  (push group insert-newsgroups)))
+      (if (null insert-newsgroups)
+	  (error "Newgroup%s already in the header"
+		 (if (> (length new-newsgroups) 1)
+		     "s" ""))
+	(when old-newsgroups
+	  (setq first nil))
+	(dolist (group insert-newsgroups)
+	  (unless first
+	    (insert ","))
+	  (setq first nil)
+	  (insert group)))))))
 
 
 
diff --git a/lisp/gnus/nnmaildir.el b/lisp/gnus/nnmaildir.el
index 7139a528e1..74a693a9c6 100644
--- a/lisp/gnus/nnmaildir.el
+++ b/lisp/gnus/nnmaildir.el
@@ -77,6 +77,56 @@
 
 (defconst nnmaildir-version "Gnus")
 
+(defconst nnmaildir-flag-mark-mapping
+  '((?F . tick)
+    (?R . reply)
+    (?S . read))
+  "Alist mapping Maildir filename flags to Gnus marks.
+Maildir filenames are of the form \"unique-id:2,FLAGS\",
+where FLAGS are a string of characters in ASCII order.
+Some of the FLAGS correspond to Gnus marks.")
+
+(defsubst nnmaildir--mark-to-flag (mark)
+  "Find the Maildir flag that corresponds to MARK (an atom).
+Return a character, or `nil' if not found.
+See `nnmaildir-flag-mark-mapping'."
+  (car (rassq mark nnmaildir-flag-mark-mapping)))
+
+(defsubst nnmaildir--flag-to-mark (flag)
+  "Find the Gnus mark that corresponds to FLAG (a character).
+Return an atom, or `nil' if not found.
+See `nnmaildir-flag-mark-mapping'."
+  (cdr (assq flag nnmaildir-flag-mark-mapping)))
+
+(defun nnmaildir--ensure-suffix (filename)
+  "Ensure that FILENAME contains the suffix \":2,\"."
+  (if (gnus-string-match-p ":2," filename)
+      filename
+    (concat filename ":2,")))
+
+(defun nnmaildir--add-flag (flag suffix)
+  "Return a copy of SUFFIX where FLAG is set.
+SUFFIX should start with \":2,\"."
+  (unless (gnus-string-match-p "^:2," suffix)
+    (error "Invalid suffix `%s'" suffix))
+  (let* ((flags (substring suffix 3))
+	 (flags-as-list (append flags nil))
+	 (new-flags
+	  (concat (gnus-delete-duplicates
+		   ;; maildir flags must be sorted
+		   (sort (cons flag flags-as-list) '<)))))
+    (concat ":2," new-flags)))
+
+(defun nnmaildir--remove-flag (flag suffix)
+  "Return a copy of SUFFIX where FLAG is cleared.
+SUFFIX should start with \":2,\"."
+  (unless (gnus-string-match-p "^:2," suffix)
+    (error "Invalid suffix `%s'" suffix))
+  (let* ((flags (substring suffix 3))
+	 (flags-as-list (append flags nil))
+	 (new-flags (concat (delq flag flags-as-list))))
+    (concat ":2," new-flags)))
+
 (defvar nnmaildir-article-file-name nil
   "*The filename of the most recently requested article.  This variable is set
 by nnmaildir-request-article.")
@@ -152,6 +202,16 @@ by nnmaildir-request-article.")
   (gnm        	 nil)                      ;; flag: split from mail-sources?
   (target-prefix nil :type string))        ;; symlink target prefix
 
+(defun nnmaildir--article-set-flags (article new-suffix curdir)
+  (let* ((prefix (nnmaildir--art-prefix article))
+	 (suffix (nnmaildir--art-suffix article))
+	 (article-file (concat curdir prefix suffix))
+	 (new-name (concat curdir prefix new-suffix)))
+    (unless (file-exists-p article-file)
+      (error "Couldn't find article file %s" article-file))
+    (rename-file article-file new-name 'replace)
+    (setf (nnmaildir--art-suffix article) new-suffix)))
+
 (defun nnmaildir--expired-article (group article)
   (setf (nnmaildir--art-nov article) nil)
   (let ((flist  (nnmaildir--grp-flist group))
@@ -208,29 +268,33 @@ by nnmaildir-request-article.")
   (eval param))
 
 (defmacro nnmaildir--with-nntp-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer nntp-server-buffer
      ,@body))
 (defmacro nnmaildir--with-work-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir work*")
      ,@body))
 (defmacro nnmaildir--with-nov-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir nov*")
      ,@body))
 (defmacro nnmaildir--with-move-buffer (&rest body)
+  (declare (debug (body)))
   `(with-current-buffer (get-buffer-create " *nnmaildir move*")
      ,@body))
 
-(defmacro nnmaildir--subdir (dir subdir)
-  `(file-name-as-directory (concat ,dir ,subdir)))
-(defmacro nnmaildir--srvgrp-dir (srv-dir gname)
-  `(nnmaildir--subdir ,srv-dir ,gname))
-(defmacro nnmaildir--tmp       (dir) `(nnmaildir--subdir ,dir "tmp"))
-(defmacro nnmaildir--new       (dir) `(nnmaildir--subdir ,dir "new"))
-(defmacro nnmaildir--cur       (dir) `(nnmaildir--subdir ,dir "cur"))
-(defmacro nnmaildir--nndir     (dir) `(nnmaildir--subdir ,dir ".nnmaildir"))
-(defmacro nnmaildir--nov-dir   (dir) `(nnmaildir--subdir ,dir "nov"))
-(defmacro nnmaildir--marks-dir (dir) `(nnmaildir--subdir ,dir "marks"))
-(defmacro nnmaildir--num-dir   (dir) `(nnmaildir--subdir ,dir "num"))
+(defsubst nnmaildir--subdir (dir subdir)
+  (file-name-as-directory (concat dir subdir)))
+(defsubst nnmaildir--srvgrp-dir (srv-dir gname)
+  (nnmaildir--subdir srv-dir gname))
+(defsubst nnmaildir--tmp       (dir) (nnmaildir--subdir dir "tmp"))
+(defsubst nnmaildir--new       (dir) (nnmaildir--subdir dir "new"))
+(defsubst nnmaildir--cur       (dir) (nnmaildir--subdir dir "cur"))
+(defsubst nnmaildir--nndir     (dir) (nnmaildir--subdir dir ".nnmaildir"))
+(defsubst nnmaildir--nov-dir   (dir) (nnmaildir--subdir dir "nov"))
+(defsubst nnmaildir--marks-dir (dir) (nnmaildir--subdir dir "marks"))
+(defsubst nnmaildir--num-dir   (dir) (nnmaildir--subdir dir "num"))
 
 (defmacro nnmaildir--unlink (file-arg)
   `(let ((file ,file-arg))
@@ -305,6 +369,7 @@ by nnmaildir-request-article.")
   string)
 
 (defmacro nnmaildir--condcase (errsym body &rest handler)
+  (declare (debug (sexp form body)))
   `(condition-case ,errsym
        (let ((system-messages-locale "C")) ,body)
      (error . ,handler)))
@@ -759,7 +824,7 @@ by nnmaildir-request-article.")
 	  (dolist (file  (funcall ls ndir nil "\\`[^.]" 'nosort))
 	    (setq x (concat ndir file))
 	    (and (time-less-p (nth 5 (file-attributes x)) (current-time))
-		 (rename-file x (concat cdir file ":2,"))))
+		 (rename-file x (concat cdir (nnmaildir--ensure-suffix file)))))
 	  (setf (nnmaildir--grp-new group) nattr))
 	(setq cattr (nth 5 (file-attributes cdir)))
 	(if (equal cattr (nnmaildir--grp-cur group))
@@ -784,11 +849,23 @@ by nnmaildir-request-article.")
 		cdir (nnmaildir--marks-dir nndir)
 		ndir (nnmaildir--subdir cdir "tick")
 		cdir (nnmaildir--subdir cdir "read"))
-	  (dolist (file files)
-	    (setq file (car file))
-	    (if (or (not (file-exists-p (concat cdir file)))
-		    (file-exists-p (concat ndir file)))
-		(setq num (1+ num)))))
+	  (dolist (prefix-suffix files)
+	    (let ((prefix (car prefix-suffix))
+		  (suffix (cdr prefix-suffix)))
+	      ;; increase num for each unread or ticked article
+	      (when (or
+		     ;; first look for marks in suffix, if it's valid...
+		     (when (and (stringp suffix)
+				(gnus-string-prefix-p ":2," suffix))
+		       (or
+			(not (gnus-string-match-p
+			      (string (nnmaildir--mark-to-flag 'read)) suffix))
+			(gnus-string-match-p
+			 (string (nnmaildir--mark-to-flag 'tick)) suffix)))
+		     ;; then look in marks directories
+		     (not (file-exists-p (concat cdir prefix)))
+		     (file-exists-p (concat ndir prefix)))
+		(incf num)))))
 	(setf (nnmaildir--grp-cache group) (make-vector num nil))
         (let ((inhibit-quit t))
           (set (intern gname groups) group))
@@ -916,12 +993,15 @@ by nnmaildir-request-article.")
 		  "\n")))))
   'group)
 
-(defun nnmaildir-request-marks (gname info &optional server)
-  (let ((group (nnmaildir--prepare server gname))
-	pgname flist always-marks never-marks old-marks dotfile num dir
-	markdirs marks mark ranges markdir article read end new-marks ls
-	old-mmth new-mmth mtime mark-sym existing missing deactivate-mark
-	article-list)
+(defun nnmaildir-request-update-info (gname info &optional server)
+  (let* ((group (nnmaildir--prepare server gname))
+	 (curdir (nnmaildir--cur
+		  (nnmaildir--srvgrp-dir
+		   (nnmaildir--srv-dir nnmaildir--cur-server) gname)))
+	 (curdir-mtime (nth 5 (file-attributes curdir)))
+	 pgname flist always-marks never-marks old-marks dotfile num dir
+	 all-marks marks mark ranges markdir read end new-marks ls
+	 old-mmth new-mmth mtime mark-sym existing missing deactivate-mark)
     (catch 'return
       (unless group
 	(setf (nnmaildir--srv-error nnmaildir--cur-server)
@@ -950,34 +1030,71 @@ by nnmaildir-request-article.")
 	    dir (nnmaildir--nndir dir)
 	    dir (nnmaildir--marks-dir dir)
             ls (nnmaildir--group-ls nnmaildir--cur-server pgname)
-	    markdirs (funcall ls dir nil "\\`[^.]" 'nosort)
-	    new-mmth (nnmaildir--up2-1 (length markdirs))
+	    all-marks (gnus-delete-duplicates
+		       ;; get mark names from mark dirs and from flag
+		       ;; mappings
+		       (append
+			(mapcar 'cdr nnmaildir-flag-mark-mapping)
+			(mapcar 'intern (funcall ls dir nil "\\`[^.]" 'nosort))))
+	    new-mmth (nnmaildir--up2-1 (length all-marks))
 	    new-mmth (make-vector new-mmth 0)
 	    old-mmth (nnmaildir--grp-mmth group))
-      (dolist (mark markdirs)
-	(setq markdir (nnmaildir--subdir dir mark)
-	      mark-sym (intern mark)
+      (dolist (mark all-marks)
+	(setq markdir (nnmaildir--subdir dir (symbol-name mark))
 	      ranges nil)
 	(catch 'got-ranges
-	  (if (memq mark-sym never-marks) (throw 'got-ranges nil))
-	  (when (memq mark-sym always-marks)
+	  (if (memq mark never-marks) (throw 'got-ranges nil))
+	  (when (memq mark always-marks)
 	    (setq ranges existing)
 	    (throw 'got-ranges nil))
-	  (setq mtime (nth 5 (file-attributes markdir)))
-	  (set (intern mark new-mmth) mtime)
-	  (when (equal mtime (symbol-value (intern-soft mark old-mmth)))
-	    (setq ranges (assq mark-sym old-marks))
+	  ;; Find the mtime for this mark.  If this mark can be expressed as
+	  ;; a filename flag, get the later of the mtimes for markdir and
+	  ;; curdir, otherwise only the markdir counts.
+	  (setq mtime
+		(let ((markdir-mtime (nth 5 (file-attributes markdir))))
+		  (cond
+		   ((null (nnmaildir--mark-to-flag mark))
+		    markdir-mtime)
+		   ((null markdir-mtime)
+		    curdir-mtime)
+		   ((null curdir-mtime)
+		    ;; this should never happen...
+		    markdir-mtime)
+		   ((time-less-p markdir-mtime curdir-mtime)
+		    curdir-mtime)
+		   (t
+		    markdir-mtime))))
+	  (set (intern (symbol-name mark) new-mmth) mtime)
+	  (when (equal mtime (symbol-value (intern-soft (symbol-name mark) old-mmth)))
+	    (setq ranges (assq mark old-marks))
 	    (if ranges (setq ranges (cdr ranges)))
 	    (throw 'got-ranges nil))
-	  (setq article-list nil)
-	  (dolist (prefix (funcall ls markdir nil "\\`[^.]" 'nosort))
-	    (setq article (nnmaildir--flist-art flist prefix))
-	    (if article
-		(setq article-list
-		      (cons (nnmaildir--art-num article) article-list))))
-	  (setq ranges (gnus-add-to-range ranges (sort article-list '<))))
-	(if (eq mark-sym 'read) (setq read ranges)
-	  (if ranges (setq marks (cons (cons mark-sym ranges) marks)))))
+	  (let ((article-list nil))
+	    ;; Consider the article marked if it either has the flag in the
+	    ;; filename, or is in the markdir.  As you'd rarely remove a
+	    ;; flag/mark, this should avoid losing information in the most
+	    ;; common usage pattern.
+	    (or
+	     (let ((flag (nnmaildir--mark-to-flag mark)))
+	       ;; If this mark has a corresponding maildir flag...
+	       (when flag
+		 (let ((regexp
+			(concat "\\`[^.].*:2,[A-Z]*" (string flag))))
+		   ;; ...then find all files with that flag.
+		   (dolist (filename (funcall ls curdir nil regexp 'nosort))
+		     (let* ((prefix (car (split-string filename ":2,")))
+			    (article (nnmaildir--flist-art flist prefix)))
+		       (when article
+			 (push (nnmaildir--art-num article) article-list)))))))
+	     ;; Also check Gnus-specific mark directory, if it exists.
+	     (when (file-directory-p markdir)
+	       (dolist (prefix (funcall ls markdir nil "\\`[^.]" 'nosort))
+		 (let ((article (nnmaildir--flist-art flist prefix)))
+		   (when article
+		     (push (nnmaildir--art-num article) article-list))))))
+	    (setq ranges (gnus-add-to-range ranges (sort article-list '<)))))
+	(if (eq mark 'read) (setq read ranges)
+	  (if ranges (setq marks (cons (cons mark ranges) marks)))))
       (gnus-info-set-read info (gnus-range-add read missing))
       (gnus-info-set-marks info marks 'extend)
       (setf (nnmaildir--grp-mmth group) new-mmth)
@@ -1525,39 +1642,63 @@ by nnmaildir-request-article.")
       didnt)))
 
 (defun nnmaildir-request-set-mark (gname actions &optional server)
-  (let ((group (nnmaildir--prepare server gname))
-	(coding-system-for-write nnheader-file-coding-system)
-	(buffer-file-coding-system nil)
-	(file-coding-system-alist nil)
-	del-mark del-action add-action set-action marksdir nlist
-	ranges begin end article all-marks todo-marks mdir mfile
-	pgname ls permarkfile deactivate-mark)
+  (let* ((group (nnmaildir--prepare server gname))
+	 (curdir (nnmaildir--cur
+		  (nnmaildir--srvgrp-dir
+		   (nnmaildir--srv-dir nnmaildir--cur-server)
+		   gname)))
+	 (coding-system-for-write nnheader-file-coding-system)
+	 (buffer-file-coding-system nil)
+	 (file-coding-system-alist nil)
+	 del-mark del-action add-action set-action marksdir nlist
+	 ranges begin end article all-marks todo-marks mdir mfile
+	 pgname ls permarkfile deactivate-mark)
     (setq del-mark
 	  (lambda (mark)
-	    (setq mfile (nnmaildir--subdir marksdir (symbol-name mark))
-		  mfile (concat mfile (nnmaildir--art-prefix article)))
-	    (nnmaildir--unlink mfile))
+	    (let ((prefix (nnmaildir--art-prefix article))
+		  (suffix (nnmaildir--art-suffix article))
+		  (flag (nnmaildir--mark-to-flag mark)))
+	      (when flag
+		;; If this mark corresponds to a flag, remove the flag from
+		;; the file name.
+		(nnmaildir--article-set-flags
+		 article (nnmaildir--remove-flag flag suffix) curdir))
+	      ;; We still want to delete the hardlink in the marks dir if
+	      ;; present, regardless of whether this mark has a maildir flag or
+	      ;; not, to avoid getting out of sync.
+	      (setq mfile (nnmaildir--subdir marksdir (symbol-name mark))
+		    mfile (concat mfile prefix))
+	      (nnmaildir--unlink mfile)))
 	  del-action (lambda (article) (mapcar del-mark todo-marks))
 	  add-action
 	  (lambda (article)
 	    (mapcar
 	     (lambda (mark)
-	       (setq mdir (nnmaildir--subdir marksdir (symbol-name mark))
-		     permarkfile (concat mdir ":")
-		     mfile (concat mdir (nnmaildir--art-prefix article)))
-	       (nnmaildir--condcase err (add-name-to-file permarkfile mfile)
-		 (cond
-		  ((nnmaildir--eexist-p err))
-		  ((nnmaildir--enoent-p err)
-		   (nnmaildir--mkdir mdir)
-		   (nnmaildir--mkfile permarkfile)
-		   (add-name-to-file permarkfile mfile))
-		  ((nnmaildir--emlink-p err)
-		   (let ((permarkfilenew (concat permarkfile "{new}")))
-		     (nnmaildir--mkfile permarkfilenew)
-		     (rename-file permarkfilenew permarkfile 'replace)
-		     (add-name-to-file permarkfile mfile)))
-		  (t (signal (car err) (cdr err))))))
+	       (let ((prefix (nnmaildir--art-prefix article))
+		     (suffix (nnmaildir--art-suffix article))
+		     (flag (nnmaildir--mark-to-flag mark)))
+		 (if flag
+		     ;; If there is a corresponding maildir flag, just rename
+		     ;; the file.
+		     (nnmaildir--article-set-flags
+		      article (nnmaildir--add-flag flag suffix) curdir)
+		   ;; Otherwise, use nnmaildir-specific marks dir.
+		   (setq mdir (nnmaildir--subdir marksdir (symbol-name mark))
+			 permarkfile (concat mdir ":")
+			 mfile (concat mdir prefix))
+		   (nnmaildir--condcase err (add-name-to-file permarkfile mfile)
+		     (cond
+		      ((nnmaildir--eexist-p err))
+		      ((nnmaildir--enoent-p err)
+		       (nnmaildir--mkdir mdir)
+		       (nnmaildir--mkfile permarkfile)
+		       (add-name-to-file permarkfile mfile))
+		      ((nnmaildir--emlink-p err)
+		       (let ((permarkfilenew (concat permarkfile "{new}")))
+			 (nnmaildir--mkfile permarkfilenew)
+			 (rename-file permarkfilenew permarkfile 'replace)
+			 (add-name-to-file permarkfile mfile)))
+		      (t (signal (car err) (cdr err))))))))
 	     todo-marks))
 	  set-action (lambda (article)
 		       (funcall add-action article)
@@ -1581,7 +1722,12 @@ by nnmaildir-request-article.")
             pgname (nnmaildir--pgname nnmaildir--cur-server gname)
             ls (nnmaildir--group-ls nnmaildir--cur-server pgname)
 	    all-marks (funcall ls marksdir nil "\\`[^.]" 'nosort)
-	    all-marks (mapcar 'intern all-marks))
+	    all-marks (gnus-delete-duplicates
+		       ;; get mark names from mark dirs and from flag
+		       ;; mappings
+		       (append
+			(mapcar 'cdr nnmaildir-flag-mark-mapping)
+			(mapcar 'intern all-marks))))
       (dolist (action actions)
 	(setq ranges (car action)
 	      todo-marks (caddr action))
diff --git a/lisp/gnus/qp.el b/lisp/gnus/qp.el
index 87252684a4..c4487c68b5 100644
--- a/lisp/gnus/qp.el
+++ b/lisp/gnus/qp.el
@@ -53,10 +53,7 @@ them into characters should be done separately."
       ;; or both of which are lowercase letters in "abcdef", is
       ;; formally illegal. A robust implementation might choose to
       ;; recognize them as the corresponding uppercase letters.''
-      (let ((case-fold-search t)
-	    (decode-hex #'(lambda (n1 n2)
-			    (+ (* (if (<= n1 ?9) (- n1 ?0) (+ (- n1 ?A) 10)) 16)
-			       (if (<= n2 ?9) (- n2 ?0) (+ (- n2 ?A) 10))))))
+      (let ((case-fold-search t))
 	(narrow-to-region from to)
 	;; Do this in case we're called from Gnus, say, in a buffer
 	;; which already contains non-ASCII characters which would
@@ -74,8 +71,15 @@ them into characters should be done separately."
 		 (let* ((n (/ (- (match-end 0) (point)) 3))
 			(str (make-string n 0)))
 		   (dotimes (i n)
-		     (aset str i (funcall decode-hex (char-after (1+ (point)))
-					  (char-after (+ 2 (point)))))
+                     (let ((n1 (char-after (1+ (point))))
+                           (n2 (char-after (+ 2 (point)))))
+                       (aset str i
+                             (+ (* 16 (- n1 (if (<= n1 ?9) ?0
+                                              (if (<= n1 ?F) (- ?A 10)
+                                                (- ?a 10)))))
+                                (- n2 (if (<= n2 ?9) ?0
+                                        (if (<= n2 ?F) (- ?A 10)
+                                          (- ?a 10)))))))
 		     (forward-char 3))
 		   (delete-region (match-beginning 0) (match-end 0))
 		   (insert str)))
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index 5791f1225c..fa0484ff4e 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -936,7 +936,7 @@ file-local variable.\n")
 		(princ "  This variable is safe as a file local variable ")
 		(princ "if its value\n  satisfies the predicate ")
 		(princ (if (byte-code-function-p safe-var)
-			   "which is byte-compiled expression.\n"
+			   "which is a byte-compiled expression.\n"
 			 (format "`%s'.\n" safe-var))))
 
               (if extra-line (terpri))
diff --git a/lisp/help.el b/lisp/help.el
index 19db7c255d..da11389d87 100644
--- a/lisp/help.el
+++ b/lisp/help.el
@@ -39,9 +39,10 @@
 ;; `help-window-point-marker' is a marker you can move to a valid
 ;; position of the buffer shown in the help window in order to override
 ;; the standard positioning mechanism (`point-min') chosen by
-;; `with-output-to-temp-buffer'.  `with-help-window' has this point
-;; nowhere before exiting.  Currently used by `view-lossage' to assert
-;; that the last keystrokes are always visible.
+;; `with-output-to-temp-buffer' and `with-temp-buffer-window'.
+;; `with-help-window' has this point nowhere before exiting.  Currently
+;; used by `view-lossage' to assert that the last keystrokes are always
+;; visible.
 (defvar help-window-point-marker (make-marker)
   "Marker to override default `window-point' in help windows.")
 
@@ -584,6 +585,8 @@ temporarily enables it to allow getting help on disabled items and buttons."
 	     (setq saved-yank-menu (copy-sequence yank-menu))
 	     (menu-bar-update-yank-menu "(any string)" nil))
 	   (setq key (read-key-sequence "Describe key (or click or menu item): "))
+	   ;; Clear the echo area message (Bug#7014).
+	   (message nil)
 	   ;; If KEY is a down-event, read and discard the
 	   ;; corresponding up-event.  Note that there are also
 	   ;; down-events on scroll bars and mode lines: the actual
@@ -961,7 +964,11 @@ is currently activated with completion."
     result))
 
 ;;; Automatic resizing of temporary buffers.
-(defcustom temp-buffer-max-height (lambda (buffer) (/ (- (frame-height) 2) 2))
+(defcustom temp-buffer-max-height
+  (lambda (buffer)
+    (if (eq (selected-window) (frame-root-window))
+	(/ (x-display-pixel-height) (frame-char-height) 2)
+      (/ (- (frame-height) 2) 2)))
   "Maximum height of a window displaying a temporary buffer.
 This is effective only when Temp Buffer Resize mode is enabled.
 The value is the maximum height (in lines) which
@@ -972,16 +979,25 @@ buffer, and should return a positive integer.  At the time the
 function is called, the window to be resized is selected."
   :type '(choice integer function)
   :group 'help
-  :version "20.4")
+  :version "24.2")
+
+(defcustom temp-buffer-resize-frames nil
+  "Non-nil means `temp-buffer-resize-mode' can resize frames.
+A frame can be resized if and only if its root window is a live
+window.  The height of the root window is subject to the values of
+`temp-buffer-max-height' and `window-min-height'."
+  :type 'boolean
+  :version "24.2"
+  :group 'help)
 
 (define-minor-mode temp-buffer-resize-mode
-  "Toggle auto-shrinking temp buffer windows (Temp Buffer Resize mode).
+  "Toggle auto-resizing temporary buffer windows (Temp Buffer Resize Mode).
 With a prefix argument ARG, enable Temp Buffer Resize mode if ARG
 is positive, and disable it otherwise.  If called from Lisp,
 enable the mode if ARG is omitted or nil.
 
 When Temp Buffer Resize mode is enabled, the windows in which we
-show a temporary buffer are automatically reduced in height to
+show a temporary buffer are automatically resized in height to
 fit the buffer's contents, but never more than
 `temp-buffer-max-height' nor less than `window-min-height'.
 
@@ -994,19 +1010,34 @@ and some others."
       (add-hook 'temp-buffer-show-hook 'resize-temp-buffer-window 'append)
     (remove-hook 'temp-buffer-show-hook 'resize-temp-buffer-window)))
 
-(defun resize-temp-buffer-window ()
-  "Resize the selected window to fit its contents.
-Will not make it higher than `temp-buffer-max-height' nor smaller
-than `window-min-height'.  Do nothing if the selected window is
-not vertically combined or some of its contents are scrolled out
-of view."
-  (when (and (pos-visible-in-window-p (point-min))
-	     (window-combined-p))
-    (fit-window-to-buffer
-     nil
-     (if (functionp temp-buffer-max-height)
-	 (funcall temp-buffer-max-height (window-buffer))
-       temp-buffer-max-height))))
+(defun resize-temp-buffer-window (&optional window)
+  "Resize WINDOW to fit its contents.
+WINDOW can be any live window and defaults to the selected one.
+
+Do not make WINDOW higher than `temp-buffer-max-height' nor
+smaller than `window-min-height'.  Do nothing if WINDOW is not
+vertically combined or some of its contents are scrolled out of
+view."
+  (setq window (window-normalize-window window t))
+  (let ((height (if (functionp temp-buffer-max-height)
+		    (with-selected-window window
+		      (funcall temp-buffer-max-height (window-buffer)))
+		  temp-buffer-max-height)))
+    (cond
+     ((and (pos-visible-in-window-p (point-min) window)
+	   (window-combined-p window))
+      (fit-window-to-buffer window height))
+     ((and temp-buffer-resize-frames
+	   (eq window (frame-root-window window))
+	   (memq (car (window-parameter window 'quit-restore))
+		 ;; If 'same is too strong, we might additionally check
+		 ;; whether the second element is 'frame.
+		 '(same frame)))
+      (let ((frame (window-frame window)))
+	(fit-frame-to-buffer
+	 frame (+ (frame-height frame)
+		  (- (window-total-size window))
+		  height)))))))
 
 ;;; Help windows.
 (defcustom help-window-select 'other
diff --git a/lisp/hi-lock.el b/lisp/hi-lock.el
index 644024a4b8..f92e2ab0af 100644
--- a/lisp/hi-lock.el
+++ b/lisp/hi-lock.el
@@ -52,14 +52,14 @@
 ;;
 ;;  Setup:
 ;;
-;;    Put the following code in your .emacs file.  This turns on
+;;    Put the following code in your init file.  This turns on
 ;;    hi-lock mode and adds a "Regexp Highlighting" entry
 ;;    to the edit menu.
 ;;
 ;;    (global-hi-lock-mode 1)
 ;;
 ;;    To enable the use of patterns found in files (presumably placed
-;;    there by hi-lock) include the following in your .emacs file:
+;;    there by hi-lock) include the following in your init file:
 ;;
 ;;    (setq hi-lock-file-patterns-policy 'ask)
 ;;
@@ -356,7 +356,7 @@ Hi-lock: end is found.  A mode is excluded if it's in the list
        "Possible archaic use of (hi-lock-mode).
 Use (global-hi-lock-mode 1) in .emacs to enable hi-lock for all buffers,
 use (hi-lock-mode 1) for individual buffers.  For compatibility with Emacs
-versions before 22 use the following in your .emacs file:
+versions before 22 use the following in your init file:
 
         (if (functionp 'global-hi-lock-mode)
             (global-hi-lock-mode 1)
diff --git a/lisp/ibuffer.el b/lisp/ibuffer.el
index c6e799252a..7746146904 100644
--- a/lisp/ibuffer.el
+++ b/lisp/ibuffer.el
@@ -123,13 +123,13 @@ own!):
   no upper limit on its size.  The size will also be aligned to the
   right.
 
-Thus, if you wanted to use these two formats, add
+Thus, if you wanted to use these two formats, the appropriate
+value for this variable would be
 
- (setq ibuffer-formats '((mark \" \" name)
-		         (mark modified read-only
-			  (name 16 16 :left) (size 6 -1 :right))))
-
-to your ~/.emacs file.
+  '((mark \" \" name)
+    (mark modified read-only
+          (name 16 16 :left)
+          (size 6 -1 :right)))
 
 Using \\[ibuffer-switch-format], you can rotate the display between
 the specified formats in the list."
diff --git a/lisp/ielm.el b/lisp/ielm.el
index c93f235d81..ba05bbcfc0 100644
--- a/lisp/ielm.el
+++ b/lisp/ielm.el
@@ -59,7 +59,7 @@ override the read-only-ness of IELM prompts is to call
 `comint-kill-whole-line' or `comint-kill-region' with no
 narrowing in effect.  This way you will be certain that none of
 the remaining prompts will be accidentally messed up.  You may
-wish to put something like the following in your `.emacs' file:
+wish to put something like the following in your init file:
 
 \(add-hook 'ielm-mode-hook
 	  (lambda ()
diff --git a/lisp/image.el b/lisp/image.el
index 7801923c3f..99c0a74a51 100644
--- a/lisp/image.el
+++ b/lisp/image.el
@@ -645,8 +645,8 @@ number, play until that number of seconds has elapsed."
     (while tail
       (setq timer (car tail)
 	    tail (cdr tail))
-      (if (and (eq (aref timer 5) 'image-animate-timeout)
-	       (eq (car-safe (aref timer 6)) image))
+      (if (and (eq (timer--function timer) 'image-animate-timeout)
+	       (eq (car-safe (timer--args timer)) image))
 	  (setq tail nil)
 	(setq timer nil)))
     timer))
diff --git a/lisp/info.el b/lisp/info.el
index fe4afd7216..5862e5e850 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -1882,9 +1882,7 @@ If DIRECTION is `backward', search in the reverse direction."
 	  (while (and (not give-up)
 		      (or (null found)
 			  (not (funcall isearch-filter-predicate beg-found found))))
-	    (let ((search-spaces-regexp
-		   (if (or (not isearch-mode) isearch-regexp)
-		       Info-search-whitespace-regexp)))
+	    (let ((search-spaces-regexp Info-search-whitespace-regexp))
 	      (if (if backward
 		      (re-search-backward regexp bound t)
 		    (re-search-forward regexp bound t))
@@ -1904,9 +1902,7 @@ If DIRECTION is `backward', search in the reverse direction."
 	  (if (null Info-current-subfile)
 	      (if isearch-mode
 		  (signal 'search-failed (list regexp "end of manual"))
-		(let ((search-spaces-regexp
-		       (if (or (not isearch-mode) isearch-regexp)
-			   Info-search-whitespace-regexp)))
+		(let ((search-spaces-regexp Info-search-whitespace-regexp))
 		  (if backward
 		      (re-search-backward regexp)
 		    (re-search-forward regexp))))
@@ -1964,9 +1960,7 @@ If DIRECTION is `backward', search in the reverse direction."
 		(while (and (not give-up)
 			    (or (null found)
 				(not (funcall isearch-filter-predicate beg-found found))))
-		  (let ((search-spaces-regexp
-			 (if (or (not isearch-mode) isearch-regexp)
-			     Info-search-whitespace-regexp)))
+		  (let ((search-spaces-regexp Info-search-whitespace-regexp))
 		    (if (if backward
 			    (re-search-backward regexp nil t)
 			  (re-search-forward regexp nil t))
@@ -2034,21 +2028,26 @@ If DIRECTION is `backward', search in the reverse direction."
 (defun Info-isearch-search ()
   (if Info-isearch-search
       (lambda (string &optional bound noerror count)
-	(Info-search
-	 (cond
-	  (isearch-word
-	   ;; Lax version of word search
-	   (let ((lax (not (or isearch-nonincremental
-			       (eq (length string)
-				   (length (isearch--state-string
-					    (car isearch-cmds))))))))
-	     (if (functionp isearch-word)
-		 (funcall isearch-word string lax)
-	       (word-search-regexp string lax))))
-	  (isearch-regexp string)
-	  (t (regexp-quote string)))
-	 bound noerror count
-	 (unless isearch-forward 'backward))
+	(let ((Info-search-whitespace-regexp
+	       (if (if isearch-regexp
+		       isearch-regexp-lax-whitespace
+		     isearch-lax-whitespace)
+		   search-whitespace-regexp)))
+	  (Info-search
+	   (cond
+	    (isearch-word
+	     ;; Lax version of word search
+	     (let ((lax (not (or isearch-nonincremental
+				 (eq (length string)
+				     (length (isearch--state-string
+					      (car isearch-cmds))))))))
+	       (if (functionp isearch-word)
+		   (funcall isearch-word string lax)
+		 (word-search-regexp string lax))))
+	    (isearch-regexp string)
+	    (t (regexp-quote string)))
+	   bound noerror count
+	   (unless isearch-forward 'backward)))
 	(point))
     (isearch-search-fun-default)))
 
@@ -4157,8 +4156,6 @@ Advanced commands:
        'Info-isearch-push-state)
   (set (make-local-variable 'isearch-filter-predicate)
        'Info-isearch-filter)
-  (set (make-local-variable 'search-whitespace-regexp)
-       Info-search-whitespace-regexp)
   (set (make-local-variable 'revert-buffer-function)
        'Info-revert-buffer-function)
   (Info-set-mode-line)
diff --git a/lisp/international/ogonek.el b/lisp/international/ogonek.el
index 39a8800111..3c34e5d9a2 100644
--- a/lisp/international/ogonek.el
+++ b/lisp/international/ogonek.el
@@ -224,13 +224,14 @@ The functions come in the following groups.
    ogonek-prefix-to-encoding      iso8859-2
 
  The above default values can be changed by placing appropriate settings
- in the '~/.emacs' file:
+ in your init file:
 
    (setq ogonek-prefix-char ?/)
    (setq ogonek-prefix-to-encoding \"iso8859-2\")
 
- Instead of loading the whole library `ogonek' it may be better to
- autoload the needed functions, for example by placing in `~/.emacs':
+ Instead of loading the whole library `ogonek' it may be better
+ to autoload the needed functions, for example by adding the
+ following lines to your init file:
 
    (autoload 'ogonek-how \"ogonek\")
    (autoload 'ogonek-recode-region \"ogonek\")
diff --git a/lisp/isearch.el b/lisp/isearch.el
index e6e0a01566..04f5a7acc2 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -1405,6 +1405,7 @@ Use `isearch-exit' to quit without signaling."
   (interactive)
   (setq isearch-word (unless (eq isearch-word 'isearch-symbol-regexp)
 		       'isearch-symbol-regexp))
+  (if isearch-word (setq isearch-regexp nil))
   (setq isearch-success t isearch-adjusted t)
   (isearch-update))
 
@@ -1579,14 +1580,10 @@ 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)
-	(replace-search-function
-	 (if (and isearch-lax-whitespace (not regexp-flag))
-	     #'search-forward-lax-whitespace
-	   replace-search-function))
-	(replace-re-search-function
-	 (if (and isearch-regexp-lax-whitespace regexp-flag)
-	     #'re-search-forward-lax-whitespace
-	   replace-re-search-function))
+	(replace-lax-whitespace
+	 isearch-lax-whitespace)
+	(replace-regexp-lax-whitespace
+	 isearch-regexp-lax-whitespace)
 	;; Set `isearch-recursive-edit' to nil to prevent calling
 	;; `exit-recursive-edit' in `isearch-done' that terminates
 	;; the execution of this command when it is non-nil.
@@ -2956,10 +2953,14 @@ Attempt to do the search exactly the way the pending Isearch would."
       (let ((case-fold-search isearch-lazy-highlight-case-fold-search)
 	    (isearch-regexp isearch-lazy-highlight-regexp)
 	    (isearch-word isearch-lazy-highlight-word)
+	    (isearch-lax-whitespace
+	     isearch-lazy-highlight-lax-whitespace)
+	    (isearch-regexp-lax-whitespace
+	     isearch-lazy-highlight-regexp-lax-whitespace)
+	    (isearch-forward isearch-lazy-highlight-forward)
 	    (search-invisible nil)	; don't match invisible text
 	    (retry t)
 	    (success nil)
-	    (isearch-forward isearch-lazy-highlight-forward)
 	    (bound (if isearch-lazy-highlight-forward
 		       (min (or isearch-lazy-highlight-end-limit (point-max))
 			    (if isearch-lazy-highlight-wrapped
diff --git a/lisp/language/chinese.el b/lisp/language/chinese.el
index ac2afa373c..782b5a363a 100644
--- a/lisp/language/chinese.el
+++ b/lisp/language/chinese.el
@@ -110,7 +110,8 @@
 				    (use-cjk-char-width-table 'zh_CN)))
 		(exit-function . use-default-char-width-table)
 		(coding-system chinese-iso-8bit iso-2022-cn chinese-hz)
-		(coding-priority chinese-iso-8bit chinese-big5 iso-2022-cn)
+		(coding-priority chinese-iso-8bit chinese-gbk chinese-big5
+				 iso-2022-cn)
 		(input-method . "chinese-py-punct")
 		(features china-util)
 		(sample-text . "Chinese ($AVPND(B,$AFUM(;0(B,$A::So(B)	$ADc:C(B")
@@ -140,7 +141,8 @@
 				      (use-cjk-char-width-table 'zh_HK)))
 		  (exit-function . use-default-char-width-table)
 		  (coding-system chinese-big5 chinese-iso-7bit)
-		  (coding-priority chinese-big5 iso-2022-cn chinese-iso-8bit)
+		  (coding-priority chinese-big5 iso-2022-cn chinese-iso-8bit
+				   chinese-gbk)
 		  (input-method . "chinese-py-punct-b5")
 		  (ctext-non-standard-encodings "big5-0")
 		  (features china-util)
@@ -196,7 +198,7 @@
 		 (exit-function . use-default-char-width-table)
 		 (coding-system iso-2022-cn euc-tw)
 		 (coding-priority iso-2022-cn euc-tw chinese-big5
-				  chinese-iso-8bit)
+				  chinese-iso-8bit chinese-gbk)
 		 (features china-util)
 		 (input-method . "chinese-cns-quick")
 		 ;; Fixme: presumably it won't accept big5 now.
@@ -216,7 +218,7 @@ accepts Big5 for input also (which is then converted to CNS)."))
 		    (exit-function . use-default-char-width-table)
 		    (coding-system euc-tw iso-2022-cn)
 		    (coding-priority euc-tw chinese-big5 iso-2022-cn
-				     chinese-iso-8bit)
+				     chinese-iso-8bit chinese-gbk)
 		    (features china-util)
 		    (input-method . "chinese-cns-quick")
 		    (documentation . "\
diff --git a/lisp/loadup.el b/lisp/loadup.el
index c70b417822..e0f5c6265b 100644
--- a/lisp/loadup.el
+++ b/lisp/loadup.el
@@ -102,6 +102,19 @@
 (setq load-source-file-function 'load-with-code-conversion)
 (load "files")
 
+;; Load-time macro-expansion can only take effect after setting
+;; load-source-file-function because of where it is called in lread.c.
+(load "emacs-lisp/macroexp")
+(if (byte-code-function-p (symbol-function 'macroexpand-all))
+    nil
+  ;; Since loaddefs is not yet loaded, macroexp's uses of pcase will simply
+  ;; fail until pcase is explicitly loaded.  This also means that we have to
+  ;; disable eager macro-expansion while loading pcase.
+  (let ((macroexp--pending-eager-loads '(skip)))
+    (load "emacs-lisp/pcase"))
+  ;; Re-load macroexp so as to eagerly macro-expand its uses of pcase.
+  (load "emacs-lisp/macroexp"))
+
 (load "cus-face")
 (load "faces")  ; after here, `defface' may be used.
 
@@ -269,21 +282,6 @@
 ;For other systems, you must edit ../src/Makefile.in.
 (load "site-load" t)
 
-;; ¡¡¡ Big Ugly Hack !!!
-;; src/bootstrap-emacs is mostly used to compile .el files, so it needs
-;; macroexp, bytecomp, cconv, and byte-opt to be fast.  Generally this is done
-;; by compiling those files first, but this only makes a difference if those
-;; files are not preloaded.  As it so happens, macroexp.el tends to be
-;; accidentally preloaded in src/bootstrap-emacs because cl.el and cl-macs.el
-;; require it.  So let's unload it here, if needed, to make sure the
-;; byte-compiled version is used.
-(if (or (not (fboundp 'macroexpand-all))
-        (byte-code-function-p (symbol-function 'macroexpand-all)))
-    nil
-  (fmakunbound 'macroexpand-all)
-  (setq features (delq 'macroexp features))
-  (autoload 'macroexpand-all "macroexp"))
-
 ;; Determine which last version number to use
 ;; based on the executables that now exist.
 (if (and (or (equal (nth 3 command-line-args) "dump")
diff --git a/lisp/locate.el b/lisp/locate.el
index 29d7c75cbb..d172ce3d6c 100644
--- a/lisp/locate.el
+++ b/lisp/locate.el
@@ -34,7 +34,7 @@
 ;;
 ;;   SHELLPROGRAM  Name-to-find
 ;;
-;; set the variable `locate-command' in your .emacs file.
+;; set the variable `locate-command' in your init file.
 ;;
 ;;   To use a more complicated expression, create a function which
 ;; takes a string (the name to find) as input and returns a list.
diff --git a/lisp/mail/feedmail.el b/lisp/mail/feedmail.el
index 520271940f..4305094611 100644
--- a/lisp/mail/feedmail.el
+++ b/lisp/mail/feedmail.el
@@ -139,9 +139,8 @@
 ;; feedmail-send-it. Hers's the best way to use the stuff in this
 ;; file:
 ;;
-;; Save this file as feedmail.el somewhere on your elisp
-;; loadpath; byte-compile it.  Put the following lines somewhere in
-;; your ~/.emacs stuff:
+;; Save this file as feedmail.el somewhere on your elisp loadpath;
+;; byte-compile it.  Put the following lines in your init file:
 ;;
 ;;     (setq send-mail-function 'feedmail-send-it)
 ;;     (autoload 'feedmail-send-it "feedmail")
diff --git a/lisp/mail/mail-hist.el b/lisp/mail/mail-hist.el
index dd489e3c6a..40d67b4e90 100644
--- a/lisp/mail/mail-hist.el
+++ b/lisp/mail/mail-hist.el
@@ -28,7 +28,7 @@
 ;; time.
 ;;
 ;; To use this package, put it in a directory in your load-path, and
-;; put this in your .emacs file:
+;; put this in your init file:
 ;;
 ;; (load "mail-hist" nil t)
 ;;
diff --git a/lisp/mail/mailabbrev.el b/lisp/mail/mailabbrev.el
index 290c57c1c5..2e4ffec138 100644
--- a/lisp/mail/mailabbrev.el
+++ b/lisp/mail/mailabbrev.el
@@ -391,35 +391,24 @@ double-quotes."
 (defun mail-abbrev-expand-hook ()
   "For use as the fourth arg to `define-abbrev'.
 After expanding a mail-abbrev, if Auto Fill mode is on and we're past the
-fill-column, break the line at the previous comma, and indent the next line."
-  ;; Disable abbrev mode to avoid recursion in indent-relative expanding
-  ;; part of the abbrev expansion as an abbrev itself.
-  (let ((abbrev-mode nil))
-    (save-excursion
-      (let ((p (point))
-	    bol comma fp)
-	(beginning-of-line)
-	(setq bol (point))
-	(goto-char p)
-	(while (and auto-fill-function
-		    (>= (current-column) fill-column)
-		    (search-backward "," bol t))
-	  (setq comma (point))
-	  (forward-char 1)		; Now we are just past the comma.
-	  (insert "\n")
-	  (delete-horizontal-space)
-	  (setq p (point))
-	  (indent-relative)
-	  (setq fp (buffer-substring p (point)))
-	  ;; Go to the end of the new line.
-	  (end-of-line)
-	  (if (> (current-column) fill-column)
-	      ;; It's still too long; do normal auto-fill.
-	      (let ((fill-prefix (or fp "\t")))
-		(do-auto-fill)))
-	  ;; Resume the search.
-	  (goto-char comma)
-	  )))))
+fill-column, break the line at the previous comma, and indent the next line
+with a space."
+  (when auto-fill-function
+    (let (p)
+      (save-excursion
+	(while (>= (current-column) fill-column)
+	  (while (and (search-backward "," (point-at-bol) 'move)
+		      (>= (current-column) (1- fill-column))
+		      (setq p (point))))
+	  (when (or (not (bolp))
+		    (and p (goto-char p)))
+	    (setq p nil)
+	    (forward-char 1)
+	    (insert "\n")
+	    (when (looking-at "[\t ]+")
+	      (delete-region (point) (match-end 0)))
+	    (insert " ")
+	    (end-of-line)))))))
 
 ;;; Syntax tables and abbrev-expansion
 
diff --git a/lisp/mail/smtpmail.el b/lisp/mail/smtpmail.el
index 804fe7a879..69a405436a 100644
--- a/lisp/mail/smtpmail.el
+++ b/lisp/mail/smtpmail.el
@@ -200,10 +200,10 @@ The list is in preference order.")
 	;; local binding in the mail buffer will take effect.
 	(smtpmail-mail-address
          (or (and mail-specify-envelope-from (mail-envelope-from))
-             (smtpmail-user-mail-address)
-	     (let ((from (mail-fetch-field "from")))
+             (let ((from (mail-fetch-field "from")))
 	       (and from
-		    (cadr (mail-extract-address-components from))))))
+		    (cadr (mail-extract-address-components from))))
+	     (smtpmail-user-mail-address)))
 	(smtpmail-code-conv-from
 	 (if enable-multibyte-characters
 	     (let ((sendmail-coding-system smtpmail-code-conv-from))
@@ -653,12 +653,10 @@ Returns an error if the server cannot be contacted."
 	 (or smtpmail-mail-address
 	     (and mail-specify-envelope-from
 		  (mail-envelope-from))
-	     (smtpmail-user-mail-address)
-	     ;; Fall back on the From: header as the envelope From
-	     ;; address.
 	     (let ((from (mail-fetch-field "from")))
 	       (and from
-		    (cadr (mail-extract-address-components from))))))
+		    (cadr (mail-extract-address-components from))))
+	     (smtpmail-user-mail-address)))
 	response-code
 	process-buffer
 	result
diff --git a/lisp/mail/uce.el b/lisp/mail/uce.el
index fdfe17a1a0..3d7495ffd1 100644
--- a/lisp/mail/uce.el
+++ b/lisp/mail/uce.el
@@ -63,7 +63,7 @@
 ;; Usage:
 
 ;; Place uce.el in your load-path (and optionally byte-compile it).
-;; Add the following line to your ~/.emacs:
+;; Add the following line to your init file:
 ;; (autoload 'uce-reply-to-uce "uce" "Reply to UCEs" t nil)
 ;; If you want to use it with Gnus rather than Rmail:
 ;; (setq uce-mail-reader 'gnus)
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index a696fff7dc..27c53744d5 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -211,7 +211,7 @@ case sensitive instead."
       (complete-with-action action table string pred))))
 
 (defun completion-table-subvert (table s1 s2)
-  "Completion table that replaces the prefix S1 with S2 in STRING.
+  "Return a completion table from TABLE with S1 replaced by S2.
 The result is a completion table which completes strings of the
 form (concat S1 S) in the same way as TABLE completes strings of
 the form (concat S2 S)."
diff --git a/lisp/mouse-copy.el b/lisp/mouse-copy.el
index 8d043b4495..a8e32bec1a 100644
--- a/lisp/mouse-copy.el
+++ b/lisp/mouse-copy.el
@@ -35,7 +35,7 @@
 ;; If you like mouse-copy, you should also check out mouse-drag
 ;; for ``one-click scrolling''.
 ;;
-;; To use mouse-copy, place the following in your .emacs file:
+;; To use mouse-copy, place the following in your init file:
 ;;	(require 'mouse-copy)
 ;;     (global-set-key [M-down-mouse-1] 'mouse-drag-secondary-pasting)
 ;;     (global-set-key [M-S-down-mouse-1] 'mouse-drag-secondary-moving)
diff --git a/lisp/mouse-drag.el b/lisp/mouse-drag.el
index 7fb1050535..acdad9a42c 100644
--- a/lisp/mouse-drag.el
+++ b/lisp/mouse-drag.el
@@ -46,7 +46,7 @@
 ;; If you like mouse-drag, you should also check out mouse-copy
 ;; for ``one-click text copy and move''.
 ;;
-;; To use mouse-drag, place the following in your .emacs file:
+;; To use mouse-drag, place the following in your init file:
 ;; -either-
 ;;     (global-set-key [down-mouse-2] 'mouse-drag-throw)
 ;; -or-
diff --git a/lisp/net/ange-ftp.el b/lisp/net/ange-ftp.el
index 1501fa41ba..265a855b84 100644
--- a/lisp/net/ange-ftp.el
+++ b/lisp/net/ange-ftp.el
@@ -79,7 +79,7 @@
 ;; that this change will take effect for the current GNU Emacs session only.
 ;; See below for a discussion of non-UNIX hosts.  If a large number of
 ;; machines with similar hostnames have this problem then it is easier to set
-;; the value of ange-ftp-dumb-unix-host-regexp in your .emacs file. ange-ftp
+;; the value of ange-ftp-dumb-unix-host-regexp in your init file.  ange-ftp
 ;; is unable to automatically recognize dumb unix hosts.
 
 ;; File name completion:
@@ -275,10 +275,10 @@
 
 ;; VMS support:
 ;;
-;; Ange-ftp has full support for VMS hosts.  It
-;; should be able to automatically recognize any VMS machine. However, if it
-;; fails to do this, you can use the command ange-ftp-add-vms-host.  As well,
-;; you can set the variable ange-ftp-vms-host-regexp in your .emacs file. We
+;; Ange-ftp has full support for VMS hosts.  It should be able to
+;; automatically recognize any VMS machine. However, if it fails to do
+;; this, you can use the command ange-ftp-add-vms-host.  Also, you can
+;; set the variable ange-ftp-vms-host-regexp in your init file.  We
 ;; would be grateful if you would report any failures to automatically
 ;; recognize a VMS host as a bug.
 ;;
@@ -332,7 +332,7 @@
 ;; the Michigan terminal system.  It should be able to automatically
 ;; recognize any MTS machine. However, if it fails to do this, you can use
 ;; the command ange-ftp-add-mts-host.  As well, you can set the variable
-;; ange-ftp-mts-host-regexp in your .emacs file. We would be grateful if you
+;; ange-ftp-mts-host-regexp in your init file. We would be grateful if you
 ;; would report any failures to automatically recognize a MTS host as a bug.
 ;;
 ;; Filename syntax:
@@ -358,7 +358,7 @@
 ;; CMS.  It should be able to automatically recognize any CMS machine.
 ;; However, if it fails to do this, you can use the command
 ;; ange-ftp-add-cms-host.  As well, you can set the variable
-;; ange-ftp-cms-host-regexp in your .emacs file. We would be grateful if you
+;; ange-ftp-cms-host-regexp in your init file. We would be grateful if you
 ;; would report any failures to automatically recognize a CMS host as a bug.
 ;;
 ;; Filename syntax:
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index 20d7121592..c1c83d2245 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -122,8 +122,7 @@
 ;; the buffer, use:
 ;; M-x browse-url
 
-;; To display a URL by shift-clicking on it, put this in your ~/.emacs
-;; file:
+;; To display a URL by shift-clicking on it, put this in your init file:
 ;;      (global-set-key [S-mouse-2] 'browse-url-at-mouse)
 ;; (Note that using Shift-mouse-1 is not desirable because
 ;; that event has a standard meaning in Emacs.)
@@ -743,7 +742,7 @@ narrowed."
     (and buffer (set-buffer buffer))
     (let ((file-name
 	   ;; Ignore real name if restricted
-	   (and (= (- (point-max) (point-min)) (buffer-size))
+	   (and (not (buffer-narrowed-p))
 		(or buffer-file-name
 		    (and (boundp 'dired-directory) dired-directory)))))
       (or file-name
diff --git a/lisp/net/goto-addr.el b/lisp/net/goto-addr.el
index 6a9d80f967..f9e3178852 100644
--- a/lisp/net/goto-addr.el
+++ b/lisp/net/goto-addr.el
@@ -33,7 +33,7 @@
 ;; INSTALLATION
 ;;
 ;; To use goto-address in a particular mode (for example, while
-;; reading mail in mh-e), add something like this in your .emacs file:
+;; reading mail in mh-e), add this to your init file:
 ;;
 ;; (add-hook 'mh-show-mode-hook 'goto-address)
 ;;
diff --git a/lisp/net/newsticker.el b/lisp/net/newsticker.el
index 5d673faf0d..91eca84ce5 100644
--- a/lisp/net/newsticker.el
+++ b/lisp/net/newsticker.el
@@ -87,7 +87,7 @@
 ;; If you are using Newsticker as part of GNU Emacs there is no need to
 ;; perform any installation steps in order to use Newsticker.  Otherwise
 ;; place Newsticker in a directory where Emacs can find it.  Add the
-;; following line to your Emacs startup file (`~/.emacs').
+;; following line to your init file:
 ;;   (add-to-list 'load-path "/path/to/newsticker/")
 ;;   (autoload 'newsticker-start "newsticker" "Emacs Newsticker" t)
 ;;   (autoload 'newsticker-show-news "newsticker" "Emacs Newsticker" t)
diff --git a/lisp/net/quickurl.el b/lisp/net/quickurl.el
index f3b0e372de..f7d41fcd97 100644
--- a/lisp/net/quickurl.el
+++ b/lisp/net/quickurl.el
@@ -164,7 +164,7 @@ To make use of this do something like:
 
   (setq quickurl-postfix quickurl-reread-hook-postfix)
 
-in your ~/.emacs (after loading/requiring quickurl).")
+in your init file (after loading/requiring quickurl).")
 
 ;; Non-customize variables.
 
diff --git a/lisp/net/tramp-cmds.el b/lisp/net/tramp-cmds.el
index 06aae1f6af..abca6b3ea0 100644
--- a/lisp/net/tramp-cmds.el
+++ b/lisp/net/tramp-cmds.el
@@ -204,7 +204,7 @@ useful thing to do is to put
 
   (setq tramp-verbose 9)
 
-in the ~/.emacs file and to repeat the bug.  Then, include the
+in your init file and to repeat the bug.  Then, include the
 contents of the *tramp/foo* buffer and the *debug tramp/foo*
 buffer in your bug report.
 
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index a17bbfa0d1..019ab1eef0 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -3293,7 +3293,9 @@ for process communication also."
       ;; Under Windows XP, accept-process-output doesn't return
       ;; sometimes.  So we add an additional timeout.
       (with-timeout ((or timeout 1))
-	(accept-process-output proc timeout timeout-msecs (and proc t))))
+	(if (featurep 'xemacs)
+	    (accept-process-output proc timeout timeout-msecs)
+	  (accept-process-output proc timeout timeout-msecs (and proc t)))))
     (tramp-message proc 10 "\n%s" (buffer-string))))
 
 (defun tramp-check-for-regexp (proc regexp)
diff --git a/lisp/net/trampver.el b/lisp/net/trampver.el
index 499af73078..2d0a8e3d23 100644
--- a/lisp/net/trampver.el
+++ b/lisp/net/trampver.el
@@ -31,7 +31,7 @@
 ;; should be changed only there.
 
 ;;;###tramp-autoload
-(defconst tramp-version "2.2.6-pre"
+(defconst tramp-version "2.2.6"
   "This version of Tramp.")
 
 ;;;###tramp-autoload
@@ -44,7 +44,7 @@
 		      (= emacs-major-version 21)
 		      (>= emacs-minor-version 4)))
 	     "ok"
-	   (format "Tramp 2.2.6-pre is not fit for %s"
+	   (format "Tramp 2.2.6 is not fit for %s"
 		   (when (string-match "^.*$" (emacs-version))
 		     (match-string 0 (emacs-version)))))))
   (unless (string-match "\\`ok\\'" x) (error "%s" x)))
diff --git a/lisp/net/webjump.el b/lisp/net/webjump.el
index 232e5ca581..d5de2f410c 100644
--- a/lisp/net/webjump.el
+++ b/lisp/net/webjump.el
@@ -38,7 +38,7 @@
 ;; example sites.  You'll probably want to override it with your own favorite
 ;; sites.  The documentation for the variable describes the syntax.
 
-;; You may wish to add something like the following to your `.emacs' file:
+;; You may wish to add something like the following to your init file:
 ;;
 ;;   (require 'webjump)
 ;;   (global-set-key "\C-cj" 'webjump)
diff --git a/lisp/novice.el b/lisp/novice.el
index bcc94c86c9..c621ac4b69 100644
--- a/lisp/novice.el
+++ b/lisp/novice.el
@@ -159,8 +159,8 @@ to future sessions."
 (defun disable-command (command)
   "Require special confirmation to execute COMMAND from now on.
 COMMAND must be a symbol.
-This command alters the user's .emacs file so that this will apply
-to future sessions."
+This command alters your init file so that this choice applies to
+future sessions."
   (interactive "CDisable command: ")
   (en/disable-command command t))
 
diff --git a/lisp/pcomplete.el b/lisp/pcomplete.el
index d357da685e..97d8b4652a 100644
--- a/lisp/pcomplete.el
+++ b/lisp/pcomplete.el
@@ -28,7 +28,7 @@
 ;; argument position.
 ;;
 ;; To use pcomplete with shell-mode, for example, you will need the
-;; following in your .emacs file:
+;; following in your init file:
 ;;
 ;;   (add-hook 'shell-mode-hook 'pcomplete-shell-setup)
 ;;
diff --git a/lisp/play/blackbox.el b/lisp/play/blackbox.el
index db2e18188e..1618960015 100644
--- a/lisp/play/blackbox.el
+++ b/lisp/play/blackbox.el
@@ -97,7 +97,9 @@
   (let ((map (make-keymap)))
     (suppress-keymap map t)
     (blackbox-redefine-key map 'backward-char 'bb-left)
+    (blackbox-redefine-key map 'left-char 'bb-left)
     (blackbox-redefine-key map 'forward-char 'bb-right)
+    (blackbox-redefine-key map 'right-char 'bb-right)
     (blackbox-redefine-key map 'previous-line 'bb-up)
     (blackbox-redefine-key map 'next-line 'bb-down)
     (blackbox-redefine-key map 'move-end-of-line 'bb-eol)
diff --git a/lisp/play/bubbles.el b/lisp/play/bubbles.el
index 1f04099a6a..3b6035473f 100644
--- a/lisp/play/bubbles.el
+++ b/lisp/play/bubbles.el
@@ -33,7 +33,7 @@
 ;; Installation
 ;; ------------
 
-;; Add the following lines to your Emacs startup file (`~/.emacs').
+;; Add the following lines to your init file:
 ;; (add-to-list 'load-path "/path/to/bubbles/")
 ;; (autoload 'bubbles "bubbles" "Play Bubbles" t)
 
diff --git a/lisp/play/decipher.el b/lisp/play/decipher.el
index 8d9506a161..ade0d15006 100644
--- a/lisp/play/decipher.el
+++ b/lisp/play/decipher.el
@@ -138,19 +138,7 @@ the tail of the list."
     ("^)\\([A-Z ]+\\)\\([a-z ]+\\)"
      (1 font-lock-keyword-face)
      (2 font-lock-string-face)))
-  "Expressions to fontify in Decipher mode.
-
-Ciphertext uses `font-lock-keyword-face', plaintext uses
-`font-lock-string-face', comments use `font-lock-comment-face', and
-checkpoints use `font-lock-constant-face'.  You can customize the
-display by changing these variables.  For best results, I recommend
-that all faces use the same background color.
-
-For example, to display ciphertext in the `bold' face, use
-  (add-hook 'decipher-mode-hook
-            (lambda () (set (make-local-variable 'font-lock-keyword-face)
-                            'bold)))
-in your `.emacs' file.")
+  "Font Lock keywords for Decipher mode.")
 
 (defvar decipher-mode-map
   (let ((map (make-keymap)))
diff --git a/lisp/play/handwrite.el b/lisp/play/handwrite.el
index d2e307c014..85c128b08e 100644
--- a/lisp/play/handwrite.el
+++ b/lisp/play/handwrite.el
@@ -45,7 +45,7 @@
 ;;  Installation
 ;;
 ;; type at your prompt "emacs -l handwrite.el" or put this file on your
-;; Emacs-Lisp load path,  add the following into your ~/.emacs startup file
+;; Emacs-Lisp load path, add the following into your init file:
 ;;
 ;;                (require 'handwrite)
 ;;
diff --git a/lisp/printing.el b/lisp/printing.el
index 0152ed63db..02b2fb0139 100644
--- a/lisp/printing.el
+++ b/lisp/printing.el
@@ -139,10 +139,9 @@ Please send all bug fixes and enhancements to
 ;;
 ;; One way to set variables is by calling `pr-customize', customize all
 ;; variables and save the customization by future sessions (see Options
-;; section).  Other way is by coding your settings on Emacs init file (that is,
-;; ~/.emacs file), see below for a first setting template that it should be
-;; inserted on your ~/.emacs file (or c:/_emacs, if you're using Windows 9x/NT
-;; or MS-DOS):
+;; section).  Other way is by adding code to your init file; see below
+;; for a first setting template that it should be inserted on your
+;; init file:
 ;;
 ;; * Example of setting for Windows system:
 ;;
@@ -297,8 +296,7 @@ Please send all bug fixes and enhancements to
 ;; Using `printing'
 ;; ----------------
 ;;
-;; To use `printing' insert in your ~/.emacs file (or c:/_emacs, if you're
-;; using Windows 9x/NT or MS-DOS):
+;; To use `printing' insert in your init file:
 ;;
 ;;    (require 'printing)
 ;;    ;; ...some user settings...
diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index 4062646c96..5a054af988 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -69,7 +69,7 @@
 ;; This file requires Emacs-20.3, XEmacs-20.4 or higher and package cc-mode.
 
 ;; If antlr-mode is not part of your distribution, put this file into your
-;; load-path and the following into your ~/.emacs:
+;; load-path and the following into your init file:
 ;;   (autoload 'antlr-mode "antlr-mode" nil t)
 ;;   (setq auto-mode-alist (cons '("\\.g\\'" . antlr-mode) auto-mode-alist))
 ;;   (add-hook 'speedbar-load-hook  ; would be too late in antlr-mode.el
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 7cd0a0b0ae..eec6873dc1 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -493,13 +493,16 @@ inside a literal or a macro, nothing special happens."
       (insert-char ?\n 1)
       ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
       ;; the syntax.  (There might already be an escaped NL there.)
-      (when (or (c-at-vsemi-p (1- (point)))
-		(let ((pt (point)))
-		  (save-excursion
-		    (backward-char)
-		    (and (c-beginning-of-macro)
-			 (progn (c-end-of-macro)
-				(< (point) pt))))))
+      (when (or
+	     (save-excursion
+	       (c-skip-ws-backward (c-point 'bopl))
+	       (c-at-vsemi-p))
+	     (let ((pt (point)))
+	       (save-excursion
+		 (backward-char)
+		 (and (c-beginning-of-macro)
+		      (progn (c-end-of-macro)
+			     (< (point) pt))))))
 	(backward-char)
 	(insert-char ?\\ 1)
 	(forward-char))
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index 8bccb44f30..0dc596a472 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -1829,7 +1829,7 @@ itself is evaluated."
   (eval form))
 
 ;; Only used at compile time - suppress "might not be defined at runtime".
-(declare-function cl-macroexpand-all "cl-extra" (form &optional env))
+(declare-function cl-macroexpand-all "cl" (form &optional env))
 
 (defmacro c-lang-defconst (name &rest args)
   "Set the language specific values of the language constant NAME.
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 142ec4cdd6..2aa04cb2b0 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -3091,6 +3091,8 @@ comment at the start of cc-engine.el for more info."
 	c-state-cache-good-pos 1
 	c-state-nonlit-pos-cache nil
 	c-state-nonlit-pos-cache-limit 1
+	c-state-semi-nonlit-pos-cache nil
+	c-state-semi-nonlit-pos-cache-limit 1
 	c-state-brace-pair-desert nil
 	c-state-point-min 1
 	c-state-point-min-lit-type nil
@@ -3350,6 +3352,8 @@ comment at the start of cc-engine.el for more info."
 	   c-state-cache-good-pos
 	   c-state-nonlit-pos-cache
 	   c-state-nonlit-pos-cache-limit
+	   c-state-semi-nonlit-pos-cache
+	   c-state-semi-nonlit-pos-cache-limit
 	   c-state-brace-pair-desert
 	   c-state-point-min
 	   c-state-point-min-lit-type
@@ -9579,12 +9583,12 @@ comment at the start of cc-engine.el for more info."
 			     (setq tmpsymbol nil)
 			     (while (and (> (point) placeholder)
 					 (zerop (c-backward-token-2 1 t))
-					 (/= (char-after) ?=))
+					 (not (looking-at "=\\([^=]\\|$\\)")))
 			       (and c-opt-inexpr-brace-list-key
 				    (not tmpsymbol)
 				    (looking-at c-opt-inexpr-brace-list-key)
 				    (setq tmpsymbol 'topmost-intro-cont)))
-			     (eq (char-after) ?=))
+			     (looking-at "=\\([^=]\\|$\\)"))
 			   (looking-at c-brace-list-key))
 		       (save-excursion
 			 (while (and (< (point) indent-point)
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 78be8ac2cc..d5a1be572b 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -208,9 +208,10 @@ the evaluated constant value at compile time."
 
 ;; Suppress "might not be defined at runtime" warning.
 ;; This file is only used when compiling other cc files.
-(declare-function delete-duplicates "cl-seq" (cl-seq &rest cl-keys))
-(declare-function mapcan "cl-extra" (cl-func cl-seq &rest cl-rest))
-(declare-function cl-macroexpand-all "cl-extra" (form &optional env))
+;; These are defined in cl as aliases to the cl- versions.
+(declare-function delete-duplicates "cl-seq" (cl-seq &rest cl-keys) t)
+(declare-function mapcan "cl-extra" (cl-func cl-seq &rest cl-rest) t)
+(declare-function cl-macroexpand-all "cl" (form &optional env))
 
 (eval-and-compile
   ;; Some helper functions used when building the language constants.
diff --git a/lisp/progmodes/cc-styles.el b/lisp/progmodes/cc-styles.el
index cf628e44de..20aa2bc277 100644
--- a/lisp/progmodes/cc-styles.el
+++ b/lisp/progmodes/cc-styles.el
@@ -352,8 +352,8 @@ might get set too.
 If DONT-OVERRIDE is neither nil nor t, style variables whose default values
 have been set (more precisely, whose default values are not the symbol
 `set-from-style') will not be changed.  This avoids overriding global settings
-done in ~/.emacs.  It is useful to call c-set-style from a mode hook in this
-way.
+done in your init file.  It is useful to call c-set-style from a mode hook
+in this way.
 
 If DONT-OVERRIDE is t, style variables that already have values (i.e., whose
 values are not the symbol `set-from-style') will not be overridden.  CC Mode
diff --git a/lisp/progmodes/cmacexp.el b/lisp/progmodes/cmacexp.el
index 943b5c6a06..525b1c9671 100644
--- a/lisp/progmodes/cmacexp.el
+++ b/lisp/progmodes/cmacexp.el
@@ -49,7 +49,7 @@
 
 ;; INSTALLATION ======================================================
 
-;; Put the following in your ~/.emacs file.
+;; Put the following in your init file.
 
 ;; If you want the *Macroexpansion* window to be not higher than
 ;; necessary:
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index fbb0c9e204..f5dedf0cd5 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -488,9 +488,12 @@ What matched the HYPERLINK'th subexpression has `mouse-face' and
 `compilation-message-face' applied.  If this is nil, the text
 matched by the whole REGEXP becomes the hyperlink.
 
-Additional HIGHLIGHTs take the shape (SUBMATCH FACE), where SUBMATCH is
-the number of a submatch that should be highlighted when it matches,
-and FACE is an expression returning the face to use for that submatch.."
+Additional HIGHLIGHTs take the shape (SUBMATCH FACE), where
+SUBMATCH is the number of a submatch and FACE is an expression
+which evaluates to a face name (a symbol or string).
+Alternatively, FACE can evaluate to a property list of the
+form (face FACE PROP1 VAL1 PROP2 VAL2 ...), in which case all the
+listed text properties PROP# are given values VAL# as well."
   :type '(repeat (choice (symbol :tag "Predefined symbol")
 			 (sexp :tag "Error specification")))
   :link `(file-link :tag "example file"
@@ -1328,16 +1331,27 @@ to `compilation-error-regexp-alist' if RULES is nil."
             (compilation--put-prop
              end-col 'font-lock-face compilation-column-face)
 
+	    ;; Obey HIGHLIGHT.
             (dolist (extra-item (nthcdr 6 item))
               (let ((mn (pop extra-item)))
                 (when (match-beginning mn)
                   (let ((face (eval (car extra-item))))
                     (cond
                      ((null face))
-                     ((symbolp face)
+                     ((or (symbolp face) (stringp face))
                       (put-text-property
                        (match-beginning mn) (match-end mn)
                        'font-lock-face face))
+		     ((and (listp face)
+			   (eq (car face) 'face)
+			   (or (symbolp (cadr face))
+			       (stringp (cadr face))))
+                      (put-text-property
+                       (match-beginning mn) (match-end mn)
+                       'font-lock-face (cadr face))
+                      (add-text-properties
+                       (match-beginning mn) (match-end mn)
+                       (nthcdr 2 face)))
                      (t
                       (error "Don't know how to handle face %S"
                              face)))))))
diff --git a/lisp/progmodes/ebnf2ps.el b/lisp/progmodes/ebnf2ps.el
index cdbaf4708a..0f18cffc3d 100644
--- a/lisp/progmodes/ebnf2ps.el
+++ b/lisp/progmodes/ebnf2ps.el
@@ -43,7 +43,7 @@ Please send all bug fixes and enhancements to
 ;;
 ;; This package translates an EBNF to a syntactic chart on PostScript.
 ;;
-;; To use ebnf2ps, insert in your ~/.emacs:
+;; To use ebnf2ps, insert in your init file:
 ;;
 ;;        (require 'ebnf2ps)
 ;;
@@ -772,7 +772,7 @@ Please send all bug fixes and enhancements to
 ;;
 ;; To set the above options you may:
 ;;
-;; a) insert the code in your ~/.emacs, like:
+;; a) insert the code in your init file, like:
 ;;
 ;;	 (setq ebnf-terminal-shape 'bevel)
 ;;
diff --git a/lisp/progmodes/ebrowse.el b/lisp/progmodes/ebrowse.el
index 1d29011762..8ac54d6524 100644
--- a/lisp/progmodes/ebrowse.el
+++ b/lisp/progmodes/ebrowse.el
@@ -4210,7 +4210,7 @@ NUMBER-OF-STATIC-VARIABLES:"
 ;; this will select the buffer from which the buffer menu was
 ;; invoked.  But this buffer is not displayed in the buffer list if
 ;; it isn't a tree buffer.  I therefore let the buffer menu command
-;; loop read the command `p' via `unread-command-char'.  This command
+;; loop read the command `p' via `unread-command-events'.  This command
 ;; has no effect since we are on the first line of the buffer.
 
 (defvar electric-buffer-menu-mode-hook nil)
diff --git a/lisp/progmodes/f90.el b/lisp/progmodes/f90.el
index cc1251f6a7..f42952685d 100644
--- a/lisp/progmodes/f90.el
+++ b/lisp/progmodes/f90.el
@@ -102,10 +102,9 @@
 ;;       (abbrev-mode 1)             ; turn on abbreviation mode
 ;;       (f90-add-imenu-menu)        ; extra menu with functions etc.
 ;;       (if f90-auto-keyword-case   ; change case of all keywords on startup
-;;           (f90-change-keywords f90-auto-keyword-case))
-;;       ))
+;;           (f90-change-keywords f90-auto-keyword-case))))
 ;;
-;; in your .emacs file. You can also customize the lists
+;; in your init file. You can also customize the lists
 ;; f90-font-lock-keywords, etc.
 ;;
 ;; The auto-fill and abbreviation minor modes are accessible from the F90 menu,
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index ad28527492..10d5fdf9c6 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -977,6 +977,9 @@ from compile.el")
 ;;   :type '(repeat (string number number number))
 ;;)
 
+(defvar flymake-warning-re "^[wW]arning"
+  "Regexp matching against err-text to detect a warning.")
+
 (defun flymake-parse-line (line)
   "Parse LINE to see if it is an error or warning.
 Return its components if so, nil otherwise."
@@ -997,7 +1000,7 @@ Return its components if so, nil otherwise."
 				  (match-string (nth 4 (car patterns)) line)
 				(flymake-patch-err-text (substring line (match-end 0)))))
 	  (or err-text (setq err-text "<no error text>"))
-	  (if (and err-text (string-match "^[wW]arning" err-text))
+	  (if (and err-text (string-match flymake-warning-re err-text))
 	      (setq err-type "w")
 	    )
 	  (flymake-log 3 "parse line: file-idx=%s line-idx=%s file=%s line=%s text=%s" file-idx line-idx
diff --git a/lisp/progmodes/hideshow.el b/lisp/progmodes/hideshow.el
index 233b9a5212..2a77ad013c 100644
--- a/lisp/progmodes/hideshow.el
+++ b/lisp/progmodes/hideshow.el
@@ -52,7 +52,7 @@
 ;;
 ;; First make sure hideshow.el is in a directory in your `load-path'.
 ;; You can optionally byte-compile it using `M-x byte-compile-file'.
-;; Then, add the following to your ~/.emacs:
+;; Then, add the following to your init file:
 ;;
 ;; (load-library "hideshow")
 ;; (add-hook 'X-mode-hook               ; other modes similarly
diff --git a/lisp/progmodes/idlw-complete-structtag.el b/lisp/progmodes/idlw-complete-structtag.el
index 246ba8f29c..24613d1463 100644
--- a/lisp/progmodes/idlw-complete-structtag.el
+++ b/lisp/progmodes/idlw-complete-structtag.el
@@ -53,8 +53,8 @@
 ;;
 ;; INSTALLATION
 ;; ============
-;; Put this file on the emacs load path and load it with the following 
-;; line in your .emacs file:
+;; Put this file on the emacs load path and load it with the following
+;; line in your init file:
 ;;
 ;;   (add-hook 'idlwave-load-hook 
 ;;             (lambda () (require 'idlw-complete-structtag)))
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index 4f9109284a..08d1461c00 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -48,7 +48,7 @@
 ;;
 ;; Follow the instructions in the INSTALL file of the distribution.
 ;; In short, put this file on your load path and add the following
-;; lines to your .emacs file:
+;; lines to your init file:
 ;;
 ;; (autoload 'idlwave-shell "idlw-shell" "IDLWAVE Shell" t)
 ;;
@@ -111,9 +111,7 @@ For example, \"^\r?IDL> \" or \"^\r?WAVE> \".
 The \"^\r?\" is needed, to indicate the beginning of the line, with
 optional return character (which IDL seems to output randomly).
 This variable is used to initialize `comint-prompt-regexp' in the
-process buffer.
-
-This is a fine thing to set in your `.emacs' file."
+process buffer."
   :group 'idlwave-shell-general-setup
   :type 'regexp)
 
diff --git a/lisp/progmodes/idlwave.el b/lisp/progmodes/idlwave.el
index a35ffd3e45..9b634328fa 100644
--- a/lisp/progmodes/idlwave.el
+++ b/lisp/progmodes/idlwave.el
@@ -51,7 +51,7 @@
 ;;
 ;; Follow the instructions in the INSTALL file of the distribution.
 ;; In short, put this file on your load path and add the following
-;; lines to your .emacs file:
+;; lines to your init file:
 ;;
 ;; (autoload 'idlwave-mode "idlwave" "IDLWAVE Mode" t)
 ;; (autoload 'idlwave-shell "idlw-shell" "IDLWAVE Shell" t)
@@ -746,7 +746,7 @@ or even '?'.  '.' is not a good choice because it can make structure
 field names act like abbrevs in certain circumstances.
 
 Changes to this in `idlwave-mode-hook' will have no effect.  Instead a user
-must set it directly using `setq' in the .emacs file before idlwave.el
+must set it directly using `setq' in the init file before idlwave.el
 is loaded."
   :group 'idlwave-abbrev-and-indent-action
   :type 'string)
diff --git a/lisp/progmodes/inf-lisp.el b/lisp/progmodes/inf-lisp.el
index cd6c8869d9..401970b2ce 100644
--- a/lisp/progmodes/inf-lisp.el
+++ b/lisp/progmodes/inf-lisp.el
@@ -168,9 +168,7 @@ This variable is only used if the variable
 More precise choices:
 Lucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\"
 franz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\"
-kcl: \"^>+ *\"
-
-This is a fine thing to set in your .emacs file or through Custom."
+kcl: \"^>+ *\""
   :type 'regexp
   :group 'inferior-lisp)
 
diff --git a/lisp/progmodes/mixal-mode.el b/lisp/progmodes/mixal-mode.el
index 54d857dd4b..a59176a5aa 100644
--- a/lisp/progmodes/mixal-mode.el
+++ b/lisp/progmodes/mixal-mode.el
@@ -32,7 +32,7 @@
 ;; GNU MDK from `https://savannah.gnu.org/projects/mdk/' and
 ;; `ftp://ftp.gnu.org/pub/gnu/mdk'.
 ;;
-;; To use this mode, place the following in your .emacs file:
+;; To use this mode, place the following in your init file:
 ;; `(load-file "/PATH-TO-FILE/mixal-mode.el")'.
 ;; When you load a file with the extension .mixal the mode will be started
 ;; automatic.  If you want to start the mode manual, use `M-x mixal-mode'.
diff --git a/lisp/progmodes/octave-mod.el b/lisp/progmodes/octave-mod.el
index 79b3fcee72..ab5a19f8a2 100644
--- a/lisp/progmodes/octave-mod.el
+++ b/lisp/progmodes/octave-mod.el
@@ -585,12 +585,12 @@ Variables you can use to customize Octave mode
 Turning on Octave mode runs the hook `octave-mode-hook'.
 
 To begin using this mode for all `.m' files that you edit, add the
-following lines to your `.emacs' file:
+following lines to your init file:
 
   (add-to-list 'auto-mode-alist '(\"\\\\.m\\\\'\" . octave-mode))
 
 To automatically turn on the abbrev and auto-fill features,
-add the following lines to your `.emacs' file as well:
+add the following lines to your init file as well:
 
   (add-hook 'octave-mode-hook
 	    (lambda ()
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index e13b67e596..3dd9a48bb3 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -28,14 +28,14 @@
 ;;; Commentary:
 
 ;; To enter perl-mode automatically, add (autoload 'perl-mode "perl-mode")
-;; to your .emacs file and change the first line of your perl script to:
+;; to your init file and change the first line of your perl script to:
 ;; #!/usr/bin/perl --	 # -*-Perl-*-
 ;; With arguments to perl:
 ;; #!/usr/bin/perl -P-	 # -*-Perl-*-
 ;; To handle files included with do 'filename.pl';, add something like
 ;; (setq auto-mode-alist (append (list (cons "\\.pl\\'" 'perl-mode))
 ;;                               auto-mode-alist))
-;; to your .emacs file; otherwise the .pl suffix defaults to prolog-mode.
+;; to your init file; otherwise the .pl suffix defaults to prolog-mode.
 
 ;; This code is based on the 18.53 version c-mode.el, with extensive
 ;; rewriting.  Most of the features of c-mode survived intact.
diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el
index 16d85cb2d7..33d43cb3d5 100644
--- a/lisp/progmodes/prolog.el
+++ b/lisp/progmodes/prolog.el
@@ -60,9 +60,7 @@
 
 ;;; Installation:
 ;;
-;; Insert the following lines in your init file--typically ~/.emacs
-;; (GNU Emacs and XEmacs <21.4), or ~/.xemacs/init.el (XEmacs
-;; 21.4)--to use this mode when editing Prolog files under Emacs:
+;; Insert the following lines in your init file:
 ;;
 ;; (setq load-path (cons "/usr/lib/xemacs/site-lisp" load-path))
 ;; (autoload 'run-prolog "prolog" "Start a Prolog sub-process." t)
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 601850ed0f..ffc6c1ac88 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -1824,7 +1824,11 @@ When MSG is non-nil messages the first line of STRING."
         (lines (split-string string "\n" t)))
     (and msg (message "Sent: %s..." (nth 0 lines)))
     (if (> (length lines) 1)
-        (let* ((temp-file-name (make-temp-file "py"))
+        (let* ((temporary-file-directory
+                (if (file-remote-p default-directory)
+                    (concat (file-remote-p default-directory) "/tmp")
+                  temporary-file-directory))
+               (temp-file-name (make-temp-file "py"))
                (file-name (or (buffer-file-name) temp-file-name)))
           (with-temp-file temp-file-name
             (insert string)
@@ -1931,8 +1935,14 @@ FILE-NAME."
   (interactive "fFile to send: ")
   (let* ((process (or process (python-shell-get-or-create-process)))
          (temp-file-name (when temp-file-name
-                           (expand-file-name temp-file-name)))
-         (file-name (or (expand-file-name file-name) temp-file-name)))
+                           (expand-file-name
+                            (or (file-remote-p temp-file-name 'localname)
+                                temp-file-name))))
+         (file-name (or (when file-name
+                          (expand-file-name
+                           (or (file-remote-p file-name 'localname)
+                               file-name)))
+                        temp-file-name)))
     (when (not file-name)
       (error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil"))
     (python-shell-send-string
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 457c7fee36..77ec8084ea 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -64,8 +64,8 @@
   "Regexp to match keywords that nest without blocks.")
 
 (defconst ruby-indent-beg-re
-  (concat "\\(\\s *" (regexp-opt '("class" "module" "def") t) "\\)\\|"
-          (regexp-opt '("if" "unless" "case" "while" "until" "for" "begin")))
+  (concat "^\\s *" (regexp-opt '("class" "module" "def" "if" "unless" "case"
+                                 "while" "until" "for" "begin")) "\\_>")
   "Regexp to match where the indentation gets deeper.")
 
 (defconst ruby-modifier-beg-keywords
@@ -98,6 +98,10 @@
 
 (defconst ruby-block-end-re "\\_<end\\_>")
 
+(defconst ruby-defun-beg-re
+  '"\\(def\\|class\\|module\\)"
+  "Regexp to match the beginning of a defun, in the general sense.")
+
 (eval-and-compile
   (defconst ruby-here-doc-beg-re
   "\\(<\\)<\\(-\\)?\\(\\([a-zA-Z0-9_]+\\)\\|[\"]\\([^\"]+\\)[\"]\\|[']\\([^']+\\)[']\\)"
@@ -138,18 +142,11 @@ This should only be called after matching against `ruby-here-doc-beg-re'."
 
 (defvar ruby-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "{" 'ruby-electric-brace)
-    (define-key map "}" 'ruby-electric-brace)
-    (define-key map (kbd "M-C-a") 'ruby-beginning-of-defun)
-    (define-key map (kbd "M-C-e") 'ruby-end-of-defun)
     (define-key map (kbd "M-C-b") 'ruby-backward-sexp)
     (define-key map (kbd "M-C-f") 'ruby-forward-sexp)
     (define-key map (kbd "M-C-p") 'ruby-beginning-of-block)
     (define-key map (kbd "M-C-n") 'ruby-end-of-block)
-    (define-key map (kbd "M-C-h") 'ruby-mark-defun)
     (define-key map (kbd "M-C-q") 'ruby-indent-exp)
-    (define-key map (kbd "C-M-h") 'backward-kill-word)
-    (define-key map (kbd "C-j")   'reindent-then-newline-and-indent)
     (define-key map (kbd "C-c {") 'ruby-toggle-block)
     map)
   "Keymap used in Ruby mode.")
@@ -840,20 +837,13 @@ and `\\' when preceded by `?'."
           (+ indent ruby-indent-level)
         indent))))
 
-(defun ruby-electric-brace (arg)
-  "Insert a brace and re-indent the current line."
-  (interactive "P")
-  (self-insert-command (prefix-numeric-value arg))
-  (ruby-indent-line t))
-
-;; TODO: Why isn't one ruby-*-of-defun written in terms of the other?
 (defun ruby-beginning-of-defun (&optional arg)
   "Move backward to the beginning of the current top-level defun.
 With ARG, move backward multiple defuns.  Negative ARG means
 move forward."
   (interactive "p")
-  (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
-                           nil 'move (or arg 1))
+  (and (re-search-backward (concat "^\\s *" ruby-defun-beg-re "\\_>")
+                           nil t (or arg 1))
        (beginning-of-line)))
 
 (defun ruby-end-of-defun (&optional arg)
@@ -861,19 +851,18 @@ move forward."
 With ARG, move forward multiple defuns.  Negative ARG means
 move backward."
   (interactive "p")
-  (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
-                          nil 'move (or arg 1))
-       (beginning-of-line))
-  (forward-line 1))
+  (ruby-forward-sexp)
+  (when (looking-back (concat "^\\s *" ruby-block-end-re))
+    (forward-line 1)))
 
 (defun ruby-beginning-of-indent ()
-  "TODO: document"
-  ;; I don't understand this function.
-  ;; It seems like it should move to the line where indentation should deepen,
-  ;; but ruby-indent-beg-re only accounts for whitespace before class, module and def,
-  ;; so this will only match other block beginners at the beginning of the line.
-  (and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\_>") nil 'move)
-       (beginning-of-line)))
+  "Backtrack to a line which can be used as a reference for
+calculating indentation on the lines after it."
+  (while (and (re-search-backward ruby-indent-beg-re nil 'move)
+              (if (ruby-in-ppss-context-p 'anything)
+                  t
+                ;; We can stop, then.
+                (beginning-of-line)))))
 
 (defun ruby-move-to-block (n)
   "Move to the beginning (N < 0) or the end (N > 0) of the current block
@@ -1024,15 +1013,6 @@ With ARG, do it many times.  Negative ARG means move forward."
         ((error)))
       i)))
 
-(defun ruby-mark-defun ()
-  "Put mark at end of this Ruby function, point at beginning."
-  (interactive)
-  (push-mark (point))
-  (ruby-end-of-defun)
-  (push-mark (point) nil t)
-  (ruby-beginning-of-defun)
-  (re-search-backward "^\n" (- (point) 1) t))
-
 (defun ruby-indent-exp (&optional ignored)
   "Indent each line in the balanced expression following the point."
   (interactive "*P")
@@ -1073,7 +1053,7 @@ See `add-log-current-defun-function'."
         (let (mname mlist (indent 0))
           ;; get current method (or class/module)
           (if (re-search-backward
-               (concat "^[ \t]*\\(def\\|class\\|module\\)[ \t]+"
+               (concat "^[ \t]*" ruby-defun-beg-re "[ \t]+"
                        "\\("
                        ;; \\. and :: for class method
                         "\\([A-Za-z_]" ruby-symbol-re "*\\|\\.\\|::" "\\)"
@@ -1127,46 +1107,65 @@ See `add-log-current-defun-function'."
               (if mlist (concat mlist mname) mname)
             mlist)))))
 
-(defun ruby-brace-to-do-end ()
-  (when (looking-at "{")
-    (let ((orig (point)) (end (progn (ruby-forward-sexp) (point))))
-      (when (eq (char-before) ?\})
-        (delete-char -1)
-        (if (eq (char-syntax (char-before)) ?w)
-            (insert " "))
-        (insert "end")
-        (if (eq (char-syntax (char-after)) ?w)
-            (insert " "))
-        (goto-char orig)
-        (delete-char 1)
-        (if (eq (char-syntax (char-before)) ?w)
-            (insert " "))
-        (insert "do")
-        (when (looking-at "\\sw\\||")
-          (insert " ")
-          (backward-char))
-        t))))
-
-(defun ruby-do-end-to-brace ()
-  (when (and (or (bolp)
-                 (not (memq (char-syntax (char-before)) '(?w ?_))))
-             (looking-at "\\<do\\(\\s \\|$\\)"))
-    (let ((orig (point)) (end (progn (ruby-forward-sexp) (point))))
-      (backward-char 3)
-      (when (looking-at ruby-block-end-re)
-        (delete-char 3)
-        (insert "}")
-        (goto-char orig)
-        (delete-char 2)
-        (insert "{")
-        (if (looking-at "\\s +|")
-            (delete-char (- (match-end 0) (match-beginning 0) 1)))
-        t))))
+(defun ruby-brace-to-do-end (orig end)
+  (let (beg-marker end-marker)
+    (goto-char end)
+    (when (eq (char-before) ?\})
+      (delete-char -1)
+      (skip-chars-backward " \t")
+      (when (not (bolp))
+        (insert "\n"))
+      (insert "end")
+      (setq end-marker (point-marker))
+      (when (and (not (eobp)) (eq (char-syntax (char-after)) ?w))
+        (insert " "))
+      (goto-char orig)
+      (delete-char 1)
+      (when (eq (char-syntax (char-before)) ?w)
+        (insert " "))
+      (insert "do")
+      (setq beg-marker (point-marker))
+      (when (looking-at "\\(\\s \\)*|")
+        (unless (match-beginning 1)
+          (insert " "))
+        (goto-char (1+ (match-end 0)))
+        (search-forward "|"))
+      (unless (looking-at "\\s *$")
+        (insert "\n"))
+      (indent-region beg-marker end-marker)
+      (goto-char beg-marker)
+      t)))
+
+(defun ruby-do-end-to-brace (orig end)
+  (goto-char (- end 3))
+  (when (looking-at ruby-block-end-re)
+    (delete-char 3)
+    (insert "}")
+    (goto-char orig)
+    (delete-char 2)
+    (insert "{")
+    (if (looking-at "\\s +|")
+        (delete-char (- (match-end 0) (match-beginning 0) 1)))
+    t))
 
 (defun ruby-toggle-block ()
+  "Toggle block type from do-end to braces or back.
+The block must begin on the current line or above it and end after the point.
+If the result is do-end block, it will always be multiline."
   (interactive)
-  (or (ruby-brace-to-do-end)
-      (ruby-do-end-to-brace)))
+  (let ((start (point)) beg end)
+    (end-of-line)
+    (unless
+        (if (and (re-search-backward "\\({\\)\\|\\_<do\\(\\s \\|$\\||\\)")
+                 (progn
+                   (setq beg (point))
+                   (save-match-data (ruby-forward-sexp))
+                   (setq end (point))
+                   (> end start)))
+            (if (match-beginning 1)
+                (ruby-brace-to-do-end beg end)
+              (ruby-do-end-to-brace beg end)))
+      (goto-char start))))
 
 (declare-function ruby-syntax-propertize-heredoc "ruby-mode" (limit))
 (declare-function ruby-syntax-enclosing-percent-literal "ruby-mode" (limit))
@@ -1193,8 +1192,6 @@ It will be properly highlighted even when the call omits parens."))
         (ruby-syntax-enclosing-percent-literal end)
         (funcall
          (syntax-propertize-rules
-          ;; #{ }, #$hoge, #@foo are not comments.
-          ("\\(#\\)[{$@]" (1 "."))
           ;; $' $" $` .... are variables.
           ;; ?' ?" ?` are ascii codes.
           ("\\([?$]\\)[#\"'`]"
@@ -1326,8 +1323,7 @@ This should only be called after matching against `ruby-here-doc-end-re'."
                   (concat "-?\\([\"']\\|\\)" contents "\\1"))))))
 
   (defconst ruby-font-lock-syntactic-keywords
-    `( ;; #{ }, #$hoge, #@foo are not comments
-    ("\\(#\\)[{$@]" 1 (1 . nil))
+    `(
     ;; the last $', $", $` in the respective string is not variable
     ;; the last ?', ?", ?` in the respective string is not ascii code
     ("\\(^\\|[\[ \t\n<+\(,=]\\)\\(['\"`]\\)\\(\\\\.\\|\\2\\|[^'\"`\n\\\\]\\)*?\\\\?[?$]\\(\\2\\)"
@@ -1549,6 +1545,9 @@ See `font-lock-syntax-table'.")
    ;; variables
    '("\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\(nil\\|self\\|true\\|false\\)\\>"
      2 font-lock-variable-name-face)
+   ;; symbols
+   '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|@?\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
+     2 font-lock-reference-face)
    ;; variables
    '("\\(\\$\\([^a-zA-Z0-9 \n]\\|[0-9]\\)\\)\\W"
      1 font-lock-variable-name-face)
@@ -1557,12 +1556,9 @@ See `font-lock-syntax-table'.")
    ;; constants
    '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
      2 font-lock-type-face)
-   ;; symbols
-   '("\\(^\\|[^:]\\)\\(:\\([-+~]@?\\|[/%&|^`]\\|\\*\\*?\\|<\\(<\\|=>?\\)?\\|>[>=]?\\|===?\\|=~\\|![~=]?\\|\\[\\]=?\\|\\(\\w\\|_\\)+\\([!?=]\\|\\b_*\\)\\|#{[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\)\\)"
-     2 font-lock-reference-face)
    '("\\(^\\s *\\|[\[\{\(,]\\s *\\|\\sw\\s +\\)\\(\\(\\sw\\|_\\)+\\):[^:]" 2 font-lock-reference-face)
    ;; expression expansion
-   '("#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)"
+   '(ruby-match-expression-expansion
      0 font-lock-variable-name-face t)
    ;; warn lower camel case
                                         ;'("\\<[a-z]+[a-z0-9]*[A-Z][A-Za-z0-9]*\\([!?]?\\|\\>\\)"
@@ -1570,6 +1566,11 @@ See `font-lock-syntax-table'.")
    )
   "Additional expressions to highlight in Ruby mode.")
 
+(defun ruby-match-expression-expansion (limit)
+  (when (re-search-forward "[^\\]\\(\\\\\\\\\\)*\\(#\\({[^}\n\\\\]*\\(\\\\.[^}\n\\\\]*\\)*}\\|\\(\\$\\|@\\|@@\\)\\(\\w\\|_\\)+\\)\\)" limit 'move)
+    (or (ruby-in-ppss-context-p 'string)
+        (ruby-match-expression-expansion limit))))
+
 ;;;###autoload
 (define-derived-mode ruby-mode prog-mode "Ruby"
   "Major mode for editing Ruby scripts.
@@ -1586,6 +1587,10 @@ The variable `ruby-indent-level' controls the amount of indentation.
        'ruby-imenu-create-index)
   (set (make-local-variable 'add-log-current-defun-function)
        'ruby-add-log-current-method)
+  (set (make-local-variable 'beginning-of-defun-function)
+       'ruby-beginning-of-defun)
+  (set (make-local-variable 'end-of-defun-function)
+       'ruby-end-of-defun)
 
   (add-hook
    (cond ((boundp 'before-save-hook) 'before-save-hook)
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index a422462775..b4d550bcee 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1062,21 +1062,22 @@ subshells can nest."
               (backward-char 1))
             (when (eq (char-before) ?|)
               (backward-char 1) t)))
-      (when (progn (backward-char 2)
-                   (if (> start (line-end-position))
-                       (put-text-property (point) (1+ start)
-                                          'syntax-multiline t))
-                   ;; FIXME: The `in' may just be a random argument to
-                   ;; a normal command rather than the real `in' keyword.
-                   ;; I.e. we should look back to try and find the
-                   ;; corresponding `case'.
-                   (and (looking-at ";[;&]\\|\\_<in")
-                        ;; ";; esac )" is a case that looks like a case-pattern
-                        ;; but it's really just a close paren after a case
-                        ;; statement.  I.e. if we skipped over `esac' just now,
-                        ;; we're not looking at a case-pattern.
-                        (not (looking-at "..[ \t\n]+esac[^[:word:]_]"))))
-        sh-st-punc))))
+      (and (> (point) (1+ (point-min)))
+           (progn (backward-char 2)
+                  (if (> start (line-end-position))
+                      (put-text-property (point) (1+ start)
+                                         'syntax-multiline t))
+                  ;; FIXME: The `in' may just be a random argument to
+                  ;; a normal command rather than the real `in' keyword.
+                  ;; I.e. we should look back to try and find the
+                  ;; corresponding `case'.
+                  (and (looking-at ";[;&]\\|\\_<in")
+                       ;; ";; esac )" is a case that looks like a case-pattern
+                       ;; but it's really just a close paren after a case
+                       ;; statement.  I.e. if we skipped over `esac' just now,
+                       ;; we're not looking at a case-pattern.
+                       (not (looking-at "..[ \t\n]+esac[^[:word:]_]"))))
+           sh-st-punc))))
 
 (defun sh-font-lock-backslash-quote ()
   (if (eq (save-excursion (nth 3 (syntax-ppss (match-beginning 0)))) ?\')
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 030cc02f3f..3d5abc4df6 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -4,7 +4,7 @@
 
 ;; Author: Alex Schroeder <[email protected]>
 ;; Maintainer: Michael Mauger <[email protected]>
-;; Version: 3.0
+;; Version: 3.1
 ;; Keywords: comm languages processes
 ;; URL: http://savannah.gnu.org/projects/emacs/
 
@@ -218,9 +218,12 @@
 ;; Michael Mauger <[email protected]> -- improved product support
 ;; Drew Adams <[email protected]> -- Emacs 20 support
 ;; Harald Maier <[email protected]> -- sql-send-string
-;; Stefan Monnier <[email protected]> -- font-lock corrections; code polish
+;; Stefan Monnier <[email protected]> -- font-lock corrections; 
+;;      code polish
 ;; Paul Sleigh <[email protected]> -- MySQL keyword enhancement
 ;; Andrew Schein <[email protected]> -- sql-port bug
+;; Ian Bjorhovde <[email protected]> -- db2 escape newlines 
+;;      incorrectly enabled by default
 
 
 
@@ -265,9 +268,8 @@
 
 (defcustom sql-password ""
   "Default password.
-
-Storing your password in a textfile such as ~/.emacs could be dangerous.
-Customizing your password will store it in your ~/.emacs file."
+If you customize this, the value will be stored in your init
+file.  Since that is a plaintext file, this could be dangerous."
   :type 'string
   :group 'SQL
   :risky t)
@@ -879,6 +881,16 @@ In older versions of SQL*Plus, this was the SET SCAN OFF command."
   :type 'boolean
   :group 'SQL)
 
+(defcustom sql-db2-escape-newlines nil
+  "Non-nil if newlines should be escaped by a backslash in DB2 SQLi.
+
+When non-nil, Emacs will automatically insert a space and
+backslash prior to every newline in multi-line SQL statements as
+they are submitted to an interactive DB2 session."
+  :version "24.3"
+  :type 'boolean
+  :group 'SQL)
+
 ;; Customization for SQLite
 
 (defcustom sql-sqlite-program (or (executable-find "sqlite3")
@@ -1272,8 +1284,8 @@ Based on `comint-mode-map'.")
    ["List all objects" sql-list-all (sql-get-product-feature sql-product :list-all)]
    ["List table details" sql-list-table (sql-get-product-feature sql-product :list-table)]))
 
-;; Abbreviations -- if you want more of them, define them in your
-;; ~/.emacs file.  Abbrevs have to be enabled in your ~/.emacs, too.
+;; Abbreviations -- if you want more of them, define them in your init
+;; file.  Abbrevs have to be enabled in your init file, too.
 
 (defvar sql-mode-abbrev-table nil
   "Abbrev table used in `sql-mode' and `sql-interactive-mode'.")
@@ -3188,20 +3200,23 @@ Placeholders are words starting with an ampersand like &this."
 
 ;; Using DB2 interactively, newlines must be escaped with " \".
 ;; The space before the backslash is relevant.
+
 (defun sql-escape-newlines-filter (string)
   "Escape newlines in STRING.
 Every newline in STRING will be preceded with a space and a backslash."
-  (let ((result "") (start 0) mb me)
-    (while (string-match "\n" string start)
-      (setq mb (match-beginning 0)
-	    me (match-end 0)
-	    result (concat result
-			   (substring string start mb)
-			   (if (and (> mb 1)
-				    (string-equal " \\" (substring string (- mb 2) mb)))
-			       "" " \\\n"))
-	    start me))
-    (concat result (substring string start))))
+  (if (not sql-db2-escape-newlines)
+      string
+    (let ((result "") (start 0) mb me)
+      (while (string-match "\n" string start)
+        (setq mb (match-beginning 0)
+              me (match-end 0)
+              result (concat result
+                             (substring string start mb)
+                             (if (and (> mb 1)
+                                      (string-equal " \\" (substring string (- mb 2) mb)))
+                                 "" " \\\n"))
+              start me))
+      (concat result (substring string start)))))
 
 
 
@@ -3699,8 +3714,8 @@ For information on how to create multiple SQLi buffers, see
 `sql-interactive-mode'.
 
 Note that SQL doesn't have an escape character unless you specify
-one.  If you specify backslash as escape character in SQL,
-you must tell Emacs.  Here's how to do that in your `~/.emacs' file:
+one.  If you specify backslash as escape character in SQL, you
+must tell Emacs.  Here's how to do that in your init file:
 
 \(add-hook 'sql-mode-hook
           (lambda ()
@@ -3790,7 +3805,7 @@ cause the window to scroll to the end of the buffer.
 If you want to make SQL buffers limited in length, add the function
 `comint-truncate-buffer' to `comint-output-filter-functions'.
 
-Here is an example for your .emacs file.  It keeps the SQLi buffer a
+Here is an example for your init file.  It keeps the SQLi buffer a
 certain length.
 
 \(add-hook 'sql-interactive-mode-hook
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index c072754e66..835d548c19 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -8790,7 +8790,7 @@ Note these are only read when the file is first visited, you must use
 \\[find-alternate-file] RET  to have these take effect after editing them!
 
 If you want to disable the \"Process `eval' or hook local variables\"
-warning message, you need to add to your .emacs file:
+warning message, you need to add to your init file:
 
     (setq enable-local-eval t)"
   (let ((origbuf (current-buffer)))
@@ -11756,7 +11756,7 @@ An example:
 
 	// For this example we declare the function in the
 	// module's file itself.  Often you'd define it instead
-	// in a site-start.el or .emacs file.
+	// in a site-start.el or init file.
 	/*
 	 Local Variables:
 	 eval:
diff --git a/lisp/progmodes/vhdl-mode.el b/lisp/progmodes/vhdl-mode.el
index 607ccd8b7e..0ca3439dd6 100644
--- a/lisp/progmodes/vhdl-mode.el
+++ b/lisp/progmodes/vhdl-mode.el
@@ -4138,10 +4138,7 @@ STRING are replaced by `-' and substrings are converted to lower case."
   (set (make-local-variable 'imenu-generic-expression)
        vhdl-imenu-generic-expression)
   (when (and vhdl-index-menu (fboundp 'imenu))
-    (if (or (not (boundp 'font-lock-maximum-size))
-	    (> font-lock-maximum-size (buffer-size)))
-	(imenu-add-to-menubar "Index")
-      (message "Scanning buffer for index...buffer too big"))))
+    (imenu-add-to-menubar "Index")))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Source file menu (using `easy-menu.el')
@@ -14385,10 +14382,10 @@ if required."
 	  (define-key vhdl-speedbar-key-map (int-to-string key)
 	    `(lambda () (interactive) (vhdl-speedbar-set-depth ,key)))
 	  (setq key (1+ key)))))
-    (define-key speedbar-key-map "h"
+    (define-key speedbar-mode-map "h"
       (lambda () (interactive)
 	(speedbar-change-initial-expansion-list "vhdl directory")))
-    (define-key speedbar-key-map "H"
+    (define-key speedbar-mode-map "H"
       (lambda () (interactive)
 	(speedbar-change-initial-expansion-list "vhdl project")))
     ;; menu
@@ -17400,7 +17397,8 @@ to visually support naming conventions.")
   "Display VARIABLE's documentation in *Help* buffer."
   (interactive)
   (unless (featurep 'xemacs)
-    (help-setup-xref (list #'vhdl-doc-variable variable) (interactive-p)))
+    (help-setup-xref (list #'vhdl-doc-variable variable)
+		     (called-interactively-p 'interactive)))
   (with-output-to-temp-buffer
       (if (fboundp 'help-buffer) (help-buffer) "*Help*")
     (princ (documentation-property variable 'variable-documentation))
@@ -17412,7 +17410,8 @@ to visually support naming conventions.")
   "Display VHDL Mode documentation in *Help* buffer."
   (interactive)
   (unless (featurep 'xemacs)
-    (help-setup-xref (list #'vhdl-doc-mode) (interactive-p)))
+    (help-setup-xref (list #'vhdl-doc-mode)
+		     (called-interactively-p 'interactive)))
   (with-output-to-temp-buffer
       (if (fboundp 'help-buffer) (help-buffer) "*Help*")
     (princ mode-name)
diff --git a/lisp/ps-print.el b/lisp/ps-print.el
index addf2975c5..930e750ab2 100644
--- a/lisp/ps-print.el
+++ b/lisp/ps-print.el
@@ -1042,7 +1042,7 @@ Please send all bug fixes and enhancements to
 ;; variables `ps-bold-faces', `ps-italic-faces' and `ps-underlined-faces'.
 ;; These variables contain lists of faces that ps-print should consider bold,
 ;; italic or underline; to set them, put code like the following into your
-;; .emacs file:
+;; init file:
 ;;
 ;;      (setq ps-bold-faces '(my-blue-face))
 ;;      (setq ps-italic-faces '(my-red-face))
diff --git a/lisp/register.el b/lisp/register.el
index 2816c9831d..fb35a26a65 100644
--- a/lisp/register.el
+++ b/lisp/register.el
@@ -76,6 +76,22 @@ A list of the form (WINDOW-CONFIGURATION POSITION)
 A list of the form (FRAME-CONFIGURATION POSITION)
  represents a saved frame configuration plus a saved value of point.")
 
+(defgroup register nil
+  "Register commands."
+  :group 'convenience
+  :version "24.3")
+
+(defcustom register-separator nil
+  "Register containing the text to put between collected texts, or nil if none.
+
+When collecting text with
+`append-to-register' (resp. `prepend-to-register') contents of
+this register is added to the beginning (resp. end) of the marked
+text."
+  :group 'register
+  :type '(choice (const :tag "None" nil)
+		 (character :tag "Use register" :value ?+)))
+
 (defun get-register (register)
   "Return contents of Emacs register named REGISTER, or nil if none."
   (cdr (assq register register-alist)))
@@ -192,13 +208,24 @@ Interactively, NUMBER is the prefix arg (none means nil)."
 			(string-to-number (match-string 0)))
 		    0))))
 
-(defun increment-register (number register)
-  "Add NUMBER to the contents of register REGISTER.
-Interactively, NUMBER is the prefix arg."
-  (interactive "p\ncIncrement register: ")
-  (or (numberp (get-register register))
-      (error "Register does not contain a number"))
-  (set-register register (+ number (get-register register))))
+(defun increment-register (prefix register)
+  "Augment contents of REGISTER.
+Interactively, PREFIX is in raw form.
+
+If REGISTER contains a number, add `prefix-numeric-value' of
+PREFIX to it.
+
+If REGISTER is empty or if it contains text, call
+`append-to-register' with `delete-flag' set to PREFIX."
+  (interactive "P\ncIncrement register: ")
+  (let ((register-val (get-register register)))
+    (cond
+     ((numberp register-val)
+      (let ((number (prefix-numeric-value prefix)))
+	(set-register register (+ number register-val))))
+     ((or (not register-val) (stringp register-val))
+      (append-to-register register (region-beginning) (region-end) prefix))
+     (t (error "Register does not contain a number or text")))))
 
 (defun view-register (register)
   "Display what is contained in register named REGISTER.
@@ -349,10 +376,11 @@ Called from program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions indicating what to append."
   (interactive "cAppend to register: \nr\nP")
   (let ((reg (get-register register))
-        (text (filter-buffer-substring start end)))
+        (text (filter-buffer-substring start end))
+	(separator (and register-separator (get-register register-separator))))
     (set-register
      register (cond ((not reg) text)
-                    ((stringp reg) (concat reg text))
+                    ((stringp reg) (concat reg separator text))
                     (t (error "Register does not contain text")))))
   (cond (delete-flag
 	 (delete-region start end))
@@ -366,10 +394,11 @@ Called from program, takes four args: REGISTER, START, END and DELETE-FLAG.
 START and END are buffer positions indicating what to prepend."
   (interactive "cPrepend to register: \nr\nP")
   (let ((reg (get-register register))
-        (text (filter-buffer-substring start end)))
+        (text (filter-buffer-substring start end))
+	(separator (and register-separator (get-register register-separator))))
     (set-register
      register (cond ((not reg) text)
-                    ((stringp reg) (concat text reg))
+                    ((stringp reg) (concat text separator reg))
                     (t (error "Register does not contain text")))))
   (cond (delete-flag
 	 (delete-region start end))
diff --git a/lisp/replace.el b/lisp/replace.el
index 3373ee8e51..001f7d1a78 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -33,6 +33,22 @@
   :type 'boolean
   :group 'matching)
 
+(defcustom replace-lax-whitespace nil
+  "Non-nil means `query-replace' matches a sequence of whitespace chars.
+When you enter a space or spaces in the strings to be replaced,
+it will match any sequence matched by the regexp `search-whitespace-regexp'."
+  :type 'boolean
+  :group 'matching
+  :version "24.3")
+
+(defcustom replace-regexp-lax-whitespace nil
+  "Non-nil means `query-replace-regexp' matches a sequence of whitespace chars.
+When you enter a space or spaces in the regexps to be replaced,
+it will match any sequence matched by the regexp `search-whitespace-regexp'."
+  :type 'boolean
+  :group 'matching
+  :version "24.3")
+
 (defvar query-replace-history nil
   "Default history list for query-replace commands.
 See `query-replace-from-history-variable' and
@@ -226,6 +242,10 @@ letters.  \(Transferring the case pattern means that if the old text
 matched is all caps, or capitalized, then its replacement is upcased
 or capitalized.)
 
+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'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on.
@@ -270,6 +290,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.)
 
+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'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on.
@@ -346,6 +370,10 @@ minibuffer.
 Preserves case in each replacement if `case-replace' and `case-fold-search'
 are non-nil and REGEXP has no uppercase letters.
 
+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'.
+
 Third arg DELIMITED (prefix arg if interactive), if non-nil, means replace
 only matches that are surrounded by word boundaries.
 Fourth and fifth arg START and END specify the region to operate on."
@@ -437,6 +465,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.)
 
+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'.
+
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer.
 
@@ -475,6 +507,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.
 
+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'.
+
 In Transient Mark mode, if the mark is active, operate on the contents
 of the region.  Otherwise, operate from point to the end of the buffer.
 
@@ -1589,14 +1625,28 @@ E to edit the replacement string"
     (define-key map "?" 'help)
     (define-key map "\C-g" 'quit)
     (define-key map "\C-]" 'quit)
-    (define-key map "\e" 'exit-prefix)
+    (define-key map "\C-v" 'scroll-up)
+    (define-key map "\M-v" 'scroll-down)
+    (define-key map [next] 'scroll-up)
+    (define-key map [prior] 'scroll-down)
+    (define-key map [?\C-\M-v] 'scroll-other-window)
+    (define-key map [M-next] 'scroll-other-window)
+    (define-key map [?\C-\M-\S-v] 'scroll-other-window-down)
+    (define-key map [M-prior] 'scroll-other-window-down)
+    ;; Binding ESC would prohibit the M-v binding.  Instead, callers
+    ;; should check for ESC specially.
+    ;; (define-key map "\e" 'exit-prefix)
     (define-key map [escape] 'exit-prefix)
     map)
-  "Keymap that defines the responses to questions in `query-replace'.
+  "Keymap of responses to questions posed by commands like `query-replace'.
 The \"bindings\" in this map are not commands; they are answers.
 The valid answers include `act', `skip', `act-and-show',
-`exit', `act-and-exit', `edit', `edit-replacement', `delete-and-edit',
-`recenter', `automatic', `backup', `exit-prefix', `quit', and `help'.")
+`act-and-exit', `exit', `exit-prefix', `recenter', `scroll-up',
+`scroll-down', `scroll-other-window', `scroll-other-window-down',
+`edit', `edit-replacement', `delete-and-edit', `automatic',
+`backup', `quit', and `help'.
+
+This keymap is used by `y-or-n-p' as well as `query-replace'.")
 
 (defvar multi-query-replace-map
   (let ((map (make-sparse-keymap)))
@@ -1717,12 +1767,12 @@ passed in.  If LITERAL is set, no checking is done, anyway."
   (replace-match newtext fixedcase literal)
   noedit)
 
-(defvar replace-search-function 'search-forward
+(defvar replace-search-function nil
   "Function to use when searching for strings to replace.
 It is used by `query-replace' and `replace-string', and is called
 with three arguments, as if it were `search-forward'.")
 
-(defvar replace-re-search-function 're-search-forward
+(defvar replace-re-search-function nil
   "Function to use when searching for regexps to replace.
 It is used by `query-replace-regexp', `replace-regexp',
 `query-replace-regexp-eval', and `map-query-replace-regexp'.
@@ -1755,9 +1805,18 @@ make, or the user didn't cancel the call."
          (nocasify (not (and case-replace case-fold-search)))
          (literal (or (not regexp-flag) (eq regexp-flag 'literal)))
          (search-function
-	  (if regexp-flag
-	      replace-re-search-function
-	    replace-search-function))
+	  (or (if regexp-flag
+		  replace-re-search-function
+		replace-search-function)
+	      (let ((isearch-regexp regexp-flag)
+		    (isearch-word delimited-flag)
+		    (isearch-lax-whitespace
+		     replace-lax-whitespace)
+		    (isearch-regexp-lax-whitespace
+		     replace-regexp-lax-whitespace)
+		    (isearch-case-fold-search case-fold-search)
+		    (isearch-forward t))
+		(isearch-search-fun))))
          (search-string from-string)
          (real-match-data nil)       ; The match data for the current match.
          (next-replacement nil)
@@ -1811,12 +1870,6 @@ make, or the user didn't cancel the call."
                                (vector repeat-count repeat-count
                                        replacements replacements)))))
 
-    (if delimited-flag
-	(setq search-function 're-search-forward
-	      search-string (concat "\\b"
-				    (if regexp-flag from-string
-				      (regexp-quote from-string))
-				    "\\b")))
     (when query-replace-lazy-highlight
       (setq isearch-lazy-highlight-last-string nil))
 
@@ -1898,7 +1951,7 @@ make, or the user didn't cancel the call."
 		    (replace-highlight
 		     (nth 0 real-match-data) (nth 1 real-match-data)
 		     start end search-string
-		     (or delimited-flag regexp-flag) case-fold-search))
+		     regexp-flag delimited-flag case-fold-search))
 		  (setq noedit
 			(replace-match-maybe-edit
 			 next-replacement nocasify literal
@@ -1917,7 +1970,7 @@ make, or the user didn't cancel the call."
 		  (replace-highlight
 		   (match-beginning 0) (match-end 0)
 		   start end search-string
-		   (or delimited-flag regexp-flag) case-fold-search)
+		   regexp-flag delimited-flag case-fold-search)
 		  ;; Bind message-log-max so we don't fill up the message log
 		  ;; with a bunch of identical messages.
 		  (let ((message-log-max nil)
@@ -2099,15 +2152,11 @@ make, or the user didn't cancel the call."
 		 (if (= replace-count 1) "" "s")))
     (or (and keep-going stack) multi-buffer)))
 
-(defvar isearch-error)
-(defvar isearch-forward)
-(defvar isearch-case-fold-search)
-(defvar isearch-string)
-
 (defvar replace-overlay nil)
 
 (defun replace-highlight (match-beg match-end range-beg range-end
-			  string regexp case-fold)
+			  search-string regexp-flag delimited-flag
+			  case-fold-search)
   (if query-replace-highlight
       (if replace-overlay
 	  (move-overlay replace-overlay match-beg match-end (current-buffer))
@@ -2115,13 +2164,14 @@ make, or the user didn't cancel the call."
 	(overlay-put replace-overlay 'priority 1001) ;higher than lazy overlays
 	(overlay-put replace-overlay 'face 'query-replace)))
   (if query-replace-lazy-highlight
-      (let ((isearch-string string)
-	    (isearch-regexp regexp)
-	    ;; Set isearch-word to nil because word-replace is regexp-based,
-	    ;; so `isearch-search-fun' should not use `word-search-forward'.
-	    (isearch-word nil)
-	    (search-whitespace-regexp nil)
-	    (isearch-case-fold-search case-fold)
+      (let ((isearch-string search-string)
+	    (isearch-regexp regexp-flag)
+	    (isearch-word delimited-flag)
+	    (isearch-lax-whitespace
+	     replace-lax-whitespace)
+	    (isearch-regexp-lax-whitespace
+	     replace-regexp-lax-whitespace)
+	    (isearch-case-fold-search case-fold-search)
 	    (isearch-forward t)
 	    (isearch-error nil))
 	(isearch-lazy-highlight-new-loop range-beg range-end))))
diff --git a/lisp/saveplace.el b/lisp/saveplace.el
index 43dad63a14..0c08216946 100644
--- a/lisp/saveplace.el
+++ b/lisp/saveplace.el
@@ -56,13 +56,12 @@ This means when you visit a file, point goes to the last place
 where it was when you previously visited the same file.
 This variable is automatically buffer-local.
 
-If you wish your place in any file to always be automatically saved,
-simply put this in your `~/.emacs' file:
+If you wish your place in any file to always be automatically
+saved, set this to t using the Customize facility, or put the
+following code in your init file:
 
 \(setq-default save-place t)
-\(require 'saveplace)
-
-or else use the Custom facility to set this option."
+\(require 'saveplace)"
   :type 'boolean
   :require 'saveplace
   :group 'save-place)
@@ -148,7 +147,8 @@ even in a later Emacs session.
 If called with a prefix arg, the mode is enabled if and only if
 the argument is positive.
 
-To save places automatically in all files, put this in your `.emacs' file:
+To save places automatically in all files, put this in your init
+file:
 
 \(setq-default save-place t\)"
   (interactive "P")
diff --git a/lisp/ses.el b/lisp/ses.el
index 8add16a699..7cdac74e31 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -1270,11 +1270,9 @@ when the width of cell (ROW,COL) has changed."
 ;; The data area
 ;;----------------------------------------------------------------------------
 
-(defun ses-narrowed-p () (/= (- (point-max) (point-min)) (buffer-size)))
-
 (defun ses-widen ()
   "Turn off narrowing, to be reenabled at end of command loop."
-  (if (ses-narrowed-p)
+  (if (buffer-narrowed-p)
       (setq ses--deferred-narrow t))
   (widen))
 
diff --git a/lisp/shell.el b/lisp/shell.el
index b98efceefb..77a4238978 100644
--- a/lisp/shell.el
+++ b/lisp/shell.el
@@ -46,7 +46,7 @@
 
 ;; YOUR .EMACS FILE
 ;;=============================================================================
-;; Some suggestions for your .emacs file.
+;; Some suggestions for your init file.
 ;;
 ;; ;; Define M-# to run some strange command:
 ;; (eval-after-load "shell"
@@ -136,9 +136,7 @@ how Shell mode treats paragraphs.
 
 The pattern should probably not match more than one line.  If it does,
 Shell mode may become confused trying to distinguish prompt from input
-on lines which don't start with a prompt.
-
-This is a fine thing to set in your `.emacs' file."
+on lines which don't start with a prompt."
   :type 'regexp
   :group 'shell)
 
@@ -146,9 +144,7 @@ This is a fine thing to set in your `.emacs' file."
   "List of suffixes to be disregarded during file/command completion.
 This variable is used to initialize `comint-completion-fignore' in the shell
 buffer.  The default is nil, for compatibility with most shells.
-Some people like (\"~\" \"#\" \"%\").
-
-This is a fine thing to set in your `.emacs' file."
+Some people like (\"~\" \"#\" \"%\")."
   :type '(repeat (string :tag "Suffix"))
   :group 'shell)
 
@@ -158,31 +154,29 @@ This variable is used to initialize `comint-delimiter-argument-list' in the
 shell buffer.  The value may depend on the operating system or shell."
   :type '(choice (const nil)
 		 (repeat :tag "List of characters" character))
-  ;; Reverted.
-;;  :version "24.1"			; changed to nil (bug#8027)
   :group 'shell)
 
-(defvar shell-file-name-chars
+(defcustom shell-file-name-chars
   (if (memq system-type '(ms-dos windows-nt cygwin))
       "~/A-Za-z0-9_^$!#%&{}@`'.,:()-"
     "[]~/A-Za-z0-9+@:_.$#%,={}-")
   "String of characters valid in a file name.
 This variable is used to initialize `comint-file-name-chars' in the
-shell buffer.  The value may depend on the operating system or shell.
-
-This is a fine thing to set in your `.emacs' file.")
+shell buffer.  The value may depend on the operating system or shell."
+  :type 'string
+  :group 'shell)
 
-(defvar shell-file-name-quote-list
+(defcustom shell-file-name-quote-list
   (if (memq system-type '(ms-dos windows-nt))
       nil
     (append shell-delimiter-argument-list '(?\s ?$ ?\* ?\! ?\" ?\' ?\` ?\# ?\\)))
   "List of characters to quote when in a file name.
 This variable is used to initialize `comint-file-name-quote-list' in the
-shell buffer.  The value may depend on the operating system or shell.
-
-This is a fine thing to set in your `.emacs' file.")
+shell buffer.  The value may depend on the operating system or shell."
+  :type '(repeat character)
+  :group 'shell)
 
-(defvar shell-dynamic-complete-functions
+(defcustom shell-dynamic-complete-functions
   '(comint-c-a-p-replace-by-expanded-history
     shell-environment-variable-completion
     shell-command-completion
@@ -192,9 +186,9 @@ This is a fine thing to set in your `.emacs' file.")
     comint-filename-completion)
   "List of functions called to perform completion.
 This variable is used to initialize `comint-dynamic-complete-functions' in the
-shell buffer.
-
-This is a fine thing to set in your `.emacs' file.")
+shell buffer."
+  :type '(repeat function)
+  :group 'shell)
 
 (defcustom shell-command-regexp "[^;&|\n]+"
   "Regexp to match a single command within a pipeline.
diff --git a/lisp/simple.el b/lisp/simple.el
index b81e0d7ee8..6e37700b91 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -974,7 +974,9 @@ rather than the region.
 
 If called from Lisp, return the number of words between positions
 START and END."
-  (interactive "r\nP")
+  (interactive (if current-prefix-arg
+		   (list nil nil current-prefix-arg)
+		 (list (region-beginning) (region-end) nil)))
   (cond ((not (called-interactively-p 'any))
 	 (count-words start end))
 	(arg
@@ -1008,9 +1010,7 @@ END, without printing any message."
 
 (defun count-words--buffer-message ()
   (count-words--message
-   (if (= (point-max) (1+ (buffer-size)))
-       "Buffer"
-     "Narrowed part of buffer")
+   (if (buffer-narrowed-p) "Narrowed part of buffer" "Buffer")
    (point-min) (point-max)))
 
 (defun count-words--message (str start end)
diff --git a/lisp/speedbar.el b/lisp/speedbar.el
index 16993ce189..25a6fbfd99 100644
--- a/lisp/speedbar.el
+++ b/lisp/speedbar.el
@@ -706,7 +706,7 @@ will be stripped by a simplified optimizer when compiled into a
 singular expression.  This variable will be turned into
 `speedbar-file-regexp' for use with speedbar.  You should use the
 function `speedbar-add-supported-extension' to add a new extension at
-runtime, or use the configuration dialog to set it in your .emacs file.
+runtime, or use the configuration dialog to set it in your init file.
 If you add an extension to this list, and it does not appear, you may
 need to also modify `completion-ignored-extension' which will also help
 file completion."
@@ -763,7 +763,7 @@ DIRECTORY-EXPRESSION to `speedbar-ignored-directory-expressions'."
   "Non-nil means to automatically update the display.
 When this is nil then speedbar will not follow the attached frame's directory.
 If you want to change this while speedbar is active, either use
-\\[customize] or call \\<speedbar-key-map> `\\[speedbar-toggle-updates]'."
+\\[customize] or call \\<speedbar-mode-map> `\\[speedbar-toggle-updates]'."
   :group 'speedbar
   :initialize 'custom-initialize-default
   :set (lambda (sym val)
@@ -1083,7 +1083,7 @@ Return nil if it doesn't exist."
 
 (define-derived-mode speedbar-mode fundamental-mode "Speedbar"
   "Major mode for managing a display of directories and tags.
-\\<speedbar-key-map>
+\\<speedbar-mode-map>
 The first line represents the default directory of the speedbar frame.
 Each directory segment is a button which jumps speedbar's default
 directory to that directory.  Buttons are activated by clicking `\\[speedbar-click]'.
@@ -1120,7 +1120,7 @@ category of tags.  Click the {+} to expand the category.  Jump-able
 tags start with >.  Click the name of the tag to go to that position
 in the selected file.
 
-\\{speedbar-key-map}"
+\\{speedbar-mode-map}"
   (save-excursion
     (setq font-lock-keywords nil) ;; no font-locking please
     (setq truncate-lines t)
diff --git a/lisp/startup.el b/lisp/startup.el
index dd21663890..a0122c7455 100644
--- a/lisp/startup.el
+++ b/lisp/startup.el
@@ -71,12 +71,13 @@ once you are familiar with the contents of the startup screen."
   "Non-nil inhibits the initial startup echo area message.
 Setting this variable takes effect
 only if you do it with the customization buffer
-or if your `.emacs' file contains a line of this form:
+or if your init file contains a line of this form:
  (setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\")
-If your `.emacs' file is byte-compiled, use the following form instead:
+If your init file is byte-compiled, use the following form
+instead:
  (eval '(setq inhibit-startup-echo-area-message \"YOUR-USER-NAME\"))
-Thus, someone else using a copy of your `.emacs' file will see
-the startup message unless he personally acts to inhibit it."
+Thus, someone else using a copy of your init file will see the
+startup message unless he personally acts to inhibit it."
   :type '(choice (const :tag "Don't inhibit")
 		 (string :tag "Enter your user name, to inhibit"))
   :group 'initialization)
@@ -261,10 +262,14 @@ and VALUE is the value which is given to that frame parameter
   "Normal hook run after handling urgent options but before loading init files.")
 
 (defvar after-init-hook nil
-  "Normal hook run after loading the init files, `~/.emacs' and `default.el'.
-There is no `condition-case' around the running of these functions;
-therefore, if you set `debug-on-error' non-nil in `.emacs',
-an error in one of these functions will invoke the debugger.")
+  "Normal hook run after initializing the Emacs session.
+It is run after Emacs loads the init file, `default' library, the
+abbrevs file, and additional Lisp packages (if any), and setting
+the value of `after-init-time'.
+
+There is no `condition-case' around the running of this hook;
+therefore, if `debug-on-error' is non-nil, an error in one of
+these functions will invoke the debugger.")
 
 (defvar emacs-startup-hook nil
   "Normal hook run after loading init files and handling the command line.")
@@ -296,7 +301,7 @@ the user's init file.")
   :group 'initialization)
 
 (defvar init-file-user nil
-  "Identity of user whose `.emacs' file is or was read.
+  "Identity of user whose init file is or was read.
 The value is nil if `-q' or `--no-init-file' was specified,
 meaning do not load any init file.
 
@@ -306,7 +311,7 @@ or it may be a string containing a user's name meaning
 use that person's init file.
 
 In either of the latter cases, `(concat \"~\" init-file-user \"/\")'
-evaluates to the name of the directory where the `.emacs' file was
+evaluates to the name of the directory where the init file was
 looked for.
 
 Setting `init-file-user' does not prevent Emacs from loading
@@ -365,7 +370,7 @@ init file is read, in case it sets `mail-host-address'."
 	(t
 	 (concat user-emacs-directory "auto-save-list/.saves-")))
   "Prefix for generating `auto-save-list-file-name'.
-This is used after reading your `.emacs' file to initialize
+This is used after reading your init file to initialize
 `auto-save-list-file-name', by appending Emacs's pid and the system name,
 if you have not already set `auto-save-list-file-name' yourself.
 Directories in the prefix will be created if necessary.
diff --git a/lisp/strokes.el b/lisp/strokes.el
index dfd0e95f61..62a8528f25 100644
--- a/lisp/strokes.el
+++ b/lisp/strokes.el
@@ -933,14 +933,7 @@ and then safely save them for later use, send letters to friends
 extracting the strokes for editing use once again, so the editing
 cycle can continue.
 
-Strokes are easy to program and fun to use.  To start strokes going,
-you'll want to put the following line in your .emacs file as mentioned
-in the commentary to strokes.el.
-
-This will load strokes when and only when you start Emacs on a window
-system, with a mouse or other pointer device defined.
-
-To toggle strokes-mode, you just do
+To toggle strokes-mode, invoke the command
 
 > M-x strokes-mode
 
diff --git a/lisp/subr.el b/lisp/subr.el
index 74afd59f8d..e9b85ff1f3 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -80,6 +80,7 @@ For more information, see Info node `(elisp)Declaring Functions'."
 (defmacro noreturn (form)
   "Evaluate FORM, expecting it not to return.
 If FORM does return, signal an error."
+  (declare (debug t))
   `(prog1 ,form
      (error "Form marked with `noreturn' did return")))
 
@@ -87,6 +88,7 @@ If FORM does return, signal an error."
   "Evaluate FORM, expecting a constant return value.
 This is the global do-nothing version.  There is also `testcover-1value'
 that complains if FORM ever does return differing values."
+  (declare (debug t))
   form)
 
 (defmacro def-edebug-spec (symbol spec)
@@ -1250,11 +1252,6 @@ is converted into a string by expressing it in decimal."
  'mode-line-inverse-video
  "use the appropriate faces instead."
  "21.1")
-(make-obsolete-variable
- 'unread-command-char
- "use `unread-command-events' instead.  That variable is a list of events
-to reread, so it now uses nil to mean `no event', instead of -1."
- "before 19.15")
 
 ;; Lisp manual only updated in 22.1.
 (define-obsolete-variable-alias 'executing-macro 'executing-kbd-macro
@@ -1548,7 +1545,7 @@ if it is empty or a duplicate."
 	       (or keep-all
 		   (not (equal (car history) newelt))))
       (if history-delete-duplicates
-	  (delete newelt history))
+	  (setq history (delete newelt history)))
       (setq history (cons newelt history))
       (when (integerp maxelt)
 	(if (= 0 maxelt)
@@ -2237,7 +2234,8 @@ keyboard-quit events while waiting for a valid input."
     (error "Called `read-char-choice' without valid char choices"))
   (let (char done show-help (helpbuf " *Char Help*"))
     (let ((cursor-in-echo-area t)
-          (executing-kbd-macro executing-kbd-macro))
+          (executing-kbd-macro executing-kbd-macro)
+	  (esc-flag nil))
       (save-window-excursion	      ; in case we call help-form-show
 	(while (not done)
 	  (unless (get-text-property 0 'face prompt)
@@ -2261,8 +2259,12 @@ keyboard-quit events while waiting for a valid input."
 	    ;; there are no more events in the macro.  Attempt to
 	    ;; get an event interactively.
 	    (setq executing-kbd-macro nil))
-	   ((and (not inhibit-keyboard-quit) (eq char ?\C-g))
-	    (keyboard-quit))))))
+	   ((not inhibit-keyboard-quit)
+	    (cond
+	     ((and (null esc-flag) (eq char ?\e))
+	      (setq esc-flag t))
+	     ((memq char '(?\C-g ?\e))
+	      (keyboard-quit))))))))
     ;; Display the question with the answer.  But without cursor-in-echo-area.
     (message "%s%s" prompt (char-to-string char))
     char))
@@ -2314,11 +2316,19 @@ floating point support."
 PROMPT is the string to display to ask the question.  It should
 end in a space; `y-or-n-p' adds \"(y or n) \" to it.
 
-No confirmation of the answer is requested; a single character is enough.
-Also accepts Space to mean yes, or Delete to mean no.  \(Actually, it uses
-the bindings in `query-replace-map'; see the documentation of that variable
-for more information.  In this case, the useful bindings are `act', `skip',
-`recenter', and `quit'.\)
+No confirmation of the answer is requested; a single character is
+enough.  SPC also means yes, and DEL means no.
+
+To be precise, this function translates user input into responses
+by consulting the bindings in `query-replace-map'; see the
+documentation of that variable for more information.  In this
+case, the useful bindings are `act', `skip', `recenter',
+`scroll-up', `scroll-down', and `quit'.
+An `act' response means yes, and a `skip' response means no.
+A `quit' response means to invoke `keyboard-quit'.
+If the user enters `recenter', `scroll-up', or `scroll-down'
+responses, perform the requested window recentering or scrolling
+and ask again.
 
 Under a windowing system a dialog box will be used if `last-nonmenu-event'
 is nil and `use-dialog-box' is non-nil."
@@ -2350,21 +2360,33 @@ is nil and `use-dialog-box' is non-nil."
                                "" " ")
                            "(y or n) "))
       (while
-          (let* ((key
+          (let* ((scroll-actions '(recenter scroll-up scroll-down
+				   scroll-other-window scroll-other-window-down))
+		 (key
                   (let ((cursor-in-echo-area t))
                     (when minibuffer-auto-raise
                       (raise-frame (window-frame (minibuffer-window))))
-                    (read-key (propertize (if (eq answer 'recenter)
+                    (read-key (propertize (if (memq answer scroll-actions)
                                               prompt
                                             (concat "Please answer y or n.  "
                                                     prompt))
                                           'face 'minibuffer-prompt)))))
             (setq answer (lookup-key query-replace-map (vector key) t))
             (cond
-             ((memq answer '(skip act)) nil)
-             ((eq answer 'recenter) (recenter) t)
-             ((memq answer '(exit-prefix quit)) (signal 'quit nil) t)
-             (t t)))
+	     ((memq answer '(skip act)) nil)
+	     ((eq answer 'recenter)
+	      (recenter) t)
+	     ((eq answer 'scroll-up)
+	      (ignore-errors (scroll-up-command)) t)
+	     ((eq answer 'scroll-down)
+	      (ignore-errors (scroll-down-command)) t)
+	     ((eq answer 'scroll-other-window)
+	      (ignore-errors (scroll-other-window)) t)
+	     ((eq answer 'scroll-other-window-down)
+	      (ignore-errors (scroll-other-window-down)) t)
+	     ((or (memq answer '(exit-prefix quit)) (eq key ?\e))
+	      (signal 'quit nil) t)
+	     (t t)))
         (ding)
         (discard-input))))
     (let ((ret (eq answer 'act)))
@@ -2647,6 +2669,10 @@ directory if it does not exist."
 
 ;;;; Misc. useful functions.
 
+(defsubst buffer-narrowed-p ()
+  "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.
 If there is no plausible default, return nil."
@@ -3728,7 +3754,7 @@ from `standard-syntax-table' otherwise."
     table))
 
 (defun syntax-after (pos)
-  "Return the raw syntax of the char after POS.
+  "Return the raw syntax descriptor for the char after POS.
 If POS is outside the buffer's accessible portion, return nil."
   (unless (or (< pos (point-min)) (>= pos (point-max)))
     (let ((st (if parse-sexp-lookup-properties
@@ -3737,7 +3763,12 @@ If POS is outside the buffer's accessible portion, return nil."
 	(aref (or st (syntax-table)) (char-after pos))))))
 
 (defun syntax-class (syntax)
-  "Return the syntax class part of the syntax descriptor SYNTAX.
+  "Return the code for the syntax class described by SYNTAX.
+
+SYNTAX should be a raw syntax descriptor; the return value is a
+integer which encodes the corresponding syntax class.  See Info
+node `(elisp)Syntax Table Internals' for a list of codes.
+
 If SYNTAX is nil, return nil."
   (and syntax (logand (car syntax) 65535)))
 
@@ -3877,6 +3908,11 @@ The properties used on SYMBOL are `composefunc', `sendfunc',
   (put symbol 'hookvar (or hookvar 'mail-send-hook)))
 
 (defun set-temporary-overlay-map (map &optional keep-pred)
+  "Set MAP as a temporary overlay map.
+When KEEP-PRED is `t', using a key from the temporary keymap
+leaves this keymap activated.  KEEP-PRED can also be a function,
+which will have the same effect when it returns `t'.
+When KEEP-PRED is nil, the temporary keymap is used only once."
   (let* ((clearfunsym (make-symbol "clear-temporary-overlay-map"))
          (overlaysym (make-symbol "t"))
          (alist (list (cons overlaysym map)))
@@ -3889,6 +3925,7 @@ The properties used on SYMBOL are `composefunc', `sendfunc',
                                   (lookup-key ',map
                                               (this-command-keys-vector))))
                             (t `(funcall ',keep-pred)))
+               (set ',overlaysym nil)   ;Just in case.
                (remove-hook 'pre-command-hook ',clearfunsym)
                (setq emulation-mode-map-alists
                      (delq ',alist emulation-mode-map-alists))))))
diff --git a/lisp/term/iris-ansi.el b/lisp/term/iris-ansi.el
index 9a9a31f425..aea2e8c109 100644
--- a/lisp/term/iris-ansi.el
+++ b/lisp/term/iris-ansi.el
@@ -322,7 +322,7 @@
   "Terminal initialization function for iris-ansi."
   ;; Use inheritance to let the main keymap override these defaults.
   ;; This way we don't override terminfo-derived settings or settings
-  ;; made in the .emacs file.
+  ;; made in the init file.
   (let ((m (copy-keymap iris-function-map)))
     (set-keymap-parent m (keymap-parent input-decode-map))
     (set-keymap-parent input-decode-map m)))
diff --git a/lisp/term/lk201.el b/lisp/term/lk201.el
index 76a3a31ced..6b9e130100 100644
--- a/lisp/term/lk201.el
+++ b/lisp/term/lk201.el
@@ -75,7 +75,7 @@
 (defun terminal-init-lk201 ()
   ;; Use inheritance to let the main keymap override these defaults.
   ;; This way we don't override terminfo-derived settings or settings
-  ;; made in the .emacs file.
+  ;; made in the init file.
   (let ((m (copy-keymap lk201-function-map)))
     (set-keymap-parent m (keymap-parent input-decode-map))
     (set-keymap-parent input-decode-map m)))
diff --git a/lisp/term/rxvt.el b/lisp/term/rxvt.el
index 481d6b498c..9814156300 100644
--- a/lisp/term/rxvt.el
+++ b/lisp/term/rxvt.el
@@ -166,7 +166,7 @@
 
   ;; Use inheritance to let the main keymap override those defaults.
   ;; This way we don't override terminfo-derived settings or settings
-  ;; made in the .emacs file.
+  ;; made in the init file.
   (let ((m (copy-keymap rxvt-function-map)))
     (set-keymap-parent m (keymap-parent input-decode-map))
     (set-keymap-parent input-decode-map m))
diff --git a/lisp/term/tvi970.el b/lisp/term/tvi970.el
index b02d39c1e0..f1b6eea887 100644
--- a/lisp/term/tvi970.el
+++ b/lisp/term/tvi970.el
@@ -93,7 +93,7 @@
   "Terminal initialization function for tvi970."
   ;; Use inheritance to let the main keymap override these defaults.
   ;; This way we don't override terminfo-derived settings or settings
-  ;; made in the .emacs file.
+  ;; made in the init file.
   (let ((m (copy-keymap tvi970-terminal-map)))
     (set-keymap-parent m (keymap-parent input-decode-map))
     (set-keymap-parent input-decode-map m))
diff --git a/lisp/term/wyse50.el b/lisp/term/wyse50.el
index d037962af1..ce148b62db 100644
--- a/lisp/term/wyse50.el
+++ b/lisp/term/wyse50.el
@@ -109,7 +109,7 @@
   "Terminal initialization function for wyse50."
   ;; Use inheritance to let the main keymap override these defaults.
   ;; This way we don't override terminfo-derived settings or settings
-  ;; made in the .emacs file.
+  ;; made in the init file.
   (let ((m (copy-keymap wyse50-terminal-map)))
     (set-keymap-parent m (keymap-parent input-decode-map))
     (set-keymap-parent input-decode-map m))
diff --git a/lisp/term/xterm.el b/lisp/term/xterm.el
index 28fb9da0b9..e4871658b9 100644
--- a/lisp/term/xterm.el
+++ b/lisp/term/xterm.el
@@ -480,7 +480,7 @@ The relevant features are:
 
       ;; Use inheritance to let the main keymap override those defaults.
       ;; This way we don't override terminfo-derived settings or settings
-      ;; made in the .emacs file.
+      ;; made in the init file.
       (set-keymap-parent map (keymap-parent input-decode-map))
       (set-keymap-parent input-decode-map map)))
 
diff --git a/lisp/textmodes/flyspell.el b/lisp/textmodes/flyspell.el
index a9320d945e..42f0418b69 100644
--- a/lisp/textmodes/flyspell.el
+++ b/lisp/textmodes/flyspell.el
@@ -290,9 +290,9 @@ If this variable is nil, all regions are treated as small."
 ;;*    Mode specific options enable users to disable flyspell on        */
 ;;*    certain word depending of the emacs mode. For instance, when     */
 ;;*    using flyspell with mail-mode add the following expression       */
-;;*    in your .emacs file:                                             */
+;;*    in your init file:                                               */
 ;;*       (add-hook 'mail-mode                                          */
-;;*    	     (lambda () (setq flyspell-generic-check-word-predicate    */
+;;*    	     (lambda () (setq flyspell-generic-check-word-predicate     */
 ;;*    			       'mail-mode-flyspell-verify)))            */
 ;;*---------------------------------------------------------------------*/
 (defvar flyspell-generic-check-word-predicate nil
@@ -488,7 +488,7 @@ invoking `ispell-change-dictionary'.
 Consider using the `ispell-parser' to check your text.  For instance
 consider adding:
 \(add-hook 'tex-mode-hook (function (lambda () (setq ispell-parser 'tex))))
-in your .emacs file.
+in your init file.
 
 \\[flyspell-region] checks all words inside a region.
 \\[flyspell-buffer] checks the whole buffer."
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 0c7966f22d..51a4800de5 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -1127,7 +1127,8 @@ aspell is used along with Emacs).")
 
     ;; If Emacs flavor supports [:alpha:] use it for global dicts.  If
     ;; spellchecker also supports UTF-8 via command-line option use it
-    ;; in communication.  This does not affect definitions in ~/.emacs.
+    ;; in communication.  This does not affect definitions in your
+    ;; init file.
     (if ispell-emacs-alpha-regexp
      	(let (tmp-dicts-alist)
     	  (dolist (adict ispell-dictionary-alist)
@@ -3680,7 +3681,7 @@ use the `x' command.  (Any subsequent regions will be checked.)
 The `X' command aborts sending the message so that you can edit the buffer.
 
 To spell-check whenever a message is sent, include the appropriate lines
-in your .emacs file:
+in your init file:
    (add-hook 'message-send-hook 'ispell-message)  ;; GNUS 5
    (add-hook 'news-inews-hook 'ispell-message)    ;; GNUS 4
    (add-hook 'mail-send-hook  'ispell-message)
diff --git a/lisp/textmodes/picture.el b/lisp/textmodes/picture.el
index 24a4ac1b03..e663c1b45f 100644
--- a/lisp/textmodes/picture.el
+++ b/lisp/textmodes/picture.el
@@ -612,13 +612,15 @@ Leaves the region surrounding the rectangle."
     (define-key map [remap self-insert-command] 'picture-self-insert)
     (define-key map [remap self-insert-command] 'picture-self-insert)
     (define-key map [remap completion-separator-self-insert-command]
-      'picture-self-insert)
+			  'picture-self-insert)
     (define-key map [remap completion-separator-self-insert-autofilling]
-      'picture-self-insert)
+			  'picture-self-insert)
     (define-key map [remap forward-char] 'picture-forward-column)
+    (define-key map [remap right-char] 'picture-forward-column)
     (define-key map [remap backward-char] 'picture-backward-column)
+    (define-key map [remap left-char] 'picture-backward-column)
     (define-key map [remap delete-char] 'picture-clear-column)
-    ;; There are two possibilities for what is normally on DEL.
+      ;; There are two possibilities for what is normally on DEL.
     (define-key map [remap backward-delete-char-untabify]
       'picture-backward-clear-column)
     (define-key map [remap delete-backward-char] 'picture-backward-clear-column)
diff --git a/lisp/textmodes/reftex.el b/lisp/textmodes/reftex.el
index d8afb3e554..8584c496a9 100644
--- a/lisp/textmodes/reftex.el
+++ b/lisp/textmodes/reftex.el
@@ -47,7 +47,7 @@
 ;; To turn RefTeX Mode on and off in a buffer, use `M-x reftex-mode'.
 ;;
 ;; To turn on RefTeX Mode for all LaTeX files, add the following lines
-;; to your .emacs file:
+;; to your init file:
 ;;
 ;;   (add-hook 'LaTeX-mode-hook 'turn-on-reftex)   ; AUCTeX LaTeX mode
 ;;   (add-hook 'latex-mode-hook 'turn-on-reftex)   ; Emacs latex mode
@@ -99,7 +99,7 @@
 ;;
 ;; To turn RefTeX Mode on and off in a particular buffer, use `M-x
 ;; reftex-mode'.  To turn on RefTeX Mode for all LaTeX files, add the
-;; following lines to your `.emacs' file:
+;; following lines to your init file:
 ;;
 ;;      (add-hook 'LaTeX-mode-hook 'turn-on-reftex)   ; with AUCTeX LaTeX mode
 ;;      (add-hook 'latex-mode-hook 'turn-on-reftex)   ; with Emacs latex mode
diff --git a/lisp/textmodes/rst.el b/lisp/textmodes/rst.el
index 767f8f360b..e2647a9877 100644
--- a/lisp/textmodes/rst.el
+++ b/lisp/textmodes/rst.el
@@ -81,7 +81,7 @@
 
 ;;; INSTALLATION
 
-;; Add the following lines to your `.emacs' file:
+;; Add the following lines to your init file:
 ;;
 ;;   (require 'rst)
 ;;
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index 5bcd87ede6..67d7f8c01f 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -451,7 +451,7 @@ the next N words.  In Transient Mark mode, when the mark is active,
 N defaults to -1, which means to wrap it around the current region.
 
 If you like upcased tags, put (setq sgml-transformation-function 'upcase)
-in your `.emacs' file.
+in your init file.
 
 Use \\[sgml-validate] to validate your document with an SGML parser.
 
diff --git a/lisp/textmodes/table.el b/lisp/textmodes/table.el
index 2664a89855..459e884d45 100644
--- a/lisp/textmodes/table.el
+++ b/lisp/textmodes/table.el
@@ -126,7 +126,7 @@
 ;; again.
 ;;
 ;; To use the package regularly place this file in the site library
-;; directory and add the next expression in your .emacs file.  Make
+;; directory and add the next expression in your init file.  Make
 ;; sure that directory is included in the `load-path'.
 ;;
 ;;   (require 'table)
@@ -342,10 +342,10 @@
 ;;     (function (lambda ()
 ;;       (local-set-key [<key sequence>] '<function>))))
 ;;
-;; Above code is well known ~/.emacs idiom for customizing a mode
-;; specific keymap however it does not work for this package.  This is
-;; because there is no table mode in effect.  This package does not
-;; use a local map therefore you must modify `table-cell-map'
+;; Adding the above to your init file is a common way to customize a
+;; mode specific keymap.  However it does not work for this package.
+;; This is because there is no table mode in effect.  This package
+;; does not use a local map therefore you must modify `table-cell-map'
 ;; explicitly.  The correct way of achieving above task is:
 ;;
 ;;   (add-hook 'table-cell-map-hook
diff --git a/lisp/textmodes/two-column.el b/lisp/textmodes/two-column.el
index 8a4fe4f87f..b21e72639f 100644
--- a/lisp/textmodes/two-column.el
+++ b/lisp/textmodes/two-column.el
@@ -276,8 +276,9 @@ You have the following commands at your disposal:
 \\[2C-merge]   Merge both buffers
 \\[2C-dissociate]   Dissociate the two buffers
 
-These keybindings can be customized in your ~/.emacs by `2C-mode-map',
-`2C-minor-mode-map' and by binding `2C-command' to some prefix.
+These keybindings can be customized in your init file by
+`2C-mode-map', `2C-minor-mode-map' and by binding `2C-command' to
+some prefix.
 
 The appearance of the screen can be customized by the variables
 `2C-window-width', `2C-beyond-fill-column', `2C-mode-line-format' and
diff --git a/lisp/time-stamp.el b/lisp/time-stamp.el
index 13963121e2..c2ac1035df 100644
--- a/lisp/time-stamp.el
+++ b/lisp/time-stamp.el
@@ -29,7 +29,7 @@
 ;;     static char *ts = "sdmain.c Time-stamp: <2001-08-13 10:20:51 gildea>";
 ;; See the top of `time-stamp.el' for another example.
 
-;; To use time-stamping, add this line to your .emacs file:
+;; To use time-stamping, add this line to your init file:
 ;;     (add-hook 'before-save-hook 'time-stamp)
 ;; Now any time-stamp templates in your files will be updated automatically.
 
@@ -254,7 +254,7 @@ time-stamped file itself.")
 (defun time-stamp ()
   "Update the time stamp string(s) in the buffer.
 A template in a file can be automatically updated with a new time stamp
-every time you save the file.  Add this line to your .emacs file:
+every time you save the file.  Add this line to your init file:
     (add-hook 'before-save-hook 'time-stamp)
 or customize `before-save-hook' through Custom.
 Normally the template must appear in the first 8 lines of a file and
diff --git a/lisp/time.el b/lisp/time.el
index 8d43b56541..fe3cdbb57b 100644
--- a/lisp/time.el
+++ b/lisp/time.el
@@ -575,7 +575,8 @@ To turn off the world time display, go to that window and type `q'."
     (let ((list timer-list))
       (while list
         (let ((elt (pop list)))
-          (when (equal (symbol-name (aref elt 5)) "display-time-world-timer")
+          (when (equal (symbol-name (timer--function elt))
+		       "display-time-world-timer")
             (cancel-timer elt)))))))
 
 ;;;###autoload
diff --git a/lisp/url/url-methods.el b/lisp/url/url-methods.el
index bd7d8e3392..26fe72014f 100644
--- a/lisp/url/url-methods.el
+++ b/lisp/url/url-methods.el
@@ -79,7 +79,7 @@
 
     ;; Store any proxying information - this will not overwrite an old
     ;; entry, so that people can still set this information in their
-    ;; .emacs file
+    ;; init file
     (cond
      (cur-proxy nil)			; Keep their old settings
      ((null env-proxy) nil)		; No proxy setup
diff --git a/lisp/userlock.el b/lisp/userlock.el
index 705d958824..4c003e423a 100644
--- a/lisp/userlock.el
+++ b/lisp/userlock.el
@@ -108,37 +108,27 @@ You can rewrite this to use any criterion you like to choose which one to do.
 The buffer in question is current when this function is called."
   (discard-input)
   (save-window-excursion
-    (let (answer)
+    (let ((prompt
+	   (format "%s changed on disk; \
+really edit the buffer? (y, n, r or C-h) "
+		   (file-name-nondirectory fn)))
+	  (choices '(?y ?n ?r ?? ?\C-h))
+	  answer)
       (while (null answer)
-	(message "%s changed on disk; really edit the buffer? (y, n, r or C-h) "
-		 (file-name-nondirectory fn))
-	(let ((tem (downcase (let ((cursor-in-echo-area t))
-			       (read-char-exclusive)))))
-	  (setq answer
-		(if (= tem help-char)
-		    'help
-		  (cdr (assoc tem '((?n . yield)
-				    (?\C-g . yield)
-				    (?y . proceed)
-				    (?r . revert)
-				    (?? . help))))))
-	  (cond ((null answer)
-		 (beep)
-		 (message "Please type y, n or r; or ? for help")
-		 (sit-for 3))
-		((eq answer 'help)
-		 (ask-user-about-supersession-help)
-		 (setq answer nil))
-		((eq answer 'revert)
-		 (revert-buffer nil (not (buffer-modified-p)))
-					; ask confirmation if buffer modified
-		 (signal 'file-supersession
-			 (list "File reverted" fn)))
-		((eq answer 'yield)
-		 (signal 'file-supersession
-			 (list "File changed on disk" fn))))))
+	(setq answer (read-char-choice prompt choices))
+	(cond ((memq answer '(?? ?\C-h))
+	       (ask-user-about-supersession-help)
+	       (setq answer nil))
+	      ((eq answer ?r)
+	       ;; Ask for confirmation if buffer modified
+	       (revert-buffer nil (not (buffer-modified-p)))
+	       (signal 'file-supersession
+		       (list "File reverted" fn)))
+	      ((eq answer ?n)
+	       (signal 'file-supersession
+		       (list "File changed on disk" fn)))))
       (message
-        "File on disk now will become a backup file if you save these changes.")
+       "File on disk now will become a backup file if you save these changes.")
       (setq buffer-backed-up nil))))
 
 (defun ask-user-about-supersession-help ()
diff --git a/lisp/vc/diff-mode.el b/lisp/vc/diff-mode.el
index c6a9371ea9..11ec785b64 100644
--- a/lisp/vc/diff-mode.el
+++ b/lisp/vc/diff-mode.el
@@ -178,6 +178,8 @@ when editing big diffs)."
     ["Unified -> Context"	diff-unified->context
      :help "Convert unified diffs to context diffs"]
     ;;["Fixup Headers"		diff-fixup-modifs	(not buffer-read-only)]
+    ["Remove trailing whitespace" diff-remove-trailing-whitespace
+     :help "Remove trailing whitespace problems introduced by the diff"]
     ["Show trailing whitespace" whitespace-mode
      :style toggle :selected (bound-and-true-p whitespace-mode)
      :help "Show trailing whitespace in modified lines"]
diff --git a/lisp/vc/pcvs-defs.el b/lisp/vc/pcvs-defs.el
index 0f71b7b82e..fc65d62c67 100644
--- a/lisp/vc/pcvs-defs.el
+++ b/lisp/vc/pcvs-defs.el
@@ -57,11 +57,7 @@ versions, such as the one in SunOS-4.")
 ;;;;	     END OF THINGS TO CHECK WHEN INSTALLING
 ;;;; --------------------------------------------------------
 
-;;;;
 ;;;;	User configuration variables:
-;;;;
-;;;; NOTE: these should be set in your ~/.emacs (or site-lisp/default.el) file.
-;;;;
 
 (defgroup pcl-cvs nil
   "Special support for the CVS versioning system."
diff --git a/lisp/vc/vc-bzr.el b/lisp/vc/vc-bzr.el
index c0dafda57b..1eb33776f6 100644
--- a/lisp/vc/vc-bzr.el
+++ b/lisp/vc/vc-bzr.el
@@ -534,7 +534,9 @@ in the branch repository (or whose status not be determined)."
 			 ;; FIXME: maybe it's overkill to check if both these
 			 ;; files exist.
 			 (and (file-exists-p branch-format-file)
-			      (file-exists-p lastrev-file)))))
+			      (file-exists-p lastrev-file)
+			      (equal (emacs-bzr-version-dirstate l-c-parent-dir)
+				     (emacs-bzr-version-dirstate rootdir))))))
 		 t)))
         (with-temp-buffer
           (insert-file-contents branch-format-file)
@@ -553,13 +555,17 @@ in the branch repository (or whose status not be determined)."
             (insert-file-contents lastrev-file)
             (when (re-search-forward "[0-9]+" nil t)
 	      (buffer-substring (match-beginning 0) (match-end 0))))))
-      ;; fallback to calling "bzr revno"
+      ;; Fallback to calling "bzr revno --tree".
+      ;; The "--tree" matters for lightweight checkouts not on the same
+      ;; revision as the parent.
       (let* ((result (vc-bzr-command-discarding-stderr
-                      vc-bzr-program "revno" (file-relative-name file)))
+                      vc-bzr-program "revno" "--tree"
+                      (file-relative-name file)))
              (exitcode (car result))
              (output (cdr result)))
         (cond
-         ((eq exitcode 0) (substring output 0 -1))
+         ((and (eq exitcode 0) (not (zerop (length output))))
+          (substring output 0 -1))
          (t nil))))))
 
 (defun vc-bzr-create-repo ()
diff --git a/lisp/vc/vc-git.el b/lisp/vc/vc-git.el
index b48ea1afd9..ea9ce949cc 100644
--- a/lisp/vc/vc-git.el
+++ b/lisp/vc/vc-git.el
@@ -31,7 +31,7 @@
 
 ;; To install: put this file on the load-path and add Git to the list
 ;; of supported backends in `vc-handled-backends'; the following line,
-;; placed in your ~/.emacs, will accomplish this:
+;; placed in your init file, will accomplish this:
 ;;
 ;;     (add-to-list 'vc-handled-backends 'Git)
 
diff --git a/lisp/vc/vc.el b/lisp/vc/vc.el
index 1ef4faaa00..47800bd4aa 100644
--- a/lisp/vc/vc.el
+++ b/lisp/vc/vc.el
@@ -653,7 +653,6 @@
 
 (require 'vc-hooks)
 (require 'vc-dispatcher)
-(require 'ediff)
 
 (declare-function diff-setup-whitespace "diff-mode" ())
 
@@ -1698,7 +1697,9 @@ saving the buffer."
     (vc-diff-internal t (vc-deduce-fileset t) nil nil
 		      (called-interactively-p 'interactive))))
 
-(declare-function ediff-vc-internal (rev1 rev2 &optional startup-hooks))
+(declare-function ediff-load-version-control "ediff" (&optional silent))
+(declare-function ediff-vc-internal "ediff-vers"
+                  (rev1 rev2 &optional startup-hooks))
 
 ;;;###autoload
 (defun vc-version-ediff (files rev1 rev2)
@@ -1719,7 +1720,8 @@ repository history using ediff."
    ;; FIXME We only support running ediff on one file for now.
    ;; We could spin off an ediff session per file in the file set.
    ((= (length files) 1)
-    (ediff-load-version-control)
+    (require 'ediff)
+    (ediff-load-version-control)  ; loads ediff-vers
     (find-file (car files))             ;FIXME: find-file from Elisp is bad.
     (ediff-vc-internal rev1 rev2 nil))
    (t
diff --git a/lisp/version.el b/lisp/version.el
index e63c51d0d2..1fb3828e15 100644
--- a/lisp/version.el
+++ b/lisp/version.el
@@ -87,40 +87,91 @@ to the system configuration; look at `system-configuration' instead."
 ;; Set during dumping, this is a defvar so that it can be setq'd.
 (defvar emacs-bzr-version nil
   "String giving the bzr revision from which this Emacs was built.
-Value is the bzr revision number and a revision ID separated by a blank.
+The format is: [revno] revision_id, where revno may be absent.
 Value is nil if Emacs was not built from a bzr checkout, or if we could
 not determine the revision.")
 
-(defun emacs-bzr-get-version (&optional dir)
-  "Try to return as a string the bzr revision number of the Emacs sources.
-Value is the bzr revision number and a revision ID separated by a blank.
+(defun emacs-bzr-version-dirstate (dir)
+  "Try to return as a string the bzr revision ID of directory DIR.
+This uses the dirstate file's parent revision entry.
+Returns nil if unable to find this information."
+  (let ((file (expand-file-name ".bzr/checkout/dirstate" dir)))
+    (when (file-readable-p file)
+      (with-temp-buffer
+        (insert-file-contents file)
+        (and (looking-at "#bazaar dirstate flat format 3")
+             (forward-line 3)
+             (looking-at "[0-9]+\0\\([^\0\n]+\\)\0")
+             (match-string 1))))))
+
+(defun emacs-bzr-version-bzr (dir)
+  "Ask bzr itself for the version information for directory DIR."
+  ;; Comments on `bzr version-info':
+  ;; i) Unknown files also cause clean != 1.
+  ;; ii) It can be slow, contacting the upstream repo to get the
+  ;; branch nick if one is not set locally, even with a custom
+  ;; template that is not asking for the nick (as used here).  You'd
+  ;; think the latter part would be trivial to fix:
+  ;; https://bugs.launchpad.net/bzr/+bug/882541/comments/3
+  ;; https://bugs.launchpad.net/bzr/+bug/629150
+  ;; You can set the nick locally with `bzr nick ...', which speeds
+  ;; things up enormously.  `bzr revno' does not have this issue, but
+  ;; has no way to print the revision_id AFAICS.
+  (message "Waiting for bzr...")
+  (with-temp-buffer
+    (if (zerop
+         (call-process "bzr" nil '(t nil) nil "version-info"
+                       "--custom"
+                       "--template={revno} {revision_id} (clean = {clean})"
+                       "dir"))
+        (buffer-string))))
+
+(defun emacs-bzr-get-version (&optional dir external)
+  "Try to return as a string the bzr revision of the Emacs sources.
+The format is: [revno] revision_id, where revno may be absent.
 Value is nil if the sources do not seem to be under bzr, or if we could
 not determine the revision.  Note that this reports on the current state
 of the sources, which may not correspond to the running Emacs.
 
-Optional argument DIR is a directory to use instead of `source-directory'."
+Optional argument DIR is a directory to use instead of `source-directory'.
+Optional argument EXTERNAL non-nil means to maybe ask `bzr' itself,
+if the sources appear to be under bzr.  If `force', always ask bzr.
+Otherwise only ask bzr if we cannot find any information ourselves."
   (or dir (setq dir source-directory))
-  (when (file-directory-p (setq dir (expand-file-name ".bzr/branch" dir)))
-    (let (file loc)
-      (cond ((file-readable-p
-              (setq file (expand-file-name "last-revision" dir)))
-             (with-temp-buffer
-               (insert-file-contents file)
-               (goto-char (point-max))
-               (if (looking-back "\n")
-                   (delete-char -1))
-               (buffer-string)))
-            ;; OK, no last-revision.  Is it a lightweight checkout?
-            ((file-readable-p
-              (setq file (expand-file-name "location" dir)))
-             ;; If the parent branch is local, try looking there for the revid.
-             (if (setq loc (with-temp-buffer
-                             (insert-file-contents file)
-                             (if (looking-at "file://\\(.*\\)")
-                                 (match-string 1))))
-                 (emacs-bzr-get-version loc)))
-            ;; Could fall back to eg `bzr testament' at this point.
-            ))))
+  (when (file-directory-p (expand-file-name ".bzr/branch" dir))
+    (if (eq external 'force)
+        (emacs-bzr-version-bzr dir)
+      (let (file loc rev)
+        (cond ((file-readable-p
+                (setq file (expand-file-name ".bzr/branch/last-revision" dir)))
+               (with-temp-buffer
+                 (insert-file-contents file)
+                 (goto-char (point-max))
+                 (if (looking-back "\n")
+                     (delete-char -1))
+                 (buffer-string)))
+              ;; OK, no last-revision.  Is it a lightweight checkout?
+              ((file-readable-p
+                (setq file (expand-file-name ".bzr/branch/location" dir)))
+               (setq rev (emacs-bzr-version-dirstate dir))
+               ;; If the parent branch is local, try looking there for the rev.
+               ;; Note: there is no guarantee that the parent branch's rev
+               ;; corresponds to this branch.  This branch could have
+               ;; been made with a specific -r revno argument, or the
+               ;; parent could have been updated since this branch was created.
+               ;; To try and detect this, we check the dirstate revids
+               ;; to see if they match.
+               (if (and (setq loc (with-temp-buffer
+                                    (insert-file-contents file)
+                                    (if (looking-at "file://\\(.*\\)")
+                                        (match-string 1))))
+                        (equal rev (emacs-bzr-version-dirstate loc)))
+                   (emacs-bzr-get-version loc)
+                 ;; If parent does not match, the best we can do without
+                 ;; calling external commands is to use the dirstate rev.
+                 rev))
+              (external
+               (emacs-bzr-version-bzr dir)))))))
 
 ;; We put version info into the executable in the form that `ident' uses.
 (purecopy (concat "\n$Id: " (subst-char-in-string ?\n ?\s (emacs-version))
diff --git a/lisp/windmove.el b/lisp/windmove.el
index 3a1afec38e..1181e409df 100644
--- a/lisp/windmove.el
+++ b/lisp/windmove.el
@@ -94,7 +94,7 @@
 
 ;; Installation:
 ;;
-;; Put the following line in your `.emacs' file:
+;; Put the following line in your init file:
 ;;
 ;;     (windmove-default-keybindings)         ; shifted arrow keys
 ;;
diff --git a/lisp/window.el b/lisp/window.el
index 2fce874e98..fccb68bd94 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -73,6 +73,108 @@ are not altered by this macro (unless they are altered in BODY)."
 	 (when (window-live-p save-selected-window-window)
 	   (select-window save-selected-window-window 'norecord))))))
 
+(defvar temp-buffer-window-setup-hook nil
+  "Normal hook run by `with-temp-buffer-window' before buffer display.
+This hook is run by `with-temp-buffer-window' with the buffer to be
+displayed current.")
+
+(defvar temp-buffer-window-show-hook nil
+  "Normal hook run by `with-temp-buffer-window' after buffer display.
+This hook is run by `with-temp-buffer-window' with the buffer
+displayed and current and its window selected.")
+
+(defun temp-buffer-window-setup (buffer-or-name)
+  "Set up temporary buffer specified by BUFFER-OR-NAME 
+Return the buffer."
+  (let ((old-dir default-directory)
+	(buffer (get-buffer-create buffer-or-name)))
+    (with-current-buffer buffer
+      (kill-all-local-variables)
+      (setq default-directory old-dir)
+      (delete-all-overlays)
+      (setq buffer-read-only nil)
+      (setq buffer-file-name nil)
+      (setq buffer-undo-list t)
+      (let ((inhibit-read-only t)
+	    (inhibit-modification-hooks t))
+	(erase-buffer)
+	(run-hooks 'temp-buffer-window-setup-hook))
+      ;; Return the buffer.
+      buffer)))
+
+(defun temp-buffer-window-show (&optional buffer action)
+  "Show temporary buffer BUFFER in a window.
+Return the window showing BUFFER.  Pass ACTION as action argument
+to `display-buffer'."
+  (let (window frame)
+    (with-current-buffer buffer
+      (set-buffer-modified-p nil)
+      (setq buffer-read-only t)
+      (goto-char (point-min))
+      (when (setq window (display-buffer buffer action))
+	(setq frame (window-frame window))
+	(unless (eq frame (selected-frame))
+	  (raise-frame frame))
+	(setq minibuffer-scroll-window window)
+	(set-window-hscroll window 0)
+	(with-selected-window window
+	  (run-hooks 'temp-buffer-window-show-hook)
+	  (when temp-buffer-resize-mode
+	    (resize-temp-buffer-window window)))
+	;; Return the window.
+	window))))
+
+(defmacro with-temp-buffer-window (buffer-or-name action quit-function &rest body)
+  "Evaluate BODY and display buffer specified by BUFFER-OR-NAME.
+BUFFER-OR-NAME must specify either a live buffer or the name of a
+buffer.  If no buffer with such a name exists, create one.
+
+Make sure the specified buffer is empty before evaluating BODY.
+Do not make that buffer current for BODY.  Instead, bind
+`standard-output' to that buffer, so that output generated with
+`prin1' and similar functions in BODY goes into that buffer.
+
+After evaluating BODY, mark the specified buffer unmodified and
+read-only, and display it in a window via `display-buffer'.  Pass
+ACTION as action argument to `display-buffer'.  Automatically
+shrink the window used if `temp-buffer-resize-mode' is enabled.
+
+Return the value returned by BODY unless QUIT-FUNCTION specifies
+a function.  In that case, run the function with two arguments -
+the window showing the specified buffer and the value returned by
+BODY - and return the value returned by that function.
+
+If the buffer is displayed on a new frame, the window manager may
+decide to select that frame.  In that case, it's usually a good
+strategy if the function specified by QUIT-FUNCTION selects the
+window showing the buffer before reading a value from the
+minibuffer, for example, when asking a `yes-or-no-p' question.
+
+This construct is similar to `with-output-to-temp-buffer' but
+does neither put the buffer in help mode nor does it call
+`temp-buffer-show-function'.  It also runs different hooks,
+namely `temp-buffer-window-setup-hook' (with the specified buffer
+current) and `temp-buffer-window-show-hook' (with the specified
+buffer current and the window showing it selected).
+
+Since this macro calls `display-buffer', the window displaying
+the buffer is usually not selected and the specified buffer
+usually not made current.  QUIT-FUNCTION can override that."
+  (declare (debug t))
+  (let ((buffer (make-symbol "buffer"))
+	(window (make-symbol "window"))
+	(value (make-symbol "value")))
+    `(let* ((,buffer (temp-buffer-window-setup ,buffer-or-name))
+	    (standard-output ,buffer)
+	    ,window ,value)
+       (with-current-buffer ,buffer
+	 (setq ,value (progn ,@body))
+	 (setq ,window (temp-buffer-window-show ,buffer ,action)))
+
+       (if (functionp ,quit-function)
+	   (funcall ,quit-function ,window ,value)
+	 ,value))))
+
 ;; The following two functions are like `window-next-sibling' and
 ;; `window-prev-sibling' but the WINDOW argument is _not_ optional (so
 ;; they don't substitute the selected window for nil), and they return
@@ -4449,6 +4551,9 @@ of the window used."
 	  (function :tag "function"))
   :group 'windows)
 
+(make-obsolete-variable 'display-buffer-function
+			'display-buffer-alist "24.3")
+
 ;; Eventually, we want to turn this into a defvar; instead of
 ;; customizing this, the user should use a `pop-up-frame-parameters'
 ;; alist entry in `display-buffer-base-action'.
@@ -4666,8 +4771,8 @@ the selected window.  If they contain (same-frame . t), display
 BUFFER in a window of the selected frame.
 
 If ARGS is a list whose car is a symbol, use (car ARGS) as a
-function to do the work.  Pass it BUFFER as first argument,
-and (cdr ARGS) as second."
+function to do the work.  Pass it BUFFER as first argument, and
+pass the elements of (cdr ARGS) as the remaining arguments."
   (if (and args (symbolp (car args)))
       (apply (car args) buffer (cdr args))
     (let ((window (get-buffer-window buffer 0)))
@@ -4696,6 +4801,9 @@ and (cdr ARGS) as second."
 		 (make-frame (append args special-display-frame-alist))))
 	      (window (frame-selected-window frame)))
 	 (display-buffer-record-window 'frame window buffer)
+	 (unless (eq buffer (window-buffer window))
+	   (set-window-buffer window buffer)
+	   (set-window-prev-buffers window nil))
 	 (set-window-dedicated-p window t)
 	 window)))))
 
@@ -5416,6 +5524,62 @@ the selected one."
 	     (window--display-buffer
 	      buffer window 'reuse display-buffer-mark-dedicated)))))
 
+(defun display-buffer-in-previous-window (buffer alist)
+  "Display BUFFER in a window previously showing it.
+If ALIST has a non-nil `inhibit-same-window' entry, the selected
+window is not eligible for reuse.
+
+If ALIST contains a `reusable-frames' entry, its value determines
+which frames to search for a reusable window:
+  nil -- the selected frame (actually the last non-minibuffer frame)
+  A frame   -- just that frame
+  `visible' -- all visible frames
+  0   -- all frames on the current terminal
+  t   -- all frames.
+
+If ALIST contains no `reusable-frames' entry, search just the
+selected frame if `display-buffer-reuse-frames' and
+`pop-up-frames' are both nil; search all frames on the current
+terminal if either of those variables is non-nil.
+
+If ALIST has a `previous-window' entry, the window specified by
+that entry will override any other window found by the methods
+above, even if that window never showed BUFFER before."
+  (let* ((alist-entry (assq 'reusable-frames alist))
+	 (inhibit-same-window
+	  (cdr (assq 'inhibit-same-window alist)))
+	 (frames (cond
+		  (alist-entry (cdr alist-entry))
+		  ((if (eq pop-up-frames 'graphic-only)
+		       (display-graphic-p)
+		     pop-up-frames)
+		   0)
+		  (display-buffer-reuse-frames 0)
+		  (t (last-nonminibuffer-frame))))
+	 entry best-window second-best-window window)
+    ;; Scan windows whether they have shown the buffer recently.
+    (catch 'best
+      (dolist (window (window-list-1 (frame-first-window) 'nomini frames))
+	(when (and (assq buffer (window-prev-buffers window))
+		   (not (window-dedicated-p window)))
+	  (if (eq window (selected-window))
+	      (unless inhibit-same-window
+		(setq second-best-window window))
+	    (setq best-window window)
+	    (throw 'best t)))))
+    ;; When ALIST has a `previous-window' entry, that entry may override
+    ;; anything we found so far.
+    (when (and (setq window (cdr (assq 'previous-window alist)))
+	       (window-live-p window)
+	       (not (window-dedicated-p window)))
+      (if (eq window (selected-window))
+	  (unless inhibit-same-window
+	    (setq second-best-window window))
+	(setq best-window window)))
+    ;; Return best or second best window found.
+    (when (setq window (or best-window second-best-window))
+      (window--display-buffer buffer window 'reuse))))
+
 (defun display-buffer-use-some-window (buffer alist)
   "Display BUFFER in an existing window.
 Search for a usable window, set that window to the buffer, and
@@ -5537,26 +5701,28 @@ buffer with the name BUFFER-OR-NAME and return that buffer."
 
 (defun switch-to-buffer (buffer-or-name &optional norecord force-same-window)
   "Switch to buffer BUFFER-OR-NAME in the selected window.
-If called interactively, prompt for the buffer name using the
+If the selected window cannot display the specified
+buffer (e.g. if it is a minibuffer window or strongly dedicated
+to another buffer), call `pop-to-buffer' to select the buffer in
+another window.
+
+If called interactively, read the buffer name using the
 minibuffer.  The variable `confirm-nonexistent-file-or-buffer'
 determines whether to request confirmation before creating a new
 buffer.
 
-BUFFER-OR-NAME may be a buffer, a string (a buffer name), or
-nil.  If BUFFER-OR-NAME is a string that does not identify an
-existing buffer, create a buffer with that name.  If
-BUFFER-OR-NAME is nil, switch to the buffer returned by
-`other-buffer'.
+BUFFER-OR-NAME may be a buffer, a string (a buffer name), or nil.
+If BUFFER-OR-NAME is a string that does not identify an existing
+buffer, create a buffer with that name.  If BUFFER-OR-NAME is
+nil, switch to the buffer returned by `other-buffer'.
 
-Optional argument NORECORD non-nil means do not put the buffer
-specified by BUFFER-OR-NAME at the front of the buffer list and
-do not make the window displaying it the most recently selected
-one.
+If optional argument NORECORD is non-nil, do not put the buffer
+at the front of the buffer list, and do not make the window
+displaying it the most recently selected one.
 
-If FORCE-SAME-WINDOW is non-nil, BUFFER-OR-NAME must be displayed
-in the selected window; signal an error if that is
-impossible (e.g. if the selected window is minibuffer-only).  If
-nil, BUFFER-OR-NAME may be displayed in another window.
+If optional argument FORCE-SAME-WINDOW is non-nil, the buffer
+must be displayed in the selected window; if that is impossible,
+signal an error rather than calling `pop-to-buffer'.
 
 Return the buffer switched to."
   (interactive
@@ -5710,7 +5876,7 @@ WINDOW must be a live window and defaults to the selected one."
 			     window))))
 
 ;;; Resizing buffers to fit their contents exactly.
-(defun fit-window-to-buffer (&optional window max-height min-height override)
+(defun fit-window-to-buffer (&optional window max-height min-height)
   "Adjust height of WINDOW to display its buffer's contents exactly.
 WINDOW must be a live window and defaults to the selected one.
 
@@ -5721,10 +5887,6 @@ defaults to `window-min-height'.  Both MAX-HEIGHT and MIN-HEIGHT
 are specified in lines and include the mode line and header line,
 if any.
 
-Optional argument OVERRIDE non-nil means override restrictions
-imposed by `window-min-height' and `window-min-width' on the size
-of WINDOW.
-
 Return the number of lines by which WINDOW was enlarged or
 shrunk.  If an error occurs during resizing, return nil but don't
 signal an error.
@@ -5733,28 +5895,27 @@ Note that even if this function makes WINDOW large enough to show
 _all_ lines of its buffer you might not see the first lines when
 WINDOW was scrolled."
   (interactive)
-  ;; Do all the work in WINDOW and its buffer and restore the selected
-  ;; window and the current buffer when we're done.
   (setq window (window-normalize-window window t))
   ;; Can't resize a full height or fixed-size window.
   (unless (or (window-size-fixed-p window)
 	      (window-full-height-p window))
-    ;; `with-selected-window' should orderly restore the current buffer.
     (with-selected-window window
-      ;; We are in WINDOW's buffer now.
-      (let* (;; Adjust MIN-HEIGHT.
+      (let* ((height (window-total-size))
 	     (min-height
-	      (if override
-		  (window-min-size window nil window)
-		(max (or min-height window-min-height)
-		     window-safe-min-height)))
-	     (max-window-height
-	      (window-total-size (frame-root-window window)))
-	     ;; Adjust MAX-HEIGHT.
+	      ;; Adjust MIN-HEIGHT.
+	      (if (numberp min-height)
+		  ;; Can't get smaller than `window-safe-min-height'.
+		  (max min-height window-safe-min-height)
+		;; Preserve header and mode line if present.
+		(window-min-size nil nil t)))
 	     (max-height
-	      (if (or override (not max-height))
-		  max-window-height
-		(min max-height max-window-height)))
+	      ;; Adjust MAX-HEIGHT.
+	      (if (numberp max-height)
+		  ;; Can't get larger than height of frame.
+		  (min max-height
+		       (window-total-size (frame-root-window window)))
+		;, Don't delete other windows.
+		(+ height (window-max-delta nil nil window))))
 	     ;; Make `desired-height' the height necessary to show
 	     ;; all of WINDOW's buffer, constrained by MIN-HEIGHT
 	     ;; and MAX-HEIGHT.
@@ -5779,7 +5940,6 @@ WINDOW was scrolled."
 		       (window-max-delta window nil window))
 		(max desired-delta
 		     (- (window-min-delta window nil window))))))
-	;; This `condition-case' shouldn't be necessary, but who knows?
 	(condition-case nil
 	    (if (zerop delta)
 		;; Return zero if DELTA became zero in the process.
@@ -5819,6 +5979,88 @@ WINDOW was scrolled."
 	  (error (setq delta nil)))
 	delta))))
 
+(defcustom fit-frame-to-buffer-bottom-margin 4
+  "Bottom margin for `fit-frame-to-buffer'.
+This is the number of lines `fit-frame-to-buffer' leaves free at the
+bottom of the display in order to not obscure the system task bar."
+  :type 'integer
+  :version "24.2"
+  :group 'windows)
+
+(defun fit-frame-to-buffer (&optional frame max-height min-height)
+  "Adjust height of FRAME to display its buffer's contents exactly.
+FRAME can be any live frame and defaults to the selected one.
+
+Optional argument MAX-HEIGHT specifies the maximum height of
+FRAME and defaults to the height of the display below the current
+top line of FRAME minus FIT-FRAME-TO-BUFFER-BOTTOM-MARGIN.
+Optional argument MIN-HEIGHT specifies the minimum height of
+FRAME."
+  (interactive)
+  (setq frame (window-normalize-frame frame))
+  (let* ((root (frame-root-window frame))
+	 (frame-min-height
+	  (+ (- (frame-height frame) (window-total-size root))
+	     window-min-height))
+	 (frame-top (frame-parameter frame 'top))
+	 (top (if (consp frame-top)
+		  (funcall (car frame-top) (cadr frame-top))
+		frame-top))
+	 (frame-max-height
+	  (- (/ (- (x-display-pixel-height frame) top)
+		(frame-char-height frame))
+	     fit-frame-to-buffer-bottom-margin))
+	 (compensate 0)
+	 delta)
+    (when (and (window-live-p root) (not (window-size-fixed-p root)))
+      (with-selected-window root
+	(cond
+	 ((not max-height)
+	  (setq max-height frame-max-height))
+	 ((numberp max-height)
+	  (setq max-height (min max-height frame-max-height)))
+	 (t
+	  (error "%s is an invalid maximum height" max-height)))
+	(cond
+	 ((not min-height)
+	  (setq min-height frame-min-height))
+	 ((numberp min-height)
+	  (setq min-height (min min-height frame-min-height)))
+	 (t
+	  (error "%s is an invalid minimum height" min-height)))
+	;; When tool-bar-mode is enabled and we have just created a new
+	;; frame, reserve lines for toolbar resizing.  This is needed
+	;; because for reasons unknown to me Emacs (1) reserves one line
+	;; for the toolbar when making the initial frame and toolbars
+	;; are enabled, and (2) later adds the remaining lines needed.
+	;; Our code runs IN BETWEEN (1) and (2).  YMMV when you're on a
+	;; system that behaves differently.
+	(let ((quit-restore (window-parameter root 'quit-restore))
+	      (lines (tool-bar-lines-needed frame)))
+	  (when (and quit-restore (eq (car quit-restore) 'frame)
+		     (not (zerop lines)))
+	    (setq compensate (1- lines))))
+	(message "%s" compensate)
+	(setq delta
+	      ;; Always count a final newline - we don't do any
+	      ;; post-processing, so let's play safe.
+	      (+ (count-screen-lines nil nil t)
+		 (- (window-body-size))
+		 compensate)))
+      ;; Move away from final newline.
+      (when (and (eobp) (bolp) (not (bobp)))
+	(set-window-point root (line-beginning-position 0)))
+      (set-window-start root (point-min))
+      (set-window-vscroll root 0)
+      (condition-case nil
+	  (set-frame-height
+	   frame
+	   (min (max (+ (frame-height frame) delta)
+		     min-height)
+		max-height))
+	(error (setq delta nil))))
+    delta))
+
 (defun window-safely-shrinkable-p (&optional window)
   "Return t if WINDOW can be shrunk without shrinking other windows.
 WINDOW defaults to the selected window."
@@ -6062,7 +6304,7 @@ This is different from `scroll-down-command' that scrolls a full screen."
 (put 'scroll-down-line 'scroll-command t)
 
 
-(defun scroll-other-window-down (lines)
+(defun scroll-other-window-down (&optional lines)
   "Scroll the \"other window\" down.
 For more details, see the documentation for `scroll-other-window'."
   (interactive "P")