lisp/progmodes/cc-menus.el

   1 ;;; cc-menus.el --- imenu support for CC Mode
   2
   3 ;; Copyright (C) 1985, 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   4 ;;   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   5 ;;   Free Software Foundation, Inc.
   6
   7 ;; Authors:    1998- Martin Stjernholm
   8 ;;             1992-1999 Barry A. Warsaw
   9 ;;             1987 Dave Detlefs
  10 ;;             1987 Stewart Clamen
  11 ;;             1985 Richard M. Stallman
  12 ;; Maintainer: bug-cc-mode@gnu.org
  13 ;; Created:    22-Apr-1997 (split from cc-mode.el)
  14 ;; Version:    See cc-mode.el
  15 ;; Keywords:   c languages oop
  16
  17 ;; This file is part of GNU Emacs.
  18
  19 ;; GNU Emacs is free software: you can redistribute it and/or modify
  20 ;; it under the terms of the GNU General Public License as published by
  21 ;; the Free Software Foundation, either version 3 of the License, or
  22 ;; (at your option) any later version.
  23
  24 ;; GNU Emacs is distributed in the hope that it will be useful,
  25 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 ;; GNU General Public License for more details.
  28
  29 ;; You should have received a copy of the GNU General Public License
  30 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  31
  32 ;;; Commentary:
  33
  34 ;;; Code:
  35
  36 (eval-when-compile
  37   (let ((load-path
  38          (if (and (boundp 'byte-compile-dest-file)
  39                   (stringp byte-compile-dest-file))
  40              (cons (file-name-directory byte-compile-dest-file) load-path)
  41            load-path)))
  42     (load "cc-bytecomp" nil t)))
  43
  44 (cc-require 'cc-defs)
  45
  46 ;; The things referenced in imenu, which we don't require.
  47 (cc-bytecomp-defvar imenu-case-fold-search)
  48 (cc-bytecomp-defvar imenu-generic-expression)
  49 (cc-bytecomp-defvar imenu-create-index-function)
  50
  51 \f
  52 ;; imenu integration
  53 (defvar cc-imenu-c-prototype-macro-regexp nil
  54   "RE matching macro names used to conditionally specify function prototypes.
  55
  56 For example:
  57
  58     #ifdef __STDC__
  59       #define _P(x) x
  60     #else
  61       #define _P(x) /*nothing*/
  62     #endif
  63
  64     int main _P( (int argc, char *argv[]) )
  65
  66 A sample value might look like: `\\(_P\\|_PROTO\\)'.")
  67
  68 (defvar cc-imenu-c++-generic-expression
  69   `(
  70     ;; Try to match ::operator definitions first. Otherwise `X::operator new ()'
  71     ;; will be incorrectly recognised as function `new ()' because the regexps
  72     ;; work by backtracking from the end of the definition.
  73     (nil
  74      ,(concat
  75        "^\\<.*"
  76        "[^" c-alnum "_:<>~]"                  ; match any non-identifier char
  77                                               ; (note: this can be `\n')
  78        "\\("
  79           "\\([" c-alnum "_:<>~]*::\\)?"      ; match an operator
  80           "operator\\>[ \t]*"
  81           "\\(()\\|[^(]*\\)"                  ; special case for `()' operator
  82        "\\)"
  83
  84        "[ \t]*([^)]*)[ \t]*[^ \t;]"           ; followed by ws, arg list,
  85                                               ; require something other than
  86                                               ; a `;' after the (...) to
  87                                               ; avoid prototypes.  Can't
  88                                               ; catch cases with () inside
  89                                               ; the parentheses surrounding
  90                                               ; the parameters.  e.g.:
  91                                               ; `int foo(int a=bar()) {...}'
  92        ) 1)
  93     ;; Special case to match a line like `main() {}'
  94     ;; e.g. no return type, not even on the previous line.
  95     (nil
  96      ,(concat
  97        "^"
  98        "\\([" c-alpha "_][" c-alnum "_:<>~]*\\)" ; match function name
  99        "[ \t]*("                              ; see above, BUT
 100        "[ \t]*\\([^ \t(*][^)]*\\)?)"          ; the arg list must not start
 101        "[ \t]*[^ \t;(]"                       ; with an asterisk or parentheses
 102        ) 1)
 103     ;; General function name regexp
 104     (nil
 105      ,(concat
 106        "^\\<"                                 ; line MUST start with word char
 107        ;; \n added to prevent overflow in regexp matcher.
 108        ;; http://lists.gnu.org/archive/html/emacs-pretest-bug/2007-02/msg00021.html
 109        "[^()\n]*"                             ; no parentheses before
 110        "[^" c-alnum "_:<>~]"                  ; match any non-identifier char
 111        "\\([" c-alpha "_][" c-alnum "_:<>~]*\\)" ; match function name
 112        "\\([ \t\n]\\|\\\\\n\\)*("             ; see above, BUT the arg list
 113        "\\([ \t\n]\\|\\\\\n\\)*\\([^ \t\n(*][^)]*\\)?)" ; must not start
 114        "\\([ \t\n]\\|\\\\\n\\)*[^ \t\n;(]"    ; with an asterisk or parentheses
 115        ) 1)
 116     ;; Special case for definitions using phony prototype macros like:
 117     ;; `int main _PROTO( (int argc,char *argv[]) )'.
 118     ;; This case is only included if cc-imenu-c-prototype-macro-regexp is set.
 119     ;; Only supported in c-code, so no `:<>~' chars in function name!
 120     ,@(if cc-imenu-c-prototype-macro-regexp
 121             `((nil
 122                  ,(concat
 123                    "^\\<.*"                   ; line MUST start with word char
 124                    "[^" c-alnum "_]"          ; match any non-identifier char
 125                    "\\([" c-alpha "_][" c-alnum "_]*\\)" ; match function name
 126                    "[ \t]*"                   ; whitespace before macro name
 127                    cc-imenu-c-prototype-macro-regexp
 128                    "[ \t]*("                  ; ws followed by first paren.
 129                    "[ \t]*([^)]*)[ \t]*)[ \t]*[^ \t;]" ; see above
 130                    ) 1)))
 131     ;; Class definitions
 132     ("Class"
 133      ,(concat
 134          "^"                                  ; beginning of line is required
 135          "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a `template <...>'
 136          "\\(class\\|struct\\)[ \t]+"
 137          "\\("                                ; the string we want to get
 138          "[" c-alnum "_]+"                    ; class name
 139          "\\(<[^>]+>\\)?"                     ; possibly explicitly specialized
 140          "\\)"
 141          "\\([ \t\n]\\|\\\\\n\\)*[:{]"
 142          ) 3))
 143   "Imenu generic expression for C++ mode.  See `imenu-generic-expression'.")
 144
 145 (defvar cc-imenu-c-generic-expression
 146   cc-imenu-c++-generic-expression
 147   "Imenu generic expression for C mode.  See `imenu-generic-expression'.")
 148
 149 (defvar cc-imenu-java-generic-expression
 150   `((nil
 151      ,(concat
 152        "[" c-alpha "_][\]\[." c-alnum "_<> ]+[ \t\n\r]+" ; type spec
 153        "\\([" c-alpha "_][" c-alnum "_]*\\)" ; method name
 154        "[ \t\n\r]*"
 155        ;; An argument list htat is either empty or contains any number
 156        ;; of arguments.  An argument is any number of annotations
 157        ;; followed by a type spec followed by a word.  A word is an
 158        ;; identifier.  A type spec is an identifier, possibly followed
 159        ;; by < typespec > possibly followed by [].
 160        (concat "("
 161                "\\("
 162                "[ \t\n\r]*"
 163                "\\("
 164                "@"
 165                "[" c-alpha "_]"
 166                "[" c-alnum "._]""*"
 167                "[ \t\n\r]+"
 168                "\\)*"
 169                "\\("
 170                "[" c-alpha "_]"
 171                "[\]\[" c-alnum "_.]*"
 172                "\\("
 173
 174                "<"
 175                "[ \t\n\r]*"
 176                "[\]\[.," c-alnum "_<> \t\n\r]*"
 177                ">"
 178                "\\)?"
 179                "\\(\\[\\]\\)?"
 180                "[ \t\n\r]+"
 181                "\\)"
 182                "[" c-alpha "_]"
 183                "[" c-alnum "_]*"
 184                "[ \t\n\r,]*"
 185                "\\)*"
 186                ")"
 187                "[.," c-alnum " \t\n\r]*"
 188                "{"
 189                )) 1))
 190   "Imenu generic expression for Java mode.  See
 191 `imenu-generic-expression'.")
 192
 193 ;;                        *Warning for cc-mode developers*
 194 ;;
 195 ;; `cc-imenu-objc-generic-expression' elements depend on
 196 ;; `cc-imenu-c++-generic-expression'. So if you change this
 197 ;; expression, you need to change following variables,
 198 ;; `cc-imenu-objc-generic-expression-*-index',
 199 ;; too. `cc-imenu-objc-function' uses these *-index variables, in
 200 ;; order to know where the each regexp *group \\(foobar\\)* elements
 201 ;; are started.
 202 ;;
 203 ;; *-index variables are initialized during `cc-imenu-objc-generic-expression'
 204 ;; being initialized.
 205 ;;
 206
 207 ;; Internal variables
 208 (defvar cc-imenu-objc-generic-expression-noreturn-index nil)
 209 (defvar cc-imenu-objc-generic-expression-general-func-index nil)
 210 (defvar cc-imenu-objc-generic-expression-proto-index nil)
 211 (defvar cc-imenu-objc-generic-expression-objc-base-index nil)
 212
 213 (defvar cc-imenu-objc-generic-expression
 214   (concat
 215    ;;
 216    ;; For C
 217    ;;
 218    ;; > Special case to match a line like `main() {}'
 219    ;; > e.g. no return type, not even on the previous line.
 220    ;; Pick a token by (match-string 1)
 221    (car (cdr (nth 1 cc-imenu-c++-generic-expression))) ; -> index += 2
 222    (prog2 (setq cc-imenu-objc-generic-expression-noreturn-index 1) "")
 223    "\\|"
 224    ;; > General function name regexp
 225    ;; Pick a token by  (match-string 3)
 226    (car (cdr (nth 2 cc-imenu-c++-generic-expression))) ; -> index += 5
 227    (prog2 (setq cc-imenu-objc-generic-expression-general-func-index 3) "")
 228    ;; > Special case for definitions using phony prototype macros like:
 229    ;; > `int main _PROTO( (int argc,char *argv[]) )'.
 230    ;; Pick a token by  (match-string 8)
 231    (if cc-imenu-c-prototype-macro-regexp
 232        (concat
 233         "\\|"
 234         (car (cdr (nth 3 cc-imenu-c++-generic-expression))) ; -> index += 1
 235         (prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 9) "")
 236         )
 237      (prog2 (setq cc-imenu-objc-generic-expression-objc-base-index 8) "")
 238      "")                                ; -> index += 0
 239    (prog2 (setq cc-imenu-objc-generic-expression-proto-index 8) "")
 240    ;;
 241    ;; For Objective-C
 242    ;; Pick a token by (match-string 8 or 9)
 243    ;;
 244    "\\|\\("
 245    "^[-+][:" c-alnum "()*_<>\n\t ]*[;{]"        ; Methods
 246    "\\|"
 247    "^@interface[\t ]+[" c-alnum "_]+[\t ]*:"
 248    "\\|"
 249    "^@interface[\t ]+[" c-alnum "_]+[\t ]*([" c-alnum "_]+)"
 250    "\\|"
 251    ;; For NSObject, NSProxy and Object... They don't have super class.
 252    "^@interface[\t ]+[" c-alnum "_]+[\t ]*.*$"
 253    "\\|"
 254    "^@implementation[\t ]+[" c-alnum "_]+[\t ]*([" c-alnum "_]+)"
 255    "\\|"
 256    "^@implementation[\t ]+[" c-alnum "_]+"
 257    "\\|"
 258    "^@protocol[\t ]+[" c-alnum "_]+" "\\)")
 259   "Imenu generic expression for ObjC mode.  See `imenu-generic-expression'.")
 260
 261
 262 ;; Imenu support for objective-c uses functions.
 263 (defsubst cc-imenu-objc-method-to-selector (method)
 264   "Return the objc selector style string of METHOD.
 265 Example:
 266 - perform: (SEL)aSelector withObject: object1 withObject: object2; /* METHOD */
 267 =>
 268 -perform:withObject:withObject:withObject: /* selector */"
 269   (let ((return "")                     ; String to be returned
 270         (p 0)                           ; Current scanning position in METHOD
 271         (pmax (length method))          ;
 272         char                            ; Current scanning target
 273         (betweenparen 0)                ; CHAR is in parentheses.
 274         argreq                          ; An argument is required.
 275         inargvar)                       ; position of CHAR is in an argument variable.
 276     (while (< p pmax)
 277       (setq char (aref method p)
 278             p (1+ p))
 279       (cond
 280        ;; Is CHAR part of a objc token?
 281        ((and (not inargvar)     ; Ignore if CHAR is part of an argument variable.
 282              (eq 0 betweenparen) ; Ignore if CHAR is in parentheses.
 283              (or (and (<= ?a char) (<= char ?z))
 284                  (and (<= ?A char) (<= char ?Z))
 285                  (and (<= ?0 char) (<= char ?9))
 286                  (= ?_ char)))
 287         (if argreq
 288             (setq inargvar t
 289                   argreq nil)
 290           (setq return (concat return (char-to-string char)))))
 291        ;; Or a white space?
 292        ((and inargvar (or (eq ?\  char) (eq ?\n char))
 293              (setq inargvar nil)))
 294        ;; Or a method separator?
 295        ;; If a method separator, the next token will be an argument variable.
 296        ((eq ?: char)
 297         (setq argreq t
 298               return (concat return (char-to-string char))))
 299        ;; Or an open parentheses?
 300        ((eq ?\( char)
 301         (setq betweenparen (1+ betweenparen)))
 302        ;; Or a close parentheses?
 303        ((eq ?\) char)
 304         (setq betweenparen (1- betweenparen)))))
 305     return))
 306
 307 (defun cc-imenu-objc-remove-white-space  (str)
 308   "Remove all spaces and tabs from STR."
 309   (let ((return "")
 310         (p 0)
 311         (max (length str))
 312         char)
 313     (while (< p max)
 314       (setq char (aref str p))
 315       (setq p (1+ p))
 316       (if (or (= char ?\ ) (= char ?\t))
 317           ()
 318         (setq return (concat return (char-to-string char)))))
 319     return))
 320
 321 (defun cc-imenu-objc-function ()
 322   "Imenu support for Objective C mode."
 323   (let (methodlist
 324         clist
 325         ;;
 326         ;; OBJC, Cnoreturn, Cgeneralfunc, Cproto are constants.
 327         ;;
 328         ;;                  *Warning for developers*
 329         ;; These constants depend on `cc-imenu-c++-generic-expression'.
 330         ;;
 331         (OBJC cc-imenu-objc-generic-expression-objc-base-index)
 332         ;; Special case to match a line like `main() {}'
 333         (Cnoreturn cc-imenu-objc-generic-expression-noreturn-index)
 334         ;; General function name regexp
 335         (Cgeneralfunc cc-imenu-objc-generic-expression-general-func-index)
 336         ;; Special case for definitions using phony prototype macros like:
 337         (Cproto cc-imenu-objc-generic-expression-proto-index)
 338         langnum
 339         ;;
 340         (classcount 0)
 341         toplist
 342         str
 343         str2
 344         (intflen (length "@interface"))
 345         (implen  (length "@implementation"))
 346         (prtlen  (length "@protocol"))
 347         (func
 348          ;;
 349          ;; Does this emacs have buffer-substring-no-properties?
 350          ;;
 351          (if (fboundp 'buffer-substring-no-properties)
 352              'buffer-substring-no-properties
 353            'buffer-substring)))
 354     (goto-char (point-max))
 355     ;;
 356     (while (re-search-backward cc-imenu-objc-generic-expression nil t)
 357       (setq langnum (if (match-beginning OBJC)
 358                         OBJC
 359                       (cond
 360                        ((match-beginning Cproto) Cproto)
 361                        ((match-beginning Cgeneralfunc) Cgeneralfunc)
 362                        ((match-beginning Cnoreturn) Cnoreturn))))
 363       (setq str (funcall func (match-beginning langnum) (match-end langnum)))
 364       ;;
 365       (cond
 366        ;;
 367        ;; C
 368        ;;
 369        ((not (eq langnum OBJC))
 370         (setq clist (cons (cons str (match-beginning langnum)) clist)))
 371        ;;
 372        ;; ObjC
 373        ;;
 374        ;; An instance Method
 375        ((eq (aref str 0) ?-)
 376         (setq str (concat "-" (cc-imenu-objc-method-to-selector str)))
 377         (setq methodlist (cons (cons str
 378                               (match-beginning langnum))
 379                         methodlist)))
 380        ;; A factory Method
 381        ((eq (aref str 0) ?+)
 382         (setq str (concat "+" (cc-imenu-objc-method-to-selector str)))
 383         (setq methodlist (cons (cons str
 384                               (match-beginning langnum))
 385                         methodlist)))
 386        ;; Interface or implementation or protocol
 387        ((eq (aref str 0) ?@)
 388         (setq classcount (1+ classcount))
 389         (cond
 390          ((and (> (length str) implen)
 391                (string= (substring  str 0 implen) "@implementation"))
 392           (setq str (substring str implen)
 393                 str2 "@implementation"))
 394          ((string= (substring  str 0 intflen) "@interface")
 395           (setq str (substring str intflen)
 396                 str2 "@interface"))
 397          ((string= (substring  str 0 prtlen) "@protocol")
 398           (setq str (substring str prtlen)
 399                 str2 "@protocol")))
 400         (setq str (cc-imenu-objc-remove-white-space str))
 401         (setq methodlist (cons (cons str2
 402                               (match-beginning langnum))
 403                                methodlist))
 404         (setq toplist (cons nil (cons (cons str
 405                                           methodlist) toplist))
 406               methodlist nil))))
 407     ;;
 408     (if (eq (car toplist) nil)
 409         (setq toplist (cdr toplist)))
 410
 411     ;; In this buffer, there is only one or zero @{interface|implementation|protocol}.
 412     (if (< classcount 2)
 413         (let ((classname (car (car toplist)))
 414               (p (cdr (car (cdr (car toplist)))))
 415               last)
 416           (setq toplist (cons (cons classname p) (cdr (cdr (car toplist)))))
 417           ;; Add C lang token
 418           (if clist
 419               (progn
 420                 (setq last toplist)
 421                 (while (cdr last)
 422                   (setq last (cdr last)))
 423                 (setcdr last clist))))
 424       ;; Add C lang tokens as a sub menu
 425       (if clist
 426           (setq toplist (cons (cons "C" clist) toplist))))
 427     ;;
 428     toplist
 429     ))
 430
 431 ;(defvar cc-imenu-pike-generic-expression
 432 ;  ())
 433 ; FIXME: Please contribute one!
 434
 435 (defun cc-imenu-init (mode-generic-expression
 436                       &optional mode-create-index-function)
 437   (setq imenu-generic-expression mode-generic-expression
 438         imenu-case-fold-search nil)
 439   (when mode-create-index-function
 440     (setq imenu-create-index-function mode-create-index-function)))
 441
 442 \f
 443 (cc-provide 'cc-menus)
 444
 445 ;; arch-tag: f6b60933-91f0-4145-ab44-70ca6d1b919b
 446 ;;; cc-menus.el ends here