Updated CC Mode to version 5.30.

1 files changed, 87 insertions, 74 deletions

diff --git a/lisp/progmodes/cc-menus.el b/lisp/progmodes/cc-menus.el
index fe33b2f755..85fee9978d 100644
--- a/lisp/progmodes/cc-menus.el
+++ b/lisp/progmodes/cc-menus.el
@@ -1,10 +1,9 @@
 ;;; cc-menus.el --- imenu support for CC Mode
 
-;; Copyright (C) 1985,1987,1992-2001 Free Software Foundation, Inc.
+;; Copyright (C) 1985,1987,1992-2003 Free Software Foundation, Inc.
 
-;; Authors:    2000- Martin Stjernholm
-;;	       1998-1999 Barry A. Warsaw and Martin Stjernholm
-;;             1992-1997 Barry A. Warsaw
+;; Authors:    1998- Martin Stjernholm
+;;             1992-1999 Barry A. Warsaw
 ;;             1987 Dave Detlefs and Stewart Clamen
 ;;             1985 Richard M. Stallman
 ;; Maintainer: [email protected]
@@ -39,11 +38,14 @@
 		  (stringp byte-compile-dest-file))
 	     (cons (file-name-directory byte-compile-dest-file) load-path)
 	   load-path)))
-    (require 'cc-bytecomp)))
+    (load "cc-bytecomp" nil t)))
+
+(cc-require 'cc-defs)
 
 ;; The things referenced in imenu, which we don't require.
 (cc-bytecomp-defvar imenu-case-fold-search)
 (cc-bytecomp-defvar imenu-generic-expression)
+(cc-bytecomp-defvar imenu-create-index-function)
 (cc-bytecomp-defun imenu-progress-message)
 
 
@@ -71,10 +73,10 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
     (nil
      ,(concat
        "^\\<.*"
-       "[^a-zA-Z0-9_:<>~]"                    ; match any non-identifier char
+       "[^" c-alnum "_:<>~]"                  ; match any non-identifier char
                                               ; (note: this can be `\n')
        "\\("
-          "\\([a-zA-Z0-9_:<>~]*::\\)?"        ; match an operator
+	  "\\([" c-alnum "_:<>~]*::\\)?"      ; match an operator
           "operator\\>[ \t]*"
           "\\(()\\|[^(]*\\)"                  ; special case for `()' operator
        "\\)"
@@ -93,7 +95,7 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
     (nil
      ,(concat
        "^"
-       "\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)"     ; match function name
+       "\\([" c-alpha "_][" c-alnum "_:<>~]*\\)" ; match function name
        "[ \t]*("			      ; see above, BUT
        "[ \t]*\\([^ \t(*][^)]*\\)?)"          ; the arg list must not start
        "[ \t]*[^ \t;(]"                       ; with an asterisk or parentheses
@@ -103,8 +105,8 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
      ,(concat
        "^\\<"                                 ; line MUST start with word char
        "[^()]*"                               ; no parentheses before
-       "[^a-zA-Z0-9_:<>~]"                    ; match any non-identifier char
-       "\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)"     ; match function name
+       "[^" c-alnum "_:<>~]"                  ; match any non-identifier char
+       "\\([" c-alpha "_][" c-alnum "_:<>~]*\\)" ; match function name
        "\\([ \t\n]\\|\\\\\n\\)*("	      ; see above, BUT the arg list
        "\\([ \t\n]\\|\\\\\n\\)*\\([^ \t\n(*][^)]*\\)?)" ; must not start
        "\\([ \t\n]\\|\\\\\n\\)*[^ \t\n;(]"    ; with an asterisk or parentheses
@@ -117,27 +119,27 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
             `((nil
                  ,(concat
                    "^\\<.*"                   ; line MUST start with word char
-                   "[^a-zA-Z0-9_]"            ; match any non-identifier char
-                   "\\([a-zA-Z_][a-zA-Z0-9_]*\\)"       ; match function name
+		   "[^" c-alnum "_]"          ; match any non-identifier char
+		   "\\([" c-alpha "_][" c-alnum "_]*\\)" ; match function name
                    "[ \t]*"                   ; whitespace before macro name
                    cc-imenu-c-prototype-macro-regexp
                    "[ \t]*("                  ; ws followed by first paren.
                    "[ \t]*([^)]*)[ \t]*)[ \t]*[^ \t;]" ; see above
                    ) 1)))
     ;; Class definitions
-    ("Class"
+    ("Class" 
      ,(concat
          "^"                                  ; beginning of line is required
          "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a `template <...>'
          "\\(class\\|struct\\)[ \t]+"
          "\\("                                ; the string we want to get
-         "[a-zA-Z0-9_]+"                      ; class name
+	 "[" c-alnum "_]+"                    ; class name
          "\\(<[^>]+>\\)?"                     ; possibly explicitly specialized
          "\\)"
          "\\([ \t\n]\\|\\\\\n\\)*[:{]"
          ) 3))
   "Imenu generic expression for C++ mode.  See `imenu-generic-expression'.")
-
+ 
 (defvar cc-imenu-c-generic-expression
   cc-imenu-c++-generic-expression
   "Imenu generic expression for C mode.  See `imenu-generic-expression'.")
@@ -145,21 +147,24 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
 (defvar cc-imenu-java-generic-expression
   `((nil
      ,(concat
-       "^\\([ \t]\\)*"
-       "\\([.A-Za-z0-9_-]+[ \t]+\\)?"	      ; type specs; there can be
-       "\\([.A-Za-z0-9_-]+[ \t]+\\)?"	      ; more than 3 tokens, right?
-       "\\([.A-Za-z0-9_-]+[ \t]*[[]?[]]?\\)"
-       "\\([ \t]\\)"
-       "\\([A-Za-z0-9_-]+\\)"		      ; the string we want to get
-       "\\([ \t]*\\)+("
-       "[][a-zA-Z,_1-9\n \t]*"		      ; arguments
-       ")[ \t]*"
-;       "[^;(]"
-       "[,a-zA-Z_1-9\n \t]*{"
-       ) 6))
+       "[" c-alpha "_][\]\[." c-alnum "_]+[ \t\n\r]+" ; type spec
+       "\\([" c-alpha "_][" c-alnum "_]+\\)" ; method name
+       "[ \t\n\r]*"
+       ;; An argument list that is either empty or contains at least
+       ;; two identifiers with only space between them.  This avoids
+       ;; matching e.g. "else if (foo)".
+       (concat "([ \t\n\r]*"
+	       "\\([\]\[.," c-alnum "_]+"
+	       "[ \t\n\r]+"
+	       "[\]\[.," c-alnum "_]"
+	       "[\]\[.," c-alnum "_ \t\n\r]*"
+	       "\\)?)")
+       "[.," c-alnum "_ \t\n\r]*"
+       "{"
+       ) 1))
   "Imenu generic expression for Java mode.  See `imenu-generic-expression'.")
 
-;;                        *Warning for cc-mode developers*
+;;                        *Warning for cc-mode developers* 
 ;;
 ;; `cc-imenu-objc-generic-expression' elements depend on
 ;; `cc-imenu-c++-generic-expression'. So if you change this
@@ -169,8 +174,8 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
 ;; order to know where the each regexp *group \\(foobar\\)* elements
 ;; are started.
 ;;
-;; *-index variables are initialized during `cc-imenu-objc-generic-expression'
-;; being initialized.
+;; *-index variables are initialized during `cc-imenu-objc-generic-expression' 
+;; being initialized. 
 ;;
 
 ;; Internal variables
@@ -179,10 +184,10 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
 (defvar cc-imenu-objc-generic-expression-proto-index nil)
 (defvar cc-imenu-objc-generic-expression-objc-base-index nil)
 
-(defvar cc-imenu-objc-generic-expression
-  (concat
+(defvar cc-imenu-objc-generic-expression 
+  (concat 
    ;;
-   ;; For C
+   ;; For C 
    ;;
    ;; > Special case to match a line like `main() {}'
    ;; > e.g. no return type, not even on the previous line.
@@ -192,52 +197,53 @@ A sample value might look like: `\\(_P\\|_PROTO\\)'.")
    "\\|"
    ;; > General function name regexp
    ;; Pick a token by  (match-string 3)
-   (car (cdr (nth 2 cc-imenu-c++-generic-expression))) ; -> index += 2
+   (car (cdr (nth 2 cc-imenu-c++-generic-expression))) ; -> index += 5
    (prog2 (setq cc-imenu-objc-generic-expression-general-func-index 3) "")
    ;; > Special case for definitions using phony prototype macros like:
    ;; > `int main _PROTO( (int argc,char *argv[]) )'.
-   ;; Pick a token by  (match-string 5)
+   ;; Pick a token by  (match-string 8)
    (if cc-imenu-c-prototype-macro-regexp
-       (concat
+       (concat    
 	"\\|"
 	(car (cdr (nth 3 cc-imenu-c++-generic-expression))) ; -> index += 1
-	(prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 6) "")
+	(prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 9) "")
 	)
-     (prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 5) "")
+     (prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 8) "")
      "")				; -> index += 0
-   (prog2 (setq cc-imenu-objc-generic-expression-proto-index 5) "")
+   (prog2 (setq cc-imenu-objc-generic-expression-proto-index 8) "")
    ;;
    ;; For Objective-C
-   ;; Pick a token by (match-string 5 or 6)
+   ;; Pick a token by (match-string 8 or 9)
    ;;
-   "\\|\\("
-   "^[-+][:a-zA-Z0-9()*_<>\n\t ]*[;{]"        ; Methods
-   "\\|"
-   "^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*:"
-   "\\|"
-   "^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*([a-zA-Z0-9_]+)"
-   "\\|"
+   "\\|\\("					     
+   "^[-+][:" c-alnum "()*_<>\n\t ]*[;{]"        ; Methods
+   "\\|" 
+   "^@interface[\t ]+[" c-alnum "_]+[\t ]*:"
+   "\\|" 
+   "^@interface[\t ]+[" c-alnum "_]+[\t ]*([" c-alnum "_]+)"
+   "\\|" 
    ;; For NSObject, NSProxy and Object... They don't have super class.
-   "^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*.*$"
-   "\\|"
-   "^@implementation[\t ]+[a-zA-Z0-9_]+[\t ]*([a-zA-Z0-9_]+)"
-   "\\|"
-   "^@implementation[\t ]+[a-zA-Z0-9_]+"
-   "\\|"
-   "^@protocol[\t ]+[a-zA-Z0-9_]+" "\\)")
+   "^@interface[\t ]+[" c-alnum "_]+[\t ]*.*$"
+   "\\|" 
+   "^@implementation[\t ]+[" c-alnum "_]+[\t ]*([" c-alnum "_]+)"
+   "\\|" 
+   "^@implementation[\t ]+[" c-alnum "_]+"
+   "\\|" 
+   "^@protocol[\t ]+[" c-alnum "_]+" "\\)")
   "Imenu generic expression for ObjC mode.  See `imenu-generic-expression'.")
 
 
 ;; Imenu support for objective-c uses functions.
 (defsubst cc-imenu-objc-method-to-selector (method)
   "Return the objc selector style string of METHOD.
-Example:
+Example: 
 - perform: (SEL)aSelector withObject: object1 withObject: object2; /* METHOD */
 =>
 -perform:withObject:withObject:withObject: /* selector */"
+  ;; This function does not do any hidden buffer changes.
   (let ((return "")			; String to be returned
-	(p 0)				; Current scanning position in METHOD
-	(pmax (length method))		;
+	(p 0)				; Current scanning position in METHOD  
+	(pmax (length method))		; 
 	char				; Current scanning target
 	(betweenparen 0)		; CHAR is in parentheses.
 	argreq				; An argument is required.
@@ -253,17 +259,17 @@ Example:
 		 (and (<= ?A char) (<= char ?Z))
 		 (and (<= ?0 char) (<= char ?9))
 		 (= ?_ char)))
-	(if argreq
+	(if argreq	
 	    (setq inargvar t
 		  argreq nil)
 	  (setq return (concat return (char-to-string char)))))
        ;; Or a white space?
-       ((and inargvar (or (eq ?\  char) (eq ?\n char))
+       ((and inargvar (or (eq ?\  char) (eq ?\n char)) 
 	     (setq inargvar nil)))
        ;; Or a method separator?
        ;; If a method separator, the next token will be an argument variable.
-       ((eq ?: char)
-	(setq argreq t
+       ((eq ?: char)			
+	(setq argreq t			
 	      return (concat return (char-to-string char))))
        ;; Or an open parentheses?
        ((eq ?\( char)
@@ -275,9 +281,10 @@ Example:
 
 (defun cc-imenu-objc-remove-white-space  (str)
   "Remove all spaces and tabs from STR."
+  ;; This function does not do any hidden buffer changes.
   (let ((return "")
 	(p 0)
-	(max (length str))
+	(max (length str)) 
 	char)
     (while (< p max)
       (setq char (aref str p))
@@ -289,12 +296,13 @@ Example:
 
 (defun cc-imenu-objc-function ()
   "imenu supports for objc-mode."
+  ;; This function does not do any hidden buffer changes.
   (let (methodlist
 	clist
 	;;
 	;; OBJC, Cnoreturn, Cgeneralfunc, Cproto are constants.
 	;;
-	;;                  *Warning for developers*
+	;;                  *Warning for developers* 
 	;; These constants depend on `cc-imenu-c++-generic-expression'.
 	;;
 	(OBJC cc-imenu-objc-generic-expression-objc-base-index)
@@ -310,13 +318,13 @@ Example:
 	toplist
 	stupid
 	str
-	str2
+	str2 
 	(intflen (length "@interface"))
 	(implen  (length "@implementation"))
 	(prtlen  (length "@protocol"))
 	(func
 	 ;;
-	 ;; Does this emacs has buffer-substring-no-properties?
+	 ;; Does this emacs has buffer-substring-no-properties? 
 	 ;;
 	 (if (fboundp 'buffer-substring-no-properties)
 	     'buffer-substring-no-properties
@@ -326,7 +334,7 @@ Example:
     ;;
     (while (re-search-backward cc-imenu-objc-generic-expression nil t)
       (imenu-progress-message stupid)
-      (setq langnum (if (match-beginning OBJC)
+      (setq langnum (if (match-beginning OBJC) 
 			OBJC
 		      (cond
 		       ((match-beginning Cproto) Cproto)
@@ -334,7 +342,7 @@ Example:
 		       ((match-beginning Cnoreturn) Cnoreturn))))
       (setq str (funcall func (match-beginning langnum) (match-end langnum)))
       ;;
-      (cond
+      (cond 
        ;;
        ;; C
        ;;
@@ -342,7 +350,7 @@ Example:
 	(setq clist (cons (cons str (match-beginning langnum)) clist)))
        ;;
        ;; ObjC
-       ;;
+       ;; 
        ;; An instance Method
        ((eq (aref str 0) ?-)
 	(setq str (concat "-" (cc-imenu-objc-method-to-selector str)))
@@ -355,10 +363,10 @@ Example:
 	(setq methodlist (cons (cons str
 			      (match-beginning langnum))
 			methodlist)))
-       ;; Interface or implementation or protocol
+       ;; Interface or implementation or protocol 
        ((eq (aref str 0) ?@)
 	(setq classcount (1+ classcount))
-	(cond
+	(cond 
 	 ((and (> (length str) implen)
 	       (string= (substring  str 0 implen) "@implementation"))
 	  (setq str (substring str implen)
@@ -376,7 +384,7 @@ Example:
 	(setq toplist (cons nil (cons (cons str
 					  methodlist) toplist))
 	      methodlist nil))))
-    ;;
+    ;; 
     (imenu-progress-message stupid 100)
     (if (eq (car toplist) nil)
 	(setq toplist (cdr toplist)))
@@ -395,7 +403,8 @@ Example:
 		  (setq last (cdr last)))
 		(setcdr last clist))))
       ;; Add C lang tokens as a sub menu
-      (setq toplist (cons (cons "C" clist) toplist)))
+      (if clist
+	  (setq toplist (cons (cons "C" clist) toplist))))
     ;;
     toplist
     ))
@@ -404,9 +413,13 @@ Example:
 ;  ())
 ; FIXME: Please contribute one!
 
-(defun cc-imenu-init (mode-generic-expression)
+(defun cc-imenu-init (mode-generic-expression
+		      &optional mode-create-index-function)
+  ;; This function does not do any hidden buffer changes.
   (setq imenu-generic-expression mode-generic-expression
-	imenu-case-fold-search nil))
+	imenu-case-fold-search nil)
+  (when mode-create-index-function
+    (setq imenu-create-index-function mode-create-index-function)))
 
 
 (cc-provide 'cc-menus)