code.delx.au - gnu-emacs/blob - lisp/imenu.el

   1 ;;; imenu.el --- Framework for mode-specific buffer indexes.
   2
   3 ;; Copyright (C) 1994 Free Software Foundation, Inc.
   4
   5 ;; Author: Ake Stenhoff <etxaksf@aom.ericsson.se>
   6 ;;         Lars Lindberg <lli@sypro.cap.se>
   7 ;; Created: 8 Feb 1994
   8 ;; Version: 1.7
   9 ;; Keywords: tools
  10 ;;
  11 ;; This program is free software; you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15 ;;
  16 ;; This program is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20 ;;
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with this program; if not, write to the Free Software
  23 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24
  25 ;;; Commentary:
  26 ;;
  27 ;; Purpose of this package:
  28 ;;
  29 ;; Installation instructions
  30 ;;
  31 ;; Usage instructions:
  32 ;;
  33 ;; Known bugs:
  34 ;;
  35 ;; Purpose of this package:
  36 ;;   To present a framework for mode-specific buffer indexes.
  37 ;;   A buffer index is an alist of names and buffer positions.
  38 ;;   For instance all functions in a C-file and their positions.
  39 ;;
  40 ;; How it works:
  41
  42 ;;   A mode-specific function is called to generate the index.  It is
  43 ;;   then presented to the user, who can choose from this index.
  44 ;;
  45 ;;   The package comes with a set of example functions for how to
  46 ;;   utilize this package.
  47
  48 ;;   There are *examples* for index gathering functions for C/C++ and
  49 ;;   Lisp/Emacs Lisp but it is easy to customize for other modes.  A
  50 ;;   function for jumping to the chosen index position is also
  51 ;;   supplied.
  52 ;;
  53 ;; Installation:
  54 ;;   Put this file in your load-path and insert the following in .emacs
  55 ;;
  56 ;;   (autoload 'imenu-choose-buffer-index "imenu" "Menu of buffer index." t)
  57 ;;   (autoload 'goto-index-pos "imenu" "Goto buffer index position." t)
  58 ;;   (define-key global-map "\C-cj" 'goto-index-pos) ;; Or some other key
  59 ;;   (cond (window-system
  60 ;;          (define-key global-map [S-down-mouse-3] 'goto-index-pos)))
  61 ;;   Also run the 'add-hook' examples at the bottom of imenu.el.
  62
  63 ;;; Change Log:
  64 ;;    v1.7 Apr 12 1994 Ake Stenhoff
  65 ;;      Changed doc strings refering to symbols.
  66 ;;      Require 'cl' when compiling only.
  67 ;;      Only uses 'cl' macros.
  68 ;;    v1.6 Feb 28 1994 Ake Stenhoff
  69 ;;      Added alist as an optional argument to
  70 ;;     'imenu-choose-buffer-index'.
  71 ;;      Thanks [dean].
  72 ;;    v1.5 Feb 25 1994 Ake Stenhoff
  73 ;;      Added code to parse DEFSTRUCT, DEFCLASS, DEFTYPE,
  74 ;;      DEFINE-CONDITION in the lisp example function.
  75 ;;      Thanks [simon].
  76 ;;    v1.4 Feb 18 1994 Ake Stenhoff
  77 ;;      Added 'imenu-create-submenu-name' for creating a submenu name.
  78 ;;      This is for getting a general look of submenu names.
  79 ;;      Added variable 'imenu-submenu-name-format' used by
  80 ;;      'imenu-create-submenu-name'.
  81 ;;    v1.3 Feb 17 1994 Lars Lindberg
  82 ;;      Added 'imenu--flatten-index-alist' for flatten nexted index
  83 ;;      alists.
  84 ;;      New examples for lisp mode that utilizes the features better.
  85 ;;      Added the variable 'imenu-space-replacement'.
  86 ;;      The completion-buffer version of the index menu now replaces
  87 ;;      spaces in the index-names to make tokens of them.
  88 ;;    v1.2 Feb 14 1994 Ake Stenhoff & Lars Lindberg
  89 ;;      Now handles nested index lists.
  90 ;;    v1.1 Feb 9 1994 Ake Stenhoff & Lars Lindberg
  91 ;;       Better comments (?).
  92 ;;    v1.0 Feb 8 1994 Ake Stenhoff & Lars Lindberg
  93 ;;       Based on func-menu.el 3.5.
  94
  95 ;;; Thanks goes to
  96 ;;  [simon] - Simon Leinen simon@lia.di.epfl.ch
  97 ;;  [dean] - Dean Andrews ada@unison.com
  98 ;;
  99
 100 ;;; Code
 101 (eval-when-compile (require 'cl))
 102
 103 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 104 ;;;
 105 ;;; Customizable variables
 106 ;;;
 107 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 108
 109 (defvar imenu-always-use-completion-buffer-p nil
 110   "*Set this to non-nil for displaying the index in a completion buffer.
 111
 112 Non-nil means always display the index in a completion buffer.
 113 Nil means display the index as a mouse menu when the mouse was
 114 used to trigger `goto-index-pos'.")
 115
 116 (defvar imenu-sort-function nil
 117   "*The function to use for sorting the index mouse-menu.
 118
 119 Affects only the mouse index menu.
 120
 121 Set this to nil if you don't want any sorting (faster).
 122 The items in the menu are then presented in the order they were found
 123 in the buffer.
 124
 125 Set it to `imenu--sort-by-name' if you want alphabetic sorting.
 126
 127 The function should take two arguments and return T if the first
 128 element should come before the second.  The arguments are cons cells;
 129 (NAME . POSITION).  Look at `imenu--sort-by-name' for an example.")
 130
 131 (defvar imenu-max-items 25
 132   "*Maximum number of elements in an index mouse-menu.")
 133
 134 (defvar imenu-scanning-message "Scanning buffer for index. (%3d%%)"
 135   "*Progress message during the index scanning of the buffer.
 136 If non NIL, user gets a message during the scanning of the buffer
 137
 138 Relevant only if the mode-specific function that creates the buffer
 139 index use `imenu-progress-message'.")
 140
 141 (defvar imenu-space-replacement "^"
 142   "*The replacement string for spaces in index names.
 143 Used when presenting the index in a completion-buffer to make the
 144 names work as tokens.")
 145
 146 (defvar imenu-level-separator ":"
 147   "*The separator between index names of different levels.
 148 Used for making mouse-menu titles and for flattening nested indexes
 149 with name concatenation.")
 150
 151 (defvar imenu-submenu-name-format "%s..."
 152   "*The format for making a submenu name.")
 153
 154 ;;;; Hooks
 155
 156 (defvar imenu-create-index-function 'imenu-default-create-index-function
 157   "The function to use for creating a buffer index.
 158
 159 It should be a function that takes no arguments and returns an index
 160 of the current buffer as an alist. The elements in the alist look
 161 like: (INDEX-NAME . INDEX-POSITION). You may also nest index list like
 162 (INDEX-NAME . INDEX-ALIST).
 163
 164 This function is called within a `save-excursion'.
 165
 166 The variable is buffer-local.")
 167 (make-variable-buffer-local 'imenu-create-index-function)
 168
 169 (defvar prev-index-position-function 'beginning-of-defun
 170   "Function for finding the next index position.
 171
 172 If `imenu-create-index-function' is set to
 173 `imenu-default-create-index-function', then you must set this variable
 174 to a function that will find the next index, looking backwards in the
 175 file.
 176
 177 The function should leave point at the place to be connected to the
 178 index and it should return nil when it doesn't find another index. ")
 179 (make-variable-buffer-local 'prev-index-position-function)
 180
 181 (defvar extract-index-name-function nil
 182   "Function for extracting the index name.
 183
 184 This function is called after the function pointed out by
 185 `prev-index-position-function'.")
 186 (make-variable-buffer-local 'extract-index-name-function)
 187
 188 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 189 ;;;
 190 ;;; Internal variables
 191 ;;;
 192 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 193
 194 ;; The item to use in the index for rescanning the buffer.
 195 (defconst imenu--rescan-item '("*Rescan*" . -99))
 196
 197 ;; The latest buffer index.
 198 ;; Buffer local.
 199 (defvar imenu--index-alist nil)
 200 (make-variable-buffer-local 'imenu--index-alist)
 201
 202 ;; History list for 'jump-to-function-in-buffer'.
 203 ;; Buffer local.
 204 (defvar imenu--history-list nil)
 205 (make-variable-buffer-local 'imenu--history-list)
 206
 207 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 208 ;;;
 209 ;;; Internal support functions
 210 ;;;
 211 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 212
 213 ;;;
 214 ;;; Sort function
 215 ;;; Sorts the items depending on their index name.
 216 ;;; An item look like (NAME . POSITION).
 217 ;;;
 218 (defun imenu--sort-by-name (item1 item2)
 219   (string-lessp (car item1) (car item2)))
 220
 221 (defun imenu--relative-position (&optional reverse)
 222   ;; Support function to calculate relative position in buffer
 223   ;; Beginning of buffer is 0 and end of buffer is 100
 224   ;; If REVERSE is non-nil then the beginning is 100 and the end is 0.
 225   (let ((pos (point))
 226         (total (buffer-size)))
 227     (and reverse (setq pos (- total pos)))
 228     (if (> total 50000)
 229         ;; Avoid overflow from multiplying by 100!
 230         (/ (1- pos) (max (/ total 100) 1))
 231       (/ (* 100 (1- pos)) (max total 1)))))
 232
 233 ;;;
 234 ;;; Macro to display a progress message.  This will probably be used
 235 ;;; in a tight loop, that is why we use a macro.
 236 ;;; RELPOS is the relative position to display.
 237 ;;; If RELPOS is nil, then the relative position in the buffer
 238 ;;; is calculated.
 239 (defmacro imenu-progress-message (&optional relpos reverse)
 240   (` (and
 241       imenu-scanning-message
 242       (message imenu-scanning-message
 243                (, (if relpos
 244                       relpos
 245                     (` (imenu--relative-position (, reverse)))))))))
 246
 247 ;;;
 248 ;;; Function for suporting general looking submenu names.
 249 ;;; Uses `imenu-submenu-name-format' for creating the name.
 250 ;;; NAME is the base of the new submenu name.
 251 ;;;
 252 (defun imenu-create-submenu-name (name)
 253   (format imenu-submenu-name-format name))
 254
 255 ;; Split LIST into sublists of max length N.
 256 ;; Example (imenu--split '(1 2 3 4 5 6 7 8) 3)-> '((1 2 3) (4 5 6) (7 8))
 257 (defun imenu--split (list n)
 258   (let ((remain list)
 259         (result '())
 260         (sublist '())
 261         (i 0))
 262     (while remain
 263       (push (pop remain) sublist)
 264       (incf i)
 265       (and (= i n)
 266            ;; We have finished a sublist
 267            (progn (push (nreverse sublist) result)
 268                   (setq i 0)
 269                   (setq sublist '()))))
 270     ;; There might be a sublist (if the length of LIST mod n is != 0)
 271     ;; that has to be added to the result list.
 272     (and sublist
 273          (push (nreverse sublist) result))
 274     (nreverse result)))
 275
 276 ;;;
 277 ;;; Split a menu in to several menus.
 278 ;;;
 279 (defun imenu--split-menu (menulist title)
 280   (cons "Function menus"
 281         (mapcar
 282          (function
 283           (lambda (menu)
 284             (cons (format "(%s)" title) menu)))
 285          (imenu--split menulist imenu-max-items))))
 286
 287 ;;;
 288 ;;; Find all items in this buffer that should be in the index.
 289 ;;; Returns an alist on the form
 290 ;;; ((NAME . POSITION) (NAME . POSITION) ...)
 291 ;;;
 292
 293 (defun imenu--make-index-alist ()
 294   ;; Create a list for this buffer only when needed.
 295   (or imenu--index-alist
 296       ;; Get the index
 297       (setq imenu--index-alist
 298             (save-excursion
 299               (funcall imenu-create-index-function))))
 300   (or imenu--index-alist
 301       (error "No items suitable for an index found in this buffer."))
 302   ;; Add a rescan option to the index.
 303   (cons imenu--rescan-item imenu--index-alist))
 304
 305 (defun imenu-default-create-index-function ()
 306   "*Wrapper for index searching functions.
 307
 308 Moves point to end of buffer and then repeatedly calls
 309 `prev-index-position-function' and `extract-index-name-function'.
 310 Their results are gathered into an index alist."
 311
 312   (or (and (fboundp prev-index-position-function)
 313            (fboundp extract-index-name-function))
 314       (error "The mode \"%s\" does not take full advantage of imenu.el yet."
 315              mode-name))
 316   (let ((index-alist '())
 317         name)
 318     (goto-char (point-max))
 319     (imenu-progress-message 0 t)
 320     ;; Search for the function
 321     (while (funcall prev-index-position-function)
 322       (imenu-progress-message nil t)
 323       (save-excursion
 324         (setq name (funcall extract-index-name-function)))
 325       (and (stringp name)
 326            (push (cons name (point)) index-alist)))
 327     (imenu-progress-message 100 t)
 328     index-alist))
 329
 330 (defun imenu--replace-spaces (name replacement)
 331   ;; Replace all spaces in NAME with REPLACEMENT.
 332   ;; That second argument should be a string.
 333   (mapconcat
 334    (function
 335     (lambda (ch)
 336       (if (char-equal ch ?\ )
 337           replacement
 338         (char-to-string ch))))
 339    name
 340    ""))
 341
 342 (defun imenu--flatten-index-alist (index-alist &optional concat-names prefix)
 343   ;; Takes a nested INDEX-ALIST and returns a flat index alist.
 344   ;; If optional CONCAT-NAMES is non-nil, then a nested index has its
 345   ;; name and a space concatenated to the names of the children.
 346   ;; Third argument PREFIX is for internal use only.
 347   (mapcan
 348    (function
 349     (lambda (item)
 350       (let* ((name (car item))
 351              (pos (cdr item))
 352              (new-prefix (and concat-names
 353                               (if prefix
 354                                   (concat prefix imenu-level-separator name)
 355                                 name))))
 356         (cond
 357          ((numberp pos)
 358           (list (cons new-prefix pos)))
 359          (t
 360           (imenu--flatten-index-alist pos new-prefix))))))
 361    index-alist))
 362
 363 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 364 ;;;
 365 ;;; The main functions for this package!
 366 ;;;
 367 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 368
 369 (defun imenu--completion-buffer (index-alist &optional prompt)
 370   "Let the user select from INDEX-ALIST in a completion buffer with PROMPT.
 371
 372 Returns t for rescan and otherwise a position number."
 373   ;; Create a list for this buffer only when needed.
 374   (let (name choice
 375         (prepared-index-alist
 376          (mapcar
 377           (function
 378            (lambda (item)
 379              (cons (imenu--replace-spaces (car item) imenu-space-replacement)
 380                    (cdr item))))
 381           index-alist)))
 382     (save-window-excursion
 383       ;; Display the completion buffer
 384       (with-output-to-temp-buffer "*Completions*"
 385         (display-completion-list
 386          (all-completions "" prepared-index-alist )))
 387       ;; Make a completion question
 388       (setq name (completing-read (or prompt "Index item: ")
 389                                     prepared-index-alist
 390                                     nil t nil 'imenu--history-list)))
 391     (cond
 392      ((not (stringp name))
 393       nil)
 394      ((string= name (car imenu--rescan-item))
 395       t)
 396      (t
 397       (setq choice (assoc name prepared-index-alist))
 398       (cond
 399        ((listp (cdr choice))
 400         (imenu--completion-buffer (cdr choice) prompt))
 401        (t
 402         choice))))))
 403 (defun imenu--mouse-menu (index-alist event &optional title)
 404   "Let the user select from a buffer index from a mouse menu.
 405
 406 INDEX-ALIST is the buffer index and EVENT is a mouse event.
 407
 408 Returns t for rescan and otherwise a position number."
 409   (let* ((menu  (imenu--split-menu
 410                  (if imenu-sort-function
 411                      (sort
 412                       (let ((res nil)
 413                             (oldlist index-alist))
 414                         ;; Copy list method from the cl package `copy-list'
 415                         (while (consp oldlist) (push (pop oldlist) res))
 416                         (prog1 (nreverse res) (setcdr res oldlist)))
 417                       imenu-sort-function)
 418                    index-alist)
 419                  (or title (buffer-name))))
 420          position)
 421     (setq position (x-popup-menu event menu))
 422     (cond
 423      ((eq position nil)
 424       position)
 425      ((listp position)
 426       (imenu--mouse-menu position event
 427                          (if title
 428                              (concat title imenu-level-separator
 429                                      (car (rassq position index-alist)))
 430                            (car (rassq position index-alist)))))
 431      ((= position (cdr imenu--rescan-item))
 432       t)
 433      (t
 434       (rassq position index-alist)))))
 435
 436 (defun imenu-choose-buffer-index (&optional prompt alist)
 437   "Let the user select from a buffer index and return the chosen index.
 438
 439 If the user originally activated this function with the mouse, a mouse
 440 menu is used.  Otherwise a completion buffer is used and the user is
 441 prompted with PROMPT.
 442
 443 If you call this function with index alist ALIST, then it lets the user
 444 select from ALIST.
 445
 446 With no index alist ALIST, it calls `imenu--make-index-alist' to
 447 create the index alist.
 448
 449 If `imenu-always-use-completion-buffer-p' is non-nil, then the
 450 completion buffer is always used, no matter if the mouse was used or
 451 not.
 452
 453 The returned value is on the form (INDEX-NAME . INDEX-POSITION)."
 454   (let (index-alist
 455         (mouse-triggered (listp last-command-event))
 456         (result t) )
 457     ;; If selected by mouse, see to that the window where the mouse is
 458     ;; really is selected.
 459     (and mouse-triggered
 460          (let ((window (posn-window (event-start last-command-event))))
 461            (or (framep window) (select-window window))))
 462     ;; Create a list for this buffer only when needed.
 463     (while (eq result t)
 464       (setq index-alist (if alist alist (imenu--make-index-alist)))
 465       (setq result
 466             (if (and mouse-triggered
 467                      (not imenu-always-use-completion-buffer-p))
 468                 (imenu--mouse-menu index-alist last-command-event)
 469               (imenu--completion-buffer index-alist prompt)))
 470       (and (eq result t)
 471            (setq imenu--index-alist nil)))
 472     result))
 473
 474 (defun goto-index-pos ()
 475   "Jump to selected part of buffer, using a buffer menu or mouse menu.
 476
 477 See `imenu-choose-buffer-index' for more information."
 478   (interactive)
 479   (let ((index-item (imenu-choose-buffer-index)))
 480     (and index-item
 481          (progn
 482            (push-mark)
 483            (goto-char (cdr index-item))))))
 484
 485 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 486 ;;;;
 487 ;;;; Some examples of functions utilizing the framework of this
 488 ;;;; package.
 489 ;;;;
 490 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 491
 492 ;; Return the current/previous sexp and the location of the sexp (it's
 493 ;; beginning) without moving the point.
 494 (defun imenu-example--name-and-position ()
 495   (save-excursion
 496     (forward-sexp -1)
 497     (let ((beg (point))
 498           (end (progn (forward-sexp) (point))))
 499       (cons (buffer-substring beg end)
 500             beg))))
 501
 502 ;;;
 503 ;;; Lisp
 504 ;;;
 505
 506 (defun imenu-example--lisp-extract-index-name ()
 507   ;; Example of a candidate for `imenu-extract-index-name-function'.
 508   ;; This will generate a flat index of definitions in a lisp file.
 509   (save-match-data
 510     (and (looking-at "(def")
 511          (condition-case nil
 512              (progn
 513                (down-list 1)
 514                (forward-sexp 2)
 515                (let ((beg (point))
 516                      (end (progn (forward-sexp -1) (point))))
 517                  (buffer-substring beg end)))
 518            (error nil)))))
 519
 520 (defun imenu-example--create-lisp-index ()
 521   ;; Example of a candidate for `imenu-create-index-function'.
 522   ;; It will generate a nested index of definitions.
 523   (let ((index-alist '())
 524         (index-var-alist '())
 525         (index-type-alist '())
 526         (index-unknown-alist '()))
 527     (goto-char (point-max))
 528     (imenu-progress-message 0)
 529     ;; Search for the function
 530     (while (beginning-of-defun)
 531       (imenu-progress-message nil t)
 532       (save-match-data
 533         (and (looking-at "(def")
 534              (save-excursion
 535                (down-list 1)
 536                (cond
 537                 ((looking-at "def\\(var\\|const\\)")
 538                  (forward-sexp 2)
 539                  (push (imenu-example--name-and-position)
 540                        index-var-alist))
 541                 ((looking-at "def\\(un\\|subst\\|macro\\|advice\\)")
 542                  (forward-sexp 2)
 543                  (push (imenu-example--name-and-position)
 544                        index-alist))
 545                 ((looking-at "def\\(type\\|struct\\|class\\|ine-condition\\)")
 546                  (forward-sexp 2)
 547                  (if (= (char-after (1- (point))) ?\))
 548                      (progn
 549                        (forward-sexp -1)
 550                        (down-list 1)
 551                        (forward-sexp 1)))
 552                  (push (imenu-example--name-and-position)
 553                        index-type-alist))
 554                 (t
 555                  (forward-sexp 2)
 556                  (push (imenu-example--name-and-position)
 557                        index-unknown-alist)))))))
 558     (imenu-progress-message 100)
 559     (and index-var-alist
 560          (push (cons (imenu-create-submenu-name "Variables") index-var-alist)
 561                index-alist))
 562     (and index-type-alist
 563          (push (cons (imenu-create-submenu-name "Types") index-type-alist)
 564                index-alist))
 565     (and index-unknown-alist
 566          (push (cons (imenu-create-submenu-name "Syntax-unknown") index-unknown-alist)
 567                index-alist))
 568     index-alist))
 569
 570
 571 ;;;
 572 ;;; C
 573 ;;;
 574 ;; Regular expression to find C functions
 575 (defvar imenu-example--function-name-regexp-c
 576   (concat
 577    "^[a-zA-Z0-9]+[ \t]?"                ; type specs; there can be no
 578    "\\([a-zA-Z0-9_*]+[ \t]+\\)?"        ; more than 3 tokens, right?
 579    "\\([a-zA-Z0-9_*]+[ \t]+\\)?"
 580    "\\([*&]+[ \t]*\\)?"                 ; pointer
 581    "\\([a-zA-Z0-9_*]+\\)[ \t]*("        ; name
 582    ))
 583
 584 (defun imenu-example--create-c-index (&optional regexp)
 585   (let ((index-alist '())
 586         (char))
 587     (goto-char (point-min))
 588     (imenu-progress-message 0)
 589     ;; Search for the function
 590     (save-match-data
 591       (while (re-search-forward
 592               (or regexp imenu-example--function-name-regexp-c)
 593               nil t)
 594         (imenu-progress-message)
 595         (backward-up-list 1)
 596         (save-excursion
 597           (goto-char (scan-sexps (point) 1))
 598           (setq char (following-char)))
 599         ;; Skip this function name if it is a prototype declaration.
 600         (if (not (eq char ?\;))
 601             (push (imenu-example--name-and-position) index-alist))))
 602     (imenu-progress-message 100)
 603     (nreverse index-alist)))
 604
 605 ;;;
 606 ;;; C++
 607 ;;;
 608 ;; Regular expression to find C++ functions
 609 (defvar imenu-example--function-name-regexp-c++
 610   (concat
 611    "^[a-zA-Z0-9:]+[ \t]?"               ; type specs; there can be no
 612    "\\([a-zA-Z0-9_:~*]+[ \t]+\\)?"      ; more than 3 tokens, right?
 613    "\\([a-zA-Z0-9_:~*]+[ \t]+\\)?"
 614    "\\([*&]+[ \t]*\\)?"                 ; pointer
 615    "\\([a-zA-Z0-9_:*]+\\)[ \t]*("       ; name
 616    ))
 617 (defun imenu-example--create-c++-index ()
 618   (imenu-example--create-c-index imenu-example--function-name-regexp-c++))
 619
 620
 621 ;;;
 622 ;;; Example of hooks for the examples above
 623 ;;; Put this in your .emacs.
 624 ;;;
 625 ;; (add-hook 'emacs-lisp-mode-hook
 626 ;;        (function
 627 ;;         (lambda ()
 628 ;;           (setq imenu-create-index-function
 629 ;;                 (function imenu-example--create-lisp-index)))))
 630
 631 ;; (add-hook 'lisp-mode-hook
 632 ;;        (function
 633 ;;         (lambda ()
 634 ;;           (setq imenu-create-index-function
 635 ;;                 (function imenu-example--create-lisp-index)))))
 636
 637 ;; (add-hook 'c++-mode-hook
 638 ;;        (function
 639 ;;         (lambda ()
 640 ;;           (setq imenu-create-index-function
 641 ;;                 (function imenu-example--create-c++-index)))))
 642
 643 ;; (add-hook 'c-mode-hook
 644 ;;        (function
 645 ;;         (lambda ()
 646 ;;           (setq imenu-create-index-function
 647 ;;                 (function imenu-example--create-c-index)))))
 648
 649 (provide 'imenu)
 650
 651 ;;; imenu.el ends here