Merge from trunk.

18 files changed, 643 insertions, 210 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 6aa1bddb9f3..8309d3256bf 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,104 @@
+2011-10-29  Chong Yidong  <cyd@gnu.org>
+
+        * subr.el (y-or-n-p): Add code for batch mode (Bug#9818).
+
+        * mouse.el (mouse-yank-primary): Push the mark (Bug#9894).
+
+        * textmodes/flyspell.el (flyspell-word): Fix char offset for
+        forged Ispell output (Bug#7904).
+
+        * emacs-lisp/package.el (package-refresh-contents): Add autoload.
+
+2011-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * doc-view.el: Avoid ugly errors about not finding nil.
+        (doc-view-ghostscript-program, doc-view-dvipdfm-program)
+        (doc-view-dvipdf-program, doc-view-unoconv-program)
+        (doc-view-ps2pdf-program, doc-view-pdftotext-program):
+        Avoid nil or absolute file name as default value.
+        (doc-view-pdf->txt, doc-view-ps->pdf): Use executable-find here.
+
+2011-10-28  Alan Mackenzie  <acm@muc.de>
+
+        * progmodes/cc-defs.el (c-version).  -> 5.32.2.
+
+2011-10-28  Alan Mackenzie  <acm@muc.de>
+
+        Amend the handling of c-beginning/end-of-defun in nested declaration
+        scopes.
+
+        * progmodes/cc-vars.el (c-defun-tactic): Move here from
+        cc-langs.el.  Change it to a defcustom.
+
+        * progmodes/cc-langs.el (c-defun-tactic): Move this variable to
+        cc-vars.el.
+        (c-nonlabel-token-2-key): New variable for change in cc-engine.el.
+
+        * progmodes/cc-engine.el (c-beginning-of-statement-1):
+        Prevent "class foo : bar" being spuriously recognized as a label.
+
+        * progmodes/cc-cmds.el (c-narrow-to-most-enclosing-decl-block):
+        Add parameter `inclusive' (to include enclosing braces in the
+        region).
+        (c-widen-to-enclosing-decl-scope): New function.
+        (c-while-widening-to-decl-block): New macro.
+        (c-beginning-of-defun, c-end-of-defun): Change algorithm to keep going
+        outward for defun boundaries, and correspondingly change symbol
+        `respect-enclosure' to `go-outward'.
+        (c-declaration-limits): Change algorithm to report only the "innermost"
+        defun's boundaries.
+
+2011-10-28  Deniz Dogan  <deniz@dogan.se>
+
+        * net/rcirc.el (rcirc-mode): Use hard newlines.
+
+2011-10-28  Alan Mackenzie  <acm@muc.de>
+
+        Amend to indent and fontify macros "which include their own semicolon"
+        correctly, using the "virtual semicolon" mechanism.
+
+        * progmodes/cc-defs.el: Update "virtual semicolon" comments.
+
+        * progmodes/cc-engine.el (c-crosses-statement-barrier-p):
+        Recoded to scan one line at at time rather than having \n and \r
+        explicitly in c-stmt-delim-chars
+        (for some modes, e.g. AWK).
+        (c-forward-label): Amend for virtual semicolons.
+        (c-at-macro-vsemi-p, c-macro-vsemi-status-unknown-p): New functions
+
+        * progmodes/cc-fonts.el (c-font-lock-declarations): Take account
+        of the new C macros.
+
+        * progmodes/cc-langs.el (c-at-vsemi-p-fn):
+        (c-vsemi-status-unknown-p-fn): move to earlier in the file.
+        (c-opt-cpp-symbol, c-line-comment-start-regexp): New language variables.
+        (c-opt-cpp-macro-define): Make into a full language variable.
+        (c-stmt-delim-chars, c-stmt-delim-chars-with-comma): Special value for
+        AWK Mode (including \n, \r) removed, no longer needed.
+
+        * progmodes/cc-mode.el (c-mode, c++-mode, objc-mode):
+        Invoke c-make-macro-with-semi-re.
+
+        * progmodes/cc-vars.el (c-macro-with-semi-re):
+        (c-macro-names-with-semicolon): New variables.
+        (c-make-macro-with-semi-re): New function
+
+2011-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * vc/log-edit.el: Fill empty field rather than adding new one.
+        (log-edit-add-field): New function.
+        (log-edit-insert-changelog): Use it.
+
+2011-10-28  Mark Lillibridge  <mark.lillibridge@hp.com>  (tiny change)
+
+        * mail/rmail.el (rmail-mode-map): Add M-C-f as in rmailsum (bug#9802).
+
+2011-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/gdb-mi.el: Warn the user when -i=mi is missing.
+        (gdb--check-interpreter): New function.
+        (gdb): Use it.
+
 2011-10-27  Glenn Morris  <rgm@gnu.org>
 
         * emacs-lisp/cl-extra.el (most-positive-float, most-negative-float)
@@ -21,8 +122,8 @@
         * subr.el (change-major-mode-after-body-hook): New hook.
         (run-mode-hooks): Run it.
 
-        * emacs-lisp/easy-mmode.el (define-globalized-minor-mode): Use
-        change-major-mode-before-body-hook.
+        * emacs-lisp/easy-mmode.el (define-globalized-minor-mode):
+        Use change-major-mode-before-body-hook.
 
         * simple.el (fundamental-mode):
         * emacs-lisp/derived.el (define-derived-mode): Revert 2010-04-28
diff --git a/lisp/doc-view.el b/lisp/doc-view.el
index ceaad83cd7c..d16d8c6f62d 100644
--- a/lisp/doc-view.el
+++ b/lisp/doc-view.el
@@ -149,7 +149,7 @@
   :group 'multimedia
   :prefix "doc-view-")
 
-(defcustom doc-view-ghostscript-program (executable-find "gs")
+(defcustom doc-view-ghostscript-program "gs"
   "Program to convert PS and PDF files to PNG."
   :type 'file
   :group 'doc-view)
@@ -175,7 +175,7 @@ Has only an effect if imagemagick support is compiled into emacs."
   :type 'number
   :group 'doc-view)
 
-(defcustom doc-view-dvipdfm-program (executable-find "dvipdfm")
+(defcustom doc-view-dvipdfm-program "dvipdfm"
   "Program to convert DVI files to PDF.
 
 DVI file will be converted to PDF before the resulting PDF is
@@ -186,7 +186,7 @@ If this and `doc-view-dvipdf-program' are set,
   :type 'file
   :group 'doc-view)
 
-(defcustom doc-view-dvipdf-program (executable-find "dvipdf")
+(defcustom doc-view-dvipdf-program "dvipdf"
   "Program to convert DVI files to PDF.
 
 DVI file will be converted to PDF before the resulting PDF is
@@ -197,21 +197,21 @@ If this and `doc-view-dvipdfm-program' are set,
   :type 'file
   :group 'doc-view)
 
-(defcustom doc-view-unoconv-program (executable-find "unoconv")
+(defcustom doc-view-unoconv-program "unoconv"
   "Program to convert any file type readable by OpenOffice.org to PDF.
 
 Needed for viewing OpenOffice.org (and MS Office) files."
   :type 'file
   :group 'doc-view)
 
-(defcustom doc-view-ps2pdf-program (executable-find "ps2pdf")
+(defcustom doc-view-ps2pdf-program "ps2pdf"
   "Program to convert PS files to PDF.
 
 PS files will be converted to PDF before searching is possible."
   :type 'file
   :group 'doc-view)
 
-(defcustom doc-view-pdftotext-program (executable-find "pdftotext")
+(defcustom doc-view-pdftotext-program "pdftotext"
   "Program to convert PDF files to plain text.
 
 Needed for searching."
@@ -881,7 +881,7 @@ Start by converting PAGES, and then the rest."
 
 (defun doc-view-pdf->txt (pdf txt callback)
   "Convert PDF to TXT asynchronously and call CALLBACK when finished."
-  (or doc-view-pdftotext-program
+  (or (executable-find doc-view-pdftotext-program)
       (error "You need the `pdftotext' program to convert a PDF to text"))
   (doc-view-start-process "pdf->txt" doc-view-pdftotext-program
                           (list "-raw" pdf txt)
@@ -917,7 +917,7 @@ Start by converting PAGES, and then the rest."
 
 (defun doc-view-ps->pdf (ps pdf callback)
   "Convert PS to PDF asynchronously and call CALLBACK when finished."
-  (or doc-view-ps2pdf-program
+  (or (executable-find doc-view-ps2pdf-program)
       (error "You need the `ps2pdf' program to convert PS to PDF"))
   (doc-view-start-process "ps->pdf" doc-view-ps2pdf-program
                           (list
diff --git a/lisp/emacs-lisp/cl.el b/lisp/emacs-lisp/cl.el
index 0b34e9f27f7..16eb31c1209 100644
--- a/lisp/emacs-lisp/cl.el
+++ b/lisp/emacs-lisp/cl.el
@@ -341,7 +341,7 @@ Call `cl-float-limits' to set this.")
 
 (defconst most-negative-float nil
   "The largest negative value that a Lisp float can hold.
-This is simply -`most-negative-float'.
+This is simply -`most-positive-float'.
 Call `cl-float-limits' to set this.")
 
 (defconst least-positive-float nil
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index 2e340a442a6..0bd37ce1d49 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -1076,6 +1076,7 @@ similar to an entry in `package-alist'.  Save the cached copy to
         (let ((version-control 'never))
           (save-buffer))))))
 
+;;;###autoload
 (defun package-refresh-contents ()
   "Download the ELPA archive description if needed.
 This informs Emacs about the latest versions of all packages, and
diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el
index 770050efb08..603a615192a 100644
--- a/lisp/mail/rmail.el
+++ b/lisp/mail/rmail.el
@@ -1008,6 +1008,7 @@ The buffer is expected to be narrowed to just the header of the message."
     (define-key map "\e\C-l" 'rmail-summary-by-labels)
     (define-key map "\e\C-r" 'rmail-summary-by-recipients)
     (define-key map "\e\C-s" 'rmail-summary-by-regexp)
+    (define-key map "\e\C-f" 'rmail-summary-by-senders)
     (define-key map "\e\C-t" 'rmail-summary-by-topic)
     (define-key map "m"      'rmail-mail)
     (define-key map "\em"    'rmail-retry-failure)
diff --git a/lisp/mouse.el b/lisp/mouse.el
index 9b1cf48ccdc..615062dc031 100644
--- a/lisp/mouse.el
+++ b/lisp/mouse.el
@@ -1133,8 +1133,8 @@ regardless of where you click."
 
 (defun mouse-yank-primary (click)
   "Insert the primary selection at the position clicked on.
-Move point to the end of the inserted text.
-If `mouse-yank-at-point' is non-nil, insert at point
+Move point to the end of the inserted text, and set mark at
+beginning.  If `mouse-yank-at-point' is non-nil, insert at point
 regardless of where you click."
   (interactive "e")
   ;; Give temporary modes such as isearch a chance to turn off.
@@ -1162,9 +1162,10 @@ regardless of where you click."
           ;; FIXME: What about xterm-mouse-mode etc.?
           (t
            (x-get-selection 'PRIMARY)))))
-    (if primary
-        (insert primary)
-      (error "No selection is available"))))
+    (unless primary
+      (error "No selection is available"))
+    (push-mark (point))
+    (insert primary)))
 
 (defun mouse-kill-ring-save (click)
   "Copy the region between point and the mouse click in the kill ring.
diff --git a/lisp/net/rcirc.el b/lisp/net/rcirc.el
index 6a912cd6273..f6981aeabd9 100644
--- a/lisp/net/rcirc.el
+++ b/lisp/net/rcirc.el
@@ -979,6 +979,7 @@ This number is independent of the number of lines in the buffer.")
   (set (make-local-variable 'rcirc-recent-quit-alist) nil)
   (set (make-local-variable 'rcirc-current-line) 0)
 
+  (use-hard-newlines t)
   (set (make-local-variable 'rcirc-short-buffer-name) nil)
   (set (make-local-variable 'rcirc-urls) nil)
 
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 0f873e678c3..e59fdc16af7 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1485,6 +1485,78 @@ No indentation or other \"electric\" behavior is performed."
       (setq n (1- n))))
    n)
 
+(defun c-narrow-to-most-enclosing-decl-block (&optional inclusive)
+  ;; If we are inside a decl-block (in the sense of c-looking-at-decl-block),
+  ;; i.e. something like namespace{} or extern{}, narrow to the insides of
+  ;; that block (NOT including the enclosing braces) if INCLUSIVE is nil,
+  ;; otherwise include the braces.  If the closing brace is missing,
+  ;; (point-max) is used instead.
+  (let ((paren-state (c-parse-state))
+        encl-decl)
+    (setq encl-decl (and paren-state (c-most-enclosing-decl-block paren-state)))
+    (if encl-decl
+        (save-excursion
+          (narrow-to-region
+           (if inclusive
+               (progn (goto-char encl-decl)
+                      (c-beginning-of-decl-1)
+                      (point))
+             (1+ encl-decl))
+           (progn
+             (goto-char encl-decl)
+             (or (c-safe (forward-list)
+                         (if inclusive
+                             (point)
+                           (1- (point))))
+                 (point-max))))))))
+
+(defun c-widen-to-enclosing-decl-scope (paren-state orig-point-min orig-point-max)
+  ;; Narrow the buffer to the innermost declaration scope (e.g. a class, a
+  ;; namespace or the "whole buffer") recorded in PAREN-STATE, the bounding
+  ;; braces NOT being included in the resulting region.  On no account may the
+  ;; final region exceed that bounded by ORIG-POINT-MIN, ORIG-POINT-MAX.
+  ;; PAREN-STATE is a list of buffer positions in the style of
+  ;; (c-parse-state), one of which will be that of the desired opening brace,
+  ;; if there is one.
+  ;;
+  ;; Return the position of the enclosing opening brace, or nil
+  (let (encl-decl)          ; putative position of decl-scope's opening brace.
+    (save-restriction
+      (narrow-to-region orig-point-min orig-point-max)
+      (setq encl-decl (and paren-state
+                           (c-most-enclosing-decl-block paren-state))))
+    (if encl-decl
+        (progn
+          (widen)
+          (narrow-to-region (1+ encl-decl)
+                            (save-excursion
+                              (goto-char encl-decl)
+                              (or (c-safe (forward-list)
+                                          (1- (point)))
+                                  orig-point-max)))
+          encl-decl)
+      (narrow-to-region orig-point-min orig-point-max)
+      nil)))
+
+(eval-and-compile
+  (defmacro c-while-widening-to-decl-block (condition)
+    ;; Repeatedly evaluate CONDITION until it returns nil.  After each
+    ;; evaluation, if `c-defun-tactic' is set appropriately, widen to innards
+    ;; of the next enclosing declaration block (e.g. namespace, class), or the
+    ;; buffer's original restriction.
+    ;;
+    ;; This is a very special purpose macro, which assumes the existence of
+    ;; several variables.  It is for use only in c-beginning-of-defun and
+    ;; c-end-of-defun.
+    `(while
+         (and ,condition
+              (eq c-defun-tactic 'go-outward)
+              lim)
+       (setq paren-state (c-whack-state-after lim paren-state))
+       (setq lim (c-widen-to-enclosing-decl-scope
+                  paren-state orig-point-min orig-point-max))
+       (setq where 'in-block))))
+
 (defun c-beginning-of-defun (&optional arg)
   "Move backward to the beginning of a defun.
 Every top level declaration that contains a brace paren block is
@@ -1509,50 +1581,66 @@ defun."
   (c-save-buffer-state
       (beginning-of-defun-function end-of-defun-function
        (start (point))
-       where paren-state pos)
+       (paren-state (copy-tree (c-parse-state))) ; This must not share list
+                                        ; structure with other users of c-state-cache.
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim                          ; Position of { which has been widened to.
+       where pos)
 
-    ;; Move back out of any macro/comment/string we happen to be in.
-    (c-beginning-of-macro)
-    (setq pos (c-literal-limits))
-    (if pos (goto-char (car pos)))
-
-    (setq where (c-where-wrt-brace-construct))
-
-    (if (< arg 0)
-        ;; Move forward to the closing brace of a function.
-        (progn
-          (if (memq where '(at-function-end outwith-function))
-              (setq arg (1+ arg)))
-          (if (< arg 0)
-              (setq arg (c-forward-to-nth-EOF-} (- arg) where)))
-          ;; Move forward to the next opening brace....
-          (when (and (= arg 0)
-                     (c-syntactic-re-search-forward "{" nil 'eob))
-            (backward-char)
-            ;; ... and backward to the function header.
-            (c-beginning-of-decl-1)
-            t))
-
-      ;; Move backward to the opening brace of a function.
-      (when (and (> arg 0)
-                 (eq (setq arg (c-backward-to-nth-BOF-{ arg where)) 0))
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
+                     paren-state orig-point-min orig-point-max)))
 
-        ;; Go backward to this function's header.
-        (c-beginning-of-decl-1)
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
 
-        (setq pos (point))
-        ;; We're now there, modulo comments and whitespace.
-        ;; Try to be line oriented; position point at the closest
-        ;; preceding boi that isn't inside a comment, but if we hit
-        ;; the previous declaration then we use the current point
-        ;; instead.
-        (while (and (/= (point) (c-point 'boi))
-                    (c-backward-single-comment)))
-        (if (/= (point) (c-point 'boi))
-            (goto-char pos)))
+      (setq where (c-where-wrt-brace-construct))
 
-      (c-keep-region-active)
-      (= arg 0))))
+      (if (< arg 0)
+          ;; Move forward to the closing brace of a function.
+          (progn
+            (if (memq where '(at-function-end outwith-function))
+                (setq arg (1+ arg)))
+            (if (< arg 0)
+                (c-while-widening-to-decl-block
+                 (< (setq arg (- (c-forward-to-nth-EOF-} (- arg) where))) 0)))
+            ;; Move forward to the next opening brace....
+            (when (and (= arg 0)
+                       (progn
+                         (c-while-widening-to-decl-block
+                          (not (c-syntactic-re-search-forward "{" nil 'eob)))
+                         (eq (char-before) ?{)))
+              (backward-char)
+              ;; ... and backward to the function header.
+              (c-beginning-of-decl-1)
+              t))
+
+        ;; Move backward to the opening brace of a function, making successively
+        ;; larger portions of the buffer visible as necessary.
+        (when (> arg 0)
+          (c-while-widening-to-decl-block
+           (> (setq arg (c-backward-to-nth-BOF-{ arg where)) 0)))
+
+        (when (eq arg 0)
+          ;; Go backward to this function's header.
+          (c-beginning-of-decl-1)
+
+          (setq pos (point))
+          ;; We're now there, modulo comments and whitespace.
+          ;; Try to be line oriented; position point at the closest
+          ;; preceding boi that isn't inside a comment, but if we hit
+          ;; the previous declaration then we use the current point
+          ;; instead.
+          (while (and (/= (point) (c-point 'boi))
+                      (c-backward-single-comment)))
+          (if (/= (point) (c-point 'boi))
+              (goto-char pos)))
+
+        (c-keep-region-active)
+        (= arg 0)))))
 
 (defun c-forward-to-nth-EOF-} (n where)
   ;; Skip to the closing brace of the Nth function after point.  If
@@ -1617,50 +1705,62 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
   (c-save-buffer-state
       (beginning-of-defun-function end-of-defun-function
        (start (point))
-       where paren-state pos)
+       (paren-state (copy-tree (c-parse-state))) ; This must not share list
+                                  ; structure with other users of c-state-cache.
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim
+       where pos)
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
+                     paren-state orig-point-min orig-point-max)))
 
-    ;; Move back out of any macro/comment/string we happen to be in.
-    (c-beginning-of-macro)
-    (setq pos (c-literal-limits))
-    (if pos (goto-char (car pos)))
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
 
-    (setq where (c-where-wrt-brace-construct))
+      (setq where (c-where-wrt-brace-construct))
 
-    (if (< arg 0)
-        ;; Move backwards to the } of a function
-        (progn
-          (if (memq where '(at-header outwith-function))
-              (setq arg (1+ arg)))
-          (if (< arg 0)
-              (setq arg (c-backward-to-nth-BOF-{ (- arg) where)))
-          (if (= arg 0)
-              (c-syntactic-skip-backward "^}")))
-
-      ;; Move forward to the } of a function
-      (if (> arg 0)
-          (setq arg (c-forward-to-nth-EOF-} arg where))))
-
-    ;; Do we need to move forward from the brace to the semicolon?
-    (when (eq arg 0)
-      (if (c-in-function-trailer-p)     ; after "}" of struct/enum, etc.
-          (c-syntactic-re-search-forward ";"))
-
-      (setq pos (point))
-      ;; We're there now, modulo comments and whitespace.
-      ;; Try to be line oriented; position point after the next
-      ;; newline that isn't inside a comment, but if we hit the
-      ;; next declaration then we use the current point instead.
-      (while (and (not (bolp))
-                  (not (looking-at "\\s *$"))
-                  (c-forward-single-comment)))
-      (cond ((bolp))
-            ((looking-at "\\s *$")
-             (forward-line 1))
-            (t
-             (goto-char pos))))
+      (if (< arg 0)
+          ;; Move backwards to the } of a function
+          (progn
+            (if (memq where '(at-header outwith-function))
+                (setq arg (1+ arg)))
+            (if (< arg 0)
+                (c-while-widening-to-decl-block
+                 (< (setq arg (- (c-backward-to-nth-BOF-{ (- arg) where))) 0)))
+            (if (= arg 0)
+                (c-while-widening-to-decl-block
+                 (progn (c-syntactic-skip-backward "^}")
+                        (not (eq (char-before) ?}))))))
+
+        ;; Move forward to the } of a function
+        (if (> arg 0)
+            (c-while-widening-to-decl-block
+             (> (setq arg (c-forward-to-nth-EOF-} arg where)) 0))))
+
+      ;; Do we need to move forward from the brace to the semicolon?
+      (when (eq arg 0)
+        (if (c-in-function-trailer-p) ; after "}" of struct/enum, etc.
+            (c-syntactic-re-search-forward ";"))
 
-    (c-keep-region-active)
-    (= arg 0)))
+        (setq pos (point))
+        ;; We're there now, modulo comments and whitespace.
+        ;; Try to be line oriented; position point after the next
+        ;; newline that isn't inside a comment, but if we hit the
+        ;; next declaration then we use the current point instead.
+        (while (and (not (bolp))
+                    (not (looking-at "\\s *$"))
+                    (c-forward-single-comment)))
+        (cond ((bolp))
+              ((looking-at "\\s *$")
+               (forward-line 1))
+              (t
+               (goto-char pos))))
+
+      (c-keep-region-active)
+      (= arg 0))))
 
 (defun c-defun-name ()
   "Return the name of the current defun, or NIL if there isn't one.
@@ -1746,6 +1846,11 @@ with a brace block."
   ;;
   ;; This function might do hidden buffer changes.
   (save-excursion
+    (save-restriction
+      (when (eq c-defun-tactic 'go-outward)
+        (c-narrow-to-most-enclosing-decl-block t)  ; e.g. class, namespace
+        (or (save-restriction
+              (c-narrow-to-most-enclosing-decl-block nil)
 
     ;; Note: Some code duplication in `c-beginning-of-defun' and
     ;; `c-end-of-defun'.
@@ -1755,11 +1860,12 @@ with a brace block."
             lim pos end-pos)
         (unless (c-safe
                   (goto-char (c-least-enclosing-brace paren-state))
-                  ;; If we moved to the outermost enclosing paren then we
-                  ;; can use c-safe-position to set the limit.  Can't do
-                  ;; that otherwise since the earlier paren pair on
-                  ;; paren-state might very well be part of the
-                  ;; declaration we should go to.
+                            ;; If we moved to the outermost enclosing paren
+                            ;; then we can use c-safe-position to set the
+                            ;; limit. Can't do that otherwise since the
+                            ;; earlier paren pair on paren-state might very
+                            ;; well be part of the declaration we should go
+                            ;; to.
                   (setq lim (c-safe-position (point) paren-state))
                   t)
           ;; At top level.  Make sure we aren't inside a literal.
@@ -1843,8 +1949,12 @@ with a brace block."
                          (forward-line 1)
                          (point))
                         (t
-                         pos)))))
-        ))))
+                                   pos))))))))
+            (and (not near)
+                 (goto-char (point-min))
+                 (c-forward-decl-or-cast-1 -1 nil nil)
+                 (eq (char-after) ?\{)
+                 (cons (point-min) (point-max))))))))
 
 (defun c-mark-function ()
   "Put mark at end of the current top-level declaration or macro, point at beginning.
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index e5b4d7e35a4..8632807f2b8 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -93,7 +93,7 @@
 
 ;;; Variables also used at compile time.
 
-(defconst c-version "5.31.9"
+(defconst c-version "5.32.2"
   "CC Mode version number.")
 
 (defconst c-version-sym (intern c-version))
@@ -744,19 +744,20 @@ be after it."
 ;; V i r t u a l   S e m i c o l o n s
 ;;
 ;; In most CC Mode languages, statements are terminated explicitly by
-;; semicolons or closing braces.  In some of the CC modes (currently only AWK
-;; Mode (April 2004)), statements are (or can be) terminated by EOLs.  Such a
-;; statement is said to be terminated by a "virtual semicolon" (VS).  A
-;; statement terminated by an actual semicolon or brace is never considered to
-;; have a VS.
+;; semicolons or closing braces.  In some of the CC modes (currently AWK Mode
+;; and certain user-specified #define macros in C, C++, etc. (November 2008)),
+;; statements are (or can be) terminated by EOLs.  Such a statement is said to
+;; be terminated by a "virtual semicolon" (VS).  A statement terminated by an
+;; actual semicolon or brace is never considered to have a VS.
 ;;
 ;; The indentation engine (or whatever) tests for a VS at a specific position
 ;; by invoking the macro `c-at-vsemi-p', which in its turn calls the mode
 ;; specific function (if any) which is the value of the language variable
-;; `c-at-vsemi-p-fn'.  The actual details of what constitutes a VS in a
-;; language are thus encapsulated in code specific to that language
-;; (e.g. cc-awk.el).  `c-at-vsemi-p' returns non-nil if point (or the optional
-;; parameter POS) is at a VS, nil otherwise.
+;; `c-at-vsemi-p-fn'.  This function should only use "low-level" features of
+;; CC Mode, i.e. features which won't trigger infinite recursion.  ;-) The
+;; actual details of what constitutes a VS in a language are thus encapsulated
+;; in code specific to that language (e.g. cc-awk.el).  `c-at-vsemi-p' returns
+;; non-nil if point (or the optional parameter POS) is at a VS, nil otherwise.
 ;;
 ;; The language specific function might well do extensive analysis of the
 ;; source text, and may use a cacheing scheme to speed up repeated calls.
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index b2c548847c3..ea0a8f2d3b3 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -705,7 +705,7 @@ comment at the start of cc-engine.el for more info."
         ;; The last position where a label is possible provided the
         ;; statement started there.  It's nil as long as no invalid
         ;; label content has been found (according to
-        ;; `c-nonlabel-token-key'.  It's `start' if no valid label
+        ;; `c-nonlabel-token-key').  It's `start' if no valid label
         ;; content was found in the label.  Note that we might still
         ;; regard it a label if it starts with `c-label-kwds'.
         label-good-pos
@@ -1035,7 +1035,12 @@ comment at the start of cc-engine.el for more info."
                   ;; (including a case label) or something like C++'s "public:"?
                   ;; A case label might use an expression rather than a token.
                   (setq after-case:-pos (or tok start))
-                  (if (looking-at c-nonlabel-token-key) ; e.g. "while" or "'a'"
+                  (if (or (looking-at c-nonlabel-token-key) ; e.g. "while" or "'a'"
+                          ;; Catch C++'s inheritance construct "class foo : bar".
+                          (save-excursion
+                            (and
+                             (c-safe (c-backward-sexp) t)
+                             (looking-at c-nonlabel-token-2-key))))
                       (setq c-maybe-labelp nil)
                     (if after-labels-pos ; Have we already encountered a label?
                         (if (not last-label-pos)
@@ -1149,42 +1154,65 @@ the line.  If this virtual semicolon is _at_ from, the function recognizes it.
 
 Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
-  (let ((skip-chars c-stmt-delim-chars)
-        lit-range)
-    (save-excursion
-      (catch 'done
-        (goto-char from)
-        (while (progn (skip-chars-forward skip-chars to)
-                      (< (point) to))
-          (cond
-           ((setq lit-range (c-literal-limits from)) ; Have we landed in a string/comment?
-            (goto-char (cdr lit-range)))
-           ((eq (char-after) ?:)
-            (forward-char)
-            (if (and (eq (char-after) ?:)
-                     (< (point) to))
-                ;; Ignore scope operators.
-                (forward-char)
-              (setq c-maybe-labelp (1- (point)))))
-           ((eq (char-after) ??)
-            ;; A question mark.  Can't be a label, so stop
-            ;; looking for more : and ?.
-            (setq c-maybe-labelp nil
-                  skip-chars (substring c-stmt-delim-chars 0 -2)))
-           ((memq (char-after) '(?# ?\n ?\r)) ; A virtual semicolon?
-            (if (and (eq (char-before) ?\\) (memq (char-after) '(?\n ?\r)))
-                (backward-char))
-            (skip-chars-backward " \t" from)
-            (if (c-at-vsemi-p)
-                (throw 'done (point))
-              (forward-line)))
-           (t (throw 'done (point)))))
-        ;; In trailing space after an as yet undetected virtual semicolon?
-        (c-backward-syntactic-ws from)
-        (if (and (< (point) to)
-                 (c-at-vsemi-p))
-            (point)
-          nil)))))
+  (let* ((skip-chars
+          ;; If the current language has CPP macros, insert # into skip-chars.
+          (if c-opt-cpp-symbol
+              (concat (substring c-stmt-delim-chars 0 1) ; "^"
+                      c-opt-cpp-symbol                   ; usually "#"
+                      (substring c-stmt-delim-chars 1))  ; e.g. ";{}?:"
+            c-stmt-delim-chars))
+         (non-skip-list
+          (append (substring skip-chars 1) nil)) ; e.g. (?# ?\; ?{ ?} ?? ?:)
+         lit-range vsemi-pos)
+    (save-restriction
+      (widen)
+      (save-excursion
+        (catch 'done
+          (goto-char from)
+          (while (progn (skip-chars-forward
+                         skip-chars
+                         (min to (c-point 'bonl)))
+                        (< (point) to))
+            (cond
+             ;; Virtual semicolon?
+             ((and (bolp)
+                   (save-excursion
+                     (progn
+                       (if (setq lit-range (c-literal-limits from)) ; Have we landed in a string/comment?
+                           (goto-char (car lit-range)))
+                       (c-backward-syntactic-ws) ; ? put a limit here, maybe?
+                       (setq vsemi-pos (point))
+                       (c-at-vsemi-p))))
+              (throw 'done vsemi-pos))
+             ;; In a string/comment?
+             ((setq lit-range (c-literal-limits))
+              (goto-char (cdr lit-range)))
+             ((eq (char-after) ?:)
+              (forward-char)
+              (if (and (eq (char-after) ?:)
+                       (< (point) to))
+                  ;; Ignore scope operators.
+                  (forward-char)
+                (setq c-maybe-labelp (1- (point)))))
+             ((eq (char-after) ??)
+              ;; A question mark.  Can't be a label, so stop
+              ;; looking for more : and ?.
+              (setq c-maybe-labelp nil
+                    skip-chars (substring c-stmt-delim-chars 0 -2)))
+             ;; At a CPP construct?
+             ((and c-opt-cpp-symbol (looking-at c-opt-cpp-symbol)
+                   (save-excursion
+                     (forward-line 0)
+                     (looking-at c-opt-cpp-prefix)))
+              (c-end-of-macro))
+             ((memq (char-after) non-skip-list)
+              (throw 'done (point)))))
+          ;; In trailing space after an as yet undetected virtual semicolon?
+          (c-backward-syntactic-ws from)
+          (if (and (< (point) to)
+                   (c-at-vsemi-p))
+              (point)
+            nil))))))
 
 (defun c-at-statement-start-p ()
   "Return non-nil if the point is at the first token in a statement
@@ -7158,12 +7186,14 @@ comment at the start of cc-engine.el for more info."
            ;; Check that we're not after a token that can't precede a label.
            (or
             ;; Trivially succeeds when there's no preceding token.
+            ;; Succeeds when we're at a virtual semicolon.
             (if preceding-token-end
                 (<= preceding-token-end (point-min))
               (save-excursion
                 (c-backward-syntactic-ws)
                 (setq preceding-token-end (point))
-                (bobp)))
+                (or (bobp)
+                    (c-at-vsemi-p))))
 
             ;; Check if we're after a label, if we're after a closing
             ;; paren that belong to statement, and with
@@ -8037,6 +8067,29 @@ comment at the start of cc-engine.el for more info."
           (back-to-indentation)
           (vector (point) open-paren-pos))))))
 
+(defmacro c-pull-open-brace (ps)
+  ;; Pull the next open brace from PS (which has the form of paren-state),
+  ;; skipping over any brace pairs.  Returns NIL when PS is exhausted.
+  `(progn
+     (while (consp (car ,ps))
+       (setq ,ps (cdr ,ps)))
+     (prog1 (car ,ps)
+       (setq ,ps (cdr ,ps)))))
+
+(defun c-most-enclosing-decl-block (paren-state)
+  ;; Return the buffer position of the most enclosing decl-block brace (in the
+  ;; sense of c-looking-at-decl-block) in the PAREN-STATE structure, or nil if
+  ;; none was found.
+  (let* ((open-brace (c-pull-open-brace paren-state))
+         (next-open-brace (c-pull-open-brace paren-state)))
+    (while (and open-brace
+                (save-excursion
+                  (goto-char open-brace)
+                  (not (c-looking-at-decl-block next-open-brace nil))))
+      (setq open-brace next-open-brace
+            next-open-brace (c-pull-open-brace paren-state)))
+    open-brace))
+
 (defun c-inside-bracelist-p (containing-sexp paren-state)
   ;; return the buffer position of the beginning of the brace list
   ;; statement if we're inside a brace list, otherwise return nil.
@@ -8372,6 +8425,57 @@ comment at the start of cc-engine.el for more info."
                                                     paren-state)
                                    containing-sexp)))))
 
+(defun c-at-macro-vsemi-p (&optional pos)
+  ;; Is there a "virtual semicolon" at POS or point?
+  ;; (See cc-defs.el for full details of "virtual semicolons".)
+  ;;
+  ;; This is true when point is at the last non syntactic WS position on the
+  ;; line, there is a macro call last on the line, and this particular macro's
+  ;; name is defined by the regexp `c-vs-macro-regexp' as not needing a
+  ;; semicolon.
+  (save-excursion
+    (save-restriction
+      (widen)
+      (if pos
+          (goto-char pos)
+        (setq pos (point)))
+      (and
+       c-macro-with-semi-re
+       (not (c-in-literal))
+       (eq (skip-chars-backward " \t") 0)
+
+       ;; Check we've got nothing after this except comments and empty lines
+       ;; joined by escaped EOLs.
+       (skip-chars-forward " \t")       ; always returns non-nil.
+       (progn
+         (while                       ; go over 1 block comment per iteration.
+             (and
+              (looking-at "\\(\\\\[\n\r][ \t]*\\)*")
+              (goto-char (match-end 0))
+              (cond
+               ((looking-at c-block-comment-start-regexp)
+                (and (forward-comment 1)
+                     (skip-chars-forward " \t"))) ; always returns non-nil
+               ((looking-at c-line-comment-start-regexp)
+                (end-of-line)
+                nil)
+               (t nil))))
+         (eolp))
+             
+       (goto-char pos)
+       (progn (c-backward-syntactic-ws)
+              (eq (point) pos))
+
+       ;; Check for one of the listed macros being before point.
+       (or (not (eq (char-before) ?\)))
+           (when (c-go-list-backward)
+             (c-backward-syntactic-ws)
+             t))
+       (c-simple-skip-symbol-backward)
+       (looking-at c-macro-with-semi-re)))))
+
+(defun c-macro-vsemi-status-unknown-p () t) ; See cc-defs.el.
+
 
 ;; `c-guess-basic-syntax' and the functions that precedes it below
 ;; implements the main decision tree for determining the syntactic
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index fd817e3b4f4..9a83d5196db 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1277,9 +1277,11 @@ casts and declarations are fontified.  Used on level 2 and higher."
          (when
           ;; The result of the form below is true when we don't recognize a
           ;; declaration or cast.
-          (if (and (eq (get-text-property (point) 'face)
-                       'font-lock-keyword-face)
-                   (looking-at c-not-decl-init-keywords))
+          (if (or (and (eq (get-text-property (point) 'face)
+                           'font-lock-keyword-face)
+                       (looking-at c-not-decl-init-keywords))
+                  (and c-macro-with-semi-re
+                       (looking-at c-macro-with-semi-re))) ; 2008-11-04
               ;; Don't do anything more if we're looking at a keyword that
               ;; can't start a declaration.
               t
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 279c5e46c46..09f8b318378 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -509,6 +509,31 @@ parameters \(point-min), \(point-max) and <buffer size>."
                (c-lang-const c-before-font-lock-function))
 
 
+;;; Syntactic analysis ("virtual semicolons") for line-oriented languages (AWK).
+(c-lang-defconst c-at-vsemi-p-fn
+  "Contains a function \"Is there a virtual semicolon at POS or point?\".
+Such a function takes one optional parameter, a buffer position (defaults to
+point), and returns nil or t.  This variable contains nil for languages which
+don't have EOL terminated statements. "
+  t nil
+  (c c++ objc) 'c-at-macro-vsemi-p
+  awk 'c-awk-at-vsemi-p)
+(c-lang-defvar c-at-vsemi-p-fn (c-lang-const c-at-vsemi-p-fn))
+
+(c-lang-defconst c-vsemi-status-unknown-p-fn
+  "Contains a function \"are we unsure whether there is a virtual semicolon on this line?\".
+The (admittedly kludgey) purpose of such a function is to prevent an infinite
+recursion in c-beginning-of-statement-1 when point starts at a `while' token.
+The function MUST NOT UNDER ANY CIRCUMSTANCES call c-beginning-of-statement-1,
+even indirectly.  This variable contains nil for languages which don't have
+EOL terminated statements."
+  t nil
+  (c c++ objc) 'c-macro-vsemi-status-unknown-p
+  awk 'c-awk-vsemi-status-unknown-p)
+(c-lang-defvar c-vsemi-status-unknown-p-fn
+  (c-lang-const c-vsemi-status-unknown-p-fn))
+
+
 ;;; Lexer-level syntax (identifiers, tokens etc).
 
 (c-lang-defconst c-has-bitfields
@@ -737,6 +762,12 @@ literal are multiline."
 (c-lang-defvar c-multiline-string-start-char
   (c-lang-const c-multiline-string-start-char))
 
+(c-lang-defconst c-opt-cpp-symbol
+  "The symbol which starts preprocessor constructs when in the margin."
+  t "#"
+  (java awk) nil)
+(c-lang-defvar c-opt-cpp-symbol (c-lang-const c-opt-cpp-symbol))
+
 (c-lang-defconst c-opt-cpp-prefix
   "Regexp matching the prefix of a cpp directive in the languages that
 normally use that macro preprocessor.  Tested at bol or at boi.
@@ -785,6 +816,8 @@ file name in angle brackets or quotes."
 definition, or nil if the language doesn't have any."
   t (if (c-lang-const c-opt-cpp-prefix)
         "define"))
+(c-lang-defvar c-opt-cpp-macro-define
+  (c-lang-const c-opt-cpp-macro-define))
 
 (c-lang-defconst c-opt-cpp-macro-define-start
   ;; Regexp matching everything up to the macro body of a cpp define, or the
@@ -1171,14 +1204,12 @@ operators."
   ;; optimize `c-crosses-statement-barrier-p' somewhat, it's assumed to
   ;; begin with "^" to negate the set.  If ? : operators should be
   ;; detected then the string must end with "?:".
-  t    "^;{}?:"
-  awk  "^;{}#\n\r?:") ; The newline chars gets special treatment.
+  t "^;{}?:")
 (c-lang-defvar c-stmt-delim-chars (c-lang-const c-stmt-delim-chars))
 
 (c-lang-defconst c-stmt-delim-chars-with-comma
   ;; Variant of `c-stmt-delim-chars' that additionally contains ','.
-  t    "^;,{}?:"
-  awk  "^;,{}\n\r?:") ; The newline chars gets special treatment.
+  t    "^;,{}?:")
 (c-lang-defvar c-stmt-delim-chars-with-comma
   (c-lang-const c-stmt-delim-chars-with-comma))
 
@@ -1238,7 +1269,6 @@ properly."
         re)))
 (c-lang-defvar c-comment-start-regexp (c-lang-const c-comment-start-regexp))
 
-;;;; Added by ACM, 2003/9/18.
 (c-lang-defconst c-block-comment-start-regexp
   ;; Regexp which matches the start of a block comment (if such exists in the
   ;; language)
@@ -1248,6 +1278,15 @@ properly."
 (c-lang-defvar c-block-comment-start-regexp
   (c-lang-const c-block-comment-start-regexp))
 
+(c-lang-defconst c-line-comment-start-regexp
+  ;; Regexp which matches the start of a line comment (if such exists in the
+  ;; language; it does in all 7 CC Mode languages).
+  t (if (c-lang-const c-line-comment-starter)
+        (regexp-quote (c-lang-const c-line-comment-starter))
+      "\\<\\>"))
+(c-lang-defvar c-line-comment-start-regexp
+               (c-lang-const c-line-comment-start-regexp))
+
 (c-lang-defconst c-literal-start-regexp
   ;; Regexp to match the start of comments and string literals.
   t (concat (c-lang-const c-comment-start-regexp)
@@ -1475,29 +1514,6 @@ properly."
 (c-lang-defvar c-syntactic-eol (c-lang-const c-syntactic-eol))
 
 
-;;; Syntactic analysis ("virtual semicolons") for line-oriented languages (AWK).
-(c-lang-defconst c-at-vsemi-p-fn
-  "Contains a function \"Is there a virtual semicolon at POS or point?\".
-Such a function takes one optional parameter, a buffer position (defaults to
-point), and returns nil or t.  This variable contains nil for languages which
-don't have EOL terminated statements. "
-  t nil
-  awk 'c-awk-at-vsemi-p)
-(c-lang-defvar c-at-vsemi-p-fn (c-lang-const c-at-vsemi-p-fn))
-
-(c-lang-defconst c-vsemi-status-unknown-p-fn
-  "Contains a function \"are we unsure whether there is a virtual semicolon on this line?\".
-The (admittedly kludgey) purpose of such a function is to prevent an infinite
-recursion in c-beginning-of-statement-1 when point starts at a `while' token.
-The function MUST NOT UNDER ANY CIRCUMSTANCES call c-beginning-of-statement-1,
-even indirectly.  This variable contains nil for languages which don't have
-EOL terminated statements."
-  t nil
-  awk 'c-awk-vsemi-status-unknown-p)
-(c-lang-defvar c-vsemi-status-unknown-p-fn
-  (c-lang-const c-vsemi-status-unknown-p-fn))
-
-
 ;;; Defun functions
 
 ;; The Emacs variables beginning-of-defun-function and
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index eec63b4fa3b..a6bf241f0db 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1187,6 +1187,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map c-mode-map)
   (c-init-language-vars-for 'c-mode)
+  (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'c-mode)
   (easy-menu-add c-c-menu)
   (cc-imenu-init cc-imenu-c-generic-expression)
@@ -1246,6 +1247,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map c++-mode-map)
   (c-init-language-vars-for 'c++-mode)
+  (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'c++-mode)
   (easy-menu-add c-c++-menu)
   (cc-imenu-init cc-imenu-c++-generic-expression)
@@ -1303,6 +1305,7 @@ Key bindings:
         abbrev-mode t)
   (use-local-map objc-mode-map)
   (c-init-language-vars-for 'objc-mode)
+  (c-make-macro-with-semi-re) ; matches macro names whose expansion ends with ;
   (c-common-init 'objc-mode)
   (easy-menu-add c-objc-menu)
   (cc-imenu-init nil 'cc-imenu-objc-function)
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 58dc1737c5a..24361e3667a 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -340,6 +340,20 @@ better with the \"do { ... } while \(0)\" trick)."
   :group 'c)
 (put 'c-syntactic-indentation-in-macros 'safe-local-variable 'booleanp)
 
+(defcustom c-defun-tactic 'go-outward
+  "*Whether functions are recognized inside, e.g., a class.
+This is used by `c-beginning-of-defun' and like functions.
+
+Its value is one of:
+ t           -- Functions are recognized only at the top level.
+ go-outward  -- Nested functions are also recognized.  Should a function
+                command hit the beginning/end of a nested scope, it will
+                carry on at the less nested level."
+  :type '(radio
+          (const :tag "Functions are at the top-level" t)
+          (const :tag "Functions are also recognized inside declaration scopes" go-outward))
+  :group 'c)
+
 (defcustom-c-stylevar c-comment-only-line-offset 0
   "*Extra offset for line which contains only the start of a comment.
 Can contain an integer or a cons cell of the form:
@@ -1608,6 +1622,54 @@ names)."))
 
 
 ;; Non-customizable variables, still part of the interface to CC Mode
+(defvar c-macro-with-semi-re nil
+  ;; Regular expression which matches a (#define'd) symbol whose expansion
+  ;; ends with a semicolon.
+  ;; 
+  ;; This variable should be set by `c-make-macros-with-semi-re' rather than
+  ;; directly.
+)
+(make-variable-buffer-local 'c-macro-with-semi-re)
+
+(defun c-make-macro-with-semi-re ()
+  ;; Convert `c-macro-names-with-semicolon' into the regexp
+  ;; `c-macro-with-semi-re' (or just copy it if it's already a re).
+  (setq c-macro-with-semi-re
+        (and
+         c-opt-cpp-macro-define
+         (cond
+          ((stringp c-macro-names-with-semicolon)
+           (copy-sequence c-macro-names-with-semicolon))
+          ((consp c-macro-names-with-semicolon)
+           (concat
+            "\\<"
+            (regexp-opt c-macro-names-with-semicolon)
+            "\\>"))   ; N.B. the PAREN param of regexp-opt isn't supported by
+                      ; all XEmacsen.
+          ((null c-macro-names-with-semicolon)
+           nil)
+          (t (error "c-make-macro-with-semi-re: invalid \
+c-macro-names-with-semicolon: %s"
+                    c-macro-names-with-semicolon))))))
+    
+(defvar c-macro-names-with-semicolon
+  '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
+  "List of #defined symbols whose expansion ends with a semicolon.
+Alternatively it can be a string, a regular expression which
+matches all such symbols.
+
+The \"symbols\" must be syntactically valid identifiers in the
+target language \(C, C++, Objective C), or \(as the case may be)
+the regular expression must match only valid identifiers.
+
+If you change this variable's value, call the function
+`c-make-macros-with-semi-re' to set the necessary internal
+variables.
+
+Note that currently \(2008-11-04) this variable is a prototype,
+and is likely to disappear or change its form soon.")
+(make-variable-buffer-local 'c-macro-names-with-semicolon)
+
 (defvar c-file-style nil
   "Variable interface for setting style via File Local Variables.
 In a file's Local Variable section, you can set this variable to a
diff --git a/lisp/progmodes/gdb-mi.el b/lisp/progmodes/gdb-mi.el
index 22db7b2e5f4..dde00d753ac 100644
--- a/lisp/progmodes/gdb-mi.el
+++ b/lisp/progmodes/gdb-mi.el
@@ -43,21 +43,10 @@
 
 ;; M-x gdb will start the debugger.
 
-;; This file uses GDB/MI as the primary interface to GDB.  It is still under
-;; development and is part of a process to migrate Emacs from annotations (as
-;; used in gdb-ui.el) to GDB/MI.  It runs gdb with GDB/MI (-interp=mi) and
-;; access CLI using "-interpreter-exec console cli-command".  This code works
-;; without gdb-ui.el and uses MI tokens instead of queues. Eventually MI
-;; should be asynchronous.
-
-;; This mode will PARTLY WORK WITH RECENT GDB RELEASES (status in modeline
-;; doesn't update properly when execution commands are issued from GUD buffer)
-;; and WORKS BEST when GDB runs asynchronously: maint set linux-async on.
-;;
-;; You need development version of GDB 7.0 for the thread buffer to work.
-
-;; This file replaces gdb-ui.el and is for development with GDB.  Use the
-;; release branch of Emacs 22 for the latest version of gdb-ui.el.
+;; This file uses GDB/MI as the primary interface to GDB.  It runs gdb with
+;; GDB/MI (-interp=mi) and access CLI using "-interpreter-exec console
+;; cli-command".  This code works without gdb-ui.el and uses MI tokens instead
+;; of queues.  Eventually MI should be asynchronous.
 
 ;; Windows Platforms:
 
@@ -599,6 +588,22 @@ NOARG must be t when this macro is used outside `gud-def'"
     (concat (gdb-gud-context-command ,cmd1 ,noall) " " ,cmd2)
     ,(when (not noarg) 'arg)))
 
+(defun gdb--check-interpreter (proc string)
+  (unless (zerop (length string))
+    (let ((filter (process-get proc 'gud-normal-filter)))
+      (set-process-filter proc filter)
+      (unless (memq (aref string 0) '(?^ ?~ ?@ ?& ?* ?=))
+        ;; Apparently we're not running with -i=mi.
+        (let ((msg "Error: you did not specify -i=mi on GDB's command line!"))
+          (message msg)
+          (setq string (concat (propertize msg 'font-lock-face 'error)
+                               "\n" string)))
+        ;; Use the old gud-gbd filter, not because it works, but because it
+        ;; will properly display GDB's answers rather than hanging waiting for
+        ;; answers that aren't coming.
+        (set (make-local-variable 'gud-marker-filter) #'gud-gdb-marker-filter))
+      (funcall filter proc string))))
+
 ;;;###autoload
 (defun gdb (command-line)
   "Run gdb on program FILE in buffer *gud-FILE*.
@@ -665,6 +670,13 @@ detailed description of this mode.
      "Multiple debugging requires restarting in text command mode"))
   ;;
   (gud-common-init command-line nil 'gud-gdbmi-marker-filter)
+
+  ;; Setup a temporary process filter to warn when GDB was not started
+  ;; with -i=mi.
+  (let ((proc (get-buffer-process gud-comint-buffer)))
+    (process-put proc 'gud-normal-filter (process-filter proc))
+    (set-process-filter proc #'gdb--check-interpreter))
+
   (set (make-local-variable 'gud-minor-mode) 'gdbmi)
   (setq comint-input-sender 'gdb-send)
   (when (ring-empty-p comint-input-ring) ; cf shell-mode
diff --git a/lisp/subr.el b/lisp/subr.el
index f3cd4dabe20..50ea49bd8c9 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -2262,11 +2262,25 @@ is nil and `use-dialog-box' is non-nil."
   ;; where all the keys were unbound (i.e. it somehow got triggered
   ;; within read-key, apparently).  I had to kill it.
   (let ((answer 'recenter))
-    (if (and (display-popup-menus-p)
-             (listp last-nonmenu-event)
-             use-dialog-box)
-        (setq answer
-              (x-popup-dialog t `(,prompt ("Yes" . act) ("No" . skip))))
+    (cond
+     (noninteractive
+      (setq prompt (concat prompt
+                           (if (eq ?\s (aref prompt (1- (length prompt))))
+                               "" " ")
+                           "(y or n) "))
+      (let ((temp-prompt prompt))
+        (while (not (memq answer '(act skip)))
+          (let ((str (read-string temp-prompt)))
+            (cond ((member str '("y" "Y")) (setq answer 'act))
+                  ((member str '("n" "N")) (setq answer 'skip))
+                  (t (setq temp-prompt (concat "Please answer y or n.  "
+                                               prompt))))))))
+     ((and (display-popup-menus-p)
+           (listp last-nonmenu-event)
+           use-dialog-box)
+      (setq answer
+            (x-popup-dialog t `(,prompt ("Yes" . act) ("No" . skip)))))
+     (t
       (setq prompt (concat prompt
                            (if (eq ?\s (aref prompt (1- (length prompt))))
                                "" " ")
@@ -2288,7 +2302,7 @@ is nil and `use-dialog-box' is non-nil."
              ((memq answer '(exit-prefix quit)) (signal 'quit nil) t)
              (t t)))
         (ding)
-        (discard-input)))
+        (discard-input))))
     (let ((ret (eq answer 'act)))
       (unless noninteractive
         (message "%s %s" prompt (if ret "y" "n")))
diff --git a/lisp/textmodes/flyspell.el b/lisp/textmodes/flyspell.el
index 4a57d00d702..a5099311307 100644
--- a/lisp/textmodes/flyspell.el
+++ b/lisp/textmodes/flyspell.el
@@ -1121,7 +1121,7 @@ misspelling and skips redundant spell-checking step."
                       (setq poss (ispell-parse-output (car ispell-filter)))))
               ;; Else, this was a known misspelling to begin with, and
               ;; we should forge an ispell return value.
-              (setq poss (list word 0 '() '())))
+              (setq poss (list word 1 nil nil)))
             (let ((res (cond ((eq poss t)
                               ;; correct
                               (setq flyspell-word-cache-result t)
diff --git a/lisp/vc/log-edit.el b/lisp/vc/log-edit.el
index c421304442f..f57429c76c7 100644
--- a/lisp/vc/log-edit.el
+++ b/lisp/vc/log-edit.el
@@ -593,6 +593,13 @@ to build the Fixes: header.")
 (put 'log-edit-rewrite-fixes 'safe-local-variable
      (lambda (v) (and (stringp (car-safe v)) (stringp (cdr v)))))
 
+(defun log-edit-add-field (field value)
+  (rfc822-goto-eoh)
+  (if (save-excursion (re-search-backward (concat "^" field ":\\([ \t]*\\)$")
+                                          nil t))
+      (replace-match (concat " " value) t t nil 1)
+    (insert field ": " value "\n" (if (looking-at "\n") "" "\n"))))
+
 (defun log-edit-insert-changelog (&optional use-first)
   "Insert a log message by looking at the ChangeLog.
 The idea is to write your ChangeLog entries first, and then use this
@@ -620,9 +627,7 @@ regardless of user name or time."
            (log-edit-insert-changelog-entries (log-edit-files)))))
     (log-edit-set-common-indentation)
     ;; Add an Author: field if appropriate.
-    (when author
-      (rfc822-goto-eoh)
-      (insert "Author: " author "\n" (if (looking-at "\n") "" "\n")))
+    (when author (log-edit-add-field "Author" author))
     ;; Add a Fixes: field if applicable.
     (when (consp log-edit-rewrite-fixes)
       (rfc822-goto-eoh)
@@ -632,8 +637,7 @@ regardless of user name or time."
               (fixes (match-substitute-replacement
                       (cdr log-edit-rewrite-fixes))))
           (delete-region start end)
-          (rfc822-goto-eoh)
-          (insert "Fixes: " fixes "\n" (if (looking-at "\n") "" "\n")))))
+          (log-edit-add-field "Fixes" fixes))))
     (and log-edit-strip-single-file-name
          (progn (rfc822-goto-eoh)
                 (if (looking-at "\n") (forward-char 1))