emacs: lisp/progmodes/cc-menus.el comparison

comparison lisp/progmodes/cc-menus.el @ 88155:d7ddb3e565de

sync with trunk

author	Henrik Enberg <henrik.enberg@telia.com>
date	Mon, 16 Jan 2006 00:03:54 +0000
parents	0d8b17d428b5
children

comparison

equal deleted inserted replaced

-:8ce476d3ba36
+:d7ddb3e565de
 ;;; cc-menus.el --- imenu support for CC Mode
-;; Copyright (C) 1985,1987,1992-2001 Free Software Foundation, Inc.
+;; Copyright (C) 1985,1987,1992-2003, 2004, 2005 Free Software Foundation,
+;; Inc.
-;; Authors:    2000- Martin Stjernholm
-;;	       1998-1999 Barry A. Warsaw and Martin Stjernholm
+;; Authors:    1998- Martin Stjernholm
-;;             1992-1997 Barry A. Warsaw
+;;             1992-1999 Barry A. Warsaw
 ;;             1987 Dave Detlefs and Stewart Clamen
 ;;             1985 Richard M. Stallman
 ;; Maintainer: bug-cc-mode@gnu.org
 ;; Created:    22-Apr-1997 (split from cc-mode.el)
 ;; Version:    See cc-mode.el
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
 ;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; along with this program; see the file COPYING.  If not, write to
-;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02111-1307, USA.
+;; Boston, MA 02110-1301, USA.
 ;;; Commentary:
 ;;; Code:
 (let ((load-path
 	 (if (and (boundp 'byte-compile-dest-file)
 		  (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)
 ;; imenu integration
 (defvar cc-imenu-c-prototype-macro-regexp nil
 ;; 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
+"[^" 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
 "\\)"
 "[ \t]*([^)]*)[ \t]*[^ \t;]"           ; followed by ws, arg list,
 ;; Special case to match a line like `main() {}'
 ;; e.g. no return type, not even on the previous line.
 (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
 ) 1)
 ;; General function name regexp
 (nil
 ,(concat
 "^\\<"                                 ; line MUST start with word char
 "[^()]*"                               ; no parentheses before
-"[^a-zA-Z0-9_:<>~]"                    ; match any non-identifier char
+"[^" c-alnum "_:<>~]"                  ; match any non-identifier char
-"\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)"     ; match function name
+"\\([" 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
 ) 1)
 ;; Special case for definitions using phony prototype macros like:
 ;; 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
+		   "[^" c-alnum "_]"          ; match any non-identifier char
-"\\([a-zA-Z_][a-zA-Z0-9_]*\\)"       ; match function name
+		   "\\([" 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"
 ,(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'.")
 (defvar cc-imenu-java-generic-expression
 `((nil
 ,(concat
-"^\\([ \t]\\)*"
+"[" c-alpha "_][\]\[." c-alnum "_]+[ \t\n\r]+" ; type spec
-"\\([.A-Za-z0-9_-]+[ \t]+\\)?"	      ; type specs; there can be
+"\\([" c-alpha "_][" c-alnum "_]+\\)" ; method name
-"\\([.A-Za-z0-9_-]+[ \t]+\\)?"	      ; more than 3 tokens, right?
+"[ \t\n\r]*"
-"\\([.A-Za-z0-9_-]+[ \t]*[[]?[]]?\\)"
+;; An argument list that is either empty or contains at least
-"\\([ \t]\\)"
+;; two identifiers with only space between them.  This avoids
-"\\([A-Za-z0-9_-]+\\)"		      ; the string we want to get
+;; matching e.g. "else if (foo)".
-"\\([ \t]*\\)+("
+(concat "([ \t\n\r]*"
-"[][a-zA-Z,_1-9\n \t]*"		      ; arguments
+	       "\\([\]\[.," c-alnum "_]+"
-")[ \t]*"
+	       "[ \t\n\r]+"
-;       "[^;(]"
+	       "[\]\[.," c-alnum "_]"
-"[,a-zA-Z_1-9\n \t]*{"
+	       "[\]\[.," c-alnum "_ \t\n\r]*"
-) 6))
+	       "\\)?)")
+"[.," c-alnum "_ \t\n\r]*"
+"{"
+) 1))
 "Imenu generic expression for Java mode.  See `imenu-generic-expression'.")
 ;;                        *Warning for cc-mode developers*
 ;;
 ;; `cc-imenu-objc-generic-expression' elements depend on
 ;; `cc-imenu-c++-generic-expression'. So if you change this
 ;; expression, you need to change following variables,
 ;; `cc-imenu-objc-generic-expression-*-index',
 ;; too. `cc-imenu-objc-function' uses these *-index variables, in
 ;; order to know where the each regexp *group \\(foobar\\)* elements
 ;; are started.
 ;;
 ;; *-index variables are initialized during `cc-imenu-objc-generic-expression'
 ;; being initialized.
 ;;
 ;; Internal variables
 (defvar cc-imenu-objc-generic-expression-noreturn-index nil)
 (defvar cc-imenu-objc-generic-expression-general-func-index nil)
 (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
 ;;
 ;; For C
 ;;
 ;; > Special case to match a line like `main() {}'
 ;; > e.g. no return type, not even on the previous line.
 ;; Pick a token by (match-string 1)
 (car (cdr (nth 1 cc-imenu-c++-generic-expression))) ; -> index += 2
 (prog2 (setq cc-imenu-objc-generic-expression-noreturn-index 1) "")
 "\\|"
 ;; > 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
 	"\\|"
 	(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
+"^[-+][:" c-alnum "()*_<>\n\t ]*[;{]"        ; Methods
 "\\|"
-"^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*:"
+"^@interface[\t ]+[" c-alnum "_]+[\t ]*:"
 "\\|"
-"^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*([a-zA-Z0-9_]+)"
+"^@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 ]*.*$"
+"^@interface[\t ]+[" c-alnum "_]+[\t ]*.*$"
 "\\|"
-"^@implementation[\t ]+[a-zA-Z0-9_]+[\t ]*([a-zA-Z0-9_]+)"
+"^@implementation[\t ]+[" c-alnum "_]+[\t ]*([" c-alnum "_]+)"
 "\\|"
-"^@implementation[\t ]+[a-zA-Z0-9_]+"
+"^@implementation[\t ]+[" c-alnum "_]+"
 "\\|"
-"^@protocol[\t ]+[a-zA-Z0-9_]+" "\\)")
+"^@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:
 - 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)
 	     (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?
 (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))
 (let (methodlist
 	clist
 	;;
 	;; OBJC, Cnoreturn, Cgeneralfunc, Cproto are constants.
 	;;
 	;;                  *Warning for developers*
 	;; These constants depend on `cc-imenu-c++-generic-expression'.
 	;;
 	(OBJC cc-imenu-objc-generic-expression-objc-base-index)
 	;; Special case to match a line like `main() {}'
 	(Cnoreturn cc-imenu-objc-generic-expression-noreturn-index)
 	;;
 	(classcount 0)
 	toplist
 	stupid
 	str
 	str2
 	(intflen (length "@interface"))
 	(implen  (length "@implementation"))
 	(prtlen  (length "@protocol"))
 	(func
 	 ;;
 	 ;; Does this emacs has buffer-substring-no-properties?
 	 ;;
 	 (if (fboundp 'buffer-substring-no-properties)
 	     'buffer-substring-no-properties
 	   '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 OBJC)
 			OBJC
 		      (cond
 		       ((match-beginning Cproto) Cproto)
 		       ((match-beginning Cgeneralfunc) Cgeneralfunc)
 		       ((match-beginning Cnoreturn) Cnoreturn))))
 (setq str (funcall func (match-beginning langnum) (match-end langnum)))
 ;;
 (cond
 ;;
 ;; C
 ;;
 ((not (eq langnum OBJC))
 	(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))
 ((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")
 			      (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}.
 		(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)))
+(if clist
+	  (setq toplist (cons (cons "C" clist) toplist))))
 ;;
 toplist
 ))
 ;(defvar cc-imenu-pike-generic-expression
 ;  ())
 ; FIXME: Please contribute one!
-(defun cc-imenu-init (mode-generic-expression)
+(defun cc-imenu-init (mode-generic-expression
+		      &optional mode-create-index-function)
 (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)
+;;; arch-tag: f6b60933-91f0-4145-ab44-70ca6d1b919b
 ;;; cc-menus.el ends here

Mercurial > emacs

comparison lisp/progmodes/cc-menus.el @ 88155:d7ddb3e565de