(imenu-generic-expression): New variable.

(imenu-example--generic-c++-expression): New variable.
(imenu-example--generic-texinfo-expression): New variable.
(imenu-example--generic-latex-expression): New variable.
(imenu-example--create-c++-index): Deleted.
(imenu-example--function-name-regexp-c++): Deleted.
(imenu--generic-function): New function.
(imenu--generic-extract-name): New function.
(imenu-default-create-index-function): Added the generic function calls for
the provided examples.

1 files changed, 333 insertions, 181 deletions

diff --git a/lisp/imenu.el b/lisp/imenu.el
index 9721677c7fb..bd7c1adbe02 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.12
+;; Version: 1.14
 ;; Keywords: tools
 ;;
 ;; This program is free software; you can redistribute it and/or modify
@@ -47,6 +47,7 @@
 ;;  [dean] - Dean Andrews ada@unison.com
 ;;  [alon] - Alon Albert al@mercury.co.il 
 ;;  [greg] - Greg Thompson gregt@porsche.visix.COM
+;;  [wolfgang] - Wolfgang Bangerth zcg51122@rpool1.rus.uni-stuttgart.de
 ;;  [kai] - Kai Grossjohann grossjoh@linus.informatik.uni-dortmund.de
 
 ;;; Code
@@ -103,6 +104,13 @@ with name concatenation.")
 (defvar imenu-submenu-name-format "%s..."
   "*The format for making a submenu name.")
 
+(defvar imenu-generic-expression nil
+  "Generic regular expression for index gathering.
+
+Can be either an regular expression or an alist in the form
+\(REGEXP PAREN).")
+(make-variable-buffer-local 'imenu-generic-expression)
+
 ;;;; Hooks
 
 (defvar imenu-create-index-function 'imenu-default-create-index-function
@@ -137,6 +145,238 @@ This function is called after the function pointed out by
 `imenu-prev-index-position-function'.")
 (make-variable-buffer-local 'imenu-extract-index-name-function)
 
+;;;
+;;; Macro to display a progress message.
+;;; RELPOS is the relative position to display.
+;;; If RELPOS is nil, then the relative position in the buffer
+;;; is calculated.
+;;; PREVPOS is the variable in which we store the last position displayed.
+(defmacro imenu-progress-message (prevpos &optional relpos reverse)
+  (` (and
+      imenu-scanning-message
+      (let ((pos (, (if relpos
+                        relpos
+                      (` (imenu--relative-position (, reverse)))))))
+        (if (, (if relpos t
+                 (` (> pos (+ 5 (, prevpos))))))
+            (progn
+              (message imenu-scanning-message pos)
+              (setq (, prevpos) pos)))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;
+;;;; Some examples of functions utilizing the framework of this
+;;;; package.
+;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Return the current/previous sexp and the location of the sexp (it's
+;; beginning) without moving the point.
+(defun imenu-example--name-and-position ()
+  (save-excursion
+    (forward-sexp -1)
+    (let ((beg (point))
+          (end (progn (forward-sexp) (point)))
+          (marker (make-marker)))
+      (set-marker marker beg)
+      (cons (buffer-substring beg end)
+            marker))))
+
+;;;
+;;; Lisp
+;;; 
+
+(defun imenu-example--lisp-extract-index-name ()
+  ;; Example of a candidate for `imenu-extract-index-name-function'.
+  ;; This will generate a flat index of definitions in a lisp file.
+  (save-match-data
+    (and (looking-at "(def")
+         (condition-case nil
+             (progn
+               (down-list 1)
+               (forward-sexp 2)
+               (let ((beg (point))
+                     (end (progn (forward-sexp -1) (point))))
+                 (buffer-substring beg end)))
+           (error nil)))))
+
+(defun imenu-example--create-lisp-index ()
+  ;; Example of a candidate for `imenu-create-index-function'.
+  ;; It will generate a nested index of definitions.
+  (let ((index-alist '())
+        (index-var-alist '())
+        (index-type-alist '())
+        (index-unknown-alist '())
+        prev-pos)
+    (goto-char (point-max))
+    (imenu-progress-message prev-pos 0)
+    ;; Search for the function
+    (while (beginning-of-defun)
+      (imenu-progress-message prev-pos nil t)
+      (save-match-data
+        (and (looking-at "(def")
+             (save-excursion
+               (down-list 1)
+               (cond
+                ((looking-at "def\\(var\\|const\\)")
+                 (forward-sexp 2)
+                 (push (imenu-example--name-and-position)
+                       index-var-alist))
+                ((looking-at "def\\(un\\|subst\\|macro\\|advice\\)")
+                 (forward-sexp 2)
+                 (push (imenu-example--name-and-position)
+                       index-alist))
+                ((looking-at "def\\(type\\|struct\\|class\\|ine-condition\\)")
+                 (forward-sexp 2)
+                 (if (= (char-after (1- (point))) ?\))
+                     (progn
+                       (forward-sexp -1)
+                       (down-list 1)
+                       (forward-sexp 1)))
+                 (push (imenu-example--name-and-position)
+                       index-type-alist))
+                (t
+                 (forward-sexp 2)
+                 (push (imenu-example--name-and-position)
+                       index-unknown-alist)))))))
+    (imenu-progress-message prev-pos 100)
+    (and index-var-alist
+         (push (cons (imenu-create-submenu-name "Variables") index-var-alist)
+               index-alist))
+    (and index-type-alist
+         (push (cons (imenu-create-submenu-name "Types") index-type-alist)
+               index-alist))
+    (and index-unknown-alist
+         (push (cons (imenu-create-submenu-name "Syntax-unknown") index-unknown-alist)
+               index-alist))
+    index-alist))
+
+;;;
+;;; C
+;;;
+;; Regular expression to find C functions
+(defvar imenu-example--function-name-regexp-c
+  (concat 
+   "^[a-zA-Z0-9]+[ \t]?"                ; type specs; there can be no
+   "\\([a-zA-Z0-9_*]+[ \t]+\\)?"        ; more than 3 tokens, right?
+   "\\([a-zA-Z0-9_*]+[ \t]+\\)?"
+   "\\([*&]+[ \t]*\\)?"                 ; pointer
+   "\\([a-zA-Z0-9_*]+\\)[ \t]*("        ; name
+   ))
+
+(defun imenu-example--create-c-index (&optional regexp)
+  (let ((index-alist '())
+        prev-pos char)
+    (goto-char (point-min))
+    (imenu-progress-message prev-pos 0)
+    ;; Search for the function
+    (save-match-data
+      (while (re-search-forward
+              (or regexp imenu-example--function-name-regexp-c)
+              nil t)
+        (imenu-progress-message prev-pos)
+        (backward-up-list 1)
+        (save-excursion
+          (goto-char (scan-sexps (point) 1))
+          (setq char (following-char)))
+        ;; Skip this function name if it is a prototype declaration.
+        (if (not (eq char ?\;))
+            (push (imenu-example--name-and-position) index-alist))))
+    (imenu-progress-message prev-pos 100)
+    (nreverse index-alist)))
+
+;;;
+;;; C++
+;;;
+;; Example of an imenu-generic-expression
+;;
+(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).")
+
+;;; 
+;;; TexInfo
+;;; 
+;; Written by Wolfgang Bangerth <zcg51122@rpool1.rus.uni-stuttgart.de>
+;;
+;;
+(defvar imenu-example--generic-texinfo-expression
+  (cons
+   (concat 
+    "^@node[ \t]+"
+    "\\([^,\n]*\\)")
+   (list 1))
+  "imenu generic expression for TexInfo mode in the form
+\(REGEXP PAR).
+
+To overide this example, Either set 'imenu-generic-expression
+or 'imenu-create-index-function")
+
+;;; 
+;;; LaTex
+;;; 
+;; 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{[^}]*}"
+   "\\)")
+  "imenu generic expression for LaTex mode in the form
+\"REGEXP\".")
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; Internal variables
@@ -183,24 +423,6 @@ This function is called after the function pointed out by
       (/ (* 100 (1- pos)) (max total 1)))))
 
 ;;;
-;;; Macro to display a progress message.
-;;; RELPOS is the relative position to display.
-;;; If RELPOS is nil, then the relative position in the buffer
-;;; is calculated.
-;;; PREVPOS is the variable in which we store the last position displayed.
-(defmacro imenu-progress-message (prevpos &optional relpos reverse)
-  (` (and
-      imenu-scanning-message
-      (let ((pos (, (if relpos
-                      relpos
-                    (` (imenu--relative-position (, reverse)))))))
-        (if (, (if relpos t
-                 (` (> pos (+ 5 (, prevpos))))))
-            (progn
-              (message imenu-scanning-message pos)
-              (setq (, prevpos) pos)))))))
-
-;;;
 ;;; Function for suporting general looking submenu names.
 ;;; Uses `imenu-submenu-name-format' for creating the name.
 ;;; NAME is the base of the new submenu name.
@@ -274,8 +496,9 @@ This function is called after the function pointed out by
              (set-marker (cdr item) nil))
             ((listp (cdr item))
              (imenu--cleanup (cdr item))))))
-         (if alist alist imenu--index-alist))
-        t))
+        (if alist alist imenu--index-alist))
+       t))
+
 (defun imenu-default-create-index-function ()
   "*Wrapper for index searching functions.
 
@@ -284,21 +507,10 @@ Moves point to end of buffer and then repeatedly calls
 Their results are gathered into an index alist."
   ;; These should really be done by setting imenu-create-index-function
   ;; in these major modes.  But save that change for later.
-  (cond ((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-example--create-c++-index))
-        ((eq major-mode 'c-mode)
-         (imenu-example--create-c-index))
-        (t
-         (or (and (fboundp imenu-prev-index-position-function)
-                  (fboundp imenu-extract-index-name-function))
-             (error "The mode \"%s\" does not take full advantage of imenu.el yet."
-                    mode-name))      
+  (cond ((and (fboundp imenu-prev-index-position-function)
+              (fboundp imenu-extract-index-name-function))
          (let ((index-alist '())
-               name prev-pos)
+               prev-pos name)
            (goto-char (point-max))
            (imenu-progress-message prev-pos 0 t)
            ;; Search for the function
@@ -309,7 +521,26 @@ Their results are gathered into an index alist."
              (and (stringp name)
                   (push (cons name (point)) index-alist)))
            (imenu-progress-message prev-pos 100 t)
-           index-alist))))
+           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))
+        (t
+         (error "The mode \"%s\" does not take full advantage of imenu.el yet."
+                mode-name))))      
 
 (defun imenu--replace-spaces (name replacement)
   ;; Replace all spaces in NAME with REPLACEMENT.
@@ -344,6 +575,65 @@ Their results are gathered into an index alist."
           (imenu--flatten-index-alist pos new-prefix))))))
    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.")))
+    (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))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;
 ;;; The main functions for this package!
@@ -356,13 +646,13 @@ Their results are gathered into an index alist."
 Returns t for rescan and otherwise a position number."
   ;; Create a list for this buffer only when needed.
   (let (name choice
-        (prepared-index-alist
-         (mapcar
-          (function
-           (lambda (item)
-             (cons (imenu--replace-spaces (car item) imenu-space-replacement)
-                   (cdr item))))
-          index-alist)))
+             (prepared-index-alist
+              (mapcar
+               (function
+                (lambda (item)
+                  (cons (imenu--replace-spaces (car item) imenu-space-replacement)
+                        (cdr item))))
+               index-alist)))
     (save-window-excursion
       ;; Display the completion buffer
       (with-output-to-temp-buffer "*Completions*"
@@ -495,144 +785,6 @@ See `imenu-choose-buffer-index' for more information."
                  (widen))
              (goto-char (cdr index-item))))))))
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;
-;;;; Some examples of functions utilizing the framework of this
-;;;; package.
-;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Return the current/previous sexp and the location of the sexp (its
-;; beginning) without moving the point.
-(defun imenu-example--name-and-position ()
-  (save-excursion
-    (forward-sexp -1)
-    (let ((beg (point))
-          (end (progn (forward-sexp) (point)))
-          (marker (make-marker)))
-      (set-marker marker beg)
-      (cons (buffer-substring beg end)
-            marker))))
-  
-;;;
-;;; Lisp
-;;; 
-
-(defun imenu-example--lisp-extract-index-name ()
-  ;; Example of a candidate for `imenu-extract-index-name-function'.
-  ;; This will generate a flat index of definitions in a lisp file.
-  (save-match-data
-    (and (looking-at "(def")
-         (condition-case nil
-             (progn
-               (down-list 1)
-               (forward-sexp 2)
-               (let ((beg (point))
-                     (end (progn (forward-sexp -1) (point))))
-                 (buffer-substring beg end)))
-           (error nil)))))
-
-(defun imenu-example--create-lisp-index ()
-  ;; Example of a candidate for `imenu-create-index-function'.
-  ;; It will generate a nested index of definitions.
-  (let ((index-alist '())
-        (index-var-alist '())
-        (index-type-alist '())
-        (index-unknown-alist '())
-        prev-pos)
-    (goto-char (point-max))
-    (imenu-progress-message prev-pos 0)
-    ;; Search for the function
-    (while (beginning-of-defun)
-      (imenu-progress-message prev-pos nil t)
-      (save-match-data
-        (and (looking-at "(def")
-             (save-excursion
-               (down-list 1)
-               (cond
-                ((looking-at "def\\(var\\|const\\)")
-                 (forward-sexp 2)
-                 (push (imenu-example--name-and-position)
-                       index-var-alist))
-                ((looking-at "def\\(un\\|subst\\|macro\\|advice\\)")
-                 (forward-sexp 2)
-                 (push (imenu-example--name-and-position)
-                       index-alist))
-                ((looking-at "def\\(type\\|struct\\|class\\|ine-condition\\)")
-                 (forward-sexp 2)
-                 (if (= (char-after (1- (point))) ?\))
-                     (progn
-                       (forward-sexp -1)
-                       (down-list 1)
-                       (forward-sexp 1)))
-                 (push (imenu-example--name-and-position)
-                       index-type-alist))
-                (t
-                 (forward-sexp 2)
-                 (push (imenu-example--name-and-position)
-                       index-unknown-alist)))))))
-    (imenu-progress-message prev-pos 100)
-    (and index-var-alist
-         (push (cons (imenu-create-submenu-name "Variables") index-var-alist)
-               index-alist))
-    (and index-type-alist
-         (push (cons (imenu-create-submenu-name "Types") index-type-alist)
-               index-alist))
-    (and index-unknown-alist
-         (push (cons (imenu-create-submenu-name "Syntax-unknown") index-unknown-alist)
-               index-alist))
-    index-alist))
-    
-
-;;;
-;;; C
-;;;
-;; Regular expression to find C functions
-(defvar imenu-example--function-name-regexp-c
-  (concat 
-   "^[a-zA-Z0-9]+[ \t]?"                ; type specs; there can be no
-   "\\([a-zA-Z0-9_*]+[ \t]+\\)?"        ; more than 3 tokens, right?
-   "\\([a-zA-Z0-9_*]+[ \t]+\\)?"
-   "\\([*&]+[ \t]*\\)?"                 ; pointer
-   "\\([a-zA-Z0-9_*]+\\)[ \t]*("        ; name
-   ))
-
-(defun imenu-example--create-c-index (&optional regexp)
-  (let ((index-alist '())
-        prev-pos char)
-    (goto-char (point-min))
-    (imenu-progress-message prev-pos 0)
-    ;; Search for the function
-    (save-match-data
-      (while (re-search-forward
-              (or regexp imenu-example--function-name-regexp-c)
-              nil t)
-        (imenu-progress-message prev-pos)
-        (backward-up-list 1)
-        (save-excursion
-          (goto-char (scan-sexps (point) 1))
-          (setq char (following-char)))
-        ;; Skip this function name if it is a prototype declaration.
-        (if (not (eq char ?\;))
-            (push (imenu-example--name-and-position) index-alist))))
-    (imenu-progress-message prev-pos 100)
-    (nreverse index-alist)))
-
-;;; 
-;;; C++
-;;; 
-;; Regular expression to find C++ functions
-(defvar imenu-example--function-name-regexp-c++
-  (concat 
-   "^[a-zA-Z0-9:]+[ \t]?"               ; type specs; there can be no
-   "\\([a-zA-Z0-9_:~*]+[ \t]+\\)?"      ; more than 3 tokens, right?
-   "\\([a-zA-Z0-9_:~*]+[ \t]+\\)?"
-   "\\([*&]+[ \t]*\\)?"                 ; pointer
-   "\\([a-zA-Z0-9_:*]+\\)[ \t]*("       ; name
-   ))
-(defun imenu-example--create-c++-index ()
-  (imenu-example--create-c-index imenu-example--function-name-regexp-c++))
-
 (provide 'imenu)
 
 ;;; imenu.el ends here