(c-inside-bracelist-p): Fix for enum test.

(c-collect-line-comments): Require same comment start column.

(c-guess-basic-syntax): Fixes for nesting of and
repeated defun-open's inside extern and namespace clauses.  This
is done by passing a relpos to `inextern-lang' and `innamespace'.
Also, the relpos in `defun-open' is no longer always bol.  It's
always bol when on the top level, however.  Changed cases: 5A.5, 5I, 14A.

(c-forward-token-1, c-backward-token-1): New functions to move by tokens.
c-guess-basic-syntax): Fixes for Java 1.1 array initialization brace lists.

1 files changed, 108 insertions, 48 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f4f37379a5b..31a26c3c3c3 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -271,6 +271,53 @@
     (if lim (goto-char (max (point) lim)))))
 
 
+;; Moving by tokens, where a token is defined as all symbols and
+;; identifiers which aren't syntactic whitespace.  COUNT specifies the
+;; number of tokens to move forward; a negative COUNT moves backward.
+;; If BALANCED is true, move over balanced parens, otherwise move into
+;; them.  Also, if BALANCED is true, never move out of an enclosing
+;; paren.  LIM sets the limit for the movement.  Point is always left
+;; at the beginning of a token or at LIM.  Returns the number of
+;; tokens left to move (positive or negative).  If BALANCED is true, a
+;; move over a balanced paren counts as one.
+
+(defun c-forward-token-1 (&optional count balanced lim)
+  (let* ((jump-syntax (if balanced
+			  '(?w ?_ ?\" ?\\ ?/ ?$ ?' ?\( ?\))
+			'(?w ?_ ?\" ?\\ ?/ ?$ ?'))))
+    (or count (setq count 1))
+    (condition-case nil
+	(while (progn
+		 (c-forward-syntactic-ws lim)
+		 (> count 0))
+	  (if (memq (char-syntax (char-after)) jump-syntax)
+	      (goto-char (scan-sexps (point) 1))
+	    (forward-char))
+	  (setq count (1- count)))
+      (error
+       (and lim (> (point) lim) (goto-char lim))))
+    count))
+
+(defun c-backward-token-1 (&optional count balanced lim)
+  (let* ((jump-syntax (if balanced
+			  '(?w ?_ ?\" ?\\ ?/ ?$ ?' ?\( ?\))
+			'(?w ?_ ?\" ?\\ ?/ ?$ ?')))
+	 last)
+    (or count (setq count 1))
+    (condition-case nil
+	(while (> count 0)
+	  (setq last (point))
+	  (c-backward-syntactic-ws lim)
+	  (if (memq (char-syntax (char-before)) jump-syntax)
+	      (goto-char (scan-sexps (point) -1))
+	    (backward-char))
+	  (setq count (1- count)))
+      (error
+       (goto-char last)
+       (and lim (< (point) lim) (goto-char lim))))
+    count))
+
+
 ;; Return `c' if in a C-style comment, `c++' if in a C++ style
 ;; comment, `string' if in a string literal, `pound' if on a
 ;; preprocessor line, or nil if not in a comment at all.  Optional LIM
@@ -376,24 +423,30 @@
   ;; If the argument is a cons of two buffer positions (such as
   ;; returned by c-literal-limits), and that range contains a C++
   ;; style line comment, then an extended range is returned that
-  ;; contains all adjacent line comments (i.e. all comments with no
-  ;; empty lines or non-whitespace characters between them).
-  ;; Otherwise the argument is returned.
+  ;; contains all adjacent line comments (i.e. all comments that
+  ;; starts in the same column with no empty lines or non-whitespace
+  ;; characters between them).  Otherwise the argument is returned.
   (save-excursion
     (condition-case nil
 	(if (and (consp range) (progn
 				 (goto-char (car range))
 				 (looking-at "//")))
-	    (let ((beg (point)))
+	    (let ((col (current-column))
+		  (beg (point))
+		  (end (cdr range)))
 	      (while (and (not (bobp))
 			  (forward-comment -1)
-			  (looking-at "//"))
+			  (looking-at "//")
+			  (= col (current-column)))
 		(setq beg (point)))
-	      (cons beg (progn
-			  (goto-char (cdr range))
-			  (while (looking-at "[ \t]*//")
-			    (forward-comment 1))
-			  (point))))
+	      (goto-char end)
+	      (while (progn
+		       (skip-chars-forward " \t")
+		       (and (looking-at "//")
+			    (= col (current-column))))
+		(forward-comment 1)
+		(setq end (point)))
+	      (cons beg end))
 	  range)
       (error range))))
 
@@ -850,35 +903,32 @@
   ;; speed.
   (or
    ;; this will pick up enum lists
-   (condition-case ()
-       (save-excursion
-	 (goto-char containing-sexp)
-	 (forward-sexp -1)
-	 (if (and (or (looking-at "enum[\t\n ]+")
-		      (progn (forward-sexp -1)
-			     (looking-at "enum[\t\n ]+")))
-		  (progn (c-end-of-statement-1)
-			 (> (point) containing-sexp)))
-	     (point)))
-     (error nil))
+   (c-safe
+    (save-excursion
+      (goto-char containing-sexp)
+      (forward-sexp -1)
+      (let (bracepos)
+	(if (and (or (looking-at "enum[\t\n ]+")
+		     (progn (forward-sexp -1)
+			    (looking-at "enum[\t\n ]+")))
+		 (setq bracepos (c-safe (scan-lists (point) 1 -1)))
+		 (not (c-crosses-statement-barrier-p (point)
+						     (- bracepos 2))))
+	    (point)))))
    ;; this will pick up array/aggregate init lists, even if they are nested.
    (save-excursion
-     (let (bufpos failedp)
+     (let (bufpos okp)
        (while (and (not bufpos)
 		   containing-sexp)
 	 (if (consp containing-sexp)
 	     (setq containing-sexp (car brace-state)
 		   brace-state (cdr brace-state))
-	   ;; see if significant character just before brace is an equal
+	   ;; see if the open brace is preceded by a = in this statement
 	   (goto-char containing-sexp)
-	   (setq failedp nil)
-	   (condition-case ()
-	       (progn
-		 (forward-sexp -1)
-		 (forward-sexp 1)
-		 (c-forward-syntactic-ws containing-sexp))
-	     (error (setq failedp t)))
-	   (if (or failedp (not (eq (char-after) ?=)))
+	   (setq okp t)
+	   (while (and (setq okp (= (c-backward-token-1 1 t) 0))
+		       (not (memq (char-after) '(?= ?{ ?\;)))))
+	   (if (not (and okp (eq (char-after) ?=)))
 	       ;; lets see if we're nested. find the most nested
 	       ;; containing brace
 	       (setq containing-sexp (car brace-state)
@@ -1109,7 +1159,12 @@
 			   (c-forward-syntactic-ws indent-point)))
 		(setq placeholder (c-point 'boi))
 		(and (or (looking-at "enum[ \t\n]+")
-			 (eq char-before-ip ?=))
+			 (save-excursion
+			   (goto-char indent-point)
+			   (while (and (> (point) placeholder)
+				       (= (c-backward-token-1 1 t) 0)
+				       (/= (char-after) ?=)))
+			   (eq (char-after) ?=)))
 		     (save-excursion
 		       (skip-chars-forward "^;(" indent-point)
 		       (not (memq (char-after) '(?\; ?\()))
@@ -1122,7 +1177,9 @@
 	     ;; CASE 5A.5: ordinary defun open
 	     (t
 	      (goto-char placeholder)
-	      (c-add-syntax 'defun-open (c-point 'bol))
+	      (if inclass-p
+		  (c-add-syntax 'defun-open (c-point 'boi))
+		(c-add-syntax 'defun-open (c-point 'bol)))
 	      )))
 	   ;; CASE 5B: first K&R arg decl or member init
 	   ((c-just-after-func-arglist-p)
@@ -1302,7 +1359,7 @@
 		 (looking-at c-access-key))
 	    (c-add-syntax 'access-label (c-point 'bonl))
 	    (c-add-syntax 'inclass (aref inclass-p 0)))
-	   ;; CASE 5F: extern-lang-close?
+	   ;; CASE 5F: extern-lang-close or namespace-close?
 	   ((and inenclosing-p
 		 (eq char-after-ip ?}))
 	    (setq tmpsymbol (if (eq inenclosing-p 'extern)
@@ -1389,9 +1446,9 @@
 			(goto-char (aref inclass-p 0)))
 		    (cond
 		     ((eq inenclosing-p 'extern)
-		      (c-add-syntax 'inextern-lang))
+		      (c-add-syntax 'inextern-lang (c-point 'boi)))
 		     ((eq inenclosing-p 'namespace)
-		      (c-add-syntax 'innamespace))
+		      (c-add-syntax 'innamespace (c-point 'boi)))
 		     (t (c-add-syntax 'inclass (c-point 'boi))))
 		    ))
 	      ))
@@ -1566,7 +1623,12 @@
 	       ((or (save-excursion
 		      (goto-char placeholder)
 		      (looking-at "\\<enum\\>"))
-		    (eq char-before-ip ?=))
+		    (save-excursion
+		      (goto-char indent-point)
+		      (while (and (> (point) placeholder)
+				  (= (c-backward-token-1 1 t) 0)
+				  (/= (char-after) ?=)))
+		      (eq (char-after) ?=)))
 		(c-add-syntax 'brace-list-open placeholder))
 	       ;; CASE 9B.3: catch-all for unknown construct.
 	       (t
@@ -1642,17 +1704,15 @@
 			       (c-beginning-of-statement-1 lim))
 			   (c-point 'boi))))
 	    (cond
-	     ;; CASE 14A: does this close an inline?
-	     ((let ((inclass-p (progn
-				 (goto-char containing-sexp)
-				 (c-search-uplist-for-classkey state))))
-		;; inenclosing-p in higher level let*
-		(setq inenclosing-p (and inclass-p
-					 (progn
-					   (goto-char (aref inclass-p 0))
-					   (looking-at c-extra-toplevel-key))))
-		(and inclass-p (not inenclosing-p)))
-	      (c-add-syntax 'inline-close relpos))
+	     ;; CASE 14A: does this close an inline or a function in
+	     ;; an extern block or namespace?
+	     ((progn
+		(goto-char containing-sexp)
+		(setq placeholder (c-search-uplist-for-classkey state)))
+	      (goto-char (aref placeholder 0))
+	      (if (looking-at c-extra-toplevel-key)
+		  (c-add-syntax 'defun-close relpos)
+		(c-add-syntax 'inline-close relpos)))
 	     ;; CASE 14B: if there an enclosing brace that hasn't
 	     ;; been narrowed out by a class, then this is a
 	     ;; block-close