merge from upstream

17 files changed, 2347 insertions, 815 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 0eec54fab6f..38f66b4504e 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -8712,6 +8712,35 @@ comment at the start of cc-engine.el for more info."
        (c-beginning-of-statement-1 containing-sexp)
        (c-add-syntax 'annotation-var-cont (point)))
 
+     ;; CASE G: a template list continuation?
+     ;; Mostly a duplication of case 5D.3 to fix templates-19:
+     ((and (c-major-mode-is 'c++-mode)
+           (save-excursion
+             (goto-char indent-point)
+             (c-with-syntax-table c++-template-syntax-table
+               (setq placeholder (c-up-list-backward)))
+             (and placeholder
+                  (eq (char-after placeholder) ?<)
+                  (/= (char-before placeholder) ?<)
+                  (progn
+                    (goto-char (1+ placeholder))
+                    (not (looking-at c-<-op-cont-regexp))))))
+      (c-with-syntax-table c++-template-syntax-table
+        (goto-char placeholder)
+        (c-beginning-of-statement-1 containing-sexp t)
+        (if (save-excursion
+              (c-backward-syntactic-ws containing-sexp)
+              (eq (char-before) ?<))
+            ;; In a nested template arglist.
+            (progn
+              (goto-char placeholder)
+              (c-syntactic-skip-backward "^,;" containing-sexp t)
+              (c-forward-syntactic-ws))
+          (back-to-indentation)))
+      ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
+      ;; template aware.
+      (c-add-syntax 'template-args-cont (point) placeholder))
+     
      ;; CASE D: continued statement.
      (t
       (c-beginning-of-statement-1 containing-sexp)
diff --git a/lisp/progmodes/cc-guess.el b/lisp/progmodes/cc-guess.el
new file mode 100644
index 00000000000..6553021e783
--- /dev/null
+++ b/lisp/progmodes/cc-guess.el
@@ -0,0 +1,574 @@
+;;; cc-guess.el --- guess indentation values by scanning existing code
+
+;; Copyright (C) 1985, 1987, 1992-2006, 2011
+;;   Free Software Foundation, Inc.
+
+;; Author:     1994-1995 Barry A. Warsaw
+;;             2011-     Masatake YAMATO
+;; Maintainer: bug-cc-mode@gnu.org
+;; Created:    August 1994, split from cc-mode.el
+;; Version:    See cc-mode.el
+;; Keywords:   c languages oop
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; This file contains routines that help guess the cc-mode style in a
+;; particular region/buffer.  Here style means `c-offsets-alist' and
+;; `c-basic-offset'.
+;;
+;; The main entry point of this program is `c-guess' command but there
+;; are some variants.
+;;
+;; Suppose the major mode for the current buffer is one of the modes
+;; provided by cc-mode. `c-guess' guesses the indentation style by
+;; examining the indentation in the region between beginning of buffer
+;; and `c-guess-region-max'.
+
+;; and installs the guessed style. The name for installed style is given
+;; by `c-guess-style-name'.
+;;
+;; `c-guess-buffer' does the same but in the whole buffer.
+;; `c-guess-region' does the same but in the region between the point
+;; and the mark.  `c-guess-no-install', `c-guess-buffer-no-install'
+;; and `c-guess-region-no-install' guess the indentation style but
+;; don't install it. You can review a guessed style with `c-guess-view'.
+;; After reviewing, use `c-guess-install' to install the style
+;; if you prefer it.
+;;
+;; If you want to reuse the guessed style in another buffer,
+;; run `c-set-style' command with the name of the guessed style:
+;; "*c-guess*:<name-of-file-which-examined-when-guessing>".
+;; Once the guessed style is installed explicitly with `c-guess-install'
+;; or implicitly with `c-guess', `c-guess-buffer', or `c-guess-region',
+;; a style name is given by `c-guess-style-name' with the above form.
+;;
+;; If you want to reuse the guessed style in future emacs sessions,
+;; you may want to put it to your .emacs. `c-guess-view' is for
+;; you. It emits emacs lisp code which defines the last guessed
+;; style, in a temporary buffer. You can put the emitted code into
+;; your .emacs. This command was suggested by Alan Mackenzie.
+
+;;; Code:
+
+(eval-when-compile
+  (let ((load-path
+         (if (and (boundp 'byte-compile-dest-file)
+                  (stringp byte-compile-dest-file))
+             (cons (file-name-directory byte-compile-dest-file) load-path)
+           load-path)))
+    (load "cc-bytecomp" nil t)))
+
+(cc-require 'cc-defs)
+(cc-require 'cc-engine)
+(cc-require 'cc-styles)
+
+
+
+(defcustom c-guess-offset-threshold 10
+  "Threshold of acceptable offsets when examining indent information.
+Discard an examined offset if its absolute value is greater than this.
+
+The offset of a line included in the indent information returned by
+`c-guess-basic-syntax'."
+  :type 'integer
+  :group 'c)
+
+(defcustom c-guess-region-max 50000
+  "The maximum region size for examining indent information with `c-guess'.
+It takes a long time to examine indent information from a large region;
+this option helps you limit that time. `nil' means no limit."
+  :type 'integer
+  :group 'c)
+
+
+;;;###autoload
+(defvar c-guess-guessed-offsets-alist nil
+  "Currently guessed offsets-alist.")
+;;;###autoload
+(defvar c-guess-guessed-basic-offset nil
+  "Currently guessed basic-offset.")
+
+(defvar c-guess-accumulator nil)
+;; Accumulated examined indent information.  Information is represented
+;; in a list.  Each element in it has following structure:
+;;
+;; (syntactic-symbol ((indentation-offset1 . number-of-times1)
+;;                    (indentation-offset2 . number-of-times2)
+;;                    ...))
+;;
+;; This structure is built by `c-guess-accumulate-offset'.
+;;
+;; Here we call the pair (indentation-offset1 . number-of-times1) a
+;; counter.  `c-guess-sort-accumulator' sorts the order of
+;; counters by number-of-times.
+;; Use `c-guess-dump-accumulator' to see the value.
+
+(defconst c-guess-conversions
+  '((c . c-lineup-C-comments)
+    (inher-cont . c-lineup-multi-inher)
+    (string . -1000)
+    (comment-intro . c-lineup-comment)
+    (arglist-cont-nonempty . c-lineup-arglist)
+    (arglist-close . c-lineup-close-paren)
+    (cpp-macro . -1000)))
+
+
+;;;###autoload
+(defun c-guess (&optional accumulate)
+  "Guess the style in the region up to `c-guess-region-max', and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch."
+  (interactive "P")
+  (c-guess-region (point-min)
+                   (min (point-max) (or c-guess-region-max
+                                        (point-max)))
+                   accumulate))
+
+;;;###autoload
+(defun c-guess-no-install (&optional accumulate)
+  "Guess the style in the region up to `c-guess-region-max'; don't install it.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch."
+  (interactive "P")
+  (c-guess-region-no-install (point-min)
+                              (min (point-max) (or c-guess-region-max
+                                                   (point-max)))
+                              accumulate))
+
+;;;###autoload
+(defun c-guess-buffer (&optional accumulate)
+  "Guess the style on the whole current buffer, and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch."
+  (interactive "P")
+  (c-guess-region (point-min)
+                   (point-max)
+                   accumulate))
+
+;;;###autoload
+(defun c-guess-buffer-no-install (&optional accumulate)
+  "Guess the style on the whole current buffer; don't install it.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch."
+  (interactive "P")
+  (c-guess-region-no-install (point-min)
+                              (point-max)
+                              accumulate))
+
+;;;###autoload
+(defun c-guess-region (start end &optional accumulate)
+  "Guess the style on the region and install it.
+
+The style is given a name based on the file's absolute file name.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous guess is extended, otherwise a new guess is
+made from scratch."
+  (interactive "r\nP")
+  (c-guess-region-no-install start end accumulate)
+  (c-guess-install))
+
+
+(defsubst c-guess-empty-line-p ()
+  (eq (line-beginning-position)
+      (line-end-position)))
+
+;;;###autoload
+(defun c-guess-region-no-install (start end &optional accumulate)
+  "Guess the style on the region; don't install it.
+
+Every line of code in the region is examined and values for the following two
+variables are guessed:
+
+* `c-basic-offset', and
+* the indentation values of the various syntactic symbols in
+  `c-offsets-alist'.
+
+The guessed values are put into `c-guess-guessed-basic-offset' and
+`c-guess-guessed-offsets-alist'.
+
+Frequencies of use are taken into account when guessing, so minor
+inconsistencies in the indentation style shouldn't produce wrong guesses.
+
+If given a prefix argument (or if the optional argument ACCUMULATE is
+non-nil) then the previous examination is extended, otherwise a new
+guess is made from scratch.
+
+Note that the larger the region to guess in, the slower the guessing.
+So you can limit the region with `c-guess-region-max'."
+  (interactive "r\nP")
+  (let ((accumulator (when accumulate c-guess-accumulator)))
+    (setq c-guess-accumulator (c-guess-examine start end accumulator))
+    (let ((pair (c-guess-guess c-guess-accumulator)))
+      (setq c-guess-guessed-basic-offset (car pair)
+            c-guess-guessed-offsets-alist (cdr pair)))))
+
+
+(defun c-guess-examine (start end accumulator)
+  (let ((reporter (when (fboundp 'make-progress-reporter)
+                    (make-progress-reporter "Examining Indentation "
+                                            start
+                                            end))))
+    (save-excursion
+      (goto-char start)
+      (while (< (point) end)
+        (unless (c-guess-empty-line-p)
+          (mapc (lambda (s)
+                  (setq accumulator (or (c-guess-accumulate accumulator s)
+                                        accumulator)))
+                (c-save-buffer-state () (c-guess-basic-syntax))))
+        (when reporter (progress-reporter-update reporter (point)))
+        (forward-line 1)))
+    (when reporter (progress-reporter-done reporter)))
+  (c-guess-sort-accumulator accumulator))
+
+(defun c-guess-guess (accumulator)
+  ;; Guess basic-offset and offsets-alist from ACCUMULATOR,
+  ;; then return them as a cons: (basic-offset . offsets-alist).
+  ;; See the comments at `c-guess-accumulator' about the format
+  ;; ACCUMULATOR.
+  (let* ((basic-offset (c-guess-make-basic-offset accumulator))
+         (typical-offsets-alist (c-guess-make-offsets-alist
+                                 accumulator))
+         (symbolic-offsets-alist (c-guess-symbolize-offsets-alist
+                                  typical-offsets-alist
+                                  basic-offset))
+         (merged-offsets-alist (c-guess-merge-offsets-alists
+                                (copy-tree c-guess-conversions)
+                                symbolic-offsets-alist)))
+    (cons basic-offset merged-offsets-alist)))
+
+(defun c-guess-current-offset (relpos)
+  ;; Calculate relative indentation (point) to RELPOS.
+  (- (progn (back-to-indentation)
+            (current-column))
+     (save-excursion
+       (goto-char relpos)
+       (current-column))))
+
+(defun c-guess-accumulate (accumulator syntax-element)
+  ;; Add SYNTAX-ELEMENT to ACCUMULATOR.
+  (let ((symbol (car syntax-element))
+        (relpos (cadr syntax-element)))
+    (when (numberp relpos)
+      (let ((offset (c-guess-current-offset relpos)))
+        (when (< (abs offset) c-guess-offset-threshold)
+          (c-guess-accumulate-offset accumulator
+                                      symbol
+                                      offset))))))
+
+(defun c-guess-accumulate-offset (accumulator symbol offset)
+  ;; Added SYMBOL and OFFSET to ACCUMULATOR.  See
+  ;; `c-guess-accumulator' about the structure of ACCUMULATOR.
+  (let* ((entry    (assoc symbol accumulator))
+         (counters (cdr entry))
+         counter)
+    (if entry
+        (progn
+          (setq counter (assoc offset counters))
+          (if counter
+              (setcdr counter (1+ (cdr counter)))
+            (setq counters (cons (cons offset 1) counters))
+            (setcdr entry counters))
+          accumulator)
+      (cons (cons symbol (cons (cons offset 1) nil)) accumulator))))
+
+(defun c-guess-sort-accumulator (accumulator)
+  ;; Sort each element of ACCUMULATOR by the number-of-times.  See
+  ;; `c-guess-accumulator' for more details.
+  (mapcar
+   (lambda (entry)
+     (let ((symbol (car entry))
+           (counters (cdr entry)))
+       (cons symbol (sort counters
+                          (lambda (a b)
+                            (if (> (cdr a) (cdr b))
+                                t
+                              (and
+                               (eq (cdr a) (cdr b))
+                               (< (car a) (car b)))))))))
+   accumulator))
+
+(defun c-guess-make-offsets-alist (accumulator)
+  ;; Throw away the rare cases in accumulator and make an offsets-alist structure.
+  (mapcar
+   (lambda (entry)
+     (cons (car entry)
+           (car (car (cdr entry)))))
+   accumulator))
+
+(defun c-guess-merge-offsets-alists (strong weak)
+  ;; Merge two offsets-alists into one.
+  ;; When two offsets-alists have the same symbol
+  ;; entry, give STRONG priority over WEAK.
+  (mapc
+   (lambda (weak-elt)
+     (unless (assoc (car weak-elt) strong)
+       (setq strong (cons weak-elt strong))))
+   weak)
+  strong)
+
+(defun c-guess-make-basic-offset (accumulator)
+  ;; As candidate for `c-basic-offset', find the most frequently appearing
+  ;; indentation-offset in ACCUMULATOR.
+  (let* (;; Drop the value related to `c' syntactic-symbol.
+         ;; (`c': Inside a multiline C style block comment.)
+         ;; The impact for values of `c' is too large for guessing
+         ;; `basic-offset' if the target source file is small and its license
+         ;; notice is at top of the file.
+         (accumulator (assq-delete-all 'c (copy-tree accumulator)))
+         ;; Drop syntactic-symbols from ACCUMULATOR.
+         (alist (apply #'append (mapcar (lambda (elts)
+                                          (mapcar (lambda (elt)
+                                                    (cons (abs (car elt))
+                                                          (cdr elt)))
+                                                  (cdr elts)))
+                                        accumulator)))
+         ;; Gather all indentation-offsets other than 0.
+         ;; 0 is meaningless as `basic-offset'.
+         (offset-list (delete 0
+                              (delete-dups (mapcar
+                                            (lambda (elt) (car elt))
+                                            alist))))
+         ;; Sum of number-of-times for offset:
+         ;;  (offset . sum)
+         (summed (mapcar (lambda (offset)
+                           (cons offset
+                                 (apply #'+
+                                        (mapcar (lambda (a)
+                                                  (if (eq (car a) offset)
+                                                      (cdr a)
+                                                    0))
+                                                alist))))
+                         offset-list)))
+    ;;
+    ;; Find the majority.
+    ;;
+    (let ((majority '(nil . 0)))
+      (while summed
+        (when (< (cdr majority) (cdr (car summed)))
+          (setq majority (car summed)))
+        (setq summed (cdr summed)))
+      (car majority))))
+
+(defun c-guess-symbolize-offsets-alist (offsets-alist basic-offset)
+  ;; Convert the representation of OFFSETS-ALIST to an alist using
+  ;; `+', `-', `++', `--', `*', or `/'. These symbols represent
+  ;; a value relative to BASIC-OFFSET.  Their meaning can be found
+  ;; in the CC Mode manual.
+  (mapcar
+   (lambda (elt)
+     (let ((s (car elt))
+           (v (cdr elt)))
+       (cond
+        ((integerp v)
+         (cons s (c-guess-symbolize-integer v
+                                             basic-offset)))
+        (t elt))))
+   offsets-alist))
+
+(defun c-guess-symbolize-integer (int basic-offset)
+  (let ((aint (abs int)))
+    (cond
+     ((eq int basic-offset) '+)
+     ((eq aint basic-offset) '-)
+     ((eq int (* 2 basic-offset)) '++)
+     ((eq aint (* 2 basic-offset)) '--)
+     ((eq (* 2 int) basic-offset) '*)
+     ((eq (* 2 aint) basic-offset) '-)
+     (t int))))
+
+(defun c-guess-style-name ()
+  ;; Make a style name for the guessed style.
+  (format "*c-guess*:%s" (buffer-file-name)))
+
+(defun c-guess-make-style (basic-offset offsets-alist)
+  (when basic-offset
+    ;; Make a style from guessed values.
+    (let*       ((offsets-alist (c-guess-merge-offsets-alists
+                                 offsets-alist
+                                 c-offsets-alist)))
+      `((c-basic-offset . ,basic-offset)
+        (c-offsets-alist . ,offsets-alist)))))
+
+;;;###autoload
+(defun c-guess-install (&optional style-name)
+  "Install the latest guessed style into the current buffer.
+\(This guessed style is a combination of `c-guess-guessed-basic-offset',
+`c-guess-guessed-offsets-alist' and `c-offsets-alist'.)
+
+The style is entered into CC Mode's style system by
+`c-add-style'.  Its name is either STYLE-NAME, or a name based on
+the absolute file name of the file if STYLE-NAME is nil."
+  (interactive "sNew style name (empty for default name): ")
+  (let* ((style (c-guess-make-style c-guess-guessed-basic-offset
+                                    c-guess-guessed-offsets-alist)))
+    (if style
+        (let ((style-name (or (if (equal style-name "")
+                                  nil
+                                style-name)
+                              (c-guess-style-name))))
+          (c-add-style style-name style t)
+          (message "Style \"%s\" is installed" style-name))
+      (error "Not yet guessed"))))
+
+(defun c-guess-dump-accumulator ()
+  "Show `c-guess-accumulator'."
+  (interactive)
+  (with-output-to-temp-buffer "*Accumulated Examined Indent Information*"
+    (pp c-guess-accumulator)))
+
+(defun c-guess-reset-accumulator ()
+  "Reset `c-guess-accumulator'."
+  (interactive)
+  (setq c-guess-accumulator nil))
+
+(defun c-guess-dump-guessed-values ()
+  "Show `c-guess-guessed-basic-offset' and `c-guess-guessed-offsets-alist'."
+  (interactive)
+  (with-output-to-temp-buffer "*Guessed Values*"
+    (princ "basic-offset: \n\t")
+    (pp c-guess-guessed-basic-offset)
+    (princ "\n\n")
+    (princ "offsets-alist: \n")
+    (pp c-guess-guessed-offsets-alist)
+    ))
+
+(defun c-guess-dump-guessed-style (&optional printer)
+  "Show the guessed style.
+`pp' is used to print the style but if PRINTER is given,
+PRINTER is used instead. If PRINTER is not `nil', it
+is called with one argument, the guessed style."
+  (interactive)
+  (let ((style (c-guess-make-style c-guess-guessed-basic-offset
+                                   c-guess-guessed-offsets-alist)))
+    (if style
+        (with-output-to-temp-buffer "*Guessed Style*"
+          (funcall (if printer printer 'pp) style))
+      (error "Not yet guessed"))))
+
+(defun c-guess-guessed-syntactic-symbols ()
+  ;; Return syntactic symbols in c-guess-guessed-offsets-alist
+  ;; but not in c-guess-conversions.
+  (let ((alist c-guess-guessed-offsets-alist)
+        elt
+        (symbols nil))
+    (while alist
+      (setq elt (car alist)
+            alist (cdr alist))
+      (unless (assq (car elt) c-guess-conversions)
+        (setq symbols (cons (car elt)
+                            symbols))))
+    symbols))
+
+(defun c-guess-view-reorder-offsets-alist-in-style (style guessed-syntactic-symbols)
+  ;; Reorder the `c-offsets-alist' field of STYLE.
+  ;; If an entry in `c-offsets-alist' holds a guessed value, move it to
+  ;; front in the field. In addition alphabetical sort by entry name is done.
+  (setq style (copy-tree style))
+  (let ((offsets-alist-cell (assq 'c-offsets-alist style))
+        (guessed-syntactic-symbols (c-guess-guessed-syntactic-symbols)))
+    (setcdr offsets-alist-cell
+            (sort (cdr offsets-alist-cell)
+                  (lambda (a b)
+                    (let ((a-guessed? (memq (car a) guessed-syntactic-symbols))
+                          (b-guessed? (memq (car b) guessed-syntactic-symbols)))
+                      (cond
+                       ((or (and a-guessed? b-guessed?)
+                            (not (or a-guessed? b-guessed?)))
+                        (string-lessp (symbol-name (car a))
+                                      (symbol-name (car b))))
+                       (a-guessed? t)
+                       (b-guessed? nil)))))))
+  style)
+
+(defun c-guess-view-mark-guessed-entries (guessed-syntactic-symbols)
+  ;; Put " ; Guess value" markers on all entries which hold
+  ;; guessed values.
+  ;; `c-basic-offset' is always considered as holding a guessed value.
+  (let ((needs-markers (cons 'c-basic-offset
+                             guessed-syntactic-symbols)))
+    (while needs-markers
+      (goto-char (point-min))
+      (when (search-forward (concat "("
+                                    (symbol-name (car needs-markers))
+                                    " ") nil t)
+        (move-end-of-line 1)
+        (comment-dwim nil)
+        (insert " Guessed value"))
+      (setq needs-markers
+            (cdr needs-markers)))))
+
+(defun c-guess-view (&optional with-name)
+  "Emit emacs lisp code which defines the last guessed style.
+So you can put the code into .emacs if you prefer the
+guessed code.
+\"STYLE NAME HERE\" is used as the name for the style in the
+emitted code. If WITH-NAME is given, it is used instead.
+WITH-NAME is expected as a string but if this function
+called interactively with prefix argument, the value for
+WITH-NAME is asked to the user."
+  (interactive "P")
+  (let* ((temporary-style-name (cond
+                                ((stringp with-name) with-name)
+                                (with-name (read-from-minibuffer
+                                            "New style name: "))
+                                (t
+                                 "STYLE NAME HERE")))
+         (guessed-style-name (c-guess-style-name))
+         (current-style-name c-indentation-style)
+         (parent-style-name (if (string-equal guessed-style-name
+                                              current-style-name)
+                                ;; The guessed style is already installed.
+                                ;; It cannot be used as the parent style.
+                                ;; Use the default style for the current
+                                ;; major mode as the parent style.
+                                (cc-choose-style-for-mode
+                                 major-mode
+                                 c-default-style)
+                              ;; The guessed style is not installed yet.
+                              current-style-name)))
+    (c-guess-dump-guessed-style
+     (lambda (style)
+       (let ((guessed-syntactic-symbols (c-guess-guessed-syntactic-symbols)))
+         (pp `(c-add-style ,temporary-style-name
+                           ',(cons parent-style-name
+                                   (c-guess-view-reorder-offsets-alist-in-style
+                                    style
+                                    guessed-syntactic-symbols))))
+         (with-current-buffer standard-output
+           (lisp-interaction-mode)
+           (c-guess-view-mark-guessed-entries
+            guessed-syntactic-symbols)
+           (buffer-enable-undo)))))))
+
+
+(cc-provide 'cc-guess)
+;;; cc-guess.el ends here
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 86a963bcf55..a6459e1724f 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -295,6 +295,19 @@ the evaluated constant value at compile time."
             ["Backslashify"           c-backslash-region
              (c-fn-region-is-active-p)]))
       "----"
+      ("Style..."
+       ["Set Style..."                   c-set-style t]
+       ["Show Current Style Name"        (message
+                                          "Style Name: %s"
+                                          c-indentation-style) t]
+       ["Guess Style from this Buffer"   c-guess-buffer-no-install t]
+       ["Install the Last Guessed Style..." c-guess-install
+        (and c-guess-guessed-offsets-alist
+             c-guess-guessed-basic-offset) ]
+       ["View the Last Guessed Style"    c-guess-view
+        (and c-guess-guessed-offsets-alist
+             c-guess-guessed-basic-offset) ])
+      "----"
       ("Toggle..."
        ["Syntactic indentation" c-toggle-syntactic-indentation
         :style toggle :selected c-syntactic-indentation]
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 3a5a643a2a8..1adc6c2eac0 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -93,6 +93,7 @@
 (cc-require 'cc-cmds)
 (cc-require 'cc-align)
 (cc-require 'cc-menus)
+(cc-require 'cc-guess)
 
 ;; Silence the compiler.
 (cc-bytecomp-defvar adaptive-fill-first-line-regexp) ; Emacs
@@ -553,11 +554,7 @@ that requires a literal mode spec at compile time."
   (c-clear-found-types)
 
   ;; now set the mode style based on default-style
-  (let ((style (if (stringp default-style)
-                   default-style
-                 (or (cdr (assq mode default-style))
-                     (cdr (assq 'other default-style))
-                     "gnu"))))
+  (let ((style (cc-choose-style-for-mode mode default-style)))
     ;; Override style variables if `c-old-style-variable-behavior' is
     ;; set.  Also override if we are using global style variables,
     ;; have already initialized a style once, and are switching to a
@@ -692,7 +689,8 @@ This function is called from the hook `before-hack-local-variables-hook'."
                    (c-count-cfss file-local-variables-alist))
                   (cfs-in-dir-count (c-count-cfss dir-local-variables-alist)))
               (c-set-style stile
-                           (= cfs-in-file-and-dir-count cfs-in-dir-count)))
+                           (and (= cfs-in-file-and-dir-count cfs-in-dir-count)
+                                'keep-defaults)))
           (c-set-style stile)))
       (when offsets
         (mapc
diff --git a/lisp/progmodes/cc-styles.el b/lisp/progmodes/cc-styles.el
index e161eb6d0f5..96cb15f2a72 100644
--- a/lisp/progmodes/cc-styles.el
+++ b/lisp/progmodes/cc-styles.el
@@ -650,6 +650,15 @@ any reason to call this function directly."
       (setq c-style-variables-are-local-p t))
     ))
 
+(defun cc-choose-style-for-mode (mode default-style)
+  "Return suitable style for MODE from DEFAULT-STYLE.
+DEFAULT-STYLE has the same format as `c-default-style'."
+  (if (stringp default-style)
+      default-style
+    (or (cdr (assq mode default-style))
+        (cdr (assq 'other default-style))
+        "gnu")))
+
 
 
 (cc-provide 'cc-styles)
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index d2a5d117635..58dc1737c5a 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1633,8 +1633,7 @@ as designated in the variable `c-file-style'.")
 ;; It isn't possible to specify a doc-string without specifying an
 ;; initial value with `defvar', so the following two variables have been
 ;; given doc-strings by setting the property `variable-documentation'
-;; directly.  C-h v will read this documentation only for versions of GNU
-;; Emacs from 22.1.  It's really good not to have an initial value for
+;; directly.  It's really good not to have an initial value for
 ;; variables like these that always should be dynamically bound, so it's
 ;; worth the inconvenience.
 
diff --git a/lisp/progmodes/cfengine.el b/lisp/progmodes/cfengine.el
index 22ece17cb28..7989c60f80c 100644
--- a/lisp/progmodes/cfengine.el
+++ b/lisp/progmodes/cfengine.el
@@ -3,6 +3,7 @@
 ;; Copyright (C) 2001-2011  Free Software Foundation, Inc.
 
 ;; Author: Dave Love <fx@gnu.org>
+;; Maintainer: Ted Zlatanov <tzz@lifelogs.com>
 ;; Keywords: languages
 
 ;; This file is part of GNU Emacs.
@@ -28,6 +29,13 @@
 ;; Possible customization for auto-mode selection:
 ;; (push '(("^cfagent.conf\\'" . cfengine-mode)) auto-mode-alist)
 ;; (push '(("^cf\\." . cfengine-mode)) auto-mode-alist)
+;; (push '(("\\.cf\\'" . cfengine-mode)) auto-mode-alist)
+
+;; Or, if you want to use the CFEngine 3.x support:
+
+;; (push '(("^cfagent.conf\\'" . cfengine3-mode)) auto-mode-alist)
+;; (push '(("^cf\\." . cfengine3-mode)) auto-mode-alist)
+;; (push '(("\\.cf\\'" . cfengine3-mode)) auto-mode-alist)
 
 ;; This is not the same as the mode written by Rolf Ebert
 ;; <ebert@waporo.muc.de>, distributed with cfengine-2.0.5.  It does
@@ -63,7 +71,27 @@
       ;; cfservd
       "admit" "grant" "deny")
     "List of the action keywords supported by Cfengine.
-This includes those for cfservd as well as cfagent."))
+This includes those for cfservd as well as cfagent.")
+
+  (defconst cfengine3-defuns
+    (mapcar
+     'symbol-name
+     '(bundle body))
+    "List of the CFEngine 3.x defun headings.")
+
+  (defconst cfengine3-defuns-regex
+    (regexp-opt cfengine3-defuns t)
+    "Regex to match the CFEngine 3.x defuns.")
+
+  (defconst cfengine3-class-selector-regex "\\([[:alnum:]_().&|!]+\\)::")
+
+  (defconst cfengine3-category-regex "\\([[:alnum:]_]+\\):")
+
+  (defconst cfengine3-vartypes
+    (mapcar
+     'symbol-name
+     '(string int real slist ilist rlist irange rrange counter))
+    "List of the CFEngine 3.x variable types."))
 
 (defvar cfengine-font-lock-keywords
   `(;; Actions.
@@ -82,6 +110,31 @@ This includes those for cfservd as well as cfagent."))
     ;; File, acl &c in group:   { token ... }
     ("{[ \t]*\\([^ \t\n]+\\)" 1 font-lock-constant-face)))
 
+(defvar cfengine3-font-lock-keywords
+  `(
+    (,(concat "^[ \t]*" cfengine3-class-selector-regex)
+     1 font-lock-keyword-face)
+    (,(concat "^[ \t]*" cfengine3-category-regex)
+     1 font-lock-builtin-face)
+    ;; Variables, including scope, e.g. module.var
+    ("[@$](\\([[:alnum:]_.]+\\))" 1 font-lock-variable-name-face)
+    ("[@$]{\\([[:alnum:]_.]+\\)}" 1 font-lock-variable-name-face)
+    ;; Variable definitions.
+    ("\\<\\([[:alnum:]_]+\\)[ \t]*=[ \t]*(" 1 font-lock-variable-name-face)
+
+    ;; CFEngine 3.x faces
+    ;; defuns
+    (,(concat "\\<" cfengine3-defuns-regex "\\>"
+              "[ \t]+\\<\\([[:alnum:]_]+\\)\\>"
+              "[ \t]+\\<\\([[:alnum:]_]+\\)\\((\\([^)]*\\))\\)?")
+    (1 font-lock-builtin-face)
+    (2 font-lock-constant-name-face)
+    (3 font-lock-function-name-face)
+    (5 font-lock-variable-name-face))
+    ;; variable types
+    (,(concat "\\<" (eval-when-compile (regexp-opt cfengine3-vartypes t)) "\\>")
+     1 font-lock-type-face)))
+
 (defvar cfengine-imenu-expression
   `((nil ,(concat "^[ \t]*" (eval-when-compile
                               (regexp-opt cfengine-actions t))
@@ -197,6 +250,191 @@ Intended as the value of `indent-line-function'."
         (fill-paragraph justify))
       t))
 
+(defun cfengine3-beginning-of-defun ()
+  "`beginning-of-defun' function for Cfengine 3 mode.
+Treats body/bundle blocks as defuns."
+  (unless (<= (current-column) (current-indentation))
+    (end-of-line))
+  (if (re-search-backward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+      (beginning-of-line)
+    (goto-char (point-min)))
+  t)
+
+(defun cfengine3-end-of-defun ()
+  "`end-of-defun' function for Cfengine 3 mode.
+Treats body/bundle blocks as defuns."
+  (end-of-line)
+  (if (re-search-forward (concat "^[ \t]*" cfengine3-defuns-regex "\\>") nil t)
+      (beginning-of-line)
+    (goto-char (point-max)))
+  t)
+
+(defun cfengine3-indent-line ()
+  "Indent a line in Cfengine 3 mode.
+Intended as the value of `indent-line-function'."
+  (let ((pos (- (point-max) (point)))
+        parse)
+    (save-restriction
+      (narrow-to-defun)
+      (back-to-indentation)
+      (setq parse (parse-partial-sexp (point-min) (point)))
+      (message "%S" parse)
+      (cond
+       ;; body/bundle blocks start at 0
+       ((looking-at (concat cfengine3-defuns-regex "\\>"))
+        (indent-line-to 0))
+       ;; categories are indented one step
+       ((looking-at (concat cfengine3-category-regex "[ \t]*$"))
+        (indent-line-to cfengine-indent))
+       ;; class selectors are indented two steps
+       ((looking-at (concat cfengine3-class-selector-regex "[ \t]*$"))
+        (indent-line-to (* 2 cfengine-indent)))
+       ;; Outdent leading close brackets one step.
+       ((or (eq ?\} (char-after))
+            (eq ?\) (char-after)))
+        (condition-case ()
+            (indent-line-to (save-excursion
+                              (forward-char)
+                              (backward-sexp)
+                              (current-column)))
+          (error nil)))
+       ;; inside a string and it starts before this line
+       ((and (nth 3 parse)
+             (< (nth 8 parse) (save-excursion (beginning-of-line) (point))))
+        (indent-line-to 0))
+       ;; inside a defun, but not a nested list (depth is 1)
+       ((= 1 (nth 0 parse))
+        (indent-line-to (* (+ 2 (nth 0 parse)) cfengine-indent)))
+       ;; Inside brackets/parens: indent to start column of non-comment
+       ;; token on line following open bracket or by one step from open
+       ;; bracket's column.
+       ((condition-case ()
+            (progn (indent-line-to (save-excursion
+                                     (backward-up-list)
+                                     (forward-char)
+                                     (skip-chars-forward " \t")
+                                     (cond
+                                      ((looking-at "[^\n#]")
+                                       (current-column))
+                                      ((looking-at "[^\n#]")
+                                       (current-column))
+                                      (t
+                                       (skip-chars-backward " \t")
+                                       (+ (current-column) -1
+                                          cfengine-indent)))))
+                   t)
+          (error nil)))
+       ;; Else don't indent.
+       (t (indent-line-to 0))))
+    ;; 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)))))
+
+;; CFEngine 3.x grammar
+
+;; specification: blocks
+;; blocks: block | blocks block;
+;; block:                 bundle typeid blockid bundlebody
+;;                      | bundle typeid blockid usearglist bundlebody
+;;                      | body typeid blockid bodybody
+;;                      | body typeid blockid usearglist bodybody;
+
+;; typeid: id
+;; blockid: id
+;; usearglist: '(' aitems ')';
+;; aitems: aitem | aitem ',' aitems |;
+;; aitem: id
+
+;; bundlebody: '{' statements '}'
+;; statements: statement | statements statement;
+;; statement: category | classpromises;
+
+;; bodybody: '{' bodyattribs '}'
+;; bodyattribs: bodyattrib | bodyattribs bodyattrib;
+;; bodyattrib: class | selections;
+;; selections: selection | selections selection;
+;; selection: id ASSIGN rval ';' ;
+
+;; classpromises: classpromise | classpromises classpromise;
+;; classpromise: class | promises;
+;; promises: promise | promises promise;
+;; category: CATEGORY
+;; promise: promiser ARROW rval constraints ';' | promiser constraints ';';
+;; constraints: constraint | constraints ',' constraint |;
+;; constraint: id ASSIGN rval;
+;; class: CLASS
+;; id: ID
+;; rval: ID | QSTRING | NAKEDVAR | list | usefunction
+;; list: '{' litems '}' ;
+;; litems: litem | litem ',' litems |;
+;; litem: ID | QSTRING | NAKEDVAR | list | usefunction
+
+;; functionid: ID | NAKEDVAR
+;; promiser: QSTRING
+;; usefunction: functionid givearglist
+;; givearglist: '(' gaitems ')'
+;; gaitems: gaitem | gaitems ',' gaitem |;
+;; gaitem: ID | QSTRING | NAKEDVAR | list | usefunction
+
+;; # from lexer:
+
+;; bundle: "bundle"
+;; body: "body"
+;; COMMENT    #[^\n]*
+;; NAKEDVAR   [$@][(][a-zA-Z0-9_\200-\377.]+[)]|[$@][{][a-zA-Z0-9_\200-\377.]+[}]
+;; ID: [a-zA-Z0-9_\200-\377]+
+;; ASSIGN: "=>"
+;; ARROW: "->"
+;; QSTRING: \"((\\\")|[^"])*\"|\'((\\\')|[^'])*\'|`[^`]*`
+;; CLASS: [.|&!()a-zA-Z0-9_\200-\377]+::
+;; CATEGORY: [a-zA-Z_]+:
+
+(defun cfengine-common-settings ()
+  (set (make-local-variable 'syntax-propertize-function)
+       ;; In the main syntax-table, \ is marked as a punctuation, because
+       ;; of its use in DOS-style directory separators.  Here we try to
+       ;; recognize the cases where \ is used as an escape inside strings.
+       (syntax-propertize-rules ("\\(\\(?:\\\\\\)+\\)\"" (1 "\\"))))
+  (set (make-local-variable 'parens-require-spaces) nil)
+  (set (make-local-variable 'comment-start)  "# ")
+  (set (make-local-variable 'comment-start-skip)
+       "\\(\\(?:^\\|[^\\\\\n]\\)\\(?:\\\\\\\\\\)*\\)#+[ \t]*")
+  ;; Like Lisp mode.  Without this, we lose with, say,
+  ;; `backward-up-list' when there's an unbalanced quote in a
+  ;; preceding comment.
+  (set (make-local-variable 'parse-sexp-ignore-comments) t))
+
+(defun cfengine-common-syntax (table)
+  ;; the syntax defaults seem OK to give reasonable word movement
+  (modify-syntax-entry ?# "<" table)
+  (modify-syntax-entry ?\n ">#" table)
+  (modify-syntax-entry ?\" "\"" table)
+  ;; variable substitution:
+  (modify-syntax-entry ?$ "." table)
+  ;; Doze path separators:
+  (modify-syntax-entry ?\\ "." table))
+
+;;;###autoload
+(define-derived-mode cfengine3-mode prog-mode "CFEngine3"
+  "Major mode for editing cfengine input.
+There are no special keybindings by default.
+
+Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
+to the action header."
+  (cfengine-common-settings)
+  (cfengine-common-syntax cfengine3-mode-syntax-table)
+
+  (set (make-local-variable 'indent-line-function) #'cfengine3-indent-line)
+  (setq font-lock-defaults
+        '(cfengine3-font-lock-keywords nil nil nil beginning-of-defun))
+
+  ;; use defuns as the essential syntax block
+  (set (make-local-variable 'beginning-of-defun-function)
+       #'cfengine3-beginning-of-defun)
+  (set (make-local-variable 'end-of-defun-function)
+       #'cfengine3-end-of-defun))
+
 ;;;###autoload
 (define-derived-mode cfengine-mode prog-mode "Cfengine"
   "Major mode for editing cfengine input.
@@ -204,25 +442,15 @@ There are no special keybindings by default.
 
 Action blocks are treated as defuns, i.e. \\[beginning-of-defun] moves
 to the action header."
-  (modify-syntax-entry ?# "<" cfengine-mode-syntax-table)
-  (modify-syntax-entry ?\n ">#" cfengine-mode-syntax-table)
+  (cfengine-common-settings)
+  (cfengine-common-syntax cfengine-mode-syntax-table)
+
   ;; Shell commands can be quoted by single, double or back quotes.
   ;; It's debatable whether we should define string syntax, but it
   ;; should avoid potential confusion in some cases.
-  (modify-syntax-entry ?\" "\"" cfengine-mode-syntax-table)
   (modify-syntax-entry ?\' "\"" cfengine-mode-syntax-table)
   (modify-syntax-entry ?\` "\"" cfengine-mode-syntax-table)
-  ;; variable substitution:
-  (modify-syntax-entry ?$ "." cfengine-mode-syntax-table)
-  ;; Doze path separators:
-  (modify-syntax-entry ?\\ "." cfengine-mode-syntax-table)
-  ;; Otherwise, syntax defaults seem OK to give reasonable word
-  ;; movement.
 
-  (set (make-local-variable 'parens-require-spaces) nil)
-  (set (make-local-variable 'comment-start)  "# ")
-  (set (make-local-variable 'comment-start-skip)
-       "\\(\\(?:^\\|[^\\\\\n]\\)\\(?:\\\\\\\\\\)*\\)#+[ \t]*")
   (set (make-local-variable 'indent-line-function) #'cfengine-indent-line)
   (set (make-local-variable 'outline-regexp) "[ \t]*\\(\\sw\\|\\s_\\)+:+")
   (set (make-local-variable 'outline-level) #'cfengine-outline-level)
@@ -233,20 +461,12 @@ to the action header."
         '(cfengine-font-lock-keywords nil nil nil beginning-of-line))
   ;; Fixme: set the args of functions in evaluated classes to string
   ;; syntax, and then obey syntax properties.
-  (set (make-local-variable 'syntax-propertize-function)
-       ;; In the main syntax-table, \ is marked as a punctuation, because
-       ;; of its use in DOS-style directory separators.  Here we try to
-       ;; recognize the cases where \ is used as an escape inside strings.
-       (syntax-propertize-rules ("\\(\\(?:\\\\\\)+\\)\"" (1 "\\"))))
   (setq imenu-generic-expression cfengine-imenu-expression)
   (set (make-local-variable 'beginning-of-defun-function)
        #'cfengine-beginning-of-defun)
-  (set (make-local-variable 'end-of-defun-function) #'cfengine-end-of-defun)
-  ;; Like Lisp mode.  Without this, we lose with, say,
-  ;; `backward-up-list' when there's an unbalanced quote in a
-  ;; preceding comment.
-  (set (make-local-variable 'parse-sexp-ignore-comments) t))
+  (set (make-local-variable 'end-of-defun-function) #'cfengine-end-of-defun))
 
+(provide 'cfengine3)
 (provide 'cfengine)
 
 ;;; cfengine.el ends here
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 1a23cd112af..503698f0f7b 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -253,7 +253,7 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
 \\(?:-\\([0-9]+\\)?\\(?:\\.\\([0-9]+\\)\\)?\\)?:\
 \\(?: *\\(\\(?:Future\\|Runtime\\)?[Ww]arning\\|W:\\)\\|\
  *\\([Ii]nfo\\(?:\\>\\|rmationa?l?\\)\\|I:\\|instantiated from\\|[Nn]ote\\)\\|\
-\[0-9]?\\(?:[^0-9\n]\\|$\\)\\|[0-9][0-9][0-9]\\)"
+ *[Ee]rror\\|\[0-9]?\\(?:[^0-9\n]\\|$\\)\\|[0-9][0-9][0-9]\\)"
      1 (2 . 4) (3 . 5) (6 . 7))
 
     (lcc
@@ -400,15 +400,16 @@ File = \\(.+\\), Line = \\([0-9]+\\)\\(?:, Column = \\([0-9]+\\)\\)?"
      "^# Failed test [0-9]+ in \\([^ \t\r\n]+\\) at line \\([0-9]+\\)"
      1 2)
     (perl--Test2
-     ;; Or when comparing got/want values,
+     ;; Or when comparing got/want values, with a "fail #n" if repeated
      ;; # Test 2 got: "xx" (t-compilation-perl-2.t at line 10)
+     ;; # Test 3 got: "xx" (t-compilation-perl-2.t at line 10 fail #2)
      ;;
      ;; And under Test::Harness they're preceded by progress stuff with
      ;; \r and "NOK",
      ;; ... NOK 1# Test 1 got: "1234" (t/foo.t at line 46)
      ;;
      "^\\(.*NOK.*\\)?# Test [0-9]+ got:.* (\\([^ \t\r\n]+\\) at line \
-\\([0-9]+\\))"
+\\([0-9]+\\)\\( fail #[0-9]+\\)?)"
      2 3)
     (perl--Test::Harness
      ;; perl Test::Harness output, eg.
@@ -2409,9 +2410,7 @@ and overlay is highlighted between MK and END-MK."
         ;; display the source in another window.
         (let ((pop-up-windows t))
           (pop-to-buffer (marker-buffer mk) 'other-window))
-      (if (window-dedicated-p (selected-window))
-          (pop-to-buffer (marker-buffer mk))
-        (switch-to-buffer (marker-buffer mk))))
+      (pop-to-buffer-same-window (marker-buffer mk)))
     (unless (eq (goto-char mk) (point))
       ;; If narrowing gets in the way of going to the right place, widen.
       (widen)
diff --git a/lisp/progmodes/cperl-mode.el b/lisp/progmodes/cperl-mode.el
index 48df73a678f..ad3b777977c 100644
--- a/lisp/progmodes/cperl-mode.el
+++ b/lisp/progmodes/cperl-mode.el
@@ -613,7 +613,7 @@ One should tune up `cperl-close-paren-offset' as well."
 (defcustom cperl-syntaxify-by-font-lock
   (and cperl-can-font-lock
        (boundp 'parse-sexp-lookup-properties))
-  "*Non-nil means that CPerl uses `font-lock's routines for syntaxification."
+  "*Non-nil means that CPerl uses the `font-lock' routines for syntaxification."
   :type '(choice (const message) boolean)
   :group 'cperl-speed)
 
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 8abf298bb76..385adf1af0a 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -1860,7 +1860,11 @@ nil, we exit; otherwise we scan the next file."
 Stops when a match is found.
 To continue searching for next match, use command \\[tags-loop-continue].
 
-See documentation of variable `tags-file-name'."
+If `file-list-form' is non-nil, it should be a form that, when
+evaluated, will return a list of file names.  The search will be
+restricted to these files.
+
+Aleso see the documentation of the `tags-file-name' variable."
   (interactive "sTags search (regexp): ")
   (if (and (equal regexp "")
            (eq (car tags-loop-scan) 're-search-forward)
diff --git a/lisp/progmodes/flymake.el b/lisp/progmodes/flymake.el
index 8f617b44dae..1c138f053d3 100644
--- a/lisp/progmodes/flymake.el
+++ b/lisp/progmodes/flymake.el
@@ -1339,8 +1339,12 @@ With arg, turn Flymake mode on if and only if arg is positive."
 
    ;; Turning the mode ON.
    (flymake-mode
-    (if (not (flymake-can-syntax-check-file buffer-file-name))
-        (flymake-log 2 "flymake cannot check syntax in buffer %s" (buffer-name))
+    (cond
+     ((not buffer-file-name)
+      (message "Flymake unable to run without a buffer file name"))
+     ((not (flymake-can-syntax-check-file buffer-file-name))
+      (flymake-log 2 "flymake cannot check syntax in buffer %s" (buffer-name)))
+     (t
       (add-hook 'after-change-functions 'flymake-after-change-function nil t)
       (add-hook 'after-save-hook 'flymake-after-save-hook nil t)
       (add-hook 'kill-buffer-hook 'flymake-kill-buffer-hook nil t)
@@ -1352,7 +1356,7 @@ With arg, turn Flymake mode on if and only if arg is positive."
             (run-at-time nil 1 'flymake-on-timer-event (current-buffer)))
 
       (when flymake-start-syntax-check-on-find-file
-        (flymake-start-syntax-check))))
+        (flymake-start-syntax-check)))))
 
    ;; Turning the mode OFF.
    (t
@@ -1406,6 +1410,7 @@ With arg, turn Flymake mode on if and only if arg is positive."
     (cancel-timer flymake-timer)
     (setq flymake-timer nil)))
 
+;;;###autoload
 (defun flymake-find-file-hook ()
   ;;+(when flymake-start-syntax-check-on-find-file
   ;;+    (flymake-log 3 "starting syntax check on file open")
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 61055ef4342..87209a78ffb 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -104,7 +104,8 @@
 (require 'bindat)
 (eval-when-compile (require 'cl))
 
-(declare-function speedbar-change-initial-expansion-list "speedbar" (new-default))
+(declare-function speedbar-change-initial-expansion-list
+                  "speedbar" (new-default))
 (declare-function speedbar-timer-fn "speedbar" ())
 (declare-function speedbar-line-text "speedbar" (&optional p))
 (declare-function speedbar-change-expand-button-char "speedbar" (char))
@@ -190,7 +191,8 @@ as returned from \"-break-list\" by `gdb-json-partial-output'
 (defvar gdb-current-language nil)
 (defvar gdb-var-list nil
   "List of variables in watch window.
-Each element has the form (VARNUM EXPRESSION NUMCHILD TYPE VALUE STATUS HAS_MORE FP)
+Each element has the form
+  (VARNUM EXPRESSION NUMCHILD TYPE VALUE STATUS HAS_MORE FP)
 where STATUS is nil (`unchanged'), `changed' or `out-of-scope', FP the frame
 address for root variables.")
 (defvar gdb-main-file nil "Source file from which program execution begins.")
@@ -329,7 +331,7 @@ valid signal handlers.")
   "Maximum size of `gdb-debug-log'.  If nil, size is unlimited."
   :group 'gdb
   :type '(choice (integer :tag "Number of elements")
-                 (const   :tag "Unlimited" nil))
+          (const   :tag "Unlimited" nil))
   :version "22.1")
 
 (defcustom gdb-non-stop-setting t
@@ -367,13 +369,18 @@ Emacs always switches to the thread which caused the stop."
           (set :tag "Selection of reasons..."
                (const :tag "A breakpoint was reached." "breakpoint-hit")
                (const :tag "A watchpoint was triggered." "watchpoint-trigger")
-               (const :tag "A read watchpoint was triggered." "read-watchpoint-trigger")
-               (const :tag "An access watchpoint was triggered." "access-watchpoint-trigger")
+               (const :tag "A read watchpoint was triggered."
+                      "read-watchpoint-trigger")
+               (const :tag "An access watchpoint was triggered."
+                      "access-watchpoint-trigger")
                (const :tag "Function finished execution." "function-finished")
                (const :tag "Location reached." "location-reached")
-               (const :tag "Watchpoint has gone out of scope" "watchpoint-scope")
-               (const :tag "End of stepping range reached." "end-stepping-range")
-               (const :tag "Signal received (like interruption)." "signal-received"))
+               (const :tag "Watchpoint has gone out of scope"
+                      "watchpoint-scope")
+               (const :tag "End of stepping range reached."
+                      "end-stepping-range")
+               (const :tag "Signal received (like interruption)."
+                      "signal-received"))
           (const :tag "None" nil))
   :group 'gdb-non-stop
   :version "23.2"
@@ -488,17 +495,17 @@ predefined macros."
   :group 'gdb
   :version "22.1")
 
- (defcustom gdb-create-source-file-list t
-   "Non-nil means create a list of files from which the executable was built.
+(defcustom gdb-create-source-file-list t
+  "Non-nil means create a list of files from which the executable was built.
  Set this to nil if the GUD buffer displays \"initializing...\" in the mode
  line for a long time when starting, possibly because your executable was
  built from a large number of files.  This allows quicker initialization
  but means that these files are not automatically enabled for debugging,
  e.g., you won't be able to click in the fringe to set a breakpoint until
  execution has already stopped there."
-   :type 'boolean
-   :group 'gdb
-   :version "23.1")
+  :type 'boolean
+  :group 'gdb
+  :version "23.1")
 
 (defcustom gdb-show-main nil
   "Non-nil means display source file containing the main routine at startup.
@@ -644,12 +651,12 @@ detailed description of this mode.
   (interactive (list (gud-query-cmdline 'gdb)))
 
   (when (and gud-comint-buffer
-           (buffer-name gud-comint-buffer)
-           (get-buffer-process gud-comint-buffer)
-           (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba)))
-        (gdb-restore-windows)
-        (error
-         "Multiple debugging requires restarting in text command mode"))
+             (buffer-name gud-comint-buffer)
+             (get-buffer-process gud-comint-buffer)
+             (with-current-buffer gud-comint-buffer (eq gud-minor-mode 'gdba)))
+    (gdb-restore-windows)
+    (error
+     "Multiple debugging requires restarting in text command mode"))
   ;;
   (gud-common-init command-line nil 'gud-gdbmi-marker-filter)
   (set (make-local-variable 'gud-minor-mode) 'gdbmi)
@@ -663,7 +670,7 @@ detailed description of this mode.
           (hsize (getenv "HISTSIZE")))
       (dolist (file (append '("~/.gdbinit")
                             (unless (string-equal (expand-file-name ".")
-                                              (expand-file-name "~"))
+                                                  (expand-file-name "~"))
                               '(".gdbinit"))))
         (if (file-readable-p (setq file (expand-file-name file)))
             (with-temp-buffer
@@ -763,7 +770,7 @@ detailed description of this mode.
     'gdb-mouse-set-clear-breakpoint)
   (define-key gud-minor-mode-map [left-fringe mouse-1]
     'gdb-mouse-set-clear-breakpoint)
-   (define-key gud-minor-mode-map [left-margin C-mouse-1]
+  (define-key gud-minor-mode-map [left-margin C-mouse-1]
     'gdb-mouse-toggle-breakpoint-margin)
   (define-key gud-minor-mode-map [left-fringe C-mouse-1]
     'gdb-mouse-toggle-breakpoint-fringe)
@@ -786,7 +793,10 @@ detailed description of this mode.
   (define-key gud-minor-mode-map [left-margin C-mouse-3]
     'gdb-mouse-jump)
 
-  (local-set-key "\C-i" 'gud-gdb-complete-command)
+  (add-hook 'completion-at-point-functions #'gud-gdb-completion-at-point
+            nil 'local)
+  (local-set-key "\C-i" 'completion-at-point)
+
   (setq gdb-first-prompt t)
   (setq gud-running nil)
 
@@ -846,11 +856,11 @@ detailed description of this mode.
 
   ;; find source file and compilation directory here
   (gdb-input
-   ; Needs GDB 6.2 onwards.
+                                        ; Needs GDB 6.2 onwards.
    (list "-file-list-exec-source-files" 'gdb-get-source-file-list))
   (if gdb-create-source-file-list
       (gdb-input
-        ; Needs GDB 6.0 onwards.
+                                        ; Needs GDB 6.0 onwards.
        (list "-file-list-exec-source-file" 'gdb-get-source-file)))
   (gdb-input
    (list "-gdb-show prompt" 'gdb-get-prompt)))
@@ -859,7 +869,8 @@ detailed description of this mode.
   (goto-char (point-min))
   (if (re-search-forward "No symbol" nil t)
       (progn
-        (message "This version of GDB doesn't support non-stop mode.  Turning it off.")
+        (message
+         "This version of GDB doesn't support non-stop mode.  Turning it off.")
         (setq gdb-non-stop nil)
         (setq gdb-version "pre-7.0"))
     (setq gdb-version "7.0+")
@@ -882,8 +893,8 @@ detailed description of this mode.
                                  (list t nil) nil "-c"
                                  (concat gdb-cpp-define-alist-program " "
                                          gdb-cpp-define-alist-flags))))))
-        (define-list (split-string output "\n" t))
-        (name))
+         (define-list (split-string output "\n" t))
+         (name))
     (setq gdb-define-alist nil)
     (dolist (define define-list)
       (setq name (nth 1 (split-string define "[( ]")))
@@ -893,13 +904,13 @@ detailed description of this mode.
 (defvar tooltip-use-echo-area)
 
 (defun gdb-tooltip-print (expr)
-   (with-current-buffer (gdb-get-buffer 'gdb-partial-output-buffer)
-     (goto-char (point-min))
-     (if (re-search-forward ".*value=\\(\".*\"\\)" nil t)
-         (tooltip-show
-          (concat expr " = " (read (match-string 1)))
-          (or gud-tooltip-echo-area tooltip-use-echo-area
-              (not (display-graphic-p)))))))
+  (with-current-buffer (gdb-get-buffer 'gdb-partial-output-buffer)
+    (goto-char (point-min))
+    (if (re-search-forward ".*value=\\(\".*\"\\)" nil t)
+        (tooltip-show
+         (concat expr " = " (read (match-string 1)))
+         (or gud-tooltip-echo-area tooltip-use-echo-area
+             (not (display-graphic-p)))))))
 
 ;; If expr is a macro for a function don't print because of possible dangerous
 ;; side-effects. Also printing a function within a tooltip generates an
@@ -923,13 +934,13 @@ detailed description of this mode.
 
 (defmacro gdb-if-arrow (arrow-position &rest body)
   `(if ,arrow-position
-      (let ((buffer (marker-buffer ,arrow-position)) (line))
-        (if (equal buffer (window-buffer (posn-window end)))
-            (with-current-buffer buffer
-              (when (or (equal start end)
-                        (equal (posn-point start)
-                               (marker-position ,arrow-position)))
-                ,@body))))))
+       (let ((buffer (marker-buffer ,arrow-position)) (line))
+         (if (equal buffer (window-buffer (posn-window end)))
+             (with-current-buffer buffer
+               (when (or (equal start end)
+                         (equal (posn-point start)
+                                (marker-position ,arrow-position)))
+                 ,@body))))))
 
 (defun gdb-mouse-until (event)
   "Continue running until a source line past the current line.
@@ -1060,7 +1071,7 @@ With arg, enter name of variable to be watched in the minibuffer."
                      (bindat-get-field result 'value)
                      nil
                      (bindat-get-field result 'has_more)
-                      gdb-frame-address)))
+                     gdb-frame-address)))
           (push var gdb-var-list)
           (speedbar 1)
           (unless (string-equal
@@ -1091,20 +1102,20 @@ With arg, enter name of variable to be watched in the minibuffer."
       (setcar (nthcdr 4 var) (read (match-string 1)))))
   (gdb-speedbar-update))
 
-; Uses "-var-list-children --all-values".  Needs GDB 6.1 onwards.
+                                        ; Uses "-var-list-children --all-values".  Needs GDB 6.1 onwards.
 (defun gdb-var-list-children (varnum)
   (gdb-input
    (list (concat "-var-update " varnum) 'ignore))
   (gdb-input
    (list (concat "-var-list-children --all-values "
-                varnum)
-             `(lambda () (gdb-var-list-children-handler ,varnum)))))
+                 varnum)
+         `(lambda () (gdb-var-list-children-handler ,varnum)))))
 
 (defun gdb-var-list-children-handler (varnum)
   (let* ((var-list nil)
          (output (bindat-get-field (gdb-json-partial-output "child")))
          (children (bindat-get-field output 'children)))
-   (catch 'child-already-watched
+    (catch 'child-already-watched
       (dolist (var gdb-var-list)
         (if (string-equal varnum (car var))
             (progn
@@ -1147,11 +1158,11 @@ With arg, enter name of variable to be watched in the minibuffer."
   (interactive)
   (let ((text (speedbar-line-text)))
     (string-match "\\(\\S-+\\)" text)
-       (let* ((var (nth (- (count-lines (point-min) (point)) 2) gdb-var-list))
-              (varnum (car var)))
-         (if (string-match "\\." (car var))
-             (message-box "Can only delete a root expression")
-           (gdb-var-delete-1 var varnum)))))
+    (let* ((var (nth (- (count-lines (point-min) (point)) 2) gdb-var-list))
+           (varnum (car var)))
+      (if (string-match "\\." (car var))
+          (message-box "Can only delete a root expression")
+        (gdb-var-delete-1 var varnum)))))
 
 (defun gdb-var-delete-children (varnum)
   "Delete children of variable object at point from the speedbar."
@@ -1174,7 +1185,7 @@ With arg, enter name of variable to be watched in the minibuffer."
   (if (re-search-forward gdb-error-regexp nil t)
       (message-box "Invalid number or expression (%s)" value)))
 
-; Uses "-var-update --all-values".  Needs GDB 6.4 onwards.
+                                        ; Uses "-var-update --all-values".  Needs GDB 6.4 onwards.
 (defun gdb-var-update ()
   (if (not (gdb-pending-p 'gdb-var-update))
       (gdb-input
@@ -1210,38 +1221,38 @@ With arg, enter name of variable to be watched in the minibuffer."
                      (gdb-var-delete-1 var varnum)))))
           (let ((var-list nil) var1
                 (children (bindat-get-field change 'new_children)))
-            (if new-num
-                (progn
-                  (setq var1 (pop temp-var-list))
-                  (while var1
-                    (if (string-equal varnum (car var1))
-                        (let ((new (string-to-number new-num))
-                              (previous (string-to-number (nth 2 var1))))
-                          (setcar (nthcdr 2 var1) new-num)
-                          (push var1 var-list)
-                          (cond ((> new previous)
-                                 ;; Add new children to list.
-                                 (dotimes (dummy previous)
-                                   (push (pop temp-var-list) var-list))
-                                 (dolist (child children)
-                                   (let ((varchild
-                                          (list (bindat-get-field child 'name)
-                                                (bindat-get-field child 'exp)
-                                                (bindat-get-field child 'numchild)
-                                                (bindat-get-field child 'type)
-                                                (bindat-get-field child 'value)
-                                                'changed
-                                                (bindat-get-field child 'has_more))))
-                                     (push varchild var-list))))
-                                ;; Remove deleted children from list.
-                                ((< new previous)
-                                 (dotimes (dummy new)
-                                     (push (pop temp-var-list) var-list))
-                                 (dotimes (dummy (- previous new))
-                                     (pop temp-var-list)))))
-                      (push var1 var-list))
-                    (setq var1 (pop temp-var-list)))
-                  (setq gdb-var-list (nreverse var-list)))))))))
+            (when new-num
+              (setq var1 (pop temp-var-list))
+              (while var1
+                (if (string-equal varnum (car var1))
+                    (let ((new (string-to-number new-num))
+                          (previous (string-to-number (nth 2 var1))))
+                      (setcar (nthcdr 2 var1) new-num)
+                      (push var1 var-list)
+                      (cond
+                       ((> new previous)
+                        ;; Add new children to list.
+                        (dotimes (dummy previous)
+                          (push (pop temp-var-list) var-list))
+                        (dolist (child children)
+                          (let ((varchild
+                                 (list (bindat-get-field child 'name)
+                                       (bindat-get-field child 'exp)
+                                       (bindat-get-field child 'numchild)
+                                       (bindat-get-field child 'type)
+                                       (bindat-get-field child 'value)
+                                       'changed
+                                       (bindat-get-field child 'has_more))))
+                            (push varchild var-list))))
+                       ;; Remove deleted children from list.
+                       ((< new previous)
+                        (dotimes (dummy new)
+                          (push (pop temp-var-list) var-list))
+                        (dotimes (dummy (- previous new))
+                          (pop temp-var-list)))))
+                  (push var1 var-list))
+                (setq var1 (pop temp-var-list)))
+              (setq gdb-var-list (nreverse var-list))))))))
   (setq gdb-pending-triggers
         (delq 'gdb-var-update gdb-pending-triggers))
   (gdb-speedbar-update))
@@ -1369,7 +1380,8 @@ this trigger is subscribed to `gdb-buf-publisher' and called with
             (when trigger
               (gdb-add-subscriber gdb-buf-publisher
                                   (cons (current-buffer)
-                                        (gdb-bind-function-to-buffer trigger (current-buffer))))
+                                        (gdb-bind-function-to-buffer
+                                         trigger (current-buffer))))
               (funcall trigger 'start))
             (current-buffer))))))
 
@@ -1783,8 +1795,8 @@ is running."
 ;; visited breakpoint is, use that window.
 (defun gdb-display-source-buffer (buffer)
   (let* ((last-window (if gud-last-last-frame
-                         (get-buffer-window
-                          (gud-find-file (car gud-last-last-frame)))))
+                          (get-buffer-window
+                           (gud-find-file (car gud-last-last-frame)))))
          (source-window (or last-window
                             (if (and gdb-source-window
                                      (window-live-p gdb-source-window))
@@ -1857,7 +1869,7 @@ is running."
             ;; Suppress "No registers." since GDB 6.8 and earlier duplicates MI
             ;; error message on internal stream.  Don't print to GUD buffer.
             (unless (and (eq record-type 'gdb-internals)
-                     (string-equal (read arg1) "No registers.\n"))
+                         (string-equal (read arg1) "No registers.\n"))
               (funcall record-type arg1))))))
 
     (setq gdb-output-sink 'user)
@@ -1881,15 +1893,15 @@ is running."
 (defun gdb-thread-exited (output-field)
   "Handle =thread-exited async record: unset `gdb-thread-number'
  if current thread exited and update threads list."
-   (let* ((thread-id (bindat-get-field (gdb-json-string output-field) 'id)))
-     (if (string= gdb-thread-number thread-id)
-         (gdb-setq-thread-number nil))
-     ;; When we continue current thread and it quickly exits,
-     ;; gdb-pending-triggers left after gdb-running disallow us to
-     ;; properly call -thread-info without --thread option. Thus we
-     ;; need to use gdb-wait-for-pending.
-     (gdb-wait-for-pending
-      (gdb-emit-signal gdb-buf-publisher 'update-threads))))
+  (let* ((thread-id (bindat-get-field (gdb-json-string output-field) 'id)))
+    (if (string= gdb-thread-number thread-id)
+        (gdb-setq-thread-number nil))
+    ;; When we continue current thread and it quickly exits,
+    ;; gdb-pending-triggers left after gdb-running disallow us to
+    ;; properly call -thread-info without --thread option. Thus we
+    ;; need to use gdb-wait-for-pending.
+    (gdb-wait-for-pending
+     (gdb-emit-signal gdb-buf-publisher 'update-threads))))
 
 (defun gdb-thread-selected (output-field)
   "Handler for =thread-selected MI output record.
@@ -1909,7 +1921,8 @@ Sets `gdb-thread-number' to new id."
      (gdb-update))))
 
 (defun gdb-running (output-field)
-  (let* ((thread-id (bindat-get-field (gdb-json-string output-field) 'thread-id)))
+  (let* ((thread-id
+          (bindat-get-field (gdb-json-string output-field) 'thread-id)))
     ;; We reset gdb-frame-number to nil if current thread has gone
     ;; running. This can't be done in gdb-thread-list-handler-custom
     ;; because we need correct gdb-frame-number by the time
@@ -1984,23 +1997,23 @@ current thread and update GDB buffers."
         ;; reasons
         (if (or (eq gdb-switch-reasons t)
                 (member reason gdb-switch-reasons))
-              (when (not (string-equal gdb-thread-number thread-id))
-                (message (concat "Switched to thread " thread-id))
-                (gdb-setq-thread-number thread-id))
+            (when (not (string-equal gdb-thread-number thread-id))
+              (message (concat "Switched to thread " thread-id))
+              (gdb-setq-thread-number thread-id))
           (message (format "Thread %s stopped" thread-id)))))
 
-  ;; Print "(gdb)" to GUD console
-  (when gdb-first-done-or-error
-    (setq gdb-filter-output (concat gdb-filter-output gdb-prompt-name)))
+    ;; Print "(gdb)" to GUD console
+    (when gdb-first-done-or-error
+      (setq gdb-filter-output (concat gdb-filter-output gdb-prompt-name)))
 
-  ;; In non-stop, we update information as soon as another thread gets
-  ;; stopped
-  (when (or gdb-first-done-or-error
-            gdb-non-stop)
-    ;; In all-stop this updates gud-running properly as well.
-    (gdb-update)
-    (setq gdb-first-done-or-error nil))
-  (run-hook-with-args 'gdb-stopped-hooks result)))
+    ;; In non-stop, we update information as soon as another thread gets
+    ;; stopped
+    (when (or gdb-first-done-or-error
+              gdb-non-stop)
+      ;; In all-stop this updates gud-running properly as well.
+      (gdb-update)
+      (setq gdb-first-done-or-error nil))
+    (run-hook-with-args 'gdb-stopped-hooks result)))
 
 ;; Remove the trimmings from log stream containing debugging messages
 ;; being produced by GDB's internals, use warning face and send to GUD
@@ -2020,7 +2033,7 @@ current thread and update GDB buffers."
 ;; Remove the trimmings from the console stream and send to GUD buffer
 ;; (frontend MI commands should not print to this stream)
 (defun gdb-console (output-field)
-   (setq gdb-filter-output
+  (setq gdb-filter-output
         (gdb-concat-output
          gdb-filter-output
          (read output-field))))
@@ -2033,11 +2046,11 @@ current thread and update GDB buffers."
         (setq token-number nil)
         ;; MI error - send to minibuffer
         (when (eq type 'error)
-            ;; Skip "msg=" from `output-field'
-            (message (read (substring output-field 4)))
-            ;; Don't send to the console twice.  (If it is a console error
-            ;; it is also in the console stream.)
-            (setq output-field nil)))
+          ;; Skip "msg=" from `output-field'
+          (message (read (substring output-field 4)))
+          ;; Don't send to the console twice.  (If it is a console error
+          ;; it is also in the console stream.)
+          (setq output-field nil)))
     ;; Output from command from frontend.
     (setq gdb-output-sink 'emacs))
 
@@ -2215,11 +2228,11 @@ calling `gdb-table-string'."
           (append row-properties (list properties)))
     (setf (gdb-table-column-sizes table)
           (gdb-mapcar* (lambda (x s)
-                     (let ((new-x
-                            (max (abs x) (string-width (or s "")))))
-                       (if right-align new-x (- new-x))))
-                   (gdb-table-column-sizes table)
-                   row))
+                         (let ((new-x
+                                (max (abs x) (string-width (or s "")))))
+                           (if right-align new-x (- new-x))))
+                       (gdb-table-column-sizes table)
+                       row))
     ;; Avoid trailing whitespace at eol
     (if (not (gdb-table-right-align table))
         (setcar (last (gdb-table-column-sizes table)) 0))))
@@ -2308,8 +2321,8 @@ If NOPRESERVE is non-nil, window point is not restored after CUSTOM-DEFUN."
           '(set-window-point window p)))))
 
 (defmacro def-gdb-trigger-and-handler (trigger-name gdb-command
-                                       handler-name custom-defun
-                                       &optional signal-list)
+                                                    handler-name custom-defun
+                                                    &optional signal-list)
   "Define trigger and handler.
 
 TRIGGER-NAME trigger is defined to send GDB-COMMAND. See
@@ -2353,29 +2366,29 @@ HANDLER-NAME handler uses customization of CUSTOM-DEFUN. See
             (pending (bindat-get-field breakpoint 'pending))
             (func (bindat-get-field breakpoint 'func))
             (type (bindat-get-field breakpoint 'type)))
-      (gdb-table-add-row table
-       (list
-        (bindat-get-field breakpoint 'number)
-        type
-        (bindat-get-field breakpoint 'disp)
-        (let ((flag (bindat-get-field breakpoint 'enabled)))
-          (if (string-equal flag "y")
-              (propertize "y" 'font-lock-face  font-lock-warning-face)
-            (propertize "n" 'font-lock-face  font-lock-comment-face)))
-        (bindat-get-field breakpoint 'addr)
-        (bindat-get-field breakpoint 'times)
-        (if (string-match ".*watchpoint" type)
-            (bindat-get-field breakpoint 'what)
-          (or pending at
-              (concat "in "
-                      (propertize (or func "unknown")
-                                  'font-lock-face font-lock-function-name-face)
-                      (gdb-frame-location breakpoint)))))
-       ;; Add clickable properties only for breakpoints with file:line
-       ;; information
-       (append (list 'gdb-breakpoint breakpoint)
-               (when func '(help-echo "mouse-2, RET: visit breakpoint"
-                            mouse-face highlight))))))
+        (gdb-table-add-row table
+                           (list
+                            (bindat-get-field breakpoint 'number)
+                            type
+                            (bindat-get-field breakpoint 'disp)
+                            (let ((flag (bindat-get-field breakpoint 'enabled)))
+                              (if (string-equal flag "y")
+                                  (propertize "y" 'font-lock-face  font-lock-warning-face)
+                                (propertize "n" 'font-lock-face  font-lock-comment-face)))
+                            (bindat-get-field breakpoint 'addr)
+                            (bindat-get-field breakpoint 'times)
+                            (if (string-match ".*watchpoint" type)
+                                (bindat-get-field breakpoint 'what)
+                              (or pending at
+                                  (concat "in "
+                                          (propertize (or func "unknown")
+                                                      'font-lock-face font-lock-function-name-face)
+                                          (gdb-frame-location breakpoint)))))
+                           ;; Add clickable properties only for breakpoints with file:line
+                           ;; information
+                           (append (list 'gdb-breakpoint breakpoint)
+                                   (when func '(help-echo "mouse-2, RET: visit breakpoint"
+                                                mouse-face highlight))))))
     (insert (gdb-table-string table " "))
     (gdb-place-breakpoints)))
 
@@ -2389,7 +2402,7 @@ HANDLER-NAME handler uses customization of CUSTOM-DEFUN. See
           (gdb-remove-breakpoint-icons (point-min) (point-max)))))
   (dolist (breakpoint gdb-breakpoints-list)
     (let* ((breakpoint (cdr breakpoint)) ; gdb-breakpoints-list is
-                                         ; an associative list
+                                        ; an associative list
            (line (bindat-get-field breakpoint 'line)))
       (when line
         (let ((file (bindat-get-field breakpoint 'fullname))
@@ -2411,7 +2424,7 @@ HANDLER-NAME handler uses customization of CUSTOM-DEFUN. See
             (gdb-input
              (list "-file-list-exec-source-file"
                    `(lambda () (gdb-get-location
-                                ,bptno ,line ,flag))))))))))
+                           ,bptno ,line ,flag))))))))))
 
 (defvar gdb-source-file-regexp "fullname=\"\\(.*?\\)\"")
 
@@ -2422,7 +2435,7 @@ Put in buffer and place breakpoint icon."
   (catch 'file-not-found
     (if (re-search-forward gdb-source-file-regexp nil t)
         (delete (cons bptno "File not found") gdb-location-alist)
-        (push (cons bptno (match-string 1)) gdb-location-alist)
+      (push (cons bptno (match-string 1)) gdb-location-alist)
       (gdb-resync)
       (unless (assoc bptno gdb-location-alist)
         (push (cons bptno "File not found") gdb-location-alist)
@@ -2510,20 +2523,20 @@ If not in a source or disassembly buffer just set point."
               (if (get-text-property 0 'gdb-enabled obj)
                   "-break-disable "
                 "-break-enable ")
-               (get-text-property 0 'gdb-bptno obj)))))))))
+              (get-text-property 0 'gdb-bptno obj)))))))))
 
 (defun gdb-breakpoints-buffer-name ()
   (concat "*breakpoints of " (gdb-get-target-string) "*"))
 
 (def-gdb-display-buffer
- gdb-display-breakpoints-buffer
- 'gdb-breakpoints-buffer
- "Display status of user-settable breakpoints.")
+  gdb-display-breakpoints-buffer
+  'gdb-breakpoints-buffer
+  "Display status of user-settable breakpoints.")
 
 (def-gdb-frame-for-buffer
- gdb-frame-breakpoints-buffer
- 'gdb-breakpoints-buffer
- "Display status of user-settable breakpoints in a new frame.")
+  gdb-frame-breakpoints-buffer
+  'gdb-breakpoints-buffer
+  "Display status of user-settable breakpoints in a new frame.")
 
 (defvar gdb-breakpoints-mode-map
   (let ((map (make-sparse-keymap))
@@ -2540,9 +2553,9 @@ If not in a source or disassembly buffer just set point."
     (define-key map "q" 'gdb-delete-frame-or-window)
     (define-key map "\r" 'gdb-goto-breakpoint)
     (define-key map "\t" (lambda ()
-                            (interactive)
-                            (gdb-set-window-buffer
-                             (gdb-get-buffer-create 'gdb-threads-buffer) t)))
+                           (interactive)
+                           (gdb-set-window-buffer
+                            (gdb-get-buffer-create 'gdb-threads-buffer) t)))
     (define-key map [mouse-2] 'gdb-goto-breakpoint)
     (define-key map [follow-link] 'mouse-face)
     map))
@@ -2585,14 +2598,14 @@ corresponding to the mode line clicked."
   (concat "*threads of " (gdb-get-target-string) "*"))
 
 (def-gdb-display-buffer
- gdb-display-threads-buffer
- 'gdb-threads-buffer
- "Display GDB threads.")
+  gdb-display-threads-buffer
+  'gdb-threads-buffer
+  "Display GDB threads.")
 
 (def-gdb-frame-for-buffer
- gdb-frame-threads-buffer
- 'gdb-threads-buffer
- "Display GDB threads in a new frame.")
+  gdb-frame-threads-buffer
+  'gdb-threads-buffer
+  "Display GDB threads in a new frame.")
 
 (def-gdb-trigger-and-handler
   gdb-invalidate-threads (gdb-current-context-command "-thread-info")
@@ -2626,18 +2639,20 @@ corresponding to the mode line clicked."
     (define-key map "i" 'gdb-interrupt-thread)
     (define-key map "c" 'gdb-continue-thread)
     (define-key map "s" 'gdb-step-thread)
-    (define-key map "\t" (lambda ()
-                            (interactive)
-                            (gdb-set-window-buffer
-                             (gdb-get-buffer-create 'gdb-breakpoints-buffer) t)))
+    (define-key map "\t"
+      (lambda ()
+        (interactive)
+        (gdb-set-window-buffer
+         (gdb-get-buffer-create 'gdb-breakpoints-buffer) t)))
     (define-key map [mouse-2] 'gdb-select-thread)
     (define-key map [follow-link] 'mouse-face)
     map))
 
 (defvar gdb-threads-header
   (list
-   (gdb-propertize-header "Breakpoints" gdb-breakpoints-buffer
-                          "mouse-1: select" mode-line-highlight mode-line-inactive)
+   (gdb-propertize-header
+    "Breakpoints" gdb-breakpoints-buffer
+    "mouse-1: select" mode-line-highlight mode-line-inactive)
    " "
    (gdb-propertize-header "Threads" gdb-threads-buffer
                           nil nil mode-line)))
@@ -2661,44 +2676,45 @@ corresponding to the mode line clicked."
     (set-marker gdb-thread-position nil)
 
     (dolist (thread (reverse threads-list))
-      (let ((running (string-equal (bindat-get-field thread 'state) "running")))
-      (add-to-list 'gdb-threads-list
-                   (cons (bindat-get-field thread 'id)
-                         thread))
-      (if running
-          (incf gdb-running-threads-count)
-        (incf gdb-stopped-threads-count))
-
-      (gdb-table-add-row table
-       (list
-        (bindat-get-field thread 'id)
-        (concat
-         (if gdb-thread-buffer-verbose-names
-             (concat (bindat-get-field thread 'target-id) " ") "")
-         (bindat-get-field thread 'state)
-         ;; Include frame information for stopped threads
-         (if (not running)
-             (concat
-              " in " (bindat-get-field thread 'frame 'func)
-              (if gdb-thread-buffer-arguments
-                  (concat
-                   " ("
-                   (let ((args (bindat-get-field thread 'frame 'args)))
-                     (mapconcat
-                      (lambda (arg)
-                        (apply 'format `("%s=%s" ,@(gdb-get-many-fields arg 'name 'value))))
-                      args ","))
-                   ")")
-                "")
-              (if gdb-thread-buffer-locations
-                  (gdb-frame-location (bindat-get-field thread 'frame)) "")
-              (if gdb-thread-buffer-addresses
-                  (concat " at " (bindat-get-field thread 'frame 'addr)) ""))
-           "")))
-       (list
-        'gdb-thread thread
-        'mouse-face 'highlight
-        'help-echo "mouse-2, RET: select thread")))
+      (let ((running (equal (bindat-get-field thread 'state) "running")))
+        (add-to-list 'gdb-threads-list
+                     (cons (bindat-get-field thread 'id)
+                           thread))
+        (if running
+            (incf gdb-running-threads-count)
+          (incf gdb-stopped-threads-count))
+
+        (gdb-table-add-row table
+                           (list
+                            (bindat-get-field thread 'id)
+                            (concat
+                             (if gdb-thread-buffer-verbose-names
+                                 (concat (bindat-get-field thread 'target-id) " ") "")
+                             (bindat-get-field thread 'state)
+                             ;; Include frame information for stopped threads
+                             (if (not running)
+                                 (concat
+                                  " in " (bindat-get-field thread 'frame 'func)
+                                  (if gdb-thread-buffer-arguments
+                                      (concat
+                                       " ("
+                                       (let ((args (bindat-get-field thread 'frame 'args)))
+                                         (mapconcat
+                                          (lambda (arg)
+                                            (apply #'format "%s=%s"
+                                                   (gdb-get-many-fields arg 'name 'value)))
+                                          args ","))
+                                       ")")
+                                    "")
+                                  (if gdb-thread-buffer-locations
+                                      (gdb-frame-location (bindat-get-field thread 'frame)) "")
+                                  (if gdb-thread-buffer-addresses
+                                      (concat " at " (bindat-get-field thread 'frame 'addr)) ""))
+                               "")))
+                           (list
+                            'gdb-thread thread
+                            'mouse-face 'highlight
+                            'help-echo "mouse-2, RET: select thread")))
       (when (string-equal gdb-thread-number
                           (bindat-get-field thread 'id))
         (setq marked-line (length gdb-threads-list))))
@@ -2727,7 +2743,8 @@ be the value of 'gdb-thread property of the current line. If
              ,custom-defun
            (error "Not recognized as thread line"))))))
 
-(defmacro def-gdb-thread-buffer-simple-command (name buffer-command &optional doc)
+(defmacro def-gdb-thread-buffer-simple-command (name buffer-command
+                                                     &optional doc)
   "Define a NAME which will call BUFFER-COMMAND with id of thread
 on the current line."
   `(def-gdb-thread-buffer-command ,name
@@ -2830,19 +2847,19 @@ line."
 (defcustom gdb-memory-format "x"
   "Display format of data items in memory window."
   :type '(choice (const :tag "Hexadecimal" "x")
-                 (const :tag "Signed decimal" "d")
-                 (const :tag "Unsigned decimal" "u")
-                 (const :tag "Octal" "o")
-                 (const :tag "Binary" "t"))
+          (const :tag "Signed decimal" "d")
+          (const :tag "Unsigned decimal" "u")
+          (const :tag "Octal" "o")
+          (const :tag "Binary" "t"))
   :group 'gud
   :version "22.1")
 
 (defcustom gdb-memory-unit 4
   "Unit size of data items in memory window."
   :type '(choice (const :tag "Byte" 1)
-                 (const :tag "Halfword" 2)
-                 (const :tag "Word" 4)
-                 (const :tag "Giant word" 8))
+          (const :tag "Halfword" 2)
+          (const :tag "Word" 4)
+          (const :tag "Giant word" 8))
   :group 'gud
   :version "23.2")
 
@@ -2893,14 +2910,14 @@ in `gdb-memory-format'."
           (setq gdb-memory-next-page (bindat-get-field res 'next-page))
           (setq gdb-memory-prev-page (bindat-get-field res 'prev-page))
           (setq gdb-memory-last-address gdb-memory-address)
-        (dolist (row memory)
-          (insert (concat (bindat-get-field row 'addr) ":"))
-          (dolist (column (bindat-get-field row 'data))
-            (insert (gdb-pad-string column
-                                    (+ 2 (gdb-memory-column-width
-                                          gdb-memory-unit
-                                          gdb-memory-format)))))
-          (newline)))
+          (dolist (row memory)
+            (insert (concat (bindat-get-field row 'addr) ":"))
+            (dolist (column (bindat-get-field row 'data))
+              (insert (gdb-pad-string column
+                                      (+ 2 (gdb-memory-column-width
+                                            gdb-memory-unit
+                                            gdb-memory-format)))))
+            (newline)))
       ;; Show last page instead of empty buffer when out of bounds
       (progn
         (let ((gdb-memory-address gdb-memory-last-address))
@@ -2925,7 +2942,7 @@ in `gdb-memory-format'."
     (define-key map "g" 'gdb-memory-unit-giant)
     (define-key map "R" 'gdb-memory-set-rows)
     (define-key map "C" 'gdb-memory-set-columns)
-     map))
+    map))
 
 (defun gdb-memory-set-address-event (event)
   "Handle a click on address field in memory buffer header."
@@ -3115,8 +3132,8 @@ DOC is an optional documentation string."
 
 (defvar gdb-memory-font-lock-keywords
   '(;; <__function.name+n>
-    ("<\\(\\(\\sw\\|[_.]\\)+\\)\\(\\+[0-9]+\\)?>" (1 font-lock-function-name-face))
-    )
+    ("<\\(\\(\\sw\\|[_.]\\)+\\)\\(\\+[0-9]+\\)?>"
+     (1 font-lock-function-name-face)))
   "Font lock keywords used in `gdb-memory-mode'.")
 
 (defvar gdb-memory-header
@@ -3124,52 +3141,52 @@ DOC is an optional documentation string."
     (concat
      "Start address["
      (propertize "-"
-                  'face font-lock-warning-face
-                  'help-echo "mouse-1: decrement address"
-                  'mouse-face 'mode-line-highlight
-                  'local-map (gdb-make-header-line-mouse-map
-                              'mouse-1
-                              #'gdb-memory-show-previous-page))
+                 'face font-lock-warning-face
+                 'help-echo "mouse-1: decrement address"
+                 'mouse-face 'mode-line-highlight
+                 'local-map (gdb-make-header-line-mouse-map
+                             'mouse-1
+                             #'gdb-memory-show-previous-page))
      "|"
      (propertize "+"
-                  'face font-lock-warning-face
-                  'help-echo "mouse-1: increment address"
+                 'face font-lock-warning-face
+                 'help-echo "mouse-1: increment address"
                  'mouse-face 'mode-line-highlight
                  'local-map (gdb-make-header-line-mouse-map
                              'mouse-1
                              #'gdb-memory-show-next-page))
-    "]: "
-    (propertize gdb-memory-address
+     "]: "
+     (propertize gdb-memory-address
                  'face font-lock-warning-face
                  'help-echo "mouse-1: set start address"
                  'mouse-face 'mode-line-highlight
                  'local-map (gdb-make-header-line-mouse-map
                              'mouse-1
                              #'gdb-memory-set-address-event))
-    "  Rows: "
-    (propertize (number-to-string gdb-memory-rows)
+     "  Rows: "
+     (propertize (number-to-string gdb-memory-rows)
                  'face font-lock-warning-face
                  'help-echo "mouse-1: set number of columns"
                  'mouse-face 'mode-line-highlight
                  'local-map (gdb-make-header-line-mouse-map
                              'mouse-1
                              #'gdb-memory-set-rows))
-    "  Columns: "
-    (propertize (number-to-string gdb-memory-columns)
+     "  Columns: "
+     (propertize (number-to-string gdb-memory-columns)
                  'face font-lock-warning-face
                  'help-echo "mouse-1: set number of columns"
                  'mouse-face 'mode-line-highlight
                  'local-map (gdb-make-header-line-mouse-map
                              'mouse-1
                              #'gdb-memory-set-columns))
-    "  Display Format: "
-    (propertize gdb-memory-format
+     "  Display Format: "
+     (propertize gdb-memory-format
                  'face font-lock-warning-face
                  'help-echo "mouse-3: select display format"
                  'mouse-face 'mode-line-highlight
                  'local-map gdb-memory-format-map)
-    "  Unit Size: "
-    (propertize (number-to-string gdb-memory-unit)
+     "  Unit Size: "
+     (propertize (number-to-string gdb-memory-unit)
                  'face font-lock-warning-face
                  'help-echo "mouse-3: select unit size"
                  'mouse-face 'mode-line-highlight
@@ -3210,18 +3227,18 @@ DOC is an optional documentation string."
    (concat "disassembly of " (gdb-get-target-string))))
 
 (def-gdb-display-buffer
- gdb-display-disassembly-buffer
- 'gdb-disassembly-buffer
- "Display disassembly for current stack frame.")
+  gdb-display-disassembly-buffer
+  'gdb-disassembly-buffer
+  "Display disassembly for current stack frame.")
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-disassembly-buffer
   'gdb-disassembly-buffer)
 
 (def-gdb-frame-for-buffer
- gdb-frame-disassembly-buffer
- 'gdb-disassembly-buffer
- "Display disassembly in a new frame.")
+  gdb-frame-disassembly-buffer
+  'gdb-disassembly-buffer
+  "Display disassembly in a new frame.")
 
 (def-gdb-auto-update-trigger gdb-invalidate-disassembly
   (let* ((frame (gdb-current-buffer-frame))
@@ -3266,7 +3283,7 @@ DOC is an optional documentation string."
   (let ((map (make-sparse-keymap)))
     (suppress-keymap map)
     (define-key map "q" 'kill-this-buffer)
-     map))
+    map))
 
 (define-derived-mode gdb-disassembly-mode gdb-parent-mode "Disassembly"
   "Major mode for GDB disassembly information."
@@ -3283,12 +3300,13 @@ DOC is an optional documentation string."
          (address (bindat-get-field (gdb-current-buffer-frame) 'addr))
          (table (make-gdb-table))
          (marked-line nil))
-      (dolist (instr instructions)
+    (dolist (instr instructions)
       (gdb-table-add-row table
-       (list
-        (bindat-get-field instr 'address)
-        (apply 'format `("<%s+%s>:" ,@(gdb-get-many-fields instr 'func-name 'offset)))
-        (bindat-get-field instr 'inst)))
+                         (list
+                          (bindat-get-field instr 'address)
+                          (apply #'format "<%s+%s>:"
+                                 (gdb-get-many-fields instr 'func-name 'offset))
+                          (bindat-get-field instr 'inst)))
       (when (string-equal (bindat-get-field instr 'address)
                           address)
         (progn
@@ -3297,17 +3315,18 @@ DOC is an optional documentation string."
                 (if (string-equal gdb-frame-number "0")
                     nil
                   '((overlay-arrow . hollow-right-triangle)))))))
-      (insert (gdb-table-string table " "))
-      (gdb-disassembly-place-breakpoints)
-      ;; Mark current position with overlay arrow and scroll window to
-      ;; that point
-      (when marked-line
-        (let ((window (get-buffer-window (current-buffer) 0)))
-          (set-window-point window (gdb-mark-line marked-line gdb-disassembly-position))))
-      (setq mode-name
-            (gdb-current-context-mode-name
-            (concat "Disassembly: "
-                    (bindat-get-field (gdb-current-buffer-frame) 'func))))))
+    (insert (gdb-table-string table " "))
+    (gdb-disassembly-place-breakpoints)
+    ;; Mark current position with overlay arrow and scroll window to
+    ;; that point
+    (when marked-line
+      (let ((window (get-buffer-window (current-buffer) 0)))
+        (set-window-point window (gdb-mark-line marked-line
+                                                gdb-disassembly-position))))
+    (setq mode-name
+          (gdb-current-context-mode-name
+           (concat "Disassembly: "
+                   (bindat-get-field (gdb-current-buffer-frame) 'func))))))
 
 (defun gdb-disassembly-place-breakpoints ()
   (gdb-remove-breakpoint-icons (point-min) (point-max))
@@ -3328,7 +3347,8 @@ DOC is an optional documentation string."
                           nil nil mode-line)
    " "
    (gdb-propertize-header "Threads" gdb-threads-buffer
-                          "mouse-1: select" mode-line-highlight mode-line-inactive)))
+                          "mouse-1: select" mode-line-highlight
+                          mode-line-inactive)))
 
 ;;; Breakpoints view
 (define-derived-mode gdb-breakpoints-mode gdb-parent-mode "Breakpoints"
@@ -3344,7 +3364,7 @@ DOC is an optional documentation string."
     (let ((breakpoint (get-text-property (point) 'gdb-breakpoint)))
       (if breakpoint
           (gud-basic-call
-           (concat (if (string-equal "y" (bindat-get-field breakpoint 'enabled))
+           (concat (if (equal "y" (bindat-get-field breakpoint 'enabled))
                        "-break-disable "
                      "-break-enable ")
                    (bindat-get-field breakpoint 'number)))
@@ -3354,11 +3374,12 @@ DOC is an optional documentation string."
   "Delete the breakpoint at current line of breakpoints buffer."
   (interactive)
   (save-excursion
-  (beginning-of-line)
-  (let ((breakpoint (get-text-property (point) 'gdb-breakpoint)))
-    (if breakpoint
-        (gud-basic-call (concat "-break-delete " (bindat-get-field breakpoint 'number)))
-      (error "Not recognized as break/watchpoint line")))))
+    (beginning-of-line)
+    (let ((breakpoint (get-text-property (point) 'gdb-breakpoint)))
+      (if breakpoint
+          (gud-basic-call (concat "-break-delete "
+                                  (bindat-get-field breakpoint 'number)))
+        (error "Not recognized as break/watchpoint line")))))
 
 (defun gdb-goto-breakpoint (&optional event)
   "Go to the location of breakpoint at current line of
@@ -3369,24 +3390,24 @@ breakpoints buffer."
   (let ((window (get-buffer-window gud-comint-buffer)))
     (if window (save-selected-window  (select-window window))))
   (save-excursion
-  (beginning-of-line)
-  (let ((breakpoint (get-text-property (point) 'gdb-breakpoint)))
-    (if breakpoint
-        (let ((bptno (bindat-get-field breakpoint 'number))
-              (file  (bindat-get-field breakpoint 'fullname))
-              (line  (bindat-get-field breakpoint 'line)))
-          (save-selected-window
-            (let* ((buffer (find-file-noselect
-                         (if (file-exists-p file) file
-                           (cdr (assoc bptno gdb-location-alist)))))
-                   (window (or (gdb-display-source-buffer buffer)
-                               (display-buffer buffer))))
-              (setq gdb-source-window window)
-              (with-current-buffer buffer
-                (goto-char (point-min))
-                (forward-line (1- (string-to-number line)))
-                (set-window-point window (point))))))
-      (error "Not recognized as break/watchpoint line")))))
+    (beginning-of-line)
+    (let ((breakpoint (get-text-property (point) 'gdb-breakpoint)))
+      (if breakpoint
+          (let ((bptno (bindat-get-field breakpoint 'number))
+                (file  (bindat-get-field breakpoint 'fullname))
+                (line  (bindat-get-field breakpoint 'line)))
+            (save-selected-window
+              (let* ((buffer (find-file-noselect
+                              (if (file-exists-p file) file
+                                (cdr (assoc bptno gdb-location-alist)))))
+                     (window (or (gdb-display-source-buffer buffer)
+                                 (display-buffer buffer))))
+                (setq gdb-source-window window)
+                (with-current-buffer buffer
+                  (goto-char (point-min))
+                  (forward-line (1- (string-to-number line)))
+                  (set-window-point window (point))))))
+        (error "Not recognized as break/watchpoint line")))))
 
 
 ;; Frames buffer.  This displays a perpetually correct bactrack trace.
@@ -3418,21 +3439,21 @@ member."
   (let ((stack (bindat-get-field (gdb-json-partial-output "frame") 'stack))
         (table (make-gdb-table)))
     (set-marker gdb-stack-position nil)
-         (dolist (frame stack)
-           (gdb-table-add-row table
-            (list
-             (bindat-get-field frame 'level)
-             "in"
-             (concat
-              (bindat-get-field frame 'func)
-              (if gdb-stack-buffer-locations
-                  (gdb-frame-location frame) "")
-              (if gdb-stack-buffer-addresses
-                  (concat " at " (bindat-get-field frame 'addr)) "")))
-            `(mouse-face highlight
-              help-echo "mouse-2, RET: Select frame"
-              gdb-frame ,frame)))
-         (insert (gdb-table-string table " ")))
+    (dolist (frame stack)
+      (gdb-table-add-row table
+                         (list
+                          (bindat-get-field frame 'level)
+                          "in"
+                          (concat
+                           (bindat-get-field frame 'func)
+                           (if gdb-stack-buffer-locations
+                               (gdb-frame-location frame) "")
+                           (if gdb-stack-buffer-addresses
+                               (concat " at " (bindat-get-field frame 'addr)) "")))
+                         `(mouse-face highlight
+                                      help-echo "mouse-2, RET: Select frame"
+                                      gdb-frame ,frame)))
+    (insert (gdb-table-string table " ")))
   (when (and gdb-frame-number
              (gdb-buffer-shows-main-thread-p))
     (gdb-mark-line (1+ (string-to-number gdb-frame-number))
@@ -3445,18 +3466,18 @@ member."
    (concat "stack frames of " (gdb-get-target-string))))
 
 (def-gdb-display-buffer
- gdb-display-stack-buffer
- 'gdb-stack-buffer
- "Display backtrace of current stack.")
+  gdb-display-stack-buffer
+  'gdb-stack-buffer
+  "Display backtrace of current stack.")
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-stack-buffer
   'gdb-stack-buffer nil t)
 
 (def-gdb-frame-for-buffer
- gdb-frame-stack-buffer
- 'gdb-stack-buffer
- "Display backtrace of current stack in a new frame.")
+  gdb-frame-stack-buffer
+  'gdb-stack-buffer
+  "Display backtrace of current stack in a new frame.")
 
 (defvar gdb-frames-mode-map
   (let ((map (make-sparse-keymap)))
@@ -3489,7 +3510,8 @@ member."
         (if (gdb-buffer-shows-main-thread-p)
             (let ((new-level (bindat-get-field frame 'level)))
               (setq gdb-frame-number new-level)
-              (gdb-input (list (concat "-stack-select-frame " new-level) 'ignore))
+              (gdb-input (list (concat "-stack-select-frame " new-level)
+                               'ignore))
               (gdb-update))
           (error "Could not select frame for non-current thread"))
       (error "Not recognized as frame line"))))
@@ -3499,7 +3521,8 @@ member."
 ;; uses "-stack-list-locals --simple-values". Needs GDB 6.1 onwards.
 (def-gdb-trigger-and-handler
   gdb-invalidate-locals
-  (concat (gdb-current-context-command "-stack-list-locals") " --simple-values")
+  (concat (gdb-current-context-command "-stack-list-locals")
+          " --simple-values")
   gdb-locals-handler gdb-locals-handler-custom
   '(start update))
 
@@ -3515,7 +3538,7 @@ member."
     (define-key map "\r" 'gud-watch)
     (define-key map [mouse-2] 'gud-watch)
     map)
- "Keymap to create watch expression of a complex data type local variable.")
+  "Keymap to create watch expression of a complex data type local variable.")
 
 (defvar gdb-edit-locals-map-1
   (let ((map (make-sparse-keymap)))
@@ -3523,7 +3546,7 @@ member."
     (define-key map "\r" 'gdb-edit-locals-value)
     (define-key map [mouse-2] 'gdb-edit-locals-value)
     map)
- "Keymap to edit value of a simple data type local variable.")
+  "Keymap to edit value of a simple data type local variable.")
 
 (defun gdb-edit-locals-value (&optional event)
   "Assign a value to a variable displayed in the locals buffer."
@@ -3549,14 +3572,14 @@ member."
         (if (or (not value)
                 (string-match "\\0x" value))
             (add-text-properties 0 (length name)
-                            `(mouse-face highlight
-                              help-echo "mouse-2: create watch expression"
-                              local-map ,gdb-locals-watch-map)
-                            name)
+                                 `(mouse-face highlight
+                                              help-echo "mouse-2: create watch expression"
+                                              local-map ,gdb-locals-watch-map)
+                                 name)
           (add-text-properties 0 (length value)
                                `(mouse-face highlight
-                                help-echo "mouse-2: edit value"
-                                local-map ,gdb-edit-locals-map-1)
+                                            help-echo "mouse-2: edit value"
+                                            local-map ,gdb-edit-locals-map-1)
                                value))
         (gdb-table-add-row
          table
@@ -3568,7 +3591,8 @@ member."
     (insert (gdb-table-string table " "))
     (setq mode-name
           (gdb-current-context-mode-name
-          (concat "Locals: " (bindat-get-field (gdb-current-buffer-frame) 'func))))))
+           (concat "Locals: "
+                   (bindat-get-field (gdb-current-buffer-frame) 'func))))))
 
 (defvar gdb-locals-header
   (list
@@ -3576,19 +3600,20 @@ member."
                           nil nil mode-line)
    " "
    (gdb-propertize-header "Registers" gdb-registers-buffer
-                          "mouse-1: select" mode-line-highlight mode-line-inactive)))
+                          "mouse-1: select" mode-line-highlight
+                          mode-line-inactive)))
 
 (defvar gdb-locals-mode-map
   (let ((map (make-sparse-keymap)))
     (suppress-keymap map)
     (define-key map "q" 'kill-this-buffer)
     (define-key map "\t" (lambda ()
-                            (interactive)
-                            (gdb-set-window-buffer
-                             (gdb-get-buffer-create
-                              'gdb-registers-buffer
-                              gdb-thread-number) t)))
-     map))
+                           (interactive)
+                           (gdb-set-window-buffer
+                            (gdb-get-buffer-create
+                             'gdb-registers-buffer
+                             gdb-thread-number) t)))
+    map))
 
 (define-derived-mode gdb-locals-mode gdb-parent-mode "Locals"
   "Major mode for gdb locals."
@@ -3600,18 +3625,18 @@ member."
    (concat "locals of " (gdb-get-target-string))))
 
 (def-gdb-display-buffer
- gdb-display-locals-buffer
- 'gdb-locals-buffer
- "Display local variables of current stack and their values.")
+  gdb-display-locals-buffer
+  'gdb-locals-buffer
+  "Display local variables of current stack and their values.")
 
 (def-gdb-preempt-display-buffer
- gdb-preemptively-display-locals-buffer
- 'gdb-locals-buffer nil t)
+  gdb-preemptively-display-locals-buffer
+  'gdb-locals-buffer nil t)
 
 (def-gdb-frame-for-buffer
- gdb-frame-locals-buffer
- 'gdb-locals-buffer
- "Display local variables of current stack and their values in a new frame.")
+  gdb-frame-locals-buffer
+  'gdb-locals-buffer
+  "Display local variables of current stack and their values in a new frame.")
 
 
 ;; Registers buffer.
@@ -3631,7 +3656,8 @@ member."
 
 (defun gdb-registers-handler-custom ()
   (when gdb-register-names
-    (let ((register-values (bindat-get-field (gdb-json-partial-output) 'register-values))
+    (let ((register-values
+           (bindat-get-field (gdb-json-partial-output) 'register-values))
           (table (make-gdb-table)))
       (dolist (register register-values)
         (let* ((register-number (bindat-get-field register 'number))
@@ -3641,7 +3667,8 @@ member."
           (gdb-table-add-row
            table
            (list
-            (propertize register-name 'font-lock-face font-lock-variable-name-face)
+            (propertize register-name
+                        'font-lock-face font-lock-variable-name-face)
             (if (member register-number gdb-changed-registers)
                 (propertize value 'font-lock-face font-lock-warning-face)
               value))
@@ -3671,17 +3698,18 @@ member."
     (define-key map [mouse-2] 'gdb-edit-register-value)
     (define-key map "q" 'kill-this-buffer)
     (define-key map "\t" (lambda ()
-                            (interactive)
-                            (gdb-set-window-buffer
-                             (gdb-get-buffer-create
-                              'gdb-locals-buffer
-                              gdb-thread-number) t)))
+                           (interactive)
+                           (gdb-set-window-buffer
+                            (gdb-get-buffer-create
+                             'gdb-locals-buffer
+                             gdb-thread-number) t)))
     map))
 
 (defvar gdb-registers-header
   (list
    (gdb-propertize-header "Locals" gdb-locals-buffer
-                          "mouse-1: select" mode-line-highlight mode-line-inactive)
+                          "mouse-1: select" mode-line-highlight
+                          mode-line-inactive)
    " "
    (gdb-propertize-header "Registers" gdb-registers-buffer
                           nil nil mode-line)))
@@ -3696,17 +3724,17 @@ member."
    (concat "registers of " (gdb-get-target-string))))
 
 (def-gdb-display-buffer
- gdb-display-registers-buffer
- 'gdb-registers-buffer
- "Display integer register contents.")
+  gdb-display-registers-buffer
+  'gdb-registers-buffer
+  "Display integer register contents.")
 
 (def-gdb-preempt-display-buffer
   gdb-preemptively-display-registers-buffer
- 'gdb-registers-buffer nil t)
+  'gdb-registers-buffer nil t)
 
 (def-gdb-frame-for-buffer
- gdb-frame-registers-buffer
- 'gdb-registers-buffer
+  gdb-frame-registers-buffer
+  'gdb-registers-buffer
   "Display integer register contents in a new frame.")
 
 ;; Needs GDB 6.4 onwards (used to fail with no stack).
@@ -3723,14 +3751,16 @@ member."
 (defun gdb-changed-registers-handler ()
   (gdb-delete-pending 'gdb-get-changed-registers)
   (setq gdb-changed-registers nil)
-  (dolist (register-number (bindat-get-field (gdb-json-partial-output) 'changed-registers))
+  (dolist (register-number
+           (bindat-get-field (gdb-json-partial-output) 'changed-registers))
     (push register-number gdb-changed-registers)))
 
 (defun gdb-register-names-handler ()
   ;; Don't use gdb-pending-triggers because this handler is called
   ;; only once (in gdb-init-1)
   (setq gdb-register-names nil)
-  (dolist (register-name (bindat-get-field (gdb-json-partial-output) 'register-names))
+  (dolist (register-name
+           (bindat-get-field (gdb-json-partial-output) 'register-names))
     (push register-name gdb-register-names))
   (setq gdb-register-names (reverse gdb-register-names)))
 
@@ -3755,7 +3785,8 @@ thread. Called from `gdb-update'."
   (if (not (gdb-pending-p 'gdb-get-main-selected-frame))
       (progn
         (gdb-input
-         (list (gdb-current-context-command "-stack-info-frame") 'gdb-frame-handler))
+         (list (gdb-current-context-command "-stack-info-frame")
+               'gdb-frame-handler))
         (gdb-add-pending 'gdb-get-main-selected-frame))))
 
 (defun gdb-frame-handler ()
@@ -3806,10 +3837,10 @@ window and show BUF there, if the window is not used for GDB
 already, in which case that window is splitted first."
   (let ((answer (get-buffer-window buf (or frame 0))))
     (if answer
-        (display-buffer buf nil (or frame 0)) ;Deiconify the frame if necessary.
+        (display-buffer buf nil (or frame 0)) ;Deiconify frame if necessary.
       (let ((window (get-lru-window)))
         (if (eq (buffer-local-value 'gud-minor-mode (window-buffer window))
-                  'gdbmi)
+                'gdbmi)
             (let ((largest (get-largest-window)))
               (setq answer (split-window largest))
               (set-window-buffer answer buf)
@@ -3872,7 +3903,8 @@ SPLIT-HORIZONTAL and show BUF in the new window."
   (define-key menu [gdb] '("Gdb" . gdb-frame-gdb-buffer))
   (define-key menu [threads] '("Threads" . gdb-frame-threads-buffer))
   (define-key menu [memory] '("Memory" . gdb-frame-memory-buffer))
-  (define-key menu [disassembly] '("Disassembly" . gdb-frame-disassembly-buffer))
+  (define-key menu [disassembly]
+    '("Disassembly" . gdb-frame-disassembly-buffer))
   (define-key menu [registers] '("Registers" . gdb-frame-registers-buffer))
   (define-key menu [inferior]
     '("IO" . gdb-frame-io-buffer))
@@ -3883,40 +3915,41 @@ SPLIT-HORIZONTAL and show BUF in the new window."
 
 (let ((menu (make-sparse-keymap "GDB-MI")))
   (define-key menu [gdb-customize]
-  '(menu-item "Customize" (lambda () (interactive) (customize-group 'gdb))
-              :help "Customize Gdb Graphical Mode options."))
+    '(menu-item "Customize" (lambda () (interactive) (customize-group 'gdb))
+      :help "Customize Gdb Graphical Mode options."))
   (define-key menu [gdb-many-windows]
-  '(menu-item "Display Other Windows" gdb-many-windows
-              :help "Toggle display of locals, stack and breakpoint information"
-              :button (:toggle . gdb-many-windows)))
+    '(menu-item "Display Other Windows" gdb-many-windows
+      :help "Toggle display of locals, stack and breakpoint information"
+      :button (:toggle . gdb-many-windows)))
   (define-key menu [gdb-restore-windows]
-  '(menu-item "Restore Window Layout" gdb-restore-windows
-              :help "Restore standard layout for debug session."))
+    '(menu-item "Restore Window Layout" gdb-restore-windows
+      :help "Restore standard layout for debug session."))
   (define-key menu [sep1]
     '(menu-item "--"))
   (define-key menu [all-threads]
     '(menu-item "GUD controls all threads"
-                (lambda ()
-                  (interactive)
-                  (setq gdb-gud-control-all-threads t))
-                :help "GUD start/stop commands apply to all threads"
-                :button (:radio . gdb-gud-control-all-threads)))
+      (lambda ()
+        (interactive)
+        (setq gdb-gud-control-all-threads t))
+      :help "GUD start/stop commands apply to all threads"
+      :button (:radio . gdb-gud-control-all-threads)))
   (define-key menu [current-thread]
     '(menu-item "GUD controls current thread"
-                (lambda ()
-                  (interactive)
-                  (setq gdb-gud-control-all-threads nil))
-                :help "GUD start/stop commands apply to current thread only"
-                :button (:radio . (not gdb-gud-control-all-threads))))
+      (lambda ()
+        (interactive)
+        (setq gdb-gud-control-all-threads nil))
+      :help "GUD start/stop commands apply to current thread only"
+      :button (:radio . (not gdb-gud-control-all-threads))))
   (define-key menu [sep2]
     '(menu-item "--"))
   (define-key menu [gdb-customize-reasons]
     '(menu-item "Customize switching..."
-                (lambda ()
-                  (interactive)
-                  (customize-option 'gdb-switch-reasons))))
+      (lambda ()
+        (interactive)
+        (customize-option 'gdb-switch-reasons))))
   (define-key menu [gdb-switch-when-another-stopped]
-    (menu-bar-make-toggle gdb-toggle-switch-when-another-stopped gdb-switch-when-another-stopped
+    (menu-bar-make-toggle gdb-toggle-switch-when-another-stopped
+                          gdb-switch-when-another-stopped
                           "Automatically switch to stopped thread"
                           "GDB thread switching %s"
                           "Switch to stopped thread"))
@@ -3930,18 +3963,18 @@ SPLIT-HORIZONTAL and show BUF in the new window."
 ;; show up right before Run button.
 (define-key-after gud-tool-bar-map [all-threads]
   '(menu-item "Switch to non-stop/A mode" gdb-control-all-threads
-              :image (find-image '((:type xpm :file "gud/thread.xpm")))
-              :visible (and (eq gud-minor-mode 'gdbmi)
-                            gdb-non-stop
-                            (not gdb-gud-control-all-threads)))
+    :image (find-image '((:type xpm :file "gud/thread.xpm")))
+    :visible (and (eq gud-minor-mode 'gdbmi)
+                  gdb-non-stop
+                  (not gdb-gud-control-all-threads)))
   'run)
 
 (define-key-after gud-tool-bar-map [current-thread]
   '(menu-item "Switch to non-stop/T mode" gdb-control-current-thread
-              :image (find-image '((:type xpm :file "gud/all.xpm")))
-              :visible (and (eq gud-minor-mode 'gdbmi)
-                            gdb-non-stop
-                            gdb-gud-control-all-threads))
+    :image (find-image '((:type xpm :file "gud/all.xpm")))
+    :visible (and (eq gud-minor-mode 'gdbmi)
+                  gdb-non-stop
+                  gdb-gud-control-all-threads))
   'all-threads)
 
 (defun gdb-frame-gdb-buffer ()
@@ -3960,15 +3993,16 @@ SPLIT-HORIZONTAL and show BUF in the new window."
   (let ((same-window-regexps nil))
     (select-window (display-buffer gud-comint-buffer nil 0))))
 
-(defun gdb-set-window-buffer (name &optional ignore-dedicated)
+(defun gdb-set-window-buffer (name &optional ignore-dedicated window)
   "Set buffer of selected window to NAME and dedicate window.
 
 When IGNORE-DEDICATED is non-nil, buffer is set even if selected
 window is dedicated."
+  (unless window (setq window (selected-window)))
   (when ignore-dedicated
-    (set-window-dedicated-p (selected-window) nil))
-  (set-window-buffer (selected-window) (get-buffer name))
-  (set-window-dedicated-p (selected-window) t))
+    (set-window-dedicated-p window nil))
+  (set-window-buffer window (get-buffer name))
+  (set-window-dedicated-p window t))
 
 (defun gdb-setup-windows ()
   "Layout the window pattern for `gdb-many-windows'."
@@ -3977,35 +4011,35 @@ window is dedicated."
   (delete-other-windows)
   (gdb-display-breakpoints-buffer)
   (delete-other-windows)
-  ; Don't dedicate.
+  ;; Don't dedicate.
   (pop-to-buffer gud-comint-buffer)
-  (split-window nil ( / ( * (window-height) 3) 4))
-  (split-window nil ( / (window-height) 3))
-  (split-window-horizontally)
-  (other-window 1)
-  (gdb-set-window-buffer (gdb-locals-buffer-name))
-  (other-window 1)
-  (switch-to-buffer
-       (if gud-last-last-frame
-           (gud-find-file (car gud-last-last-frame))
-         (if gdb-main-file
-             (gud-find-file gdb-main-file)
-           ;; Put buffer list in window if we
-           ;; can't find a source file.
-           (list-buffers-noselect))))
-  (setq gdb-source-window (selected-window))
-  (split-window-horizontally)
-  (other-window 1)
-  (gdb-set-window-buffer
-   (gdb-get-buffer-create 'gdb-inferior-io))
-  (other-window 1)
-  (gdb-set-window-buffer (gdb-stack-buffer-name))
-  (split-window-horizontally)
-  (other-window 1)
-  (gdb-set-window-buffer (if gdb-show-threads-by-default
-                             (gdb-threads-buffer-name)
-                           (gdb-breakpoints-buffer-name)))
-  (other-window 1))
+  (let ((win0 (selected-window))
+        (win1 (split-window nil ( / ( * (window-height) 3) 4)))
+        (win2 (split-window nil ( / (window-height) 3)))
+        (win3 (split-window-horizontally)))
+    (gdb-set-window-buffer (gdb-locals-buffer-name) nil win3)
+    (select-window win2)
+    (set-window-buffer
+     win2
+     (if gud-last-last-frame
+         (gud-find-file (car gud-last-last-frame))
+       (if gdb-main-file
+           (gud-find-file gdb-main-file)
+         ;; Put buffer list in window if we
+         ;; can't find a source file.
+         (list-buffers-noselect))))
+    (setq gdb-source-window (selected-window))
+    (let ((win4 (split-window-horizontally)))
+      (gdb-set-window-buffer
+       (gdb-get-buffer-create 'gdb-inferior-io) nil win4))
+    (select-window win1)
+    (gdb-set-window-buffer (gdb-stack-buffer-name))
+    (let ((win5 (split-window-horizontally)))
+      (gdb-set-window-buffer (if gdb-show-threads-by-default
+                                 (gdb-threads-buffer-name)
+                               (gdb-breakpoints-buffer-name))
+                             nil win5))
+    (select-window win0)))
 
 (defcustom gdb-many-windows nil
   "If nil just pop up the GUD buffer unless `gdb-show-main' is t.
@@ -4022,34 +4056,33 @@ of the debugged program.  Non-nil means display the layout shown for
 With arg, display additional buffers iff arg is positive."
   (interactive "P")
   (setq gdb-many-windows
-        (if (null arg)
-            (not gdb-many-windows)
-          (> (prefix-numeric-value arg) 0)))
+        (if (null arg)
+            (not gdb-many-windows)
+          (> (prefix-numeric-value arg) 0)))
   (message (format "Display of other windows %sabled"
-                   (if gdb-many-windows "en" "dis")))
+                   (if gdb-many-windows "en" "dis")))
   (if (and gud-comint-buffer
-           (buffer-name gud-comint-buffer))
+           (buffer-name gud-comint-buffer))
       (condition-case nil
-          (gdb-restore-windows)
-        (error nil))))
+          (gdb-restore-windows)
+        (error nil))))
 
 (defun gdb-restore-windows ()
   "Restore the basic arrangement of windows used by gdb.
 This arrangement depends on the value of `gdb-many-windows'."
   (interactive)
-  (pop-to-buffer gud-comint-buffer)     ;Select the right window and frame.
-    (delete-other-windows)
+  (pop-to-buffer gud-comint-buffer) ;Select the right window and frame.
+  (delete-other-windows)
   (if gdb-many-windows
       (gdb-setup-windows)
     (when (or gud-last-last-frame gdb-show-main)
-      (split-window)
-      (other-window 1)
-      (switch-to-buffer
-       (if gud-last-last-frame
-           (gud-find-file (car gud-last-last-frame))
-         (gud-find-file gdb-main-file)))
-      (setq gdb-source-window (selected-window))
-      (other-window 1))))
+      (let ((win (split-window)))
+        (set-window-buffer
+         win
+         (if gud-last-last-frame
+             (gud-find-file (car gud-last-last-frame))
+           (gud-find-file gdb-main-file)))
+        (setq gdb-source-window win)))))
 
 (defun gdb-reset ()
   "Exit a debugging session cleanly.
@@ -4057,23 +4090,23 @@ Kills the gdb buffers, and resets variables and the source buffers."
   (dolist (buffer (buffer-list))
     (unless (eq buffer gud-comint-buffer)
       (with-current-buffer buffer
-        (if (eq gud-minor-mode 'gdbmi)
-            (if (string-match "\\` ?\\*.+\\*\\'" (buffer-name))
-                (kill-buffer nil)
-              (gdb-remove-breakpoint-icons (point-min) (point-max) t)
-              (setq gud-minor-mode nil)
-              (kill-local-variable 'tool-bar-map)
-              (kill-local-variable 'gdb-define-alist))))))
+        (if (eq gud-minor-mode 'gdbmi)
+            (if (string-match "\\` ?\\*.+\\*\\'" (buffer-name))
+                (kill-buffer nil)
+              (gdb-remove-breakpoint-icons (point-min) (point-max) t)
+              (setq gud-minor-mode nil)
+              (kill-local-variable 'tool-bar-map)
+              (kill-local-variable 'gdb-define-alist))))))
   (setq gdb-disassembly-position nil)
   (setq overlay-arrow-variable-list
-        (delq 'gdb-disassembly-position overlay-arrow-variable-list))
+        (delq 'gdb-disassembly-position overlay-arrow-variable-list))
   (setq fringe-indicator-alist '((overlay-arrow . right-triangle)))
   (setq gdb-stack-position nil)
   (setq overlay-arrow-variable-list
-        (delq 'gdb-stack-position overlay-arrow-variable-list))
+        (delq 'gdb-stack-position overlay-arrow-variable-list))
   (setq gdb-thread-position nil)
   (setq overlay-arrow-variable-list
-        (delq 'gdb-thread-position overlay-arrow-variable-list))
+        (delq 'gdb-thread-position overlay-arrow-variable-list))
   (if (boundp 'speedbar-frame) (speedbar-timer-fn))
   (setq gud-running nil)
   (setq gdb-active-process nil)
@@ -4085,12 +4118,12 @@ buffers, if required."
   (goto-char (point-min))
   (if (re-search-forward gdb-source-file-regexp nil t)
       (setq gdb-main-file (match-string 1)))
- (if gdb-many-windows
+  (if gdb-many-windows
       (gdb-setup-windows)
-   (gdb-get-buffer-create 'gdb-breakpoints-buffer)
-   (if gdb-show-main
-       (let ((pop-up-windows t))
-         (display-buffer (gud-find-file gdb-main-file))))))
+    (gdb-get-buffer-create 'gdb-breakpoints-buffer)
+    (if gdb-show-main
+        (let ((pop-up-windows t))
+          (display-buffer (gud-find-file gdb-main-file))))))
 
 ;;from put-image
 (defun gdb-put-string (putstring pos &optional dprop &rest sprops)
@@ -4099,14 +4132,14 @@ PUTSTRING is displayed by putting an overlay into the current buffer with a
 `before-string' string that has a `display' property whose value is
 PUTSTRING."
   (let ((string (make-string 1 ?x))
-        (buffer (current-buffer)))
+        (buffer (current-buffer)))
     (setq putstring (copy-sequence putstring))
     (let ((overlay (make-overlay pos pos buffer))
-          (prop (or dprop
-                    (list (list 'margin 'left-margin) putstring))))
+          (prop (or dprop
+                    (list (list 'margin 'left-margin) putstring))))
       (put-text-property 0 1 'display prop string)
       (if sprops
-          (add-text-properties 0 1 sprops string))
+          (add-text-properties 0 1 sprops string))
       (overlay-put overlay 'put-break t)
       (overlay-put overlay 'before-string string))))
 
@@ -4119,7 +4152,7 @@ BUFFER nil or omitted means use the current buffer."
     (setq buffer (current-buffer)))
   (dolist (overlay (overlays-in start end))
     (when (overlay-get overlay 'put-break)
-          (delete-overlay overlay))))
+      (delete-overlay overlay))))
 
 (defun gdb-put-breakpoint-icon (enabled bptno &optional line)
   (let* ((posns (gdb-line-posns (or line (line-number-at-pos))))
@@ -4131,62 +4164,63 @@ BUFFER nil or omitted means use the current buffer."
      0 1 '(help-echo "mouse-1: clear bkpt, mouse-3: enable/disable bkpt")
      putstring)
     (if enabled
-        (add-text-properties
-         0 1 `(gdb-bptno ,bptno gdb-enabled t) putstring)
+        (add-text-properties
+         0 1 `(gdb-bptno ,bptno gdb-enabled t) putstring)
       (add-text-properties
        0 1 `(gdb-bptno ,bptno gdb-enabled nil) putstring))
     (gdb-remove-breakpoint-icons start end)
     (if (display-images-p)
-        (if (>= (or left-fringe-width
-                    (if source-window (car (window-fringes source-window)))
-                    gdb-buffer-fringe-width) 8)
-            (gdb-put-string
-             nil (1+ start)
-             `(left-fringe breakpoint
-                           ,(if enabled
-                                'breakpoint-enabled
-                              'breakpoint-disabled))
-             'gdb-bptno bptno
-             'gdb-enabled enabled)
-          (when (< left-margin-width 2)
-            (save-current-buffer
-              (setq left-margin-width 2)
-              (if source-window
-                  (set-window-margins
-                   source-window
-                   left-margin-width right-margin-width))))
-          (put-image
-           (if enabled
-               (or breakpoint-enabled-icon
-                   (setq breakpoint-enabled-icon
-                         (find-image `((:type xpm :data
-                                              ,breakpoint-xpm-data
-                                              :ascent 100 :pointer hand)
-                                       (:type pbm :data
-                                              ,breakpoint-enabled-pbm-data
-                                              :ascent 100 :pointer hand)))))
-             (or breakpoint-disabled-icon
-                 (setq breakpoint-disabled-icon
-                       (find-image `((:type xpm :data
-                                            ,breakpoint-xpm-data
-                                            :conversion disabled
-                                            :ascent 100 :pointer hand)
-                                     (:type pbm :data
-                                            ,breakpoint-disabled-pbm-data
-                                            :ascent 100 :pointer hand))))))
-           (+ start 1)
-           putstring
-           'left-margin))
+        (if (>= (or left-fringe-width
+                    (if source-window (car (window-fringes source-window)))
+                    gdb-buffer-fringe-width) 8)
+            (gdb-put-string
+             nil (1+ start)
+             `(left-fringe breakpoint
+                           ,(if enabled
+                                'breakpoint-enabled
+                              'breakpoint-disabled))
+             'gdb-bptno bptno
+             'gdb-enabled enabled)
+          (when (< left-margin-width 2)
+            (save-current-buffer
+              (setq left-margin-width 2)
+              (if source-window
+                  (set-window-margins
+                   source-window
+                   left-margin-width right-margin-width))))
+          (put-image
+           (if enabled
+               (or breakpoint-enabled-icon
+                   (setq breakpoint-enabled-icon
+                         (find-image `((:type xpm :data
+                                        ,breakpoint-xpm-data
+                                        :ascent 100 :pointer hand)
+                                       (:type pbm :data
+                                        ,breakpoint-enabled-pbm-data
+                                        :ascent 100 :pointer hand)))))
+             (or breakpoint-disabled-icon
+                 (setq breakpoint-disabled-icon
+                       (find-image `((:type xpm :data
+                                      ,breakpoint-xpm-data
+                                      :conversion disabled
+                                      :ascent 100 :pointer hand)
+                                     (:type pbm :data
+                                      ,breakpoint-disabled-pbm-data
+                                      :ascent 100 :pointer hand))))))
+           (+ start 1)
+           putstring
+           'left-margin))
       (when (< left-margin-width 2)
-        (save-current-buffer
-          (setq left-margin-width 2)
-          (let ((window (get-buffer-window (current-buffer) 0)))
-            (if window
-              (set-window-margins
-               window left-margin-width right-margin-width)))))
+        (save-current-buffer
+          (setq left-margin-width 2)
+          (let ((window (get-buffer-window (current-buffer) 0)))
+            (if window
+                (set-window-margins
+                 window left-margin-width right-margin-width)))))
       (gdb-put-string
        (propertize putstring
-                   'face (if enabled 'breakpoint-enabled 'breakpoint-disabled))
+                   'face (if enabled
+                             'breakpoint-enabled 'breakpoint-disabled))
        (1+ start)))))
 
 (defun gdb-remove-breakpoint-icons (start end &optional remove-margin)
@@ -4197,8 +4231,8 @@ BUFFER nil or omitted means use the current buffer."
     (setq left-margin-width 0)
     (let ((window (get-buffer-window (current-buffer) 0)))
       (if window
-          (set-window-margins
-           window left-margin-width right-margin-width)))))
+          (set-window-margins
+           window left-margin-width right-margin-width)))))
 
 (provide 'gdb-mi)
 
diff --git a/lisp/progmodes/grep.el b/lisp/progmodes/grep.el
index db8e82193b3..5561575ea20 100644
--- a/lisp/progmodes/grep.el
+++ b/lisp/progmodes/grep.el
@@ -1023,7 +1023,8 @@ This command shares argument histories with \\[lgrep] and \\[grep-find]."
                     (read-from-minibuffer "Confirm: "
                                           command nil nil 'grep-find-history))
             (add-to-history 'grep-find-history command))
-          (let ((default-directory dir))
+          (let ((default-directory dir)
+                (process-connection-type nil))
             (compilation-start command 'grep-mode))
           ;; Set default-directory if we started rgrep in the *grep* buffer.
           (if (eq next-error-last-buffer (current-buffer))
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index 259ee81c9ba..a54d1438368 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -1581,7 +1581,8 @@ and source-file directory for your debugger."
 ;; Last group is for return value, e.g. "> test.py(2)foo()->None"
 ;; Either file or function name may be omitted: "> <string>(0)?()"
 (defvar gud-pdb-marker-regexp
-  "^> \\([-a-zA-Z0-9_/.:\\]*\\|<string>\\)(\\([0-9]+\\))\\([a-zA-Z0-9_]*\\|\\?\\|<module>\\)()\\(->[^\n]*\\)?\n")
+  "^> \\([-a-zA-Z0-9_/.:\\]*\\|<string>\\)(\\([0-9]+\\))\\([a-zA-Z0-9_]*\\|\\?\\|<module>\\)()\\(->[^\n\r]*\\)?[\n\r]")
+
 (defvar gud-pdb-marker-regexp-file-group 1)
 (defvar gud-pdb-marker-regexp-line-group 2)
 (defvar gud-pdb-marker-regexp-fnname-group 3)
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index a0437ccf9ae..1bdcb4cfa89 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -3306,8 +3306,8 @@ If one hasn't been set, or if it's stale, prompt for a new one."
        #'js--which-func-joiner)
 
   ;; Comments
-  (setq comment-start "// ")
-  (setq comment-end "")
+  (set (make-local-variable 'comment-start) "// ")
+  (set (make-local-variable 'comment-end) "")
   (set (make-local-variable 'fill-paragraph-function)
        'js-c-fill-paragraph)
 
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 1da819660d2..80358e1c651 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -4,10 +4,9 @@
 
 ;; Author: Alex Schroeder <alex@gnu.org>
 ;; Maintainer: Michael Mauger <mmaug@yahoo.com>
-;; Version: 2.8
+;; Version: 3.0
 ;; Keywords: comm languages processes
 ;; URL: http://savannah.gnu.org/projects/emacs/
-;; URL: http://www.emacswiki.org/cgi-bin/wiki.pl?SqlMode
 
 ;; This file is part of GNU Emacs.
 
@@ -46,7 +45,7 @@
 ;; available in early versions of sql.el.  This support has been
 ;; extended and formalized in later versions.  Part of the impetus for
 ;; the improved support of SQL flavors was borne out of the current
-;; maintainer's consulting experience.  In the past fifteen years, I
+;; maintainers consulting experience.  In the past twenty years, I
 ;; have used Oracle, Sybase, Informix, MySQL, Postgres, and SQLServer.
 ;; On some assignments, I have used two or more of these concurrently.
 
@@ -130,7 +129,7 @@
 ;;    identifier characters.
 
 ;;     (sql-set-product-feature 'xyz
-;;                              :syntax-alist ((?# . "w")))
+;;                              :syntax-alist ((?# . "_")))
 
 ;; 4) Define the interactive command interpreter for the database
 ;;    product.
@@ -184,7 +183,7 @@
 ;;     (sql-set-product-feature 'xyz
 ;;                              :sqli-comint-func 'my-sql-comint-xyz)
 
-;; 6) Define a convienence function to invoke the SQL interpreter.
+;; 6) Define a convenience function to invoke the SQL interpreter.
 
 ;;     (defun my-sql-xyz (&optional buffer)
 ;;       "Run ixyz by XyzDB as an inferior process."
@@ -230,9 +229,18 @@
 (eval-when-compile
   (require 'regexp-opt))
 (require 'custom)
+(require 'thingatpt)
 (eval-when-compile ;; needed in Emacs 19, 20
   (setq max-specpdl-size (max max-specpdl-size 2000)))
 
+(defun sql-signum (n)
+  "Return 1, 0, or -1 to identify the sign of N."
+  (cond
+   ((not (numberp n)) nil)
+   ((< n 0) -1)
+   ((> n 0) 1)
+   (t 0)))
+
 (defvar font-lock-keyword-face)
 (defvar font-lock-set-defaults)
 (defvar font-lock-string-face)
@@ -327,7 +335,8 @@ Customizing your password will store it in your ~/.emacs file."
 (defvar sql-product-alist
   '((ansi
      :name "ANSI"
-     :font-lock sql-mode-ansi-font-lock-keywords)
+     :font-lock sql-mode-ansi-font-lock-keywords
+     :statement sql-ansi-statement-starters)
 
     (db2
      :name "DB2"
@@ -392,7 +401,7 @@ Customizing your password will store it in your ~/.emacs file."
      :sqli-comint-func sql-comint-ms
      :prompt-regexp "^[0-9]*>"
      :prompt-length 5
-     :syntax-alist ((?@ . "w"))
+     :syntax-alist ((?@ . "_"))
      :terminator ("^go" . "go"))
 
     (mysql
@@ -408,6 +417,7 @@ Customizing your password will store it in your ~/.emacs file."
      :prompt-regexp "^mysql> "
      :prompt-length 6
      :prompt-cont-regexp "^    -> "
+     :syntax-alist ((?# . "< b"))
      :input-filter sql-remove-tabs-filter)
 
     (oracle
@@ -417,11 +427,15 @@ Customizing your password will store it in your ~/.emacs file."
      :sqli-options sql-oracle-options
      :sqli-login sql-oracle-login-params
      :sqli-comint-func sql-comint-oracle
+     :list-all sql-oracle-list-all
+     :list-table sql-oracle-list-table
+     :completion-object sql-oracle-completion-object
      :prompt-regexp "^SQL> "
      :prompt-length 5
-     :prompt-cont-regexp "^\\s-*\\d+> "
-     :syntax-alist ((?$ . "w") (?# . "w"))
-     :terminator ("\\(^/\\|;\\)" . "/")
+     :prompt-cont-regexp "^\\s-*[[:digit:]]+  "
+     :statement sql-oracle-statement-starters
+     :syntax-alist ((?$ . "_") (?# . "_"))
+     :terminator ("\\(^/\\|;\\)$" . "/")
      :input-filter sql-placeholders-filter)
 
     (postgres
@@ -434,11 +448,12 @@ Customizing your password will store it in your ~/.emacs file."
      :sqli-comint-func sql-comint-postgres
      :list-all ("\\d+" . "\\dS+")
      :list-table ("\\d+ %s" . "\\dS+ %s")
-     :prompt-regexp "^.*=[#>] "
+     :completion-object sql-postgres-completion-object
+     :prompt-regexp "^\\w*=[#>] "
      :prompt-length 5
-     :prompt-cont-regexp "^.*[-(][#>] "
+     :prompt-cont-regexp "^\\w*[-(][#>] "
      :input-filter sql-remove-tabs-filter
-     :terminator ("\\(^\\s-*\\\\g\\|;\\)" . ";"))
+     :terminator ("\\(^\\s-*\\\\g$\\|;\\)" . "\\g"))
 
     (solid
      :name "Solid"
@@ -460,9 +475,10 @@ Customizing your password will store it in your ~/.emacs file."
      :sqli-comint-func sql-comint-sqlite
      :list-all ".tables"
      :list-table ".schema %s"
+     :completion-object sql-sqlite-completion-object
      :prompt-regexp "^sqlite> "
      :prompt-length 8
-     :prompt-cont-regexp "^   ...> "
+     :prompt-cont-regexp "^   \.\.\.> "
      :terminator ";")
 
     (sybase
@@ -474,7 +490,7 @@ Customizing your password will store it in your ~/.emacs file."
      :sqli-comint-func sql-comint-sybase
      :prompt-regexp "^SQL> "
      :prompt-length 5
-     :syntax-alist ((?@ . "w"))
+     :syntax-alist ((?@ . "_"))
      :terminator ("^go" . "go"))
     )
   "An alist of product specific configuration settings.
@@ -513,10 +529,11 @@ may be any one of the following:
  :sqli-comint-func      name of a function which accepts no
                         parameters that will use the values of
                         `sql-user', `sql-password',
-                        `sql-database' and `sql-server' to open a
-                        comint buffer and connect to the
-                        database.  Do product specific
-                        configuration of comint in this function.
+                        `sql-database', `sql-server' and
+                        `sql-port' to open a comint buffer and
+                        connect to the database.  Do product
+                        specific configuration of comint in this
+                        function.
 
  :list-all              Command string or function which produces
                         a listing of all objects in the database.
@@ -535,6 +552,20 @@ may be any one of the following:
                         produces the standard list and the cdr
                         produces an enhanced list.
 
+ :completion-object     A function that returns a list of
+                        objects.  Called with a single
+                        parameter--if nil then list objects
+                        accessible in the current schema, if
+                        not-nil it is the name of a schema whose
+                        objects should be listed.
+
+ :completion-column     A function that returns a list of
+                        columns.  Called with a single
+                        parameter--if nil then list objects
+                        accessible in the current schema, if
+                        not-nil it is the name of a schema whose
+                        objects should be listed.
+
  :prompt-regexp         regular expression string that matches
                         the prompt issued by the product
                         interpreter.
@@ -555,6 +586,9 @@ may be any one of the following:
                         filtered string.  May also be a list of
                         such functions.
 
+ :statement             name of a variable containing a regexp that
+                        matches the beginning of SQL statements.
+
  :terminator            the terminator to be sent after a
                         `sql-send-string', `sql-send-region',
                         `sql-send-paragraph' and
@@ -574,7 +608,7 @@ using `sql-get-product-feature' to lookup the product specific
 settings.")
 
 (defvar sql-indirect-features
-  '(:font-lock :sqli-program :sqli-options :sqli-login))
+  '(:font-lock :sqli-program :sqli-options :sqli-login :statement))
 
 (defcustom sql-connection-alist nil
   "An alist of connection parameters for interacting with a SQL
@@ -683,6 +717,13 @@ it automatically."
   :version "22.2"
   :group 'SQL)
 
+(defvar sql-contains-names nil
+  "When non-nil, the current buffer contains database names.
+
+Globally should be set to nil; it will be non-nil in `sql-mode',
+`sql-interactive-mode' and list all buffers.")
+
+
 (defcustom sql-pop-to-buffer-after-send-region nil
   "When non-nil, pop to the buffer SQL statements are sent to.
 
@@ -770,6 +811,19 @@ is changed."
   :type 'hook
   :group 'SQL)
 
+;; Customization for ANSI
+
+(defcustom sql-ansi-statement-starters (regexp-opt '(
+ "create" "alter" "drop"
+ "select" "insert" "update" "delete" "merge"
+ "grant" "revoke"
+))
+  "Regexp of keywords that start SQL commands
+
+All products share this list; products should define a regexp to
+identify additional keywords in a variable defined by
+the :statement feature.")
+
 ;; Customization for Oracle
 
 (defcustom sql-oracle-program "sqlplus"
@@ -795,18 +849,22 @@ You will find the file in your Orant\\bin directory."
   :version "24.1"
   :group 'SQL)
 
+(defcustom sql-oracle-statement-starters (regexp-opt '("declare" "begin" "with"))
+  "Additional statement starting keywords in Oracle.")
+
 (defcustom sql-oracle-scan-on t
   "Non-nil if placeholders should be replaced in Oracle SQLi.
 
 When non-nil, Emacs will scan text sent to sqlplus and prompt
 for replacement text for & placeholders as sqlplus does.  This
-is needed on Windows where sqlplus output is buffered and the
+is needed on Windows where SQL*Plus output is buffered and the
 prompts are not shown until after the text is entered.
 
-You will probably want to issue the following command in sqlplus
-to be safe:
+You need to issue the following command in SQL*Plus to be safe:
+
+    SET DEFINE OFF
 
-    SET SCAN OFF"
+In older versions of SQL*Plus, this was the SET SCAN OFF command."
   :type 'boolean
   :group 'SQL)
 
@@ -833,7 +891,7 @@ Starts `sql-interactive-mode' after doing some setup."
   :version "24.1"
   :group 'SQL)
 
-;; Customization for MySql
+;; Customization for MySQL
 
 (defcustom sql-mysql-program "mysql"
   "Command to start mysql by TcX.
@@ -851,7 +909,7 @@ on Windows: \"-C\" \"-t\" \"-f\" \"-n\"."
   :group 'SQL)
 
 (defcustom sql-mysql-login-params '(user password database server)
-  "List of login parameters needed to connect to MySql."
+  "List of login parameters needed to connect to MySQL."
   :type 'sql-login-params
   :version "24.1"
   :group 'SQL)
@@ -1085,13 +1143,13 @@ You can change `sql-prompt-length' on `sql-interactive-mode-hook'.")
 
 Used by `sql-rename-buffer'.")
 
-(defun sql-buffer-live-p (buffer &optional product)
+(defun sql-buffer-live-p (buffer &optional product connection)
   "Returns non-nil if the process associated with buffer is live.
 
 BUFFER can be a buffer object or a buffer name.  The buffer must
 be a live buffer, have an running process attached to it, be in
-`sql-interactive-mode', and, if PRODUCT is specified, it's
-`sql-product' must match."
+`sql-interactive-mode', and, if PRODUCT or CONNECTION are
+specified, it's `sql-product' or `sql-connection' must match."
 
   (when buffer
     (setq buffer (get-buffer buffer))
@@ -1102,7 +1160,9 @@ be a live buffer, have an running process attached to it, be in
          (with-current-buffer buffer
            (and (derived-mode-p 'sql-interactive-mode)
                 (or (not product)
-                    (eq product sql-product)))))))
+                    (eq product sql-product))
+                (or (not connection)
+                    (eq connection sql-connection)))))))
 
 ;; Keymap for sql-interactive-mode.
 
@@ -1136,6 +1196,8 @@ Based on `comint-mode-map'.")
     (define-key map (kbd "C-c C-i") 'sql-product-interactive)
     (define-key map (kbd "C-c C-l a") 'sql-list-all)
     (define-key map (kbd "C-c C-l t") 'sql-list-table)
+    (define-key map [remap beginning-of-defun] 'sql-beginning-of-statement)
+    (define-key map [remap end-of-defun] 'sql-end-of-statement)
     map)
   "Mode map used for `sql-mode'.")
 
@@ -1151,8 +1213,10 @@ Based on `comint-mode-map'.")
    ["Send Buffer" sql-send-buffer (sql-buffer-live-p sql-buffer)]
    ["Send String" sql-send-string (sql-buffer-live-p sql-buffer)]
    "--"
-   ["List all objects" sql-list-all (sql-buffer-live-p sql-buffer)]
-   ["List table details" sql-list-table (sql-buffer-live-p sql-buffer)]
+   ["List all objects" sql-list-all (and (sql-buffer-live-p sql-buffer)
+                                         (sql-get-product-feature sql-product :list-all))]
+   ["List table details" sql-list-table (and (sql-buffer-live-p sql-buffer)
+                                             (sql-get-product-feature sql-product :list-table))]
    "--"
    ["Start SQLi session" sql-product-interactive
     :visible (not sql-connection-alist)
@@ -1194,8 +1258,8 @@ Based on `comint-mode-map'.")
    ["Rename Buffer" sql-rename-buffer t]
    ["Save Connection" sql-save-connection (not sql-connection)]
    "--"
-   ["List all objects" sql-list-all t]
-   ["List table details" sql-list-table t]))
+   ["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.
@@ -1238,8 +1302,9 @@ Based on `comint-mode-map'.")
     (modify-syntax-entry ?' "\"" table)
     ;; double quotes (") don't delimit strings
     (modify-syntax-entry ?\" "." table)
-    ;; backslash is no escape character
-    (modify-syntax-entry ?\\ "." table)
+    ;; Make these all punctuation
+    (mapc (lambda (c) (modify-syntax-entry c "." table))
+          (string-to-list "!#$%&+,.:;<=>?@\\|"))
     table)
   "Syntax table used in `sql-mode' and `sql-interactive-mode'.")
 
@@ -1298,20 +1363,45 @@ statement.  The format of variable should be a valid
 
       ;; Remove keywords that are defined in ANSI
       (setq kwd keywords)
-      (dolist (k keywords)
-        (catch 'next
-          (dolist (a sql-mode-ansi-font-lock-keywords)
-            (when (and (eq face (cdr a))
-                       (eq (string-match (car a) k 0) 0)
-                       (eq (match-end 0) (length k)))
-              (setq kwd (delq k kwd))
-              (throw 'next nil)))))
+      ;; (dolist (k keywords)
+      ;;   (catch 'next
+      ;;     (dolist (a sql-mode-ansi-font-lock-keywords)
+      ;;       (when (and (eq face (cdr a))
+      ;;               (eq (string-match (car a) k 0) 0)
+      ;;               (eq (match-end 0) (length k)))
+      ;;         (setq kwd (delq k kwd))
+      ;;         (throw 'next nil)))))
 
       ;; Create a properly formed font-lock-keywords item
       (cons (concat (car bdy)
                     (regexp-opt kwd t)
                     (cdr bdy))
-            face))))
+            face)))
+
+  (defun sql-regexp-abbrev (keyword)
+    (let ((brk   (string-match "[~]" keyword))
+          (len   (length keyword))
+          (sep   "\\(?:")
+          re i)
+      (if (not brk)
+          keyword
+        (setq re  (substring keyword 0 brk)
+              i   (+ 2 brk)
+              brk (1+ brk))
+        (while (<= i len)
+          (setq re  (concat re sep (substring keyword brk i))
+                sep "\\|"
+                i   (1+ i)))
+        (concat re "\\)?"))))
+
+  (defun sql-regexp-abbrev-list (&rest keyw-list)
+    (let ((re nil)
+          (sep "\\<\\(?:"))
+      (while keyw-list
+        (setq re (concat re sep (sql-regexp-abbrev (car keyw-list)))
+              sep "\\|"
+              keyw-list (cdr keyw-list)))
+      (concat re "\\)\\>"))))
 
 (eval-when-compile
   (setq sql-mode-ansi-font-lock-keywords
@@ -1346,6 +1436,7 @@ statement.  The format of variable should be a valid
 "user_defined_type_catalog" "user_defined_type_name"
 "user_defined_type_schema"
 )
+
          ;; ANSI Reserved keywords
          (sql-font-lock-keywords-builder 'font-lock-keyword-face nil
 "absolute" "action" "add" "admin" "after" "aggregate" "alias" "all"
@@ -1395,6 +1486,7 @@ statement.  The format of variable should be a valid
 "substring" "sum" "system_user" "translate" "treat" "trim" "upper"
 "user"
 )
+
          ;; ANSI Data Types
          (sql-font-lock-keywords-builder 'font-lock-type-face nil
 "array" "binary" "bit" "blob" "boolean" "char" "character" "clob"
@@ -1414,86 +1506,142 @@ function `regexp-opt'.  Therefore, take a look at the source before
 you define your own `sql-mode-ansi-font-lock-keywords'.  You may want
 to add functions and PL/SQL keywords.")
 
+(defun sql-oracle-show-reserved-words ()
+  ;; This function is for use by the maintainer of SQL.EL only.
+  (interactive)
+  (if (or (and (not (derived-mode-p 'sql-mode))
+               (not (derived-mode-p 'sql-interactive-mode)))
+          (not sql-buffer)
+          (not (eq sql-product 'oracle)))
+      (error "Not an Oracle buffer")
+
+    (let ((b "*RESERVED WORDS*"))
+      (sql-execute sql-buffer b
+                   (concat "SELECT "
+                           "  keyword "
+                           ", reserved AS \"Res\" "
+                           ", res_type AS \"Type\" "
+                           ", res_attr AS \"Attr\" "
+                           ", res_semi AS \"Semi\" "
+                           ", duplicate AS \"Dup\" "
+                           "FROM V$RESERVED_WORDS "
+                           "WHERE length > 1 "
+                           "AND SUBSTR(keyword, 1, 1) BETWEEN 'A' AND 'Z' "
+                           "ORDER BY 2 DESC, 3 DESC, 4 DESC, 5 DESC, 6 DESC, 1;")
+                   nil nil)
+      (with-current-buffer b
+        (set (make-local-variable 'sql-product) 'oracle)
+        (sql-product-font-lock t nil)
+        (font-lock-mode +1)))))
+
 (defvar sql-mode-oracle-font-lock-keywords
   (eval-when-compile
     (list
      ;; Oracle SQL*Plus Commands
-     (cons
-      (concat
-       "^\\s-*\\(?:\\(?:" (regexp-opt '(
-"@" "@@" "accept" "append" "archive" "attribute" "break"
-"btitle" "change" "clear" "column" "connect" "copy" "define"
-"del" "describe" "disconnect" "edit" "execute" "exit" "get" "help"
-"host" "input" "list" "password" "pause" "print" "prompt" "recover"
-"remark" "repfooter" "repheader" "run" "save" "show" "shutdown"
-"spool" "start" "startup" "store" "timing" "ttitle" "undefine"
-"variable" "whenever"
-) t)
+     ;;   Only recognized in they start in column 1 and the
+     ;;   abbreviation is followed by a space or the end of line.
 
-       "\\)\\|"
-       "\\(?:compute\\s-+\\(?:avg\\|cou\\|min\\|max\\|num\\|sum\\|std\\|var\\)\\)\\|"
-       "\\(?:set\\s-+\\("
-
-       (regexp-opt
-        '("appi" "appinfo" "array" "arraysize" "auto" "autocommit"
-          "autop" "autoprint" "autorecovery" "autot" "autotrace" "blo"
-          "blockterminator" "buffer" "closecursor" "cmds" "cmdsep"
-          "colsep" "com" "compatibility" "con" "concat" "constraint"
-          "constraints" "copyc" "copycommit" "copytypecheck" "database"
-          "def" "define" "document" "echo" "editf" "editfile" "emb"
-          "embedded" "esc" "escape" "feed" "feedback" "flagger" "flu"
-          "flush" "hea" "heading" "heads" "headsep" "instance" "lin"
-          "linesize" "lobof" "loboffset" "logsource" "long" "longc"
-          "longchunksize" "maxdata" "newp" "newpage" "null" "num"
-          "numf" "numformat" "numwidth" "pages" "pagesize" "pau"
-          "pause" "recsep" "recsepchar" "role" "scan" "serveroutput"
-          "shift" "shiftinout" "show" "showmode" "space" "sqlbl"
-          "sqlblanklines" "sqlc" "sqlcase" "sqlco" "sqlcontinue" "sqln"
-          "sqlnumber" "sqlp" "sqlpluscompat" "sqlpluscompatibility"
-          "sqlpre" "sqlprefix" "sqlprompt" "sqlt" "sqlterminator"
-          "statement_id" "suf" "suffix" "tab" "term" "termout" "ti"
-          "time" "timi" "timing" "transaction" "trim" "trimout" "trims"
-          "trimspool" "truncate" "und" "underline" "ver" "verify" "wra"
-          "wrap")) "\\)\\)"
-
-       "\\)\\b.*"
-       )
-      'font-lock-doc-face)
-     '("^\\s-*rem\\(?:ark\\)?\\>.*" . font-lock-comment-face)
+     "\\|"
+     (list (concat "^" (sql-regexp-abbrev "rem~ark") "\\(?:\\s-.*\\)?$")
+           0 'font-lock-comment-face t)
+
+     (list
+      (concat
+       "^\\(?:"
+       (sql-regexp-abbrev-list
+        "[@]\\{1,2\\}" "acc~ept" "a~ppend" "archive" "attribute"
+        "bre~ak" "bti~tle" "c~hange" "cl~ear" "col~umn" "conn~ect"
+        "copy" "def~ine" "del" "desc~ribe" "disc~onnect" "ed~it"
+        "exec~ute" "exit" "get" "help" "ho~st" "[$]" "i~nput" "l~ist"
+        "passw~ord" "pau~se" "pri~nt" "pro~mpt" "quit" "recover"
+        "repf~ooter" "reph~eader" "r~un" "sav~e" "sho~w" "shutdown"
+        "spo~ol" "sta~rt" "startup" "store" "tim~ing" "tti~tle"
+        "undef~ine" "var~iable" "whenever")
+       "\\|"
+       (concat "\\(?:"
+               (sql-regexp-abbrev "comp~ute")
+               "\\s-+"
+               (sql-regexp-abbrev-list
+                "avg" "cou~nt" "min~imum" "max~imum" "num~ber" "sum"
+                "std" "var~iance")
+               "\\)")
+       "\\|"
+       (concat "\\(?:set\\s-+"
+               (sql-regexp-abbrev-list
+                "appi~nfo" "array~size" "auto~commit" "autop~rint"
+                "autorecovery" "autot~race" "blo~ckterminator"
+                "cmds~ep" "colsep" "com~patibility" "con~cat"
+                "copyc~ommit" "copytypecheck" "def~ine" "describe"
+                "echo" "editf~ile" "emb~edded" "esc~ape" "feed~back"
+                "flagger" "flu~sh" "hea~ding" "heads~ep" "instance"
+                "lin~esize" "lobof~fset" "long" "longc~hunksize"
+                "mark~up" "newp~age" "null" "numf~ormat" "num~width"
+                "pages~ize" "pau~se" "recsep" "recsepchar"
+                "scan" "serverout~put" "shift~inout" "show~mode"
+                "sqlbl~anklines" "sqlc~ase" "sqlco~ntinue"
+                "sqln~umber" "sqlpluscompat~ibility" "sqlpre~fix"
+                "sqlp~rompt" "sqlt~erminator" "suf~fix" "tab"
+                "term~out" "ti~me" "timi~ng" "trim~out" "trims~pool"
+                "und~erline" "ver~ify" "wra~p")
+               "\\)")
+
+       "\\)\\(?:\\s-.*\\)?\\(?:[-]\n.*\\)*$")
+      0 'font-lock-doc-face t)
 
      ;; Oracle Functions
      (sql-font-lock-keywords-builder 'font-lock-builtin-face nil
-"abs" "acos" "add_months" "ascii" "asciistr" "asin" "atan" "atan2"
-"avg" "bfilename" "bin_to_num" "bitand" "cast" "ceil" "chartorowid"
-"chr" "coalesce" "compose" "concat" "convert" "corr" "cos" "cosh"
-"count" "covar_pop" "covar_samp" "cume_dist" "current_date"
-"current_timestamp" "current_user" "dbtimezone" "decode" "decompose"
-"dense_rank" "depth" "deref" "dump" "empty_clob" "existsnode" "exp"
-"extract" "extractvalue" "first" "first_value" "floor" "following"
-"from_tz" "greatest" "group_id" "grouping_id" "hextoraw" "initcap"
-"instr" "lag" "last" "last_day" "last_value" "lead" "least" "length"
-"ln" "localtimestamp" "lower" "lpad" "ltrim" "make_ref" "max" "min"
-"mod" "months_between" "new_time" "next_day" "nls_charset_decl_len"
+"abs" "acos" "add_months" "appendchildxml" "ascii" "asciistr" "asin"
+"atan" "atan2" "avg" "bfilename" "bin_to_num" "bitand" "cardinality"
+"cast" "ceil" "chartorowid" "chr" "cluster_id" "cluster_probability"
+"cluster_set" "coalesce" "collect" "compose" "concat" "convert" "corr"
+"corr_k" "corr_s" "cos" "cosh" "count" "covar_pop" "covar_samp"
+"cube_table" "cume_dist" "currrent_date" "currrent_timestamp" "cv"
+"dataobj_to_partition" "dbtimezone" "decode" "decompose" "deletexml"
+"dense_rank" "depth" "deref" "dump" "empty_blob" "empty_clob"
+"existsnode" "exp" "extract" "extractvalue" "feature_id" "feature_set"
+"feature_value" "first" "first_value" "floor" "from_tz" "greatest"
+"grouping" "grouping_id" "group_id" "hextoraw" "initcap"
+"insertchildxml" "insertchildxmlafter" "insertchildxmlbefore"
+"insertxmlafter" "insertxmlbefore" "instr" "instr2" "instr4" "instrb"
+"instrc" "iteration_number" "lag" "last" "last_day" "last_value"
+"lead" "least" "length" "length2" "length4" "lengthb" "lengthc"
+"listagg" "ln" "lnnvl" "localtimestamp" "log" "lower" "lpad" "ltrim"
+"make_ref" "max" "median" "min" "mod" "months_between" "nanvl" "nchr"
+"new_time" "next_day" "nlssort" "nls_charset_decl_len"
 "nls_charset_id" "nls_charset_name" "nls_initcap" "nls_lower"
-"nls_upper" "nlssort" "ntile" "nullif" "numtodsinterval"
-"numtoyminterval" "nvl" "nvl2" "over" "path" "percent_rank"
-"percentile_cont" "percentile_disc" "power" "preceding" "rank"
-"ratio_to_report" "rawtohex" "rawtonhex" "reftohex" "regr_"
-"regr_avgx" "regr_avgy" "regr_count" "regr_intercept" "regr_r2"
-"regr_slope" "regr_sxx" "regr_sxy" "regr_syy" "replace" "round"
-"row_number" "rowidtochar" "rowidtonchar" "rpad" "rtrim"
-"sessiontimezone" "sign" "sin" "sinh" "soundex" "sqrt" "stddev"
-"stddev_pop" "stddev_samp" "substr" "sum" "sys_connect_by_path"
-"sys_context" "sys_dburigen" "sys_extract_utc" "sys_guid" "sys_typeid"
-"sys_xmlagg" "sys_xmlgen" "sysdate" "systimestamp" "tan" "tanh"
+"nls_upper" "nth_value" "ntile" "nullif" "numtodsinterval"
+"numtoyminterval" "nvl" "nvl2" "ora_dst_affected" "ora_dst_convert"
+"ora_dst_error" "ora_hash" "path" "percentile_cont" "percentile_disc"
+"percent_rank" "power" "powermultiset" "powermultiset_by_cardinality"
+"prediction" "prediction_bounds" "prediction_cost"
+"prediction_details" "prediction_probability" "prediction_set"
+"presentnnv" "presentv" "previous" "rank" "ratio_to_report" "rawtohex"
+"rawtonhex" "ref" "reftohex" "regexp_count" "regexp_instr"
+"regexp_replace" "regexp_substr" "regr_avgx" "regr_avgy" "regr_count"
+"regr_intercept" "regr_r2" "regr_slope" "regr_sxx" "regr_sxy"
+"regr_syy" "remainder" "replace" "round" "rowidtochar" "rowidtonchar"
+"row_number" "rpad" "rtrim" "scn_to_timestamp" "sessiontimezone" "set"
+"sign" "sin" "sinh" "soundex" "sqrt" "stats_binomial_test"
+"stats_crosstab" "stats_f_test" "stats_ks_test" "stats_mode"
+"stats_mw_test" "stats_one_way_anova" "stats_t_test_indep"
+"stats_t_test_indepu" "stats_t_test_one" "stats_t_test_paired"
+"stats_wsr_test" "stddev" "stddev_pop" "stddev_samp" "substr"
+"substr2" "substr4" "substrb" "substrc" "sum" "sysdate" "systimestamp"
+"sys_connect_by_path" "sys_context" "sys_dburigen" "sys_extract_utc"
+"sys_guid" "sys_typeid" "sys_xmlagg" "sys_xmlgen" "tan" "tanh"
+"timestamp_to_scn" "to_binary_double" "to_binary_float" "to_blob"
 "to_char" "to_clob" "to_date" "to_dsinterval" "to_lob" "to_multi_byte"
 "to_nchar" "to_nclob" "to_number" "to_single_byte" "to_timestamp"
 "to_timestamp_tz" "to_yminterval" "translate" "treat" "trim" "trunc"
-"tz_offset" "uid" "unbounded" "unistr" "updatexml" "upper" "user"
-"userenv" "var_pop" "var_samp" "variance" "vsize" "width_bucket" "xml"
-"xmlagg" "xmlattribute" "xmlcolattval" "xmlconcat" "xmlelement"
-"xmlforest" "xmlsequence" "xmltransform"
+"tz_offset" "uid" "unistr" "updatexml" "upper" "user" "userenv"
+"value" "variance" "var_pop" "var_samp" "vsize" "width_bucket"
+"xmlagg" "xmlcast" "xmlcdata" "xmlcolattval" "xmlcomment" "xmlconcat"
+"xmldiff" "xmlelement" "xmlexists" "xmlforest" "xmlisvalid" "xmlparse"
+"xmlpatch" "xmlpi" "xmlquery" "xmlroot" "xmlsequence" "xmlserialize"
+"xmltable" "xmltransform"
 )
+
+     ;; See the table V$RESERVED_WORDS
      ;; Oracle Keywords
      (sql-font-lock-keywords-builder 'font-lock-keyword-face nil
 "abort" "access" "accessed" "account" "activate" "add" "admin"
@@ -1582,52 +1730,120 @@ to add functions and PL/SQL keywords.")
 "varray" "version" "view" "wait" "when" "whenever" "where" "with"
 "without" "wnds" "wnps" "work" "write" "xmldata" "xmlschema" "xmltype"
 )
+
      ;; Oracle Data Types
      (sql-font-lock-keywords-builder 'font-lock-type-face nil
-"bfile" "blob" "byte" "char" "character" "clob" "date" "dec" "decimal"
-"double" "float" "int" "integer" "interval" "long" "national" "nchar"
-"nclob" "number" "numeric" "nvarchar2" "precision" "raw" "real"
-"rowid" "second" "smallint" "time" "timestamp" "urowid" "varchar"
-"varchar2" "varying" "year" "zone"
+"bfile" "binary_double" "binary_float" "blob" "byte" "char" "charbyte"
+"clob" "date" "day" "float" "interval" "local" "long" "longraw"
+"minute" "month" "nchar" "nclob" "number" "nvarchar2" "raw" "rowid" "second"
+"time" "timestamp" "urowid" "varchar2" "with" "year" "zone"
 )
 
      ;; Oracle PL/SQL Attributes
-     (sql-font-lock-keywords-builder 'font-lock-builtin-face '("" . "\\b")
-"%bulk_rowcount" "%found" "%isopen" "%notfound" "%rowcount" "%rowtype"
-"%type"
+     (sql-font-lock-keywords-builder 'font-lock-builtin-face '("%" . "\\b")
+"bulk_exceptions" "bulk_rowcount" "found" "isopen" "notfound"
+"rowcount" "rowtype" "type"
 )
 
      ;; Oracle PL/SQL Functions
      (sql-font-lock-keywords-builder 'font-lock-builtin-face nil
-"extend" "prior"
+"delete" "trim" "extend" "exists" "first" "last" "count" "limit"
+"prior" "next"
+)
+
+     ;; Oracle PL/SQL Reserved words
+     (sql-font-lock-keywords-builder 'font-lock-keyword-face nil
+"all" "alter" "and" "any" "as" "asc" "at" "begin" "between" "by"
+"case" "check" "clusters" "cluster" "colauth" "columns" "compress"
+"connect" "crash" "create" "cursor" "declare" "default" "desc"
+"distinct" "drop" "else" "end" "exception" "exclusive" "fetch" "for"
+"from" "function" "goto" "grant" "group" "having" "identified" "if"
+"in" "index" "indexes" "insert" "intersect" "into" "is" "like" "lock"
+"minus" "mode" "nocompress" "not" "nowait" "null" "of" "on" "option"
+"or" "order" "overlaps" "procedure" "public" "resource" "revoke"
+"select" "share" "size" "sql" "start" "subtype" "tabauth" "table"
+"then" "to" "type" "union" "unique" "update" "values" "view" "views"
+"when" "where" "with"
+
+"true" "false"
+"raise_application_error"
 )
 
      ;; Oracle PL/SQL Keywords
      (sql-font-lock-keywords-builder 'font-lock-keyword-face nil
-"autonomous_transaction" "bulk" "char_base" "collect" "constant"
-"cursor" "declare" "do" "elsif" "exception_init" "execute" "exit"
-"extends" "false" "fetch" "forall" "goto" "hour" "if" "interface"
-"loop" "minute" "number_base" "ocirowid" "opaque" "others" "rowtype"
-"separate" "serially_reusable" "sql" "sqlcode" "sqlerrm" "subtype"
-"the" "timezone_abbr" "timezone_hour" "timezone_minute"
-"timezone_region" "true" "varrying" "while"
+"a" "add" "agent" "aggregate" "array" "attribute" "authid" "avg"
+"bfile_base" "binary" "blob_base" "block" "body" "both" "bound" "bulk"
+"byte" "c" "call" "calling" "cascade" "char" "char_base" "character"
+"charset" "charsetform" "charsetid" "clob_base" "close" "collect"
+"comment" "commit" "committed" "compiled" "constant" "constructor"
+"context" "continue" "convert" "count" "current" "customdatum"
+"dangling" "data" "date" "date_base" "day" "define" "delete"
+"deterministic" "double" "duration" "element" "elsif" "empty" "escape"
+"except" "exceptions" "execute" "exists" "exit" "external" "final"
+"fixed" "float" "forall" "force" "general" "hash" "heap" "hidden"
+"hour" "immediate" "including" "indicator" "indices" "infinite"
+"instantiable" "int" "interface" "interval" "invalidate" "isolation"
+"java" "language" "large" "leading" "length" "level" "library" "like2"
+"like4" "likec" "limit" "limited" "local" "long" "loop" "map" "max"
+"maxlen" "member" "merge" "min" "minute" "mod" "modify" "month"
+"multiset" "name" "nan" "national" "native" "nchar" "new" "nocopy"
+"number_base" "object" "ocicoll" "ocidate" "ocidatetime" "ociduration"
+"ociinterval" "ociloblocator" "ocinumber" "ociraw" "ociref"
+"ocirefcursor" "ocirowid" "ocistring" "ocitype" "old" "only" "opaque"
+"open" "operator" "oracle" "oradata" "organization" "orlany" "orlvary"
+"others" "out" "overriding" "package" "parallel_enable" "parameter"
+"parameters" "parent" "partition" "pascal" "pipe" "pipelined" "pragma"
+"precision" "prior" "private" "raise" "range" "raw" "read" "record"
+"ref" "reference" "relies_on" "rem" "remainder" "rename" "result"
+"result_cache" "return" "returning" "reverse" "rollback" "row"
+"sample" "save" "savepoint" "sb1" "sb2" "sb4" "second" "segment"
+"self" "separate" "sequence" "serializable" "set" "short" "size_t"
+"some" "sparse" "sqlcode" "sqldata" "sqlname" "sqlstate" "standard"
+"static" "stddev" "stored" "string" "struct" "style" "submultiset"
+"subpartition" "substitutable" "sum" "synonym" "tdo" "the" "time"
+"timestamp" "timezone_abbr" "timezone_hour" "timezone_minute"
+"timezone_region" "trailing" "transaction" "transactional" "trusted"
+"ub1" "ub2" "ub4" "under" "unsigned" "untrusted" "use" "using"
+"valist" "value" "variable" "variance" "varray" "varying" "void"
+"while" "work" "wrapped" "write" "year" "zone"
+;; Pragma
+"autonomous_transaction" "exception_init" "inline"
+"restrict_references" "serially_reusable"
 )
 
      ;; Oracle PL/SQL Data Types
      (sql-font-lock-keywords-builder 'font-lock-type-face nil
-"binary_integer" "boolean" "naturaln" "pls_integer" "positive"
-"positiven" "record" "signtype" "string"
+"\"BINARY LARGE OBJECT\"" "\"CHAR LARGE OBJECT\"" "\"CHAR VARYING\""
+"\"CHARACTER LARGE OBJECT\"" "\"CHARACTER VARYING\""
+"\"DOUBLE PRECISION\"" "\"INTERVAL DAY TO SECOND\""
+"\"INTERVAL YEAR TO MONTH\"" "\"LONG RAW\"" "\"NATIONAL CHAR\""
+"\"NATIONAL CHARACTER LARGE OBJECT\"" "\"NATIONAL CHARACTER\""
+"\"NCHAR LARGE OBJECT\"" "\"NCHAR\"" "\"NCLOB\"" "\"NVARCHAR2\""
+"\"TIME WITH TIME ZONE\"" "\"TIMESTAMP WITH LOCAL TIME ZONE\""
+"\"TIMESTAMP WITH TIME ZONE\""
+"bfile" "bfile_base" "binary_double" "binary_float" "binary_integer"
+"blob" "blob_base" "boolean" "char" "character" "char_base" "clob"
+"clob_base" "cursor" "date" "day" "dec" "decimal"
+"dsinterval_unconstrained" "float" "int" "integer" "interval" "local"
+"long" "mlslabel" "month" "natural" "naturaln" "nchar_cs" "number"
+"number_base" "numeric" "pls_integer" "positive" "positiven" "raw"
+"real" "ref" "rowid" "second" "signtype" "simple_double"
+"simple_float" "simple_integer" "smallint" "string" "time" "timestamp"
+"timestamp_ltz_unconstrained" "timestamp_tz_unconstrained"
+"timestamp_unconstrained" "time_tz_unconstrained" "time_unconstrained"
+"to" "urowid" "varchar" "varchar2" "with" "year"
+"yminterval_unconstrained" "zone"
 )
 
      ;; Oracle PL/SQL Exceptions
      (sql-font-lock-keywords-builder 'font-lock-warning-face nil
 "access_into_null" "case_not_found" "collection_is_null"
 "cursor_already_open" "dup_val_on_index" "invalid_cursor"
-"invalid_number" "login_denied" "no_data_found" "not_logged_on"
-"program_error" "rowtype_mismatch" "self_is_null" "storage_error"
-"subscript_beyond_count" "subscript_outside_limit" "sys_invalid_rowid"
-"timeout_on_resource" "too_many_rows" "value_error" "zero_divide"
-"exception" "notfound"
+"invalid_number" "login_denied" "no_data_found" "no_data_needed"
+"not_logged_on" "program_error" "rowtype_mismatch" "self_is_null"
+"storage_error" "subscript_beyond_count" "subscript_outside_limit"
+"sys_invalid_rowid" "timeout_on_resource" "too_many_rows"
+"value_error" "zero_divide"
 )))
 
   "Oracle SQL keywords used by font-lock.
@@ -2296,10 +2512,7 @@ also be configured."
 
   (let
       ;; Get the product-specific syntax-alist.
-      ((syntax-alist
-        (append
-         (sql-get-product-feature sql-product :syntax-alist)
-         '((?_ . "w") (?. . "w")))))
+      ((syntax-alist (sql-product-font-lock-syntax-alist)))
 
     ;; Get the product-specific keywords.
     (set (make-local-variable 'sql-mode-font-lock-keywords)
@@ -2388,9 +2601,30 @@ adds a fontification pattern to fontify identifiers ending in
 
 ;;; Functions to switch highlighting
 
+(defun sql-product-syntax-table ()
+  (let ((table (copy-syntax-table sql-mode-syntax-table)))
+    (mapc (lambda (entry)
+            (modify-syntax-entry (car entry) (cdr entry) table))
+          (sql-get-product-feature sql-product :syntax-alist))
+    table))
+
+(defun sql-product-font-lock-syntax-alist ()
+  (append
+   ;; Change all symbol character to word characters
+   (mapcar
+    (lambda (entry) (if (string= (substring (cdr entry) 0 1) "_")
+                        (cons (car entry)
+                              (concat "w" (substring (cdr entry) 1)))
+                      entry))
+    (sql-get-product-feature sql-product :syntax-alist))
+   '((?_ . "w"))))
+
 (defun sql-highlight-product ()
   "Turn on the font highlighting for the SQL product selected."
   (when (derived-mode-p 'sql-mode)
+    ;; Enhance the syntax table for the product
+    (set-syntax-table (sql-product-syntax-table))
+
     ;; Setup font-lock
     (sql-product-font-lock nil t)
 
@@ -2418,11 +2652,77 @@ adds a fontification pattern to fontify identifiers ending in
     ;; comint-line-beginning-position is defined in Emacs 21
     (defun comint-line-beginning-position ()
       "Return the buffer position of the beginning of the line, after any prompt.
-The prompt is assumed to be any text at the beginning of the line matching
-the regular expression `comint-prompt-regexp', a buffer local variable."
+The prompt is assumed to be any text at the beginning of the line
+matching the regular expression `comint-prompt-regexp', a buffer
+local variable."
       (save-excursion (comint-bol nil) (point))))
 
-
+;;; Motion Functions
+
+(defun sql-statement-regexp (prod)
+  (let* ((ansi-stmt (sql-get-product-feature 'ansi :statement))
+         (prod-stmt (sql-get-product-feature prod  :statement)))
+    (concat "^\\<"
+            (if prod-stmt
+                ansi-stmt
+              (concat "\\(" ansi-stmt "\\|" prod-stmt "\\)"))
+            "\\>")))
+
+(defun sql-beginning-of-statement (arg)
+  "Moves the cursor to the beginning of the current SQL statement."
+  (interactive "p")
+
+  (let ((here (point))
+        (regexp (sql-statement-regexp sql-product))
+        last next)
+
+    ;; Go to the end of the statement before the start we desire
+    (setq last (or (sql-end-of-statement (- arg))
+                   (point-min)))
+    ;; And find the end after that
+    (setq next (or (sql-end-of-statement 1)
+                   (point-max)))
+
+    ;; Our start must be between them
+    (goto-char last)
+    ;; Find an beginning-of-stmt that's not in a comment
+    (while (and (re-search-forward regexp next t 1)
+                (nth 7 (syntax-ppss)))
+      (goto-char (match-end 0)))
+    (goto-char
+     (if (match-data)
+        (match-beginning 0)
+       last))
+    (beginning-of-line)
+    ;; If we didn't move, try again
+    (when (= here (point))
+      (sql-beginning-of-statement (* 2 (sql-signum arg))))))
+
+(defun sql-end-of-statement (arg)
+  "Moves the cursor to the end of the current SQL statement."
+  (interactive "p")
+  (let ((term (sql-get-product-feature sql-product :terminator))
+        (re-search (if (> 0 arg) 're-search-backward 're-search-forward))
+        (here (point))
+        (n 0))
+    (when (consp term)
+      (setq term (car term)))
+    ;; Iterate until we've moved the desired number of stmt ends
+    (while (not (= (sql-signum arg) 0))
+      ;; if we're looking at the terminator, jump by 2
+      (if (or (and (> 0 arg) (looking-back term))
+              (and (< 0 arg) (looking-at term)))
+          (setq n 2)
+        (setq n 1))
+      ;; If we found another end-of-stmt
+      (if (not (apply re-search term nil t n nil))
+          (setq arg 0)
+        ;; count it if we're not in a comment
+        (unless (nth 7 (syntax-ppss))
+          (setq arg (- arg (sql-signum arg))))))
+    (goto-char (if (match-data)
+                   (match-end 0)
+                 here))))
 
 ;;; Small functions
 
@@ -2456,7 +2756,7 @@ the regular expression `comint-prompt-regexp', a buffer local variable."
 (defun sql-help-list-products (indent freep)
   "Generate listing of products available for use under SQLi.
 
-List products with :free-softare attribute set to FREEP.  Indent
+List products with :free-software attribute set to FREEP.  Indent
 each line with INDENT."
 
   (let (sqli-func doc)
@@ -2649,7 +2949,7 @@ function like this: (sql-get-login 'user 'password 'database)."
                                 nil (append '(:number t) plist)))))))
    what))
 
-(defun sql-find-sqli-buffer (&optional product)
+(defun sql-find-sqli-buffer (&optional product connection)
   "Returns the name of the current default SQLi buffer or nil.
 In order to qualify, the SQLi buffer must be alive, be in
 `sql-interactive-mode' and have a process."
@@ -2657,16 +2957,16 @@ In order to qualify, the SQLi buffer must be alive, be in
         (prod (or product sql-product)))
     (or
      ;; Current sql-buffer, if there is one.
-     (and (sql-buffer-live-p buf prod)
+     (and (sql-buffer-live-p buf prod connection)
           buf)
      ;; Global sql-buffer
      (and (setq buf (default-value 'sql-buffer))
-          (sql-buffer-live-p buf prod)
+          (sql-buffer-live-p buf prod connection)
           buf)
      ;; Look thru each buffer
      (car (apply 'append
                  (mapcar (lambda (b)
-                           (and (sql-buffer-live-p b prod)
+                           (and (sql-buffer-live-p b prod connection)
                                 (list (buffer-name b))))
                          (buffer-list)))))))
 
@@ -2722,7 +3022,8 @@ If you call it from anywhere else, it sets the global copy of
 This is the buffer SQL strings are sent to.  It is stored in the
 variable `sql-buffer'.  See `sql-help' on how to create such a buffer."
   (interactive)
-  (if (null (buffer-live-p (get-buffer sql-buffer)))
+  (if (or (null sql-buffer)
+          (null (buffer-live-p (get-buffer sql-buffer))))
       (message "%s has no SQLi buffer set." (buffer-name (current-buffer)))
     (if (null (get-buffer-process sql-buffer))
         (message "Buffer %s has no process." sql-buffer)
@@ -2932,37 +3233,58 @@ Allows the suppression of continuation prompts.")
 
 ;;; Strip out continuation prompts
 
+(defvar sql-preoutput-hold nil)
+
 (defun sql-interactive-remove-continuation-prompt (oline)
   "Strip out continuation prompts out of the OLINE.
 
 Added to the `comint-preoutput-filter-functions' hook in a SQL
-interactive buffer.  If `sql-outut-newline-count' is greater than
+interactive buffer.  If `sql-output-newline-count' is greater than
 zero, then an output line matching the continuation prompt is filtered
-out.  If the count is one, then the prompt is replaced with a newline
-to force the output from the query to appear on a new line."
-  (if (and sql-prompt-cont-regexp
-           sql-output-newline-count
-           (numberp sql-output-newline-count)
-           (>= sql-output-newline-count 1))
-      (progn
-        (while (and oline
-                    sql-output-newline-count
-                    (> sql-output-newline-count 0)
-                    (string-match sql-prompt-cont-regexp oline))
-
-          (setq oline
-                (replace-match (if (and
-                                    (= 1 sql-output-newline-count)
-                                    sql-output-by-send)
-                                   "\n" "")
-                               nil nil oline)
-                sql-output-newline-count
-                (1- sql-output-newline-count)))
-        (if (= sql-output-newline-count 0)
-            (setq sql-output-newline-count nil))
-        (setq sql-output-by-send nil))
-    (setq sql-output-newline-count nil))
-  oline)
+out.  If the count is zero, then a newline is inserted into the output
+to force the output from the query to appear on a new line.
+
+The complication to this filter is that the continuation prompts
+may arrive in multiple chunks.  If they do, then the function
+saves any unfiltered output in a buffer and prepends that buffer
+to the next chunk to properly match the broken-up prompt.
+
+If the filter gets confused, it should reset and stop filtering
+to avoid deleting non-prompt output."
+
+  (let (did-filter)
+    (setq oline (concat (or sql-preoutput-hold "") oline)
+          sql-preoutput-hold nil)
+
+    (if (and comint-prompt-regexp
+             (integerp sql-output-newline-count)
+             (>= sql-output-newline-count 1))
+        (progn
+          (while (and (not (string= oline ""))
+                      (> sql-output-newline-count 0)
+                      (string-match comint-prompt-regexp oline)
+                      (= (match-beginning 0) 0))
+
+            (setq oline (replace-match "" nil nil oline)
+                  sql-output-newline-count (1- sql-output-newline-count)
+                  did-filter t))
+
+          (if (= sql-output-newline-count 0)
+              (setq sql-output-newline-count nil
+                    oline (concat "\n" oline)
+                    sql-output-by-send nil)
+
+            (setq sql-preoutput-hold oline
+                  oline ""))
+
+          (unless did-filter
+            (setq oline (or sql-preoutput-hold "")
+                  sql-preoutput-hold nil
+                  sql-output-newline-count nil)))
+
+      (setq sql-output-newline-count nil))
+
+    oline))
 
 ;;; Sending the region to the SQLi buffer.
 
@@ -3066,16 +3388,35 @@ If given the optional parameter VALUE, sets
 
 ;;; Redirect output functions
 
-(defun sql-redirect (command combuf &optional outbuf save-prior)
+(defvar sql-debug-redirect nil
+  "If non-nil, display messages related to the use of redirection.")
+
+(defun sql-str-literal (s)
+  (concat "'" (replace-regexp-in-string "[']" "''" s) "'"))
+
+(defun sql-redirect (sqlbuf command &optional outbuf save-prior)
   "Execute the SQL command and send output to OUTBUF.
 
-COMBUF must be an active SQL interactive buffer.  OUTBUF may be
+SQLBUF must be an active SQL interactive buffer.  OUTBUF may be
 an existing buffer, or the name of a non-existing buffer.  If
 omitted the output is sent to a temporary buffer which will be
 killed after the command completes.  COMMAND should be a string
-of commands accepted by the SQLi program."
-
-  (with-current-buffer combuf
+of commands accepted by the SQLi program.  COMMAND may also be a
+list of SQLi command strings."
+
+  (let* ((visible (and outbuf
+                       (not (string= " " (substring outbuf 0 1))))))
+    (when visible
+      (message "Executing SQL command..."))
+    (if (consp command)
+        (mapc (lambda (c) (sql-redirect-one sqlbuf c outbuf save-prior))
+              command)
+      (sql-redirect-one sqlbuf command outbuf save-prior))
+    (when visible
+      (message "Executing SQL command...done"))))
+
+(defun sql-redirect-one (sqlbuf command outbuf save-prior)
+  (with-current-buffer sqlbuf
     (let ((buf  (get-buffer-create (or outbuf " *SQL-Redirect*")))
           (proc (get-buffer-process (current-buffer)))
           (comint-prompt-regexp (sql-get-product-feature sql-product
@@ -3090,12 +3431,13 @@ of commands accepted by the SQLi program."
           (insert "\n"))
         (setq start (point)))
 
+      (when sql-debug-redirect
+        (message ">>SQL> %S" command))
+
       ;; Run the command
-      (message "Executing SQL command...")
       (comint-redirect-send-command-to-process command buf proc nil t)
       (while (null comint-redirect-completed)
         (accept-process-output nil 1))
-      (message "Executing SQL command...done")
 
       ;; Clean up the output results
       (with-current-buffer buf
@@ -3107,12 +3449,16 @@ of commands accepted by the SQLi program."
         (goto-char start)
         (when (looking-at (concat "^" (regexp-quote command) "[\\n]"))
           (delete-region (match-beginning 0) (match-end 0)))
+        ;; Remove Ctrl-Ms
+        (goto-char start)
+        (while (re-search-forward "\r+$" nil t)
+          (replace-match "" t t))
         (goto-char start)))))
 
-(defun sql-redirect-value (command combuf regexp &optional regexp-groups)
+(defun sql-redirect-value (sqlbuf command regexp &optional regexp-groups)
   "Execute the SQL command and return part of result.
 
-COMBUF must be an active SQL interactive buffer.  COMMAND should
+SQLBUF must be an active SQL interactive buffer.  COMMAND should
 be a string of commands accepted by the SQLi program.  From the
 output, the REGEXP is repeatedly matched and the list of
 REGEXP-GROUPS submatches is returned.  This behaves much like
@@ -3122,18 +3468,19 @@ for each match."
 
   (let ((outbuf " *SQL-Redirect-values*")
         (results nil))
-    (sql-redirect command combuf outbuf nil)
+    (sql-redirect sqlbuf command outbuf nil)
     (with-current-buffer outbuf
       (while (re-search-forward regexp nil t)
         (push
          (cond
           ;; no groups-return all of them
           ((null regexp-groups)
-           (let ((i 1)
+           (let ((i (/ (length (match-data)) 2))
                  (r nil))
-             (while (match-beginning i)
+             (while (> i 0)
+               (setq i (1- i))
                (push (match-string i) r))
-             (nreverse r)))
+             r))
           ;; one group specified
           ((numberp regexp-groups)
            (match-string regexp-groups))
@@ -3152,10 +3499,14 @@ for each match."
            (error "sql-redirect-value: unknown REGEXP-GROUPS value - %s"
                   regexp-groups)))
          results)))
-      (nreverse results)))
 
-(defun sql-execute (sqlbuf outbuf command arg)
-  "Executes a command in a SQL interacive buffer and captures the output.
+    (when sql-debug-redirect
+      (message ">>SQL> = %S" (reverse results)))
+
+    (nreverse results)))
+
+(defun sql-execute (sqlbuf outbuf command enhanced arg)
+  "Executes a command in a SQL interactive buffer and captures the output.
 
 The commands are run in SQLBUF and the output saved in OUTBUF.
 COMMAND must be a string, a function or a list of such elements.
@@ -3168,9 +3519,9 @@ buffer is popped into a view window. "
    (lambda (c)
      (cond
       ((stringp c)
-       (sql-redirect (if arg (format c arg) c) sqlbuf outbuf) t)
+       (sql-redirect sqlbuf (if arg (format c arg) c) outbuf) t)
       ((functionp c)
-       (apply c sqlbuf outbuf arg))
+       (apply c sqlbuf outbuf enhanced arg nil))
       (t (error "Unknown sql-execute item %s" c))))
    (if (consp command) command (cons command nil)))
 
@@ -3197,14 +3548,92 @@ buffer is popped into a view window. "
       (setq command (if enhanced
                         (cdr command)
                       (car command))))
-    (sql-execute sqlbuf outbuf command arg)))
+    (sql-execute sqlbuf outbuf command enhanced arg)))
+
+(defvar sql-completion-object nil
+  "A list of database objects used for completion.
+
+The list is maintained in SQL interactive buffers.")
+
+(defvar sql-completion-column nil
+  "A list of column names used for completion.
+
+The list is maintained in SQL interactive buffers.")
+
+(defun sql-build-completions-1 (schema completion-list feature)
+  "Generate a list of objects in the database for use as completions."
+  (let ((f (sql-get-product-feature sql-product feature)))
+    (when f
+      (set completion-list
+            (let (cl)
+              (dolist (e (append (symbol-value completion-list)
+                                 (apply f (current-buffer) (cons schema nil)))
+                         cl)
+                (unless (member e cl) (setq cl (cons e cl))))
+              (sort cl (function string<)))))))
+
+(defun sql-build-completions (schema)
+  "Generate a list of names in the database for use as completions."
+  (sql-build-completions-1 schema 'sql-completion-object :completion-object)
+  (sql-build-completions-1 schema 'sql-completion-column :completion-column))
+
+(defvar sql-completion-sqlbuf nil)
+
+(defun sql-try-completion (string collection &optional predicate)
+  (when sql-completion-sqlbuf
+      (with-current-buffer sql-completion-sqlbuf
+        (let ((schema (and (string-match "\\`\\(\\sw\\(:?\\sw\\|\\s_\\)*\\)[.]" string)
+                           (downcase (match-string 1 string)))))
+
+          ;; If we haven't loaded any object name yet, load local schema
+          (unless sql-completion-object
+            (sql-build-completions nil))
+
+          ;; If they want another schema, load it if we haven't yet
+          (when schema
+            (let ((schema-dot (concat schema "."))
+                  (schema-len (1+ (length schema)))
+                  (names sql-completion-object)
+                  has-schema)
+
+              (while (and (not has-schema) names)
+                (setq has-schema (and
+                                  (>= (length (car names)) schema-len)
+                                  (string= schema-dot
+                                           (downcase (substring (car names) 
+                                                                0 schema-len))))
+                      names (cdr names)))
+              (unless has-schema
+                (sql-build-completions schema)))))
+        
+        ;; Try to find the completion
+        (cond
+         ((not predicate)
+          (try-completion string sql-completion-object))
+         ((eq predicate t)
+          (all-completions string sql-completion-object))
+         ((eq predicate 'lambda)
+          (test-completion string sql-completion-object))
+         ((eq (car predicate) 'boundaries)
+          (completion-boundaries string sql-completion-object nil (cdr predicate)))))))
 
 (defun sql-read-table-name (prompt)
   "Read the name of a database table."
-  ;; TODO: Fetch table/view names from database and provide completion.
-  ;; Also implement thing-at-point if the buffer has valid names in it
-  ;; (i.e. sql-mode, sql-interactive-mode, or sql-list-all buffers)
-  (read-from-minibuffer prompt))
+  (let* ((tname
+          (and (buffer-local-value 'sql-contains-names (current-buffer))
+               (thing-at-point-looking-at
+                (concat "\\_<\\sw\\(:?\\sw\\|\\s_\\)*"
+                        "\\(?:[.]+\\sw\\(?:\\sw\\|\\s_\\)*\\)*\\_>"))
+               (buffer-substring-no-properties (match-beginning 0)
+                                               (match-end 0))))
+         (sql-completion-sqlbuf (sql-find-sqli-buffer))
+         (product (with-current-buffer sql-completion-sqlbuf sql-product))
+         (completion-ignore-case t))
+
+    (if (sql-get-product-feature product :completion-object)
+        (completing-read prompt (function sql-try-completion)
+                         nil nil tname)
+      (read-from-minibuffer prompt tname))))
 
 (defun sql-list-all (&optional enhanced)
   "List all database objects."
@@ -3212,7 +3641,11 @@ buffer is popped into a view window. "
   (let ((sqlbuf (sql-find-sqli-buffer)))
     (unless sqlbuf
       (error "No SQL interactive buffer found"))
-    (sql-execute-feature sqlbuf "*List All*" :list-all enhanced nil)))
+    (sql-execute-feature sqlbuf "*List All*" :list-all enhanced nil)
+    (with-current-buffer sqlbuf
+      ;; Contains the name of database objects
+      (set (make-local-variable 'sql-contains-names) t)
+      (set (make-local-variable 'sql-buffer) sqlbuf))))
 
 (defun sql-list-table (name &optional enhanced)
   "List the details of a database table. "
@@ -3226,7 +3659,6 @@ buffer is popped into a view window. "
       (error "No table name specified"))
     (sql-execute-feature sqlbuf (format "*List %s*" name)
                          :list-table enhanced name)))
-
 
 
 ;;; SQL mode -- uses SQL interactive mode
@@ -3277,6 +3709,8 @@ you must tell Emacs.  Here's how to do that in your `~/.emacs' file:
   (set (make-local-variable 'paragraph-start) "[\n\f]")
   ;; Abbrevs
   (setq abbrev-all-caps 1)
+  ;; Contains the name of database objects
+  (set (make-local-variable 'sql-contains-names) t)
   ;; Catch changes to sql-product and highlight accordingly
   (add-hook 'hack-local-variables-hook 'sql-highlight-product t t))
 
@@ -3362,7 +3796,7 @@ you entered, right above the output it created.
            sql-product))
 
   ;; Setup the mode.
-  (setq major-mode 'sql-interactive-mode) ;FIXME: Use define-derived-mode.
+  (setq major-mode 'sql-interactive-mode)
   (setq mode-name
         (concat "SQLi[" (or (sql-get-product-feature sql-product :name)
                             (symbol-name sql-product)) "]"))
@@ -3385,9 +3819,18 @@ you entered, right above the output it created.
   (setq abbrev-all-caps 1)
   ;; Exiting the process will call sql-stop.
   (set-process-sentinel (get-buffer-process (current-buffer)) 'sql-stop)
-  ;; Save the connection name
-  (make-local-variable 'sql-connection)
-  ;; Create a usefull name for renaming this buffer later.
+  ;; Save the connection and login params
+  (set (make-local-variable 'sql-user)       sql-user)
+  (set (make-local-variable 'sql-database)   sql-database)
+  (set (make-local-variable 'sql-server)     sql-server)
+  (set (make-local-variable 'sql-port)       sql-port)
+  (set (make-local-variable 'sql-connection) sql-connection)
+  ;; Contains the name of database objects
+  (set (make-local-variable 'sql-contains-names) t)
+  ;; Keep track of existing object names
+  (set (make-local-variable 'sql-completion-object) nil)
+  (set (make-local-variable 'sql-completion-column) nil)
+  ;; Create a useful name for renaming this buffer later.
   (set (make-local-variable 'sql-alternate-buffer-name)
        (sql-make-alternate-buffer-name))
   ;; User stuff.  Initialize before the hook.
@@ -3398,6 +3841,7 @@ you entered, right above the output it created.
   (set (make-local-variable 'sql-prompt-cont-regexp)
        (sql-get-product-feature sql-product :prompt-cont-regexp))
   (make-local-variable 'sql-output-newline-count)
+  (make-local-variable 'sql-preoutput-hold)
   (make-local-variable 'sql-output-by-send)
   (add-hook 'comint-preoutput-filter-functions
             'sql-interactive-remove-continuation-prompt nil t)
@@ -3450,7 +3894,7 @@ Sentinels will always get the two parameters PROCESS and EVENT."
                      nil t initial 'sql-connection-history default)))
 
 ;;;###autoload
-(defun sql-connect (connection)
+(defun sql-connect (connection &optional new-name)
   "Connect to an interactive session using CONNECTION settings.
 
 See `sql-connection-alist' to see how to define connections and
@@ -3462,7 +3906,8 @@ is specified in the connection settings."
   ;; Prompt for the connection from those defined in the alist
   (interactive
    (if sql-connection-alist
-       (list (sql-read-connection "Connection: " nil '(nil)))
+       (list (sql-read-connection "Connection: " nil '(nil))
+             current-prefix-arg)
      nil))
 
   ;; Are there connections defined
@@ -3500,14 +3945,15 @@ is specified in the connection settings."
                                            (unless (member token set-params)
                                                     (if plist
                                                         (cons token plist)
-                                                      token)))))
-                          ;; Remember the connection
-                          (sql-connection connection))
+                                                      token))))))
 
                        ;; Set the remaining parameters and start the
                        ;; interactive session
-                       (eval `(let ((,param-var ',rem-params))
-                                (sql-product-interactive sql-product)))))
+                       (eval `(let ((sql-connection ,connection)
+                                     (,param-var ',rem-params))
+                                (sql-product-interactive sql-product 
+                                                         new-name)))))
+
             (message "SQL Connection <%s> does not exist" connection)
             nil)))
     (message "No SQL Connections defined")
@@ -3521,39 +3967,51 @@ optionally is saved to the user's init file."
 
   (interactive "sNew connection name: ")
 
-  (if sql-connection
-      (message "This session was started by a connection; it's already been saved.")
-
-    (let ((login (sql-get-product-feature sql-product :sqli-login))
-          (alist sql-connection-alist)
-          connect)
-
-      ;; Remove the existing connection if the user says so
-      (when (and (assoc name alist)
-                 (yes-or-no-p (format "Replace connection definition <%s>? " name)))
-        (setq alist (assq-delete-all name alist)))
-
-      ;; Add the new connection if it doesn't exist
-      (if (assoc name alist)
-          (message "Connection <%s> already exists" name)
-        (setq connect
-              (append (list name)
-                      (sql-for-each-login
-                       `(product ,@login)
-                       (lambda (token _plist)
-                         (cond
-                          ((eq token 'product)  `(sql-product  ',sql-product))
-                          ((eq token 'user)     `(sql-user     ,sql-user))
-                          ((eq token 'database) `(sql-database ,sql-database))
-                          ((eq token 'server)   `(sql-server   ,sql-server))
-                          ((eq token 'port)     `(sql-port     ,sql-port)))))))
-
-        (setq alist (append alist (list connect)))
-
-        ;; confirm whether we want to save the connections
-        (if (yes-or-no-p "Save the connections for future sessions? ")
-            (customize-save-variable 'sql-connection-alist alist)
-          (customize-set-variable 'sql-connection-alist alist))))))
+  (unless (derived-mode-p 'sql-interactive-mode)
+    (error "Not in a SQL interactive mode!"))
+
+  ;; Capture the buffer local settings
+  (let* ((buf        (current-buffer))
+         (connection (buffer-local-value 'sql-connection buf))
+         (product    (buffer-local-value 'sql-product    buf))
+         (user       (buffer-local-value 'sql-user       buf))
+         (database   (buffer-local-value 'sql-database   buf))
+         (server     (buffer-local-value 'sql-server     buf))
+         (port       (buffer-local-value 'sql-port       buf)))
+
+    (if connection
+        (message "This session was started by a connection; it's already been saved.")
+      
+      (let ((login (sql-get-product-feature product :sqli-login))
+            (alist sql-connection-alist)
+            connect)
+        
+        ;; Remove the existing connection if the user says so
+        (when (and (assoc name alist)
+                   (yes-or-no-p (format "Replace connection definition <%s>? " name)))
+          (setq alist (assq-delete-all name alist)))
+        
+        ;; Add the new connection if it doesn't exist
+        (if (assoc name alist)
+            (message "Connection <%s> already exists" name)
+          (setq connect
+                (append (list name)
+                        (sql-for-each-login
+                         `(product ,@login)
+                         (lambda (token _plist)
+                           (cond
+                            ((eq token 'product)  `(sql-product  ',product))
+                            ((eq token 'user)     `(sql-user     ,user))
+                            ((eq token 'database) `(sql-database ,database))
+                            ((eq token 'server)   `(sql-server   ,server))
+                            ((eq token 'port)     `(sql-port     ,port)))))))
+
+          (setq alist (append alist (list connect)))
+
+          ;; confirm whether we want to save the connections
+          (if (yes-or-no-p "Save the connections for future sessions? ")
+              (customize-save-variable 'sql-connection-alist alist)
+            (customize-set-variable 'sql-connection-alist alist)))))))
 
 (defun sql-connection-menu-filter (tail)
   "Generates menu entries for using each connection."
@@ -3561,7 +4019,10 @@ optionally is saved to the user's init file."
    (mapcar
     (lambda (conn)
       (vector
-       (format "Connection <%s>" (car conn))
+       (format "Connection <%s>\t%s" (car conn)
+               (let ((sql-user "") (sql-database "")
+                     (sql-server "") (sql-port 0))
+                 (eval `(let ,(cdr conn) (sql-make-alternate-buffer-name)))))
        (list 'sql-connect (car conn))
        t))
     sql-connection-alist)
@@ -3599,10 +4060,10 @@ the call to \\[sql-product-interactive] with
   ;; Get the value of product that we need
   (setq product
         (cond
-         ((and product                  ; Product specified
-               (symbolp product)) product)
          ((= (prefix-numeric-value product) 4) ; C-u, prompt for product
           (sql-read-product "SQL product: " sql-product))
+         ((and product                  ; Product specified
+               (symbolp product)) product)
          (t sql-product)))              ; Default to sql-product
 
   ;; If we have a product and it has a interactive mode
@@ -3610,7 +4071,7 @@ the call to \\[sql-product-interactive] with
       (when (sql-get-product-feature product :sqli-comint-func)
         ;; If no new name specified, try to pop to an active SQL
         ;; interactive for the same product
-        (let ((buf (sql-find-sqli-buffer product)))
+        (let ((buf (sql-find-sqli-buffer product sql-connection)))
           (if (and (not new-name) buf)
               (pop-to-buffer buf)
 
@@ -3629,23 +4090,24 @@ the call to \\[sql-product-interactive] with
                        (sql-get-product-feature product :sqli-options))
 
               ;; Set SQLi mode.
-              (setq new-sqli-buffer (current-buffer))
               (let ((sql-interactive-product product))
                 (sql-interactive-mode))
 
               ;; Set the new buffer name
+              (setq new-sqli-buffer (current-buffer))
               (when new-name
                 (sql-rename-buffer new-name))
-
-              ;; Set `sql-buffer' in the new buffer and the start buffer
               (setq sql-buffer (buffer-name new-sqli-buffer))
+
+              ;; Set `sql-buffer' in the start buffer
               (with-current-buffer start-buffer
-                (setq sql-buffer (buffer-name new-sqli-buffer))
-                (run-hooks 'sql-set-sqli-hook))
+                (when (derived-mode-p 'sql-mode)
+                  (setq sql-buffer (buffer-name new-sqli-buffer))
+                  (run-hooks 'sql-set-sqli-hook)))
 
               ;; All done.
               (message "Login...done")
-              (pop-to-buffer sql-buffer)))))
+              (pop-to-buffer new-sqli-buffer)))))
     (message "No default SQL product defined.  Set `sql-product'.")))
 
 (defun sql-comint (product params)
@@ -3720,6 +4182,157 @@ The default comes from `process-coding-system-alist' and
       (setq parameter options))
     (sql-comint product parameter)))
 
+(defun sql-oracle-save-settings (sqlbuf)
+  "Saves most SQL*Plus settings so they may be reset by \\[sql-redirect]."
+  ;; Note: does not capture the following settings:
+  ;;
+  ;; APPINFO
+  ;; BTITLE
+  ;; COMPATIBILITY
+  ;; COPYTYPECHECK
+  ;; MARKUP
+  ;; RELEASE
+  ;; REPFOOTER
+  ;; REPHEADER
+  ;; SQLPLUSCOMPATIBILITY
+  ;; TTITLE
+  ;; USER
+  ;;
+
+  (append
+  ;; (apply 'concat (append
+  ;;  '("SET")
+
+   ;; option value...
+   (sql-redirect-value
+    sqlbuf
+    (concat "SHOW ARRAYSIZE AUTOCOMMIT AUTOPRINT AUTORECOVERY AUTOTRACE"
+            " CMDSEP COLSEP COPYCOMMIT DESCRIBE ECHO EDITFILE EMBEDDED"
+            " ESCAPE FLAGGER FLUSH HEADING INSTANCE LINESIZE LNO LOBOFFSET"
+            " LOGSOURCE LONG LONGCHUNKSIZE NEWPAGE NULL NUMFORMAT NUMWIDTH"
+            " PAGESIZE PAUSE PNO RECSEP SERVEROUTPUT SHIFTINOUT SHOWMODE"
+            " SPOOL SQLBLANKLINES SQLCASE SQLCODE SQLCONTINUE SQLNUMBER"
+            " SQLPROMPT SUFFIX TAB TERMOUT TIMING TRIMOUT TRIMSPOOL VERIFY")
+    "^.+$"
+    "SET \\&")
+
+   ;; option "c" (hex xx)
+   (sql-redirect-value
+    sqlbuf
+    (concat "SHOW BLOCKTERMINATOR CONCAT DEFINE SQLPREFIX SQLTERMINATOR"
+            " UNDERLINE HEADSEP RECSEPCHAR")
+    "^\\(.+\\) (hex ..)$"
+    "SET \\1")
+
+   ;; FEDDBACK ON for 99 or more rows
+   ;; feedback OFF
+   (sql-redirect-value
+    sqlbuf
+    "SHOW FEEDBACK"
+    "^\\(?:FEEDBACK ON for \\([[:digit:]]+\\) or more rows\\|feedback \\(OFF\\)\\)"
+    "SET FEEDBACK \\1\\2")
+
+   ;; wrap : lines will be wrapped
+   ;; wrap : lines will be truncated
+   (list (concat "SET WRAP "
+                 (if (string=
+                      (car (sql-redirect-value
+                            sqlbuf
+                            "SHOW WRAP"
+                            "^wrap : lines will be \\(wrapped\\|truncated\\)" 1))
+                      "wrapped")
+                     "ON" "OFF")))))
+
+(defun sql-oracle-restore-settings (sqlbuf saved-settings)
+  "Restore the SQL*Plus settings in SAVED-SETTINGS."
+
+  ;; Remove any settings that haven't changed
+  (mapc
+   (lambda (one-cur-setting)
+     (setq saved-settings (delete one-cur-setting saved-settings)))
+   (sql-oracle-save-settings sqlbuf))
+
+  ;; Restore the changed settings
+  (sql-redirect sqlbuf saved-settings))
+
+(defun sql-oracle-list-all (sqlbuf outbuf enhanced table-name)
+  ;; Query from USER_OBJECTS or ALL_OBJECTS
+  (let ((settings (sql-oracle-save-settings sqlbuf))
+        (simple-sql
+         (concat
+          "SELECT INITCAP(x.object_type) AS SQL_EL_TYPE "
+          ", x.object_name AS SQL_EL_NAME "
+          "FROM user_objects                    x "
+          "WHERE x.object_type NOT LIKE '%% BODY' "
+          "ORDER BY 2, 1;"))
+        (enhanced-sql
+         (concat
+          "SELECT INITCAP(x.object_type) AS SQL_EL_TYPE "
+          ", x.owner ||'.'|| x.object_name AS SQL_EL_NAME "
+          "FROM all_objects x "
+          "WHERE x.object_type NOT LIKE '%% BODY' "
+          "AND x.owner <> 'SYS' "
+          "ORDER BY 2, 1;")))
+
+    (sql-redirect sqlbuf
+                  (concat "SET LINESIZE 80 PAGESIZE 50000 TRIMOUT ON"
+                          " TAB OFF TIMING OFF FEEDBACK OFF"))
+
+    (sql-redirect sqlbuf
+                  (list "COLUMN SQL_EL_TYPE  HEADING \"Type\" FORMAT A19"
+                        "COLUMN SQL_EL_NAME  HEADING \"Name\""
+                        (format "COLUMN SQL_EL_NAME  FORMAT A%d"
+                                (if enhanced 60 35))))
+
+    (sql-redirect sqlbuf
+                  (if enhanced enhanced-sql simple-sql)
+                  outbuf)
+
+    (sql-redirect sqlbuf
+                  '("COLUMN SQL_EL_NAME CLEAR"
+                    "COLUMN SQL_EL_TYPE CLEAR"))
+
+    (sql-oracle-restore-settings sqlbuf settings)))
+
+(defun sql-oracle-list-table (sqlbuf outbuf enhanced table-name)
+  "Implements :list-table under Oracle."
+  (let ((settings (sql-oracle-save-settings sqlbuf)))
+
+    (sql-redirect sqlbuf
+                  (format
+                   (concat "SET LINESIZE %d PAGESIZE 50000"
+                           " DESCRIBE DEPTH 1 LINENUM OFF INDENT ON")
+                   (max 65 (min 120 (window-width)))))
+
+    (sql-redirect sqlbuf (format "DESCRIBE %s" table-name)
+                  outbuf)
+
+    (sql-oracle-restore-settings sqlbuf settings)))
+
+(defcustom sql-oracle-completion-types '("FUNCTION" "PACKAGE" "PROCEDURE"
+                                         "SEQUENCE" "SYNONYM" "TABLE" "TRIGGER"
+                                         "TYPE" "VIEW")
+  "List of object types to include for completion under Oracle.
+
+See the distinct values in ALL_OBJECTS.OBJECT_TYPE for possible values."
+  :version "24.1"
+  :type '(repeat string)
+  :group 'SQL)
+
+(defun sql-oracle-completion-object (sqlbuf schema)
+  (sql-redirect-value
+   sqlbuf
+   (concat
+    "SELECT CHR(1)||"
+    (if schema
+        (format "owner||'.'||object_name AS o FROM all_objects WHERE owner = %s AND "
+                (sql-str-literal (upcase schema)))
+      "object_name AS o FROM user_objects WHERE ")
+    "temporary = 'N' AND generated = 'N' AND secondary = 'N' AND "
+    "object_type IN ("
+    (mapconcat (function sql-str-literal) sql-oracle-completion-types ",")
+    ");")
+   "^[\001]\\(.+\\)$" 1))
 
 
 ;;;###autoload
@@ -3858,6 +4471,9 @@ The default comes from `process-coding-system-alist' and
     (setq params (append options params))
     (sql-comint product params)))
 
+(defun sql-sqlite-completion-object (sqlbuf schema)
+  (sql-redirect-value sqlbuf ".tables" "\\sw\\(?:\\sw\\|\\s_\\)*" 0))
+
 
 
 ;;;###autoload
@@ -4112,6 +4728,33 @@ Try to set `comint-output-filter-functions' like this:
         (setq params (append (list "-p" sql-port) params)))
     (sql-comint product params)))
 
+(defun sql-postgres-completion-object (sqlbuf schema)
+  (let (cl re fs a r)
+    (sql-redirect sqlbuf "\\t on")
+    (setq a (car (sql-redirect-value sqlbuf "\\a" "Output format is \\(.*\\)[.]$" 1)))
+    (when (string= a "aligned")
+      (sql-redirect sqlbuf "\\a"))
+    (setq fs (or (car (sql-redirect-value sqlbuf "\\f" "Field separator is \"\\(.\\)[.]$" 1)) "|"))
+
+    (setq re (concat "^\\([^" fs "]*\\)" fs "\\([^" fs "]*\\)" fs "[^" fs "]*" fs  "[^" fs "]*$"))
+    (setq cl (if (not schema)
+                 (sql-redirect-value sqlbuf "\\d" re '(1 2))
+               (append (sql-redirect-value sqlbuf (format "\\dt %s.*" schema) re '(1 2))
+                       (sql-redirect-value sqlbuf (format "\\dv %s.*" schema) re '(1 2))
+                       (sql-redirect-value sqlbuf (format "\\ds %s.*" schema) re '(1 2)))))
+
+    ;; Restore tuples and alignment to what they were
+    (sql-redirect sqlbuf "\\t off")
+    (when (not (string= a "aligned"))
+      (sql-redirect sqlbuf "\\a"))
+    
+    ;; Return the list of table names (public schema name can be omitted) 
+    (mapcar (lambda (tbl)
+              (if (string= (car tbl) "public")
+                  (cadr tbl)
+                (format "%s.%s" (car tbl) (cadr tbl))))
+            cl)))
+
 
 
 ;;;###autoload
@@ -4199,8 +4842,7 @@ The default comes from `process-coding-system-alist' and
   "Create comint buffer and connect to DB2."
   ;; Put all parameters to the program (if defined) in a list and call
   ;; make-comint.
-  (sql-comint product options)
-)
+  (sql-comint product options))
 
 ;;;###autoload
 (defun sql-linter (&optional buffer)
@@ -4257,3 +4899,6 @@ buffer.
 (provide 'sql)
 
 ;;; sql.el ends here
+
+; LocalWords:  sql SQL SQLite sqlite Sybase Informix MySQL
+; LocalWords:  Postgres SQLServer SQLi
diff --git a/lisp/progmodes/which-func.el b/lisp/progmodes/which-func.el
index 4e4d7b15053..97e188139e9 100644
--- a/lisp/progmodes/which-func.el
+++ b/lisp/progmodes/which-func.el
@@ -206,7 +206,8 @@ It creates the Imenu index for the buffer, if necessary."
           (setq imenu--index-alist
                 (save-excursion (funcall imenu-create-index-function))))
     (error
-     (message "which-func-ff-hook error: %S" err)
+     (unless (equal err '(error "This buffer cannot use `imenu-default-create-index-function'"))
+       (message "which-func-ff-hook error: %S" err))
      (setq which-func-mode nil))))
 
 (defun which-func-update ()