(cc-imenu-c-prototype-macro-regexp): New var.

(cc-imenu-c++-generic-expression): Patches to better match C++ code.
Given by jan.dubois@ibm.net (Jan Dubois)

(cc-imenu-java-generic-expression):
Removed test for declaration
statements.  Patch given by Ake Stenhoff <etxaksf@aom.ericsson.se>, as
forwarded to me by RMS.

Imenu support for Objective-C given by Masatake (jet) YAMATO.

1 files changed, 261 insertions, 40 deletions

diff --git a/lisp/progmodes/cc-menus.el b/lisp/progmodes/cc-menus.el
index 20c7640b606..d758d0707f8 100644
--- a/lisp/progmodes/cc-menus.el
+++ b/lisp/progmodes/cc-menus.el
@@ -7,7 +7,7 @@
 ;;             1985 Richard M. Stallman
 ;; Maintainer: cc-mode-help@python.org
 ;; Created:    22-Apr-1997 (split from cc-mode.el)
-;; Version:    5.17
+;; Version:    5.18
 ;; Keywords:   c languages oop
 
 ;; This file is part of GNU Emacs.
@@ -29,56 +29,97 @@
 
 
 ;; imenu integration
+(defvar cc-imenu-c-prototype-macro-regexp nil
+  "RE matching macro names used to conditionally specify function prototypes.
+
+For example:
+
+    #ifdef __STDC__
+      #define _P(x) x
+    #else
+      #define _P(x) /*nothing*/
+    #endif
+
+    int main _P( (int argc, char *argv[]) )
+
+A sample value might look like: `\\(_P\\|_PROTO\\)'.")
+
 (defvar cc-imenu-c++-generic-expression
   (` 
-   ((nil
+   (
+    ;; Try to match ::operator definitions first. Otherwise `X::operator new ()'
+    ;; will be incorrectly recognised as function `new ()' because the regexps
+    ;; work by backtracking from the end of the definition.
+    (nil
+     (, 
+      (concat
+       "^\\<.*"
+       "[^a-zA-Z0-9_:<>~]"                    ; match any non-identifier char
+                                              ; (note: this can be `\n')
+       "\\("
+          "\\([a-zA-Z0-9_:<>~]*::\\)?"        ; match an operator
+          "operator\\>[ \t]*"
+          "\\(()\\|[^(]*\\)"                  ; special case for `()' operator
+       "\\)"
+
+       "[ \t]*([^)]*)[ \t]*[^ \t;]"           ; followed by ws, arg list,
+                                              ; require something other than
+                                              ; a `;' after the (...) to
+                                              ; avoid prototypes.  Can't
+                                              ; catch cases with () inside
+                                              ; the parentheses surrounding
+                                              ; the parameters.  e.g.:
+                                              ; `int foo(int a=bar()) {...}'
+       )) 1)
+    ;; Special case to match a line like `main() {}'
+    ;; e.g. no return type, not even on the previous line.
+    (nil
      (, 
       (concat
-       "^"				      ; beginning of line is required
-       "\\(template[ \t]*<[^>]+>[ \t]*\\)?"   ; there may be a "template <...>"
-       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"	      ; type specs; there can be no
-       "\\([a-zA-Z0-9_:]+[ \t]+\\)?"	      ; more than 3 tokens, right?
-        
-       "\\("				      ; last type spec including */&
-       "[a-zA-Z0-9_:]+"
-       "\\([ \t]*[*&]+[ \t]*\\|[ \t]+\\)"     ; either ptr/ref sign or ws
-       "\\)?"				      ; if there is a last type spec
-       "\\("				      ; name, take into the imenu entry
-       "[a-zA-Z0-9_:~]+"		      ; member func, ctor or dtor...
- 					      ; (may not contain * because then
- 					      ; "a::operator char*" would
-					      ; become "char*"!)
-       "\\|"
-       "\\([a-zA-Z0-9_:~]*::\\)?operator"
-       "[^a-zA-Z1-9_][^(]*"		      ; ...or operator
-       " \\)"
-       "[ \t]*([^)]*)[ \t\n]*[^		;]"   ; require something other than
-					      ; a `;' after the (...) to
-					      ; avoid prototypes.  Can't
-					      ; catch cases with () inside
-					      ; the parentheses surrounding
-					      ; the parameters.  e.g.:
-					      ; "int foo(int a=bar()) {...}"
-        
-       )) 6)    
+       "^"
+       "\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)"     ; match function name
+       "[ \t]*([^)]*)[ \t]*[^ \t;]"           ; see above
+       )) 1)
+    ;; Special case for definitions using phony prototype macros like:
+    ;; `int main _PROTO( (int argc,char *argv[]) )'.
+    ;; This case is only included if cc-imenu-c-prototype-macro-regexp is set.
+    ;; Only supported in c-code, so no `:<>~' chars in function name!
+    (,@ (if cc-imenu-c-prototype-macro-regexp
+            (` ((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
+                   "[ \t]*"                   ; whitespace before macro name
+                   cc-imenu-c-prototype-macro-regexp
+                   "[ \t]*("                  ; ws followed by first paren.
+                   "[ \t]*([^)]*)[ \t]*[^ \t;]" ; see above
+                   )) 1)))))
+    ;; General function name regexp
+    (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
+       "[ \t]*([^)]*)[ \t]*[^ \t;]"           ; see above
+       )) 1)
+    ;; Class definitions
     ("Class" 
      (, (concat 
- 	 "^"				      ; beginning of line is required
- 	 "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
- 	 "class[ \t]+"
- 	 "\\([a-zA-Z0-9_]+\\)"		      ; the string we want to get
- 	 "[ \t]*[:{]"
- 	 )) 2)))
+         "^"                                  ; beginning of line is required
+         "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a `template <...>'
+         "class[ \t]+"
+         "\\([a-zA-Z0-9_]+\\)"                ; the string we want to get
+         "[ \t]*[:{]"
+         )) 2)))
   "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'.")
 
-;(defvar cc-imenu-objc-generic-expression
-;  ())
-; Please contribute one!
-
 (defvar cc-imenu-java-generic-expression
   (`
    ((nil
@@ -93,11 +134,191 @@
        "\\([ \t]*\\)+("
        "\\([a-zA-Z,_1-9\n \t]*[[]?[]]?\\)*"   ; arguments
        ")[ \t]*"
-       "[^;(]"
+;       "[^;(]"
        "[,a-zA-Z_1-9\n \t]*{"               
        )) 6)))
   "Imenu generic expression for Java mode.  See `imenu-generic-expression'.")
 
+(defvar cc-imenu-objc-generic-expression 
+  (concat 
+   ;; For C 
+   ;; Pick a token by (match-string 6)
+   (car (cdr (car cc-imenu-c++-generic-expression))) 
+   ;; For Objective-C
+   ;; Pick a token by (match-string 8)
+   "\\|\\("					     
+   "^[-+][: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_]+)"
+   "\\|" 
+   ;; 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_]+" "\\)")
+  "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: 
+- perform: (SEL)aSelector withObject: object1 withObject: object2; /* METHOD */
+=>
+-perform:withObject:withObject:withObject: /* selector */"
+  (let ((return "")			; String to be returned
+	(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.
+	inargvar)			; position of CHAR is in an argument variable.
+    (while (< p pmax)
+      (setq char (aref method p)
+	    p (1+ p))
+      (cond
+       ;; Is CHAR part of a objc token?
+       ((and (not inargvar)     ; Ignore if CHAR is part of an argument variable.
+	     (eq 0 betweenparen) ; Ignore if CHAR is in parentheses.
+	     (or (and (<= ?a char) (<= char ?z))
+		 (and (<= ?A char) (<= char ?Z))
+		 (and (<= ?0 char) (<= char ?9))
+		 (= ?_ char)))
+	(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)) 
+	     (setq inargvar nil)))
+       ;; Or a method separator?
+       ;; If a method separator, the next token will be an argument variable.
+       ((eq ?: char)			
+	(setq argreq t			
+	      return (concat return (char-to-string char))))
+       ;; Or an open parentheses?
+       ((eq ?\( char)
+	(setq betweenparen (1+ betweenparen)))
+       ;; Or a close parentheses?
+       ((eq ?\) char)
+	(setq betweenparen (1- betweenparen)))))
+    return))
+
+(defun cc-imenu-objc-remove-white-space  (str)
+  "Remove all spaces and tabs from STR."
+  (let ((return "")
+	(p 0)
+	(max (length str)) 
+	char)
+    (while (< p max)
+      (setq char (aref str p))
+      (setq p (1+ p))
+      (if (or (= char ?\ ) (= char ?\t))
+	  ()
+	(setq return (concat return (char-to-string char)))))
+    return))
+
+(defun cc-imenu-objc-function ()
+  "imenu supports for objc-mode."
+  (let (methodlist
+	clist
+	(C 6)
+	(OBJC 8)
+	langnum
+	(classcount 0)
+	toplist
+	stupid
+	str
+	str2 
+	(intflen (length "@interface"))
+	(implen  (length "@implementation"))
+	(prtlen  (length "@protocol"))
+	bufsubst-fun)
+    ;;
+    ;; Does this emacs has buffer-substring-no-properties? 
+    ;;
+    (fset 'bufsubst-fun (if (fboundp 'buffer-substring-no-properties)
+			    (symbol-function 'buffer-substring-no-properties)
+			  (symbol-function 'buffer-substring)))
+    (goto-char (point-max)) 
+    (imenu-progress-message stupid 0)
+    ;;
+    (while (re-search-backward cc-imenu-objc-generic-expression nil t)
+      (imenu-progress-message stupid)
+      (setq langnum (if (match-beginning C) C OBJC))
+      (setq str (bufsubst-fun (match-beginning langnum) (match-end langnum)))
+      ;;
+      (cond 
+       ;;
+       ;; C
+       ;;
+       ((eq langnum C)
+	(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)))
+	(setq methodlist (cons (cons str
+			      (match-beginning langnum))
+			methodlist)))
+       ;; A factory Method
+       ((eq (aref str 0) ?+)
+	(setq str (concat "+" (cc-imenu-objc-method-to-selector str)))
+	(setq methodlist (cons (cons str
+			      (match-beginning langnum))
+			methodlist)))
+       ;; Interface or implementation or protocol 
+       ((eq (aref str 0) ?@)
+	(setq classcount (1+ classcount))
+	(cond 
+	 ((and (> (length str) implen)
+	       (string= (substring  str 0 implen) "@implementation"))
+	  (setq str (substring str implen)
+		str2 "@implementation"))
+	 ((string= (substring  str 0 intflen) "@interface")
+	  (setq str (substring str intflen)
+		str2 "@interface"))
+	 ((string= (substring  str 0 prtlen) "@protocol")
+	  (setq str (substring str prtlen)
+		str2 "@protocol")))
+	(setq str (cc-imenu-objc-remove-white-space str))
+	(setq methodlist (cons (cons str2
+			      (match-beginning langnum))
+			       methodlist))
+	(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)))
+
+    ;; In this buffer, there is only one or zero @{interface|implementation|protocol}.
+    (if (< classcount 2)
+	(let ((classname (car (car toplist)))
+	      (p (cdr (car (cdr (car toplist)))))
+	      last)
+	  (setq toplist (cons (cons classname p) (cdr (cdr (car toplist)))))
+	  ;; Add C lang token
+	  (if clist
+	      (progn
+		(setq last toplist)
+		(while (cdr last)
+		  (setq last (cdr last)))
+		(setcdr last clist))))
+      ;; Add C lang tokens as a sub menu
+      (setq toplist (cons (cons "C" clist) toplist)))
+    ;;
+    toplist
+    ))
+
 
 (provide 'cc-menus)
 ;;; cc-menus.el ends here