14 files changed, 303 insertions, 105 deletions

diff --git a/doc/emacs/ChangeLog b/doc/emacs/ChangeLog
index 6b4c12511dd..f356d35f1c5 100644
--- a/doc/emacs/ChangeLog
+++ b/doc/emacs/ChangeLog
@@ -1,3 +1,9 @@
+2013-09-26  Xue Fuqiao  <xfq.free@gmail.com>
+
+        * dired.texi (Flagging Many Files): Use @emph instead of @strong.
+
+        * emacs.texi (Intro): Minor cleanup.
+
 2013-09-22  Xue Fuqiao  <xfq.free@gmail.com>
 
         * fixit.texi (Transpose):
diff --git a/doc/emacs/dired.texi b/doc/emacs/dired.texi
index f4ca6c30a5a..391cd99fbce 100644
--- a/doc/emacs/dired.texi
+++ b/doc/emacs/dired.texi
@@ -281,9 +281,9 @@ say they are backup files---that is, files whose names end in
 the backup files for deletion: all but the oldest few and newest few
 backups of any one file.  Normally, the number of newest versions kept
 for each file is given by the variable @code{dired-kept-versions}
-(@strong{not} @code{kept-new-versions}; that applies only when
-saving).  The number of oldest versions to keep is given by the
-variable @code{kept-old-versions}.
+(@emph{not} @code{kept-new-versions}; that applies only when saving).
+The number of oldest versions to keep is given by the variable
+@code{kept-old-versions}.
 
   Period with a positive numeric argument, as in @kbd{C-u 3 .},
 specifies the number of newest versions to keep, overriding
diff --git a/doc/emacs/emacs.texi b/doc/emacs/emacs.texi
index 985466810f2..7c594503afb 100644
--- a/doc/emacs/emacs.texi
+++ b/doc/emacs/emacs.texi
@@ -1469,7 +1469,7 @@ Neal Ziring, Teodor Zlatanov, and Detlev Zundel.
 
   You are reading about GNU Emacs, the GNU incarnation of the
 advanced, self-documenting, customizable, extensible editor Emacs.
-(The `G' in `GNU' is not silent.)
+(The @samp{G} in @acronym{GNU, @acronym{GNU}'s Not Unix} is not silent.)
 
   We call Emacs @dfn{advanced} because it can do much more than simple
 insertion and deletion of text.  It can control subprocesses, indent
diff --git a/doc/lispref/sequences.texi b/doc/lispref/sequences.texi
index 00384de7ec8..b6cf322211e 100644
--- a/doc/lispref/sequences.texi
+++ b/doc/lispref/sequences.texi
@@ -713,6 +713,16 @@ This returns @code{t} if @var{object} is a bool-vector,
 and @code{nil} otherwise.
 @end defun
 
+@c FIXME: Document these functions:
+@c `bool-vector-exclusive-or'
+@c `bool-vector-union'
+@c `bool-vector-intersection'
+@c `bool-vector-set-difference'
+@c `bool-vector-not'
+@c `bool-vector-subsetp'
+@c `bool-vector-count-matches'
+@c `bool-vector-count-matches-at'
+
   Here is an example of creating, examining, and updating a
 bool-vector.  Note that the printed form represents up to 8 boolean
 values as a single character.
diff --git a/etc/ChangeLog b/etc/ChangeLog
index 06ca0f3f8bc..a68d76fc4d1 100644
--- a/etc/ChangeLog
+++ b/etc/ChangeLog
@@ -2,7 +2,7 @@
 
         * NEWS: Mention new bool-vector functionality.
 
-aaaa2013-09-15  Jan Djärv  <jan.h.d@swipnet.se>
+2013-09-15  Jan Djärv  <jan.h.d@swipnet.se>
 
         * NEWS: Mention the macfont backend.
 
diff --git a/etc/NEWS b/etc/NEWS
index da17f5ddba5..e26d18c93ed 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -154,6 +154,9 @@ not consume CPU cycles.
 some enhancements, like the ability to restore deleted frames.  Command
 `frame-configuration-to-register' is still available, but unbound.
 
+** The command `quail-help' is deleted.  Use `C-h C-\'
+(`describe-input-method') instead.
+
 
 * Editing Changes in Emacs 24.4
 
@@ -644,7 +647,7 @@ for something (not just adding elements to it), it ought not to affect you.
 *** `bool-vector-intersection'
 *** `bool-vector-set-difference'
 *** `bool-vector-not'
-*** `bool-vector-subset'
+*** `bool-vector-subsetp'
 *** `bool-vector-count-matches'
 *** `bool-vector-count-matches-at'
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index cf450c55612..971cc182448 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,60 @@
+2013-09-28  Leo Liu  <sdl.web@gmail.com>
+
+        * progmodes/octave.el (inferior-octave-completion-table)
+        (inferior-octave-completion-at-point): Minor tweaks.
+
+        * textmodes/ispell.el (ispell-lookup-words): Rename from
+        lookup-words.  (Bug#15460)
+        (lookup-words): Obsolete.
+        (ispell-complete-word, ispell-command-loop): All uses changed.
+
+2013-09-28  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * lisp/progmodes/octave.el (octave-mode-map): Bind octave-send-buffer.
+        (octave-mode-menu): Add octave-send-buffer.
+        (octave-send-buffer): New function.
+
+2013-09-28  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        * lisp/progmodes/octave.el (octave-mode-map): Add key binding for
+        octave-lookfor.
+        (octave-mode-menu): Add octave-lookfor.
+        (inferior-octave-mode-map, octave-help-mode-map): Bind C-ha to
+        octave-lookfor.
+        (octave-lookfor): New function.
+
+2013-09-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/cl-macs.el:
+        (cl--loop-destr-temps): Remove.
+        (cl--loop-iterator-function): Rename from cl--loop-map-form and change
+        its convention.
+        (cl--loop-set-iterator-function): New function.
+        (cl-loop): Adjust accordingly, so as not to use cl-subst.
+        (cl--parse-loop-clause): Adjust all uses of cl--loop-map-form.
+        Bind `it' with `let' instead of substituting it with `cl-subst'.
+        (cl--unused-var-p): New function.
+        (cl--loop-let): Don't use the cl--loop-destr-temps hack any more.
+        Eliminate some unused variable warnings (bug#15326).
+
+2013-09-27  Tassilo Horn  <tsdh@gnu.org>
+
+        * doc-view.el (doc-view-scale-reset): Rename from
+        `doc-view-reset-zoom-level'.
+        (doc-view-scale-adjust): New command.
+        (doc-view-mode-map): Remap `text-scale-adjust' bindings to
+        `doc-view-scale-adjust'.
+
+2013-09-26  Tassilo Horn  <tsdh@gnu.org>
+
+        * doc-view.el (doc-view-reset-zoom-level): New command.
+        (doc-view-mode-map): Remap text-scale-adjust bindings to doc-view
+        zoom commands (bug#15466).
+
+2013-09-26  Kenichi Handa  <handa@gnu.org>
+
+        * international/quail.el (quail-help): Make it not a command.
+
 2013-09-26  Leo Liu  <sdl.web@gmail.com>
 
         * minibuffer.el (completion-all-sorted-completions): Make args
diff --git a/lisp/cedet/ChangeLog b/lisp/cedet/ChangeLog
index ed3301510f0..4a017644c84 100644
--- a/lisp/cedet/ChangeLog
+++ b/lisp/cedet/ChangeLog
@@ -1,3 +1,8 @@
+2013-09-28  Leo Liu  <sdl.web@gmail.com>
+
+        * semantic/texi.el (semantic-analyze-possible-completions): Use
+        ispell-lookup-words instead.  (Bug#15460)
+
 2013-09-20  Glenn Morris  <rgm@gnu.org>
 
         * semantic.el (semantic-new-buffer-fcn-was-run, semantic-active-p):
diff --git a/lisp/cedet/semantic/texi.el b/lisp/cedet/semantic/texi.el
index 34a85b8b79b..51105077188 100644
--- a/lisp/cedet/semantic/texi.el
+++ b/lisp/cedet/semantic/texi.el
@@ -32,7 +32,7 @@
 (require 'texinfo)
 
 (defvar ede-minor-mode)
-(declare-function lookup-words "ispell")
+(declare-function ispell-lookup-words "ispell")
 (declare-function ede-current-project "ede")
 
 (defvar semantic-texi-super-regex
@@ -431,7 +431,7 @@ that start with that symbol."
           ((member 'word (oref context :prefixclass))
            ;; Do completion for words via ispell.
            (require 'ispell)
-           (let ((word-list (lookup-words prefix)))
+           (let ((word-list (ispell-lookup-words prefix)))
              (mapcar (lambda (f) (semantic-tag f 'word)) word-list))
            )
           (t nil))
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index cbf4d0bda31..e59aecc8773 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -405,7 +405,10 @@ Typically \"page-%s.png\".")
     (define-key map (kbd "RET")       'image-next-line)
     ;; Zoom in/out.
     (define-key map "+"               'doc-view-enlarge)
+    (define-key map "="               'doc-view-enlarge)
     (define-key map "-"               'doc-view-shrink)
+    (define-key map "0"               'doc-view-scale-reset)
+    (define-key map [remap text-scale-adjust] 'doc-view-scale-adjust)
     ;; Fit the image to the window
     (define-key map "W"               'doc-view-fit-width-to-window)
     (define-key map "H"               'doc-view-fit-height-to-window)
@@ -753,6 +756,38 @@ OpenDocument format)."
   (interactive (list doc-view-shrink-factor))
   (doc-view-enlarge (/ 1.0 factor)))
 
+(defun doc-view-scale-reset ()
+  "Reset the document size/zoom level to the initial one."
+  (interactive)
+  (if (and doc-view-scale-internally
+           (eq (plist-get (cdr (doc-view-current-image)) :type)
+               'imagemagick))
+      (progn
+        (kill-local-variable 'doc-view-image-width)
+        (doc-view-insert-image
+         (plist-get (cdr (doc-view-current-image)) :file)
+         :width doc-view-image-width))
+    (kill-local-variable 'doc-view-resolution)
+    (doc-view-reconvert-doc)))
+
+(defun doc-view-scale-adjust (factor)
+  "Adjust the scale of the DocView page images by FACTOR.
+FACTOR defaults to `doc-view-shrink-factor'.
+
+The actual adjustment made depends on the final component of the
+key-binding used to invoke the command, with all modifiers removed:
+
+   +, =   Increase the image scale by FACTOR
+   -      Decrease the image scale by FACTOR
+   0      Reset the image scale to the initial scale"
+  (interactive (list doc-view-shrink-factor))
+  (let ((ev last-command-event)
+        (echo-keystrokes nil))
+    (pcase (event-basic-type ev)
+      ((or ?+ ?=) (doc-view-enlarge factor))
+      (?-         (doc-view-shrink factor))
+      (?0         (doc-view-scale-reset)))))
+
 (defun doc-view-fit-width-to-window ()
   "Fit the image width to the window width."
   (interactive)
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 031bf5553d0..60fdc09c053 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -756,14 +756,22 @@ This is compatible with Common Lisp, but note that `defun' and
 ;;; The "cl-loop" macro.
 
 (defvar cl--loop-args) (defvar cl--loop-accum-var) (defvar cl--loop-accum-vars)
-(defvar cl--loop-bindings) (defvar cl--loop-body) (defvar cl--loop-destr-temps)
-(defvar cl--loop-finally) (defvar cl--loop-finish-flag)
+(defvar cl--loop-bindings) (defvar cl--loop-body)
+(defvar cl--loop-finally)
+(defvar cl--loop-finish-flag)           ;Symbol set to nil to exit the loop?
 (defvar cl--loop-first-flag)
-(defvar cl--loop-initially) (defvar cl--loop-map-form) (defvar cl--loop-name)
+(defvar cl--loop-initially) (defvar cl--loop-iterator-function)
+(defvar cl--loop-name)
 (defvar cl--loop-result) (defvar cl--loop-result-explicit)
 (defvar cl--loop-result-var) (defvar cl--loop-steps)
 (defvar cl--loop-symbol-macs)
 
+(defun cl--loop-set-iterator-function (kind iterator)
+  (if cl--loop-iterator-function
+      ;; FIXME: Of course, we could make it work, but why bother.
+      (error "Iteration on %S does not support this combination" kind)
+    (setq cl--loop-iterator-function iterator)))
+
 ;;;###autoload
 (defmacro cl-loop (&rest loop-args)
   "The Common Lisp `loop' macro.
@@ -817,13 +825,35 @@ For more details, see Info node `(cl)Loop Facility'.
                            (delq nil (delq t (cl-copy-list loop-args))))))
       `(cl-block nil (while t ,@loop-args))
     (let ((cl--loop-args loop-args) (cl--loop-name nil) (cl--loop-bindings nil)
-          (cl--loop-body nil)   (cl--loop-steps nil)
-          (cl--loop-result nil) (cl--loop-result-explicit nil)
-          (cl--loop-result-var nil) (cl--loop-finish-flag nil)
+          (cl--loop-body nil)           (cl--loop-steps nil)
+          (cl--loop-result nil)         (cl--loop-result-explicit nil)
+          (cl--loop-result-var nil)     (cl--loop-finish-flag nil)
           (cl--loop-accum-var nil)      (cl--loop-accum-vars nil)
           (cl--loop-initially nil)      (cl--loop-finally nil)
-          (cl--loop-map-form nil)   (cl--loop-first-flag nil)
-          (cl--loop-destr-temps nil) (cl--loop-symbol-macs nil))
+          (cl--loop-iterator-function nil) (cl--loop-first-flag nil)
+          (cl--loop-symbol-macs nil))
+      ;; Here is more or less how those dynbind vars are used after looping
+      ;; over cl--parse-loop-clause:
+      ;;
+      ;; (cl-block ,cl--loop-name
+      ;;   (cl-symbol-macrolet ,cl--loop-symbol-macs
+      ;;     (foldl #'cl--loop-let
+      ;;            `((,cl--loop-result-var)
+      ;;              ((,cl--loop-first-flag t))
+      ;;              ((,cl--loop-finish-flag t))
+      ;;              ,@cl--loop-bindings)
+      ;;           ,@(nreverse cl--loop-initially)
+      ;;           (while                   ;(well: cl--loop-iterator-function)
+      ;;               ,(car (cl--loop-build-ands (nreverse cl--loop-body)))
+      ;;             ,@(cadr (cl--loop-build-ands (nreverse cl--loop-body)))
+      ;;             ,@(nreverse cl--loop-steps)
+      ;;             (setq ,cl--loop-first-flag nil))
+      ;;           (if (not ,cl--loop-finish-flag) ;FIXME: Why `if' vs `progn'?
+      ;;               ,cl--loop-result-var
+      ;;             ,@(nreverse cl--loop-finally)
+      ;;             ,(or cl--loop-result-explicit
+      ;;                  cl--loop-result)))))
+      ;;
       (setq cl--loop-args (append cl--loop-args '(cl-end-loop)))
       (while (not (eq (car cl--loop-args) 'cl-end-loop))
         (cl--parse-loop-clause))
@@ -839,15 +869,15 @@ For more details, see Info node `(cl)Loop Facility'.
              (while-body (nconc (cadr ands) (nreverse cl--loop-steps)))
              (body (append
                     (nreverse cl--loop-initially)
-                    (list (if cl--loop-map-form
+                    (list (if cl--loop-iterator-function
                               `(cl-block --cl-finish--
-                                 ,(cl-subst
-                                   (if (eq (car ands) t) while-body
-                                     (cons `(or ,(car ands)
-                                                (cl-return-from --cl-finish--
-                                                  nil))
-                                           while-body))
-                                   '--cl-map cl--loop-map-form))
+                                 ,(funcall cl--loop-iterator-function
+                                           (if (eq (car ands) t) while-body
+                                             (cons `(or ,(car ands)
+                                                        (cl-return-from
+                                                            --cl-finish--
+                                                          nil))
+                                                   while-body))))
                             `(while ,(car ands) ,@while-body)))
                     (if cl--loop-finish-flag
                         (if (equal epilogue '(nil)) (list cl--loop-result-var)
@@ -1216,15 +1246,18 @@ For more details, see Info node `(cl)Loop Facility'.
                           (make-symbol "--cl-var--"))))
                   (if (memq word '(hash-value hash-values))
                       (setq var (prog1 other (setq other var))))
-                  (setq cl--loop-map-form
-                        `(maphash (lambda (,var ,other) . --cl-map) ,table))))
+                  (cl--loop-set-iterator-function
+                   'hash-tables (lambda (body)
+                                  `(maphash (lambda (,var ,other) . ,body)
+                                            ,table)))))
 
                ((memq word '(symbol present-symbol external-symbol
                              symbols present-symbols external-symbols))
                 (let ((ob (and (memq (car cl--loop-args) '(in of))
                                (cl--pop2 cl--loop-args))))
-                  (setq cl--loop-map-form
-                        `(mapatoms (lambda (,var) . --cl-map) ,ob))))
+                  (cl--loop-set-iterator-function
+                   'symbols (lambda (body)
+                              `(mapatoms (lambda (,var) . ,body) ,ob)))))
 
                ((memq word '(overlay overlays extent extents))
                 (let ((buf nil) (from nil) (to nil))
@@ -1234,11 +1267,12 @@ For more details, see Info node `(cl)Loop Facility'.
                           ((eq (car cl--loop-args) 'to)
                            (setq to (cl--pop2 cl--loop-args)))
                           (t (setq buf (cl--pop2 cl--loop-args)))))
-                  (setq cl--loop-map-form
-                        `(cl--map-overlays
-                          (lambda (,var ,(make-symbol "--cl-var--"))
-                            (progn . --cl-map) nil)
-                          ,buf ,from ,to))))
+                  (cl--loop-set-iterator-function
+                   'overlays (lambda (body)
+                               `(cl--map-overlays
+                                 (lambda (,var ,(make-symbol "--cl-var--"))
+                                   (progn . ,body) nil)
+                                 ,buf ,from ,to)))))
 
                ((memq word '(interval intervals))
                 (let ((buf nil) (prop nil) (from nil) (to nil)
@@ -1255,10 +1289,11 @@ For more details, see Info node `(cl)Loop Facility'.
                   (if (and (consp var) (symbolp (car var)) (symbolp (cdr var)))
                       (setq var1 (car var) var2 (cdr var))
                     (push (list var `(cons ,var1 ,var2)) loop-for-sets))
-                  (setq cl--loop-map-form
-                        `(cl--map-intervals
-                          (lambda (,var1 ,var2) . --cl-map)
-                          ,buf ,prop ,from ,to))))
+                  (cl--loop-set-iterator-function
+                   'intervals (lambda (body)
+                                `(cl--map-intervals
+                                  (lambda (,var1 ,var2) . ,body)
+                                  ,buf ,prop ,from ,to)))))
 
                ((memq word key-types)
                 (or (memq (car cl--loop-args) '(in of))
@@ -1274,10 +1309,11 @@ For more details, see Info node `(cl)Loop Facility'.
                          (make-symbol "--cl-var--"))))
                   (if (memq word '(key-binding key-bindings))
                       (setq var (prog1 other (setq other var))))
-                  (setq cl--loop-map-form
-                        `(,(if (memq word '(key-seq key-seqs))
-                               'cl--map-keymap-recursively 'map-keymap)
-                          (lambda (,var ,other) . --cl-map) ,cl-map))))
+                  (cl--loop-set-iterator-function
+                   'keys (lambda (body)
+                           `(,(if (memq word '(key-seq key-seqs))
+                                  'cl--map-keymap-recursively 'map-keymap)
+                             (lambda (,var ,other) . ,body) ,cl-map)))))
 
                ((memq word '(frame frames screen screens))
                 (let ((temp (make-symbol "--cl-var--")))
@@ -1448,12 +1484,9 @@ For more details, see Info node `(cl)Loop Facility'.
         (if (eq word 'unless) (setq then (prog1 else (setq else then))))
         (let ((form (cons (if simple (cons 'progn (nth 1 then)) (nth 2 then))
                           (if simple (nth 1 else) (list (nth 2 else))))))
-          (if (cl--expr-contains form 'it)
-              (let ((temp (make-symbol "--cl-var--")))
-                (push (list temp) cl--loop-bindings)
-                (setq form `(if (setq ,temp ,cond)
-                                ,@(cl-subst temp 'it form))))
-            (setq form `(if ,cond ,@form)))
+          (setq form (if (cl--expr-contains form 'it)
+                         `(let ((it ,cond)) (if it ,@form))
+                       `(if ,cond ,@form)))
           (push (if simple `(progn ,form t) form) cl--loop-body))))
 
      ((memq word '(do doing))
@@ -1478,36 +1511,50 @@ For more details, see Info node `(cl)Loop Facility'.
     (if (eq (car cl--loop-args) 'and)
         (progn (pop cl--loop-args) (cl--parse-loop-clause)))))
 
-(defun cl--loop-let (specs body par)   ; uses loop-*
-  (let ((p specs) (temps nil) (new nil))
-    (while (and p (or (symbolp (car-safe (car p))) (null (cl-cadar p))))
-      (setq p (cdr p)))
-    (and par p
-         (progn
-           (setq par nil p specs)
-           (while p
-             (or (macroexp-const-p (cl-cadar p))
-                 (let ((temp (make-symbol "--cl-var--")))
-                   (push (list temp (cl-cadar p)) temps)
-                   (setcar (cdar p) temp)))
-             (setq p (cdr p)))))
+(defun cl--unused-var-p (sym)
+  (or (null sym) (eq ?_ (aref (symbol-name sym) 0))))
+
+(defun cl--loop-let (specs body par)    ; modifies cl--loop-bindings
+  "Build an expression equivalent to (let SPECS BODY).
+SPECS can include bindings using `cl-loop's destructuring (not to be
+confused with the patterns of `cl-destructuring-bind').
+If PAR is nil, do the bindings step by step, like `let*'.
+If BODY is `setq', then use SPECS for assignments rather than for bindings."
+  (let ((temps nil) (new nil))
+    (when par
+      (let ((p specs))
+        (while (and p (or (symbolp (car-safe (car p))) (null (cl-cadar p))))
+          (setq p (cdr p)))
+        (when p
+          (setq par nil)
+          (dolist (spec specs)
+            (or (macroexp-const-p (cadr spec))
+                (let ((temp (make-symbol "--cl-var--")))
+                  (push (list temp (cadr spec)) temps)
+                  (setcar (cdr spec) temp)))))))
     (while specs
-      (if (and (consp (car specs)) (listp (caar specs)))
-          (let* ((spec (caar specs)) (nspecs nil)
-                 (expr (cadr (pop specs)))
-                 (temp
-                  (cdr (or (assq spec cl--loop-destr-temps)
-                           (car (push (cons spec
-                                            (or (last spec 0)
-                                                (make-symbol "--cl-var--")))
-                                      cl--loop-destr-temps))))))
-            (push (list temp expr) new)
-            (while (consp spec)
-              (push (list (pop spec)
-                             (and expr (list (if spec 'pop 'car) temp)))
-                       nspecs))
-            (setq specs (nconc (nreverse nspecs) specs)))
-        (push (pop specs) new)))
+      (let* ((binding (pop specs))
+             (spec (car-safe binding)))
+        (if (and (consp binding) (or (consp spec) (cl--unused-var-p spec)))
+            (let* ((nspecs nil)
+                   (expr (car (cdr-safe binding)))
+                   (temp (last spec 0)))
+              (if (and (cl--unused-var-p temp) (null expr))
+                  nil ;; Don't bother declaring/setting `temp' since it won't
+                      ;; be used when `expr' is nil, anyway.
+                (when (and (eq body 'setq) (cl--unused-var-p temp))
+                  ;; Prefer a fresh uninterned symbol over "_to", to avoid
+                  ;; warnings that we set an unused variable.
+                  (setq temp (make-symbol "--cl-var--"))
+                  ;; Make sure this temp variable is locally declared.
+                  (push (list (list temp)) cl--loop-bindings))
+                (push (list temp expr) new))
+              (while (consp spec)
+                (push (list (pop spec)
+                            (and expr (list (if spec 'pop 'car) temp)))
+                      nspecs))
+              (setq specs (nconc (nreverse nspecs) specs)))
+          (push binding new))))
     (if (eq body 'setq)
         (let ((set (cons (if par 'cl-psetq 'setq)
                          (apply 'nconc (nreverse new)))))
diff --git a/lisp/international/quail.el b/lisp/international/quail.el
index 245f7975d91..f2df229e349 100644
--- a/lisp/international/quail.el
+++ b/lisp/international/quail.el
@@ -2486,7 +2486,6 @@ should be made by `quail-build-decode-map' (which see)."
   "Show brief description of the current Quail package.
 Optional arg PACKAGE specifies the name of alternative Quail
 package to describe."
-  (interactive)
   (require 'help-mode)
   (let ((help-xref-mule-regexp help-xref-mule-regexp-template)
         (mb enable-multibyte-characters)
diff --git a/lisp/progmodes/octave.el b/lisp/progmodes/octave.el
index f20a57940be..899f2752a7e 100644
--- a/lisp/progmodes/octave.el
+++ b/lisp/progmodes/octave.el
@@ -1,4 +1,4 @@
-;;; octave.el --- editing octave source files under emacs   -*- lexical-binding: t; -*-
+;;; octave.el --- editing octave source files under emacs  -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
 
@@ -24,7 +24,7 @@
 
 ;;; Commentary:
 
-;; This package provides emacs support for Octave.  It defines a major
+;; This package provides Emacs support for Octave.  It defines a major
 ;; mode for editing Octave code and contains code for interacting with
 ;; an inferior Octave process using comint.
 
@@ -109,11 +109,13 @@ parenthetical grouping.")
     (define-key map "\C-c/" 'smie-close-block)
     (define-key map "\C-c;" 'octave-update-function-file-comment)
     (define-key map "\C-hd" 'octave-help)
+    (define-key map "\C-ha" 'octave-lookfor)
     (define-key map "\C-c\C-f" 'octave-insert-defun)
     (define-key map "\C-c\C-il" 'octave-send-line)
     (define-key map "\C-c\C-ib" 'octave-send-block)
     (define-key map "\C-c\C-if" 'octave-send-defun)
     (define-key map "\C-c\C-ir" 'octave-send-region)
+    (define-key map "\C-c\C-ia" 'octave-send-buffer)
     (define-key map "\C-c\C-is" 'octave-show-process-buffer)
     (define-key map "\C-c\C-iq" 'octave-hide-process-buffer)
     (define-key map "\C-c\C-ik" 'octave-kill-process)
@@ -121,6 +123,7 @@ parenthetical grouping.")
     (define-key map "\C-c\C-i\C-b" 'octave-send-block)
     (define-key map "\C-c\C-i\C-f" 'octave-send-defun)
     (define-key map "\C-c\C-i\C-r" 'octave-send-region)
+    (define-key map "\C-c\C-i\C-a" 'octave-send-buffer)
     (define-key map "\C-c\C-i\C-s" 'octave-show-process-buffer)
     (define-key map "\C-c\C-i\C-q" 'octave-hide-process-buffer)
     (define-key map "\C-c\C-i\C-k" 'octave-kill-process)
@@ -143,6 +146,7 @@ parenthetical grouping.")
     ["Start Octave Process"         run-octave t]
     ["Documentation Lookup"         info-lookup-symbol t]
     ["Help on Function"             octave-help t]
+    ["Search help"                  octave-lookfor t]
     ["Find Function Definition"     octave-find-definition t]
     ["Insert Function"              octave-insert-defun t]
     ["Update Function File Comment" octave-update-function-file-comment t]
@@ -169,6 +173,7 @@ parenthetical grouping.")
      ["Send Current Block"      octave-send-block t]
      ["Send Current Function"   octave-send-defun t]
      ["Send Region"             octave-send-region t]
+     ["Send Buffer"             octave-send-buffer t]
      ["Show Process Buffer"     octave-show-process-buffer t]
      ["Hide Process Buffer"     octave-hide-process-buffer t]
      ["Kill Process"            octave-kill-process t])
@@ -634,6 +639,7 @@ mode, include \"-q\" and \"--traditional\"."
     (define-key map "\M-." 'octave-find-definition)
     (define-key map "\t" 'completion-at-point)
     (define-key map "\C-hd" 'octave-help)
+    (define-key map "\C-ha" 'octave-lookfor)
     ;; Same as in `shell-mode'.
     (define-key map "\M-?" 'comint-dynamic-list-filename-completions)
     (define-key map "\C-c\C-l" 'inferior-octave-dynamic-list-input-ring)
@@ -645,7 +651,7 @@ mode, include \"-q\" and \"--traditional\"."
 (defvar inferior-octave-mode-syntax-table
   (let ((table (make-syntax-table octave-mode-syntax-table)))
     table)
-  "Syntax table in use in inferior-octave-mode buffers.")
+  "Syntax table in use in `inferior-octave-mode' buffers.")
 
 (defvar inferior-octave-font-lock-keywords
   (list
@@ -798,34 +804,30 @@ startup file, `~/.emacs-octave'."
   ;;
   ;; Use cache to avoid repetitive computation of completions due to
   ;; bug#11906 - http://debbugs.gnu.org/11906 - which may cause
-  ;; noticeable delay.  CACHE: (CMD TIME VALUE).
+  ;; noticeable delay.  CACHE: (CMD . VALUE).
   (let ((cache))
     (completion-table-dynamic
      (lambda (command)
-       (unless (and (equal (car cache) command)
-                    (< (float-time) (+ 5 (cadr cache))))
+       (unless (equal (car cache) command)
          (inferior-octave-send-list-and-digest
           (list (format "completion_matches ('%s');\n" command)))
-         (setq cache (list command (float-time)
+         (setq cache (cons command
                            (delete-consecutive-dups
                             (sort inferior-octave-output-list 'string-lessp)))))
-       (car (cddr cache))))))
+       (cdr cache)))))
 
 (defun inferior-octave-completion-at-point ()
   "Return the data to complete the Octave symbol at point."
   ;; http://debbugs.gnu.org/14300
-  (let* ((filecomp (string-match-p
-                    "/" (or (comint--match-partial-filename) "")))
-         (end (point))
-         (start
-          (unless filecomp
-            (save-excursion
-              (skip-syntax-backward "w_" (comint-line-beginning-position))
-              (point)))))
-    (when (and start (> end start))
-      (list start end (completion-table-in-turn
+  (unless (string-match-p "/" (or (comint--match-partial-filename) ""))
+    (let ((beg (save-excursion
+                 (skip-syntax-backward "w_" (comint-line-beginning-position))
+                 (point)))
+          (end (point)))
+      (when (and beg (> end beg))
+        (list beg end (completion-table-in-turn
                        inferior-octave-completion-table
-                       'comint-completion-file-name-table)))))
+                       'comint-completion-file-name-table))))))
 
 (define-obsolete-function-alias 'inferior-octave-complete
   'completion-at-point "24.1")
@@ -1462,6 +1464,11 @@ entered without parens)."
   (if octave-send-show-buffer
       (display-buffer inferior-octave-buffer)))
 
+(defun octave-send-buffer ()
+  "Send current buffer to the inferior Octave process."
+  (interactive)
+  (octave-send-region (point-min) (point-max)))
+
 (defun octave-send-block ()
   "Send current Octave block to the inferior Octave process."
   (interactive)
@@ -1599,6 +1606,7 @@ code line."
   (let ((map (make-sparse-keymap)))
     (define-key map "\M-." 'octave-find-definition)
     (define-key map "\C-hd" 'octave-help)
+    (define-key map "\C-ha" 'octave-lookfor)
     map))
 
 (define-derived-mode octave-help-mode help-mode "OctHelp"
@@ -1677,6 +1685,32 @@ code line."
                                   :type 'octave-help-function)))))
         (octave-help-mode)))))
 
+(defun octave-lookfor (str &optional all)
+  "Search for the string STR in all function help strings.
+If ALL is non-nil search the entire help string else only search the first
+sentence."
+  (interactive "sSearch for: \nP")
+  (inferior-octave-send-list-and-digest
+   (list (format "lookfor (%s'%s');\n"
+                 (if all "'-all', " "")
+                 str)))
+  (let ((lines inferior-octave-output-list))
+    (when (string-match "error: \\(.*\\)$" (car lines))
+      (error "%s" (match-string 1 (car lines))))
+    (with-help-window octave-help-buffer
+      (princ (mapconcat 'identity lines "\n"))
+      (with-current-buffer octave-help-buffer
+        ;; Bound to t so that `help-buffer' returns current buffer for
+        ;; `help-setup-xref'.
+        (let ((help-xref-following t))
+          (help-setup-xref (list 'octave-lookfor str all)
+                           (called-interactively-p 'interactive)))
+        (goto-char (point-min))
+        (while (re-search-forward "^\\([^[:blank:]]+\\) " nil 'noerror)
+          (make-text-button (match-beginning 1) (match-end 1)
+                            :type 'octave-help-function))
+        (octave-help-mode)))))
+
 (defcustom octave-source-directories nil
   "A list of directories for Octave sources.
 If the environment variable OCTAVE_SRCDIR is set, it is searched first."
@@ -1722,7 +1756,7 @@ If the environment variable OCTAVE_SRCDIR is set, it is searched first."
 (defun octave-find-definition (fn)
   "Find the definition of FN.
 Functions implemented in C++ can be found if
-`octave-source-directories' is set correctly."
+variable `octave-source-directories' is set correctly."
   (interactive (list (octave-completing-read)))
   (require 'etags)
   (let ((orig (point)))
diff --git a/lisp/textmodes/ispell.el b/lisp/textmodes/ispell.el
index 3998fafa5cc..a361bdae64b 100644
--- a/lisp/textmodes/ispell.el
+++ b/lisp/textmodes/ispell.el
@@ -2407,7 +2407,7 @@ Global `ispell-quit' set to start location to continue spell session."
                                             "  --  word-list: "
                                             (or ispell-complete-word-dict
                                                 ispell-alternate-dictionary))
-                                    miss (lookup-words new-word)
+                                    miss (ispell-lookup-words new-word)
                                     choices miss
                                     line ispell-choices-win-default-height)
                               (while (and choices ; adjust choices window.
@@ -2613,8 +2613,9 @@ SPC:   Accept word this time.
                 (sit-for 5))
             (erase-buffer)))))))
 
+(define-obsolete-function-alias 'lookup-words 'ispell-lookup-words "24.4")
 
-(defun lookup-words (word &optional lookup-dict)
+(defun ispell-lookup-words (word &optional lookup-dict)
   "Look up WORD in optional word-list dictionary LOOKUP-DICT.
 A `*' serves as a wild card.  If no wild cards, `look' is used if it exists.
 Otherwise the variable `ispell-grep-command' contains the command used to
@@ -3766,7 +3767,7 @@ Use APPEND to append the info to previous buffer if exists."
 
 ;;;###autoload
 (defun ispell-complete-word (&optional interior-frag)
-  "Try to complete the word before or under point (see `lookup-words').
+  "Try to complete the word before or under point.
 If optional INTERIOR-FRAG is non-nil then the word may be a character
 sequence inside of a word.
 
@@ -3782,11 +3783,12 @@ Standard ispell choices are then available."
           word (car word)
           possibilities
           (or (string= word "")         ; Will give you every word
-              (lookup-words (concat (and interior-frag "*") word
-                                    (if (or interior-frag (null ispell-look-p))
-                                        "*"))
-                            (or ispell-complete-word-dict
-                                ispell-alternate-dictionary))))
+              (ispell-lookup-words
+               (concat (and interior-frag "*") word
+                       (if (or interior-frag (null ispell-look-p))
+                           "*"))
+               (or ispell-complete-word-dict
+                   ispell-alternate-dictionary))))
     (cond ((eq possibilities t)
            (message "No word to complete"))
           ((null possibilities)