(imenu-use-keymap-menu): New variable.

(imenu-auto-rescan): New variable.
(imenu-auto-rescan-maxout): New variable.
(imenu-generic-expression): Doc changes.
(imenu-generic-lisp-expression): New variable.
(imenu-generic-c-expression): New variable.
(imenu-example--generic-c++-expression): Changed the name to
imenu-generic-c++-expression.
(imenu-example--generic-texinfo-expression): Changed the name to
imenu-generic-texinfo-expression.
(imenu-example--generic-latex-expression): Changed the name to
imenu-generic-latex-expression.
(imenu--scanning-method-alist): New variable.
(imenu--split-menu): Changed it to make the title "Index menu"
instead of "Function menus".
(imenu--make-index-alist): Changed to handle auto rescan.
(imenu--create-keymap-2): New function to create a keymap.
(imenu--create-keymap-1): New function.
(imenu--in-alist): New function.
(imenu-default-create-index-function): Changed to handle
imenu--scanning-method-alist).
(imenu--generic-extract-name): Removed.
(imenu--generic-function): Rewritten to handle submenus.
(imenu--mouse-menu): Changed to handle keymaps.

1 files changed, 372 insertions, 149 deletions

diff --git a/lisp/imenu.el b/lisp/imenu.el
index f35116d840c..315e2caf599 100644
--- a/lisp/imenu.el
+++ b/lisp/imenu.el
@@ -5,7 +5,7 @@
 ;; Author: Ake Stenhoff <etxaksf@aom.ericsson.se>
 ;;         Lars Lindberg <lli@sypro.cap.se>
 ;; Created: 8 Feb 1994
-;; Version: 1.15
+;; Version: 1.17
 ;; Keywords: tools
 ;;
 ;; This program is free software; you can redistribute it and/or modify
@@ -37,10 +37,10 @@
 ;;   The package comes with a set of example functions for how to
 ;;   utilize this package.
 
-;;   There are *examples* for index gathering functions for C/C++ and
-;;   Lisp/Emacs Lisp but it is easy to customize for other modes.  A
-;;   function for jumping to the chosen index position is also
-;;   supplied.
+;;   There are *examples* for index gathering functions/regular
+;;   expressions for C/C++ and Lisp/Emacs Lisp but it is easy to
+;;   customize for other modes.  A function for jumping to the chosen
+;;   index position is also supplied.
 
 ;;; Thanks goes to
 ;;  [simon] - Simon Leinen simon@lia.di.epfl.ch
@@ -50,6 +50,9 @@
 ;;  [wolfgang] - Wolfgang Bangerth zcg51122@rpool1.rus.uni-stuttgart.de
 ;;  [kai] - Kai Grossjohann grossjoh@linus.informatik.uni-dortmund.de
 ;;  [david] - David M. Smith dsmith@stats.adelaide.edu.au
+;;  [christian] - Christian Egli Christian.Egli@hcsd.hac.com
+;;  [karl] - Karl Fogel kfogel@floss.life.uiuc.edu
+
 ;;; Code
 (eval-when-compile (require 'cl))
 
@@ -58,6 +61,17 @@
 ;;; Customizable variables
 ;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defvar imenu-use-keymap-menu nil
+  "* Set this to non-nil for using a keymap when making 
+  the mouse menu.")
+
+(defvar imenu-auto-rescan nil
+  "* T if we always should rescan the buffers, nil to disable
+  automatic rescan.")
+
+(defvar imenu-auto-rescan-maxout 60000 
+  "* auto-rescan is disabled in buffers larger than this.
+  This variable is buffer-local.")
 
 (defvar imenu-always-use-completion-buffer-p nil
   "*Set this to non-nil for displaying the index in a completion buffer.
@@ -105,12 +119,40 @@ with name concatenation.")
 (defvar imenu-submenu-name-format "%s..."
   "*The format for making a submenu name.")
 
+;;;###autoload
 (defvar imenu-generic-expression nil
-  "Generic regular expression for index gathering.
+  "The regex pattern to use for creating a buffer index.
+
+If non-nil this pattern is passed to `imenu-create-index-with-pattern'
+to create a buffer index.
+
+It is an alist with elements that look like this: (MENU-TITLE
+REGEXP INDEX). 
+
+MENU-TITLE is a string used as the title for the submenu or nil if the
+entries are not nested.
+
+REGEXP is a regexp that should match a construct in the buffer that is
+to be displayed in the menu i.e. function or variable definitions,
+etc. It contains a substring which is the name to appear in the
+menu. See the info section on Regexps for more information.
+
+INDEX points to the substring in REGEXP that contains the name (of the
+function, variable or type) that is to appear in the menu.
+
+For emacs-lisp-mode for example PATTERN would look like:
+
+'((nil \"^\\s-*(def\\(un\\|subst\\|macro\\|advice\\)\\s-+\\([-A-Za-z0-9+]+\\)\" 2)
+  (\"*Vars*\" \"^\\s-*(def\\(var\\|const\\)\\s-+\\([-A-Za-z0-9+]+\\)\" 2)
+  (\"*Types*\" \"^\\s-*(def\\(type\\|struct\\|class\\|ine-condition\\)\\s-+\\([-A-Za-z0-9+]+\\)\" 2))
+
+The variable is buffer-local.")
+
+;;;###autoload
+(make-variable-buffer-local 'imenu-create-index-pattern)
 
-Can be either an regular expression or an alist in the form
-\(REGEXP PAREN).")
-(make-variable-buffer-local 'imenu-generic-expression)
+;; make sure the default is nil
+(setq-default imenu-create-index-pattern nil)
 
 ;;;; Hooks
 
@@ -253,9 +295,134 @@ This function is called after the function pointed out by
                index-alist))
     index-alist))
 
+(defvar imenu-generic-lisp-expression
+      '(
+        (nil 
+         "^\\s-*(def\\(un\\|subst\\|macro\\|advice\\)\\s-+\\([-A-Za-z0-9+]+\\)" 2)
+        ("Variables" 
+         "^\\s-*(def\\(var\\|const\\)\\s-+\\([-A-Za-z0-9+]+\\)" 2)
+        ("Types" 
+         "^\\s-*(def\\(type\\|struct\\|class\\|ine-condition\\)\\s-+\\([-A-Za-z0-9+]+\\)" 
+         2))
+
+  "imenu generic expression for Lisp mode in the form
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.")
+
+;;;
+;;; C++
+;;;
+;; Example of an imenu-generic-expression
+;;
+(defvar imenu-generic-c++-expression
+  (` 
+   ((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 pointer/ref sign or whitespace
+       "\\)?"                             ; if there is a last type spec
+       "\\("                          ; name; take that into the imenu entry
+       "[a-zA-Z0-9_:~]+"                      ; member function, 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
+                                        ; (like "int foo(int a=bar()) {...}"
+       
+       )) 6)    
+    ("Class" 
+     (, (concat 
+         "^"                               ; beginning of line is required
+         "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
+         "class[ \t]+"
+         "\\([a-zA-Z0-9_]+\\)"                ; this is the string we want to get
+         "[ \t]*[:{]"
+         )) 2)
+;; Example of generic expression for finding prototypes, structs, unions, enums.
+;; Uncomment if You want to find these too. It will be at bit slower gathering
+;; the indexes.
+;    ("Prototypes"
+;     (, 
+;      (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 pointer/ref sign or whitespace
+;       "\\)?"                            ; if there is a last type spec
+;       "\\("                         ; name; take that into the imenu entry
+;       "[a-zA-Z0-9_:~]+"                     ; member function, 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 ';' after
+;                                       ; the (...) Can't
+;                                       ; catch cases with () inside the parentheses
+;                                       ; surrounding the parameters
+;                                       ; (like "int foo(int a=bar());"       
+;       )) 6)    
+;    ("Struct"
+;     (, (concat
+;        "^"                            ; beginning of line is required
+;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;        "\\(const[ \t]+\\)?"
+;        "struct[ \t]+"
+;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;        "[ \t]*[{]"
+;        )) 3)
+;    ("Enum"
+;     (, (concat
+;        "^"                            ; beginning of line is required
+;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;        "\\(const[ \t]+\\)?"
+;        "enum[ \t]+"
+;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;        "[ \t]*[{]"
+;        )) 3)
+;    ("Union"
+;     (, (concat
+;        "^"                            ; beginning of line is required
+;        "\\(static[ \t]+\\)?"          ; there may be static or const.
+;        "\\(const[ \t]+\\)?"
+;        "union[ \t]+"
+;        "\\([a-zA-Z0-9_]+\\)"          ; this is the string we want to get
+;        "[ \t]*[{]"
+;        )) 3)
+    ))
+  "imenu generic expression for C++ mode in the form
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.")
+
 ;;;
 ;;; C
 ;;;
+;;;
+(defvar imenu-generic-c-expression 
+  ;; Use the C++ expression above.
+  imenu-generic-c++-expression
+  "imenu generic expression for C mode in the form
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.")
+
 ;; Regular expression to find C functions
 (defvar imenu-example--function-name-regexp-c
   (concat 
@@ -287,55 +454,19 @@ This function is called after the function pointed out by
     (imenu-progress-message prev-pos 100)
     (nreverse index-alist)))
 
-;;;
-;;; C++
-;;;
-;; Example of an imenu-generic-expression
+
+;; 
+;; Ada
+;; 
+;; Written by Christian Egli <Christian.Egli@hcsd.hac.com>
 ;;
-(defvar imenu-example--generic-c++-expression
-  (cons
-   ;; regular expression
-   (concat 
-    "^"                                 ; beginning of line is required
-    "\\(template[ \t]*<[^>]+>[ \t]*\\)?" ; there may be a "template <...>"
-    "\\("
-    
-    "\\("                               ; >>looking for a function definition<<
-    "\\([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 pointer/ref sign or whitespace
-    "\\)?"                              ; if there is a last type spec
-    
-    "\\("                               ; name; take that into the imenu entry
-    "[a-zA-Z0-9_:~]+"                   ; member function, 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
-                                        ; (like "int foo(int a=bar()) {...}"
-    "\\)"                               ; <<looking for a function definition>>
-    
-    "\\|"
-    
-    "\\("                               ; >>class decl<<
-    "\\(class[ \t]+[a-zA-Z0-9_]+\\)"    ; this is the string we want to get
-    "[ \t]*[:{]"
-    "\\)"                               ; <<class decl>>
-    
-    "\\)")
-   ;; paren
-   (list 8 11))
-  "imenu generic expression for C++ mode in the form
-\(REGEXP PAR).")
+(defvar imenu-generic-ada-expression
+      '((nil "^\\s-*\\(procedure\\|function\\)\\s-+\\([A-Za-z0-9_]+\\)" 2)
+        ("Type Defs" "^\\s-*\\(sub\\)?type\\s-+\\([A-Za-z0-9_]+\\)" 2))
+
+  "imenu generic expression for Ada mode in the form
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.")
 
 ;;; 
 ;;; TexInfo
@@ -343,14 +474,13 @@ This function is called after the function pointed out by
 ;; Written by Wolfgang Bangerth <zcg51122@rpool1.rus.uni-stuttgart.de>
 ;;
 ;;
-(defvar imenu-example--generic-texinfo-expression
-  (cons
-   (concat 
-    "^@node[ \t]+"
-    "\\([^,\n]*\\)")
-   (list 1))
+(defvar imenu-generic-texinfo-expression
+  '((nil "^@node[ \t]+\\([^,\n]*\\)" 1)
+    ("Chapters" "^@chapter[ \t]+\\(.*\\)$" 1))
+
   "imenu generic expression for TexInfo mode in the form
-\(REGEXP PAR).
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.
 
 To overide this example, Either set 'imenu-generic-expression
 or 'imenu-create-index-function")
@@ -361,22 +491,20 @@ or 'imenu-create-index-function")
 ;; Written by Wolfgang Bangerth <zcg51122@rpool1.rus.uni-stuttgart.de>
 ;;
 ;;
-(defvar imenu-example--generic-latex-expression
-  (concat
-   "\\("
-   "%[ \t]*[0-9]+\\.[0-9]+[,;]?[ \t]?"  ; i put numbers like 3.15 before my
-                                        ; \begin{equation}'s which tell me
-                                        ; the number the equation will get when
-                                        ; being printed.
-   "\\|"
-   "\\\\part{[^}]*}"
-   "\\|"
-   "\\\\chapter{[^}]*}"
-   "\\|"
-   "\\\\[a-zA-Z]*section{[^}]*}"
-   "\\)")
+(defvar imenu-generic-latex-expression
+  '(
+    ("Part" "\\\\part{\\([^}]*\\)}" 1)
+    ("Chapter" "\\\\chapter{\\([^}]*\\)}" 1)
+    ("Section" "\\\\[a-zA-Z]*section{\\([^}]*\\)}" 1)
+    ;; i put numbers like 3.15 before my
+    ;; \begin{equation}'s which tell me
+    ;; the number the equation will get when
+    ;; being printed.
+    ("Equations" "%[ \t]*\\([0-9]+\\.[0-9]+\\)[,;]?[ \t]?" 1))  
+
   "imenu generic expression for LaTex mode in the form
-\"REGEXP\".")
+(PATTERN), where PATTERN is a list containing entries of the form 
+(MENU-TITLE REGEXP INDEX). See `imenu-generic-expression'.")
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
@@ -397,6 +525,23 @@ or 'imenu-create-index-function")
 (defvar imenu--history-list nil)
 (make-variable-buffer-local 'imenu--history-list)
 
+(defvar imenu--scanning-method-alist
+  '((emacs-lisp-mode  imenu-generic-lisp-expression)
+    (lisp-mode        imenu-example--create-lisp-index)
+    (c++-mode         imenu-generic-c++-expression)
+    (c-mode           imenu-generic-c-expression)
+    (latex-mode       imenu-generic-latex-expression)
+    (texinfo-mode     imenu-generic-texinfo-expression)
+    (ada-mode         imenu-generic-ada-expression))
+
+  "Alist of major mode and imenu scanning methods.  
+
+Each item should be a list of the form: (MAJOR-MODE
+IMENU-SCANNING-METHOD) where both MAJOR-MODE and IMENU-SCANNING-METHOD
+are symbols. If IMENU-SCANNING-METHOD is a function then it is called
+to create an index. If it is a `pattern' (See `imenu-generic-expression') 
+it is passed to imenu--generic-function to create an index.")
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; Internal support functions
@@ -429,7 +574,7 @@ or 'imenu-create-index-function")
 ;;; NAME is the base of the new submenu name.
 ;;;
 (defun imenu-create-submenu-name (name)
-  (format imenu-submenu-name-format name))
+   (format imenu-submenu-name-format name))
 
 ;; Split LIST into sublists of max length N.
 ;; Example (imenu--split '(1 2 3 4 5 6 7 8) 3)-> '((1 2 3) (4 5 6) (7 8))
@@ -456,7 +601,7 @@ or 'imenu-create-index-function")
 ;;; Split a menu in to several menus.
 ;;;
 (defun imenu--split-menu (menulist title)
-  (cons "Function menus"
+  (cons "Index menu"
         (mapcar
          (function
           (lambda (menu)
@@ -471,7 +616,10 @@ or 'imenu-create-index-function")
 
 (defun imenu--make-index-alist ()
   ;; Create a list for this buffer only when needed.
-  (or imenu--index-alist
+  (or (and imenu--index-alist
+           (or (not imenu-auto-rescan)
+               (and imenu-auto-rescan
+                    (> (buffer-size)  imenu-auto-rescan-maxout))))
       ;; Get the index
       (setq imenu--index-alist
             (save-excursion
@@ -502,6 +650,42 @@ or 'imenu-create-index-function")
         alist)
        t))
 
+(defun imenu--create-keymap-2 (alist counter)
+  (let ((map nil))
+    (mapcar
+     (function
+      (lambda (item)
+        (cond
+         ((listp (cdr item))
+          (append (list (incf counter) (car item) 'keymap (car item))
+                  (imenu--create-keymap-2 (cdr item) (+ counter 10))))
+         (t
+          (let ((end (cons '(nil) t)))
+            (cons (car item)
+                  (cons (car item) end))))
+         )))
+     alist)))
+
+(defun imenu--create-keymap-1 (title alist)
+  (append (list 'keymap title) (imenu--create-keymap-2 alist 0)))
+
+
+(defun imenu--in-alist (str alist)
+  "Check whether the string STR is contained in multi-level ALIST."
+  (let (elt head tail res)
+    (setq res nil)
+    (while alist
+      (setq elt (car alist) 
+            tail (cdr elt)
+            alist (cdr alist) 
+            head (car elt)) 
+      (if (string= str head)
+          (setq alist nil res elt)
+        (if (and (listp tail)
+                 (setq res (imenu--in-alist str tail)))
+            (setq alist nil))))
+    res))
+
 (defun imenu-default-create-index-function ()
   "*Wrapper for index searching functions.
 
@@ -528,19 +712,15 @@ Their results are gathered into an index alist."
         ;; Use generic expression if possible.
         ((and imenu-generic-expression)
          (imenu--generic-function imenu-generic-expression))
-        ;; Use supplied example functions
-        ((eq major-mode 'emacs-lisp-mode)
-         (imenu-example--create-lisp-index))
-        ((eq major-mode 'lisp-mode)
-         (imenu-example--create-lisp-index))
-        ((eq major-mode 'c++-mode)
-         (imenu--generic-function imenu-example--generic-c++-expression))
-        ((eq major-mode 'c-mode)
-         (imenu-example--create-c-index))
-        ((eq major-mode 'latex-mode)
-         (imenu--generic-function imenu-example--generic-latex-expression))
-        ((eq major-mode 'texinfo-mode)
-         (imenu--generic-function imenu-example--generic-texinfo-expression))
+        ;; Use supplied example functions or expressions
+        ((assq major-mode imenu--scanning-method-alist)
+         (let ((method (cadr (assq major-mode imenu--scanning-method-alist))))
+           ;; is it a function?
+           (if (fboundp method)
+               ;; ... then call it
+               (funcall method) 
+             ;; ...otherwise pass the pattern to imenu--generic-function
+             (imenu--generic-function (eval method))))) 
         (t
          (error "The mode \"%s\" does not take full advantage of imenu.el yet."
                 mode-name))))      
@@ -581,61 +761,83 @@ Their results are gathered into an index alist."
 ;;;
 ;;; Generic index gathering function.
 ;;;
-(defun imenu--generic-extract-name (paren)
-  (let ((numofpar (1- (length paren)))
-        (parencount 0)
-        (par)
-        (index))
-    ;; Try until we get a match
-    (beginning-of-line)
-    (while (and (<= parencount numofpar)
-                (setq par (nth parencount paren))
-                (equal (match-beginning par) nil)
-                (equal (match-end par) nil))
-      (setq parencount (1+ parencount)))
-    (or (and 
-         (<= parencount numofpar)
-         (setq index (buffer-substring (match-beginning par)
-                                       (match-end par))))
-        ;; take the whole match just in case.
-        (setq index (buffer-substring (match-beginning 0)
-                                      (match-end 0))))
-    index))
-
-(defun imenu--generic-function (exp)
-  "Generic function for index gathering.
-
-EXP can be either an regular expression or an alist in the form
-\(REGEXP PAREN). "
-  
-  (let ((index-alist '())
-        (regexp nil)
-        (paren nil)
-        prev-pos name)
-    (cond ((stringp exp)
-           (setq regexp exp)
-           (setq paren nil))
-          ((listp exp)
-           (setq regexp (car exp))
-           (setq paren (cdr exp)))
-          (t
-           (error "Wrong type of argument.")))
+
+(defun imenu--generic-function (patterns)
+;; Built on some ideas that Erik Naggum <erik@naggum.no> once posted
+;; to comp.emacs
+  "Return an index of the current buffer as an alist.
+
+PATTERN is an alist with elements that look like this: (MENU-TITLE
+REGEXP INDEX). 
+
+MENU-TITLE is a string used as the title for the submenu or nil if the
+entries are not nested.
+
+REGEXP is a regexp that should match a construct in the buffer that is
+to be displayed in the menu i.e. function or variable definitions,
+etc. It contains a substring which is the name to appear in the
+menu. See the info section on Regexps for more information.
+
+INDEX points to the substring in REGEXP that contains the name (of the
+function, variable or type) that is to appear in the menu.
+
+For emacs-lisp-mode for example PATTERN would look like:
+
+'((nil \"^\\s-*(def\\(un\\|subst\\|macro\\|advice\\)\\s-+\\([-A-Za-z0-9]+\\)\" 2)
+  (\"*Vars*\" \"^\\s-*(def\\(var\\|const\\)\\s-+\\([-A-Za-z0-9]+\\)\" 2)
+  (\"*Types*\" \"^\\s-*(def\\(type\\|struct\\|class\\|ine-condition\\)\\s-+\\([-A-Za-z0-9]+\\)\" 2))'
+
+Returns an index of the current buffer as an alist. The elements in
+the alist look like: (INDEX-NAME . INDEX-POSITION). They may also be
+nested index lists like (INDEX-NAME . INDEX-ALIST) depending on
+pattern.
+
+\(imenu--generic-function PATTERN\)."
+
+  (let ((index-alist (list 'dummy))
+        (found nil)
+        (global-regexp 
+         (concat "\\(" 
+                 (mapconcat
+                  (function (lambda (pattern) (identity (cadr pattern)))) 
+                  patterns "\\)\\|\\(") 
+                 "\\)"))
+        prev-pos)
+
     (goto-char (point-max))
     (imenu-progress-message prev-pos 0 t)
-    (while (re-search-backward regexp 1 t)
-      (imenu-progress-message prev-pos nil t)
-      (save-excursion
-        ;; If paren get sub expression
-        (or  (and paren
-                  (setq name (imenu--generic-extract-name paren)))
-             ;; get the whole expression
-             (beginning-of-line)
-             (setq name (buffer-substring (match-beginning 0) 
-                                          (match-end 0)))))
-      (and (stringp name)
-           (push (cons name (point)) index-alist)))
-    (imenu-progress-message prev-pos 100 t)
-    index-alist))
+    (save-match-data
+      (while (re-search-backward global-regexp nil t)
+        (imenu-progress-message prev-pos nil t)
+        (setq found nil)
+        (save-excursion
+          (goto-char (match-beginning 0))
+          (mapcar 
+           (function 
+            (lambda (pat) 
+              (let ((menu-title (car pat))
+                    (regexp (cadr pat))
+                    (index (caddr pat)))
+                    (if (and (not found) ; Only allow one entry;
+                             (looking-at regexp))
+                        (let ((beg (match-beginning index))
+                              (end (match-end index)))
+                          (setq found t)
+                          (push 
+                           (cons (buffer-substring beg end) beg)
+                           (cdr 
+                            (or (if (not (stringp menu-title)) index-alist) 
+                                (assoc 
+                                 (imenu-create-submenu-name menu-title) 
+                                 index-alist)
+                                (car (push 
+                                      (cons 
+                                       (imenu-create-submenu-name menu-title) 
+                                       '()) 
+                                      index-alist))))))))))
+            patterns))))
+      (imenu-progress-message prev-pos 100 t)
+      (delete 'dummy index-alist)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
@@ -703,7 +905,22 @@ Returns t for rescan and otherwise a position number."
                    index-alist)
                  (or title (buffer-name))))
          position)
+    (and imenu-use-keymap-menu
+         (setq menu (imenu--create-keymap-1 (car menu) 
+                                            (if (< 1 (length (cdr menu)))
+                                                (cdr menu)
+                                              (cdr (cadr menu))))))
     (setq position (x-popup-menu event menu))
+    (if imenu-use-keymap-menu
+        (progn
+          (cond 
+           ((and (listp position)
+                 (numberp (car position))
+                 (stringp (nth (1- (length position)) position)))
+            (setq position (nth (1- (length position)) position)))
+           ((and (stringp (car position))
+                 (null (cdr position)))
+            (setq position (car position))))))
     (cond
      ((eq position nil)
       position)
@@ -713,7 +930,12 @@ Returns t for rescan and otherwise a position number."
                              (concat title imenu-level-separator
                                      (car (rassq position index-alist)))
                            (car (rassq position index-alist)))))
-     ((= position (cdr imenu--rescan-item))
+     ((stringp position)
+      (or (string= position (car imenu--rescan-item))
+          (imenu--in-alist position index-alist)))
+     ((or (= position (cdr imenu--rescan-item))
+          (and (stringp position)
+               (string= position (car imenu--rescan-item))))
       t)
      (t
       (rassq position index-alist)))))
@@ -757,6 +979,7 @@ The returned value is on the form (INDEX-NAME . INDEX-POSITION)."
            (setq imenu--index-alist nil)))
     result))
 
+;;;###autoload
 (defun imenu-add-to-menubar (name)
   "Adds an \"imenu\" entry to the menubar for the 
 current local keymap.