(eval-when-compile
(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)))
(condition-case nil
(require 'imenu)
(error nil))
(cc-bytecomp-defvar imenu-case-fold-search)
(cc-bytecomp-defvar imenu-generic-expression)
(cc-bytecomp-defun imenu-progress-message)
(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
,(concat
"^\\<.*"
"[^a-zA-Z0-9_:<>~]" "\\("
"\\([a-zA-Z0-9_:<>~]*::\\)?" "operator\\>[ \t]*"
"\\(()\\|[^(]*\\)" "\\)"
"[ \t]*([^)]*)[ \t]*[^ \t;]" ) 1)
(nil
,(concat
"^"
"\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)" "[ \t]*(" "[ \t]*\\([^ \t(*][^)]*\\)?)" "[ \t]*[^ \t;(]" ) 1)
(nil
,(concat
"^\\<" "[^()]*" "[^a-zA-Z0-9_:<>~]" "\\([a-zA-Z_][a-zA-Z0-9_:<>~]*\\)" "[ \t]*(" "[ \t]*\\([^ \t(*][^)]*\\)?)" "[ \t]*[^ \t;(]" ) 1)
,@(if cc-imenu-c-prototype-macro-regexp
`((nil
,(concat
"^\\<.*" "[^a-zA-Z0-9_]" "\\([a-zA-Z_][a-zA-Z0-9_]*\\)" "[ \t]*" cc-imenu-c-prototype-macro-regexp
"[ \t]*(" "[ \t]*([^)]*)[ \t]*)[ \t]*[^ \t;]" ) 1)))
("Class"
,(concat
"^" "\\(template[ \t]*<[^>]+>[ \t]*\\)?" "\\(class\\|struct\\)[ \t]+"
"\\(" "[a-zA-Z0-9_]+" "\\(<[^>]+>\\)?" "\\)"
"[ \t\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]\\)*"
"\\([.A-Za-z0-9_-]+[ \t]+\\)?" "\\([.A-Za-z0-9_-]+[ \t]+\\)?" "\\([.A-Za-z0-9_-]+[ \t]*[[]?[]]?\\)"
"\\([ \t]\\)"
"\\([A-Za-z0-9_-]+\\)" "\\([ \t]*\\)+("
"[][a-zA-Z,_1-9\n \t]*" ")[ \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-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
(car (cdr (nth 1 cc-imenu-c++-generic-expression))) (prog2 (setq cc-imenu-objc-generic-expression-noreturn-index 1) "")
"\\|"
(car (cdr (nth 2 cc-imenu-c++-generic-expression))) (prog2 (setq cc-imenu-objc-generic-expression-general-func-index 3) "")
(if cc-imenu-c-prototype-macro-regexp
(concat
"\\|"
(car (cdr (nth 3 cc-imenu-c++-generic-expression))) (prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 6) "")
)
(prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 5) "")
"") (prog2 (setq cc-imenu-objc-generic-expression-proto-index 5) "")
"\\|\\("
"^[-+][:a-zA-Z0-9()*_<>\n\t ]*[;{]" "\\|"
"^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*:"
"\\|"
"^@interface[\t ]+[a-zA-Z0-9_]+[\t ]*([a-zA-Z0-9_]+)"
"\\|"
"^@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'.")
(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 "") (p 0) (pmax (length method)) char (betweenparen 0) argreq inargvar) (while (< p pmax)
(setq char (aref method p)
p (1+ p))
(cond
((and (not inargvar) (eq 0 betweenparen) (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)))))
((and inargvar (or (eq ?\ char) (eq ?\n char))
(setq inargvar nil)))
((eq ?: char)
(setq argreq t
return (concat return (char-to-string char))))
((eq ?\( char)
(setq betweenparen (1+ betweenparen)))
((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
(OBJC cc-imenu-objc-generic-expression-objc-base-index)
(Cnoreturn cc-imenu-objc-generic-expression-noreturn-index)
(Cgeneralfunc cc-imenu-objc-generic-expression-general-func-index)
(Cproto cc-imenu-objc-generic-expression-proto-index)
langnum
(classcount 0)
toplist
stupid
str
str2
(intflen (length "@interface"))
(implen (length "@implementation"))
(prtlen (length "@protocol"))
(func
(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
((not (eq langnum OBJC))
(setq clist (cons (cons str (match-beginning langnum)) clist)))
((eq (aref str 0) ?-)
(setq str (concat "-" (cc-imenu-objc-method-to-selector str)))
(setq methodlist (cons (cons str
(match-beginning langnum))
methodlist)))
((eq (aref str 0) ?+)
(setq str (concat "+" (cc-imenu-objc-method-to-selector str)))
(setq methodlist (cons (cons str
(match-beginning langnum))
methodlist)))
((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)))
(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)))))
(if clist
(progn
(setq last toplist)
(while (cdr last)
(setq last (cdr last)))
(setcdr last clist))))
(setq toplist (cons (cons "C" clist) toplist)))
toplist
))
(defun cc-imenu-init (mode-generic-expression)
(setq imenu-generic-expression mode-generic-expression
imenu-case-fold-search nil))
(cc-provide 'cc-menus)