[Emacs-diffs] /srv/bzr/emacs/trunk r101442: (c-forward-<>-arglist-recur): Correct the indentation.

[Alan Mackenzie]

------------------------------------------------------------
revno: 101442
committer: Alan Mackenzie <address@hidden>
branch nick: trunk
timestamp: Wed 2010-09-15 17:51:15 +0000
message:
  (c-forward-<>-arglist-recur): Correct the indentation.
modified:
  lisp/ChangeLog
  lisp/progmodes/cc-engine.el

=== modified file 'lisp/ChangeLog'
--- a/lisp/ChangeLog    2010-09-15 15:30:43 +0000
+++ b/lisp/ChangeLog    2010-09-15 17:51:15 +0000
@@ -1,3 +1,8 @@
+2010-09-15  Alan Mackenzie  <address@hidden>
+
+       * progmodes/cc-engine.el (c-forward-<>-arglist-recur): Correct the
+       indentation.
+
 2010-09-15  Stefan Monnier  <address@hidden>
 
        * emacs-lisp/bytecomp.el (byte-compile-warning-types): New type

=== modified file 'lisp/progmodes/cc-engine.el'
--- a/lisp/progmodes/cc-engine.el       2010-08-29 16:17:13 +0000
+++ b/lisp/progmodes/cc-engine.el       2010-09-15 17:51:15 +0000
@@ -5449,49 +5449,49 @@
       (forward-char)
 
       (unless (looking-at c-<-op-cont-regexp)
-               (while (and
+       (while (and
                (progn
-                     (c-forward-syntactic-ws)
-                (let ((orig-record-found-types c-record-found-types))
-                  (when (or (and c-record-type-identifiers all-types)
-                            (c-major-mode-is 'java-mode))
-                    ;; All encountered identifiers are types, so set the
-                    ;; promote flag and parse the type.
-                    (progn
-                      (c-forward-syntactic-ws)
-                      (if (looking-at "\\?")
-                          (forward-char)
-                        (when (looking-at c-identifier-start)
-                          (let ((c-promote-possible-types t)
-                                (c-record-found-types t))
-                            (c-forward-type))))
-
-                    (c-forward-syntactic-ws)
-
-                    (when (or (looking-at "extends")
-                              (looking-at "super"))
-                      (forward-word)
-                      (c-forward-syntactic-ws)
-                      (let ((c-promote-possible-types t)
-                           (c-record-found-types t))
-                        (c-forward-type)
-                        (c-forward-syntactic-ws))))))
-
-                     (setq pos (point))
-
-                     (or
-                      ;; Note: These regexps exploit the match order in \| so
-                      ;; that "<>" is matched by "<" rather than "[^>:-]>".
-                      (c-syntactic-re-search-forward
-                       ;; Stop on ',', '|', '&', '+' and '-' to catch
-                       ;; common binary operators that could be between
-                       ;; two comparison expressions "a<b" and "c>d".
-                       "[<;{},|+&-]\\|[>)]"
-                       nil t t)
-                      t))
-
-                   (cond
-                    ((eq (char-before) ?>)
+                 (c-forward-syntactic-ws)
+                 (let ((orig-record-found-types c-record-found-types))
+                   (when (or (and c-record-type-identifiers all-types)
+                             (c-major-mode-is 'java-mode))
+                     ;; All encountered identifiers are types, so set the
+                     ;; promote flag and parse the type.
+                     (progn
+                       (c-forward-syntactic-ws)
+                       (if (looking-at "\\?")
+                           (forward-char)
+                         (when (looking-at c-identifier-start)
+                           (let ((c-promote-possible-types t)
+                                 (c-record-found-types t))
+                             (c-forward-type))))
+
+                       (c-forward-syntactic-ws)
+
+                       (when (or (looking-at "extends")
+                                 (looking-at "super"))
+                         (forward-word)
+                         (c-forward-syntactic-ws)
+                         (let ((c-promote-possible-types t)
+                               (c-record-found-types t))
+                           (c-forward-type)
+                           (c-forward-syntactic-ws))))))
+
+                 (setq pos (point))
+
+                 (or
+                  ;; Note: These regexps exploit the match order in \| so
+                  ;; that "<>" is matched by "<" rather than "[^>:-]>".
+                  (c-syntactic-re-search-forward
+                   ;; Stop on ',', '|', '&', '+' and '-' to catch
+                   ;; common binary operators that could be between
+                   ;; two comparison expressions "a<b" and "c>d".
+                   "[<;{},|+&-]\\|[>)]"
+                   nil t t)
+                  t))
+
+               (cond
+                ((eq (char-before) ?>)
                  ;; Either an operator starting with '>' or the end of
                  ;; the angle bracket arglist.
 
@@ -5532,14 +5532,14 @@
                              (when (or (setq keyword-match
                                              (looking-at c-opt-<>-sexp-key))
                                        (not (looking-at c-keywords-regexp)))
-                                   (setq id-start (point))))
+                               (setq id-start (point))))
 
-                               (setq subres
-                                     (let ((c-promote-possible-types t)
-                                           (c-record-found-types t))
-                                       (c-forward-<>-arglist-recur
-                                        (and keyword-match
-                                             (c-keyword-member
+                           (setq subres
+                                 (let ((c-promote-possible-types t)
+                                       (c-record-found-types t))
+                                   (c-forward-<>-arglist-recur
+                                    (and keyword-match
+                                         (c-keyword-member
                                           (c-keyword-sym (match-string 1))
                                           'c-<>-type-kwds)))))
                            )))
@@ -5560,16 +5560,16 @@
                                   (c-forward-syntactic-ws)
                                   (looking-at c-opt-identifier-concat-key)))
                            (c-record-ref-id (cons id-start id-end))
-                             (c-record-type-id (cons id-start id-end))))))
-                     t)
+                         (c-record-type-id (cons id-start id-end))))))
+                 t)
 
-               ((and (not c-restricted-<>-arglists)
-                     (or (and (eq (char-before) ?&)
-                              (not (eq (char-after) ?&)))
-                         (eq (char-before) ?,)))
-                     ;; Just another argument.  Record the position.  The
-                     ;; type check stuff that made us stop at it is at
-                     ;; the top of the loop.
+                ((and (not c-restricted-<>-arglists)
+                      (or (and (eq (char-before) ?&)
+                               (not (eq (char-after) ?&)))
+                          (eq (char-before) ?,)))
+                 ;; Just another argument.      Record the position.  The
+                 ;; type check stuff that made us stop at it is at
+                 ;; the top of the loop.
                  (setq arg-start-pos (cons (point) arg-start-pos)))
 
                 (t