;;; imenu.el --- Framework for mode-specific buffer indexes.
-;; Copyright (C) 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
;; Author: Ake Stenhoff <etxaksf@aom.ericsson.se>
;; Lars Lindberg <lli@sypro.cap.se>
;; Created: 8 Feb 1994
-;; Version: 1.15
;; Keywords: tools
-;;
-;; This program is free software; you can redistribute it and/or modify
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
+
+;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
-;;
+
;; You should have received a copy of the GNU General Public License
-;; along with this program; if not, write to the Free Software
-;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;;
+
;; Purpose of this package:
;; To present a framework for mode-specific buffer indexes.
;; A buffer index is an alist of names and buffer positions.
;; 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
;; [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))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defvar imenu-always-use-completion-buffer-p nil
+(defgroup imenu nil
+ "Mode-specific buffer indexes."
+ :group 'matching
+ :group 'frames)
+
+(defcustom imenu-use-markers t
+ "*Non-nil means use markers instead of integers for Imenu buffer positions.
+Setting this to nil makes Imenu work faster.
+
+This might not yet be honored by all index-building functions."
+ :type 'boolean
+ :group 'imenu)
+
+
+(defcustom imenu-max-item-length 60
+ "*If a number, truncate Imenu entries to that length."
+ :type 'integer
+ :group 'imenu)
+
+(defcustom imenu-auto-rescan nil
+ "*Non-nil means Imenu should always rescan the buffers."
+ :type 'boolean
+ :group 'imenu)
+
+(defcustom imenu-auto-rescan-maxout 60000
+ "*Imenu auto-rescan is disabled in buffers larger than this size.
+This variable is buffer-local."
+ :type 'integer
+ :group 'imenu)
+
+(defcustom imenu-always-use-completion-buffer-p nil
"*Set this to non-nil for displaying the index in a completion buffer.
-Non-nil means always display the index in a completion buffer.
-Nil means display the index as a mouse menu when the mouse was
-used to invoke `imenu'.
-`never' means never automatically display a listing of any kind.")
+`never' means never automatically display a listing of any kind.
+A value of nil (the default) means display the index as a mouse menu
+if the mouse was used to invoke `imenu'.
+Another non-nil value means always display the index in a completion buffer."
+ :type '(choice (const :tag "On Mouse" nil)
+ (const :tag "Never" never)
+ (sexp :tag "Always" :format "%t\n" t))
+ :group 'imenu)
-(defvar imenu-sort-function nil
+(defcustom imenu-sort-function nil
"*The function to use for sorting the index mouse-menu.
Affects only the mouse index menu.
The function should take two arguments and return T if the first
element should come before the second. The arguments are cons cells;
-\(NAME . POSITION). Look at `imenu--sort-by-name' for an example.")
+\(NAME . POSITION). Look at `imenu--sort-by-name' for an example."
+ :type 'function
+ :group 'imenu)
-(defvar imenu-max-items 25
- "*Maximum number of elements in an index mouse-menu.")
+(defcustom imenu-max-items 25
+ "*Maximum number of elements in a mouse menu for Imenu."
+ :type 'integer
+ :group 'imenu)
-(defvar imenu-scanning-message "Scanning buffer for index. (%3d%%)"
+(defcustom imenu-scanning-message "Scanning buffer for index (%3d%%)"
"*Progress message during the index scanning of the buffer.
-If non-nil, user gets a message during the scanning of the buffer
+If non-nil, user gets a message during the scanning of the buffer.
Relevant only if the mode-specific function that creates the buffer
-index use `imenu-progress-message'.")
+index use `imenu-progress-message'."
+ :type 'string
+ :group 'imenu)
-(defvar imenu-space-replacement "^"
+(defcustom imenu-space-replacement "^"
"*The replacement string for spaces in index names.
Used when presenting the index in a completion-buffer to make the
-names work as tokens.")
+names work as tokens."
+ :type 'string
+ :group 'imenu)
-(defvar imenu-level-separator ":"
+(defcustom imenu-level-separator ":"
"*The separator between index names of different levels.
Used for making mouse-menu titles and for flattening nested indexes
-with name concatenation.")
-
-(defvar imenu-submenu-name-format "%s..."
- "*The format for making a submenu name.")
+with name concatenation."
+ :type 'string
+ :group 'imenu)
+;;;###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--generic-function'
+to create a buffer index.
+
+The value should be an alist with elements that look like this:
+ (MENU-TITLE REGEXP INDEX)
+or like this:
+ (MENU-TITLE REGEXP INDEX FUNCTION ARGUMENTS...)
+with zero or more ARGUMENTS. The former format creates a simple element in
+the index alist when it matches; the latter creates a special element
+of the form (NAME FUNCTION NAME POSITION-MARKER ARGUMENTS...)
+with FUNCTION and ARGUMENTS beiong copied from `imenu-generic-expression'.
+
+MENU-TITLE is a string used as the title for the submenu or nil if the
+entries are not nested.
-Can be either an regular expression or an alist in the form
-\(REGEXP PAREN).")
+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-generic-expression)
;;;; Hooks
"The function to use for creating a buffer index.
It should be a function that takes no arguments and returns an index
-of the current buffer as an alist. The elements in the alist look
-like: (INDEX-NAME . INDEX-POSITION). You may also nest index list like
-\(INDEX-NAME . INDEX-ALIST).
+of the current buffer as an alist.
+
+Simple elements in the alist look like (INDEX-NAME . INDEX-POSITION).
+Special elements look like (INDEX-NAME FUNCTION ARGUMENTS...).
+A nested sub-alist element looks like (INDEX-NAME SUB-ALIST).
+The function `imenu--subalist-p' tests an element and returns t
+ if it is a sub-alist.
This function is called within a `save-excursion'.
file.
The function should leave point at the place to be connected to the
-index and it should return nil when it doesn't find another index. ")
+index and it should return nil when it doesn't find another index.")
(make-variable-buffer-local 'imenu-prev-index-position-function)
(defvar imenu-extract-index-name-function nil
`imenu-prev-index-position-function'.")
(make-variable-buffer-local 'imenu-extract-index-name-function)
+(defvar imenu-default-goto-function 'imenu-default-goto-function
+ "The default function called when selecting an Imenu item.
+The function in this variable is called when selecting a normal index-item.")
+(make-variable-buffer-local 'imenu-default-goto-function)
+
+
+(defun imenu--subalist-p (item)
+ (and (consp (cdr item)) (listp (cadr item))
+ (not (eq (caadr item) 'lambda))))
+
;;;
;;; Macro to display a progress message.
;;; RELPOS is the relative position to display.
;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Return the current/previous sexp and the location of the sexp (it's
+;; 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)
+ ;; [ydi] modified for imenu-use-markers
+ (let ((beg (if imenu-use-markers (point-marker) (point)))
+ (end (progn (forward-sexp) (point))))
(cons (buffer-substring beg end)
- marker))))
+ beg))))
;;;
;;; Lisp
index-unknown-alist)))))))
(imenu-progress-message prev-pos 100)
(and index-var-alist
- (push (cons (imenu-create-submenu-name "Variables") index-var-alist)
+ (push (cons "Variables" index-var-alist)
index-alist))
(and index-type-alist
- (push (cons (imenu-create-submenu-name "Types") index-type-alist)
+ (push (cons "Types" index-type-alist)
index-alist))
(and index-unknown-alist
- (push (cons (imenu-create-submenu-name "Syntax-unknown") index-unknown-alist)
+ (push (cons "Syntax-unknown" index-unknown-alist)
index-alist))
index-alist))
-;;;
-;;; C
-;;;
;; Regular expression to find C functions
(defvar imenu-example--function-name-regexp-c
(concat
(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\".")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
(defvar imenu--index-alist nil)
(make-variable-buffer-local 'imenu--index-alist)
+;; The latest buffer index used to update the menu bar menu.
+(defvar imenu--last-menubar-index-alist nil)
+(make-variable-buffer-local 'imenu--last-menubar-index-alist)
+
;; History list for 'jump-to-function-in-buffer'.
-;; Buffer local.
+;; Making this buffer local caused it not to work!
(defvar imenu--history-list nil)
-(make-variable-buffer-local 'imenu--history-list)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
(/ (1- pos) (max (/ total 100) 1))
(/ (* 100 (1- pos)) (max total 1)))))
-;;;
-;;; 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.
-;;;
-(defun imenu-create-submenu-name (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))
(defun imenu--split (list n)
(push (nreverse sublist) result))
(nreverse result)))
-;;;
-;;; Split a menu in to several menus.
-;;;
+;;; Split the alist MENULIST into a nested alist, if it is long enough.
+;;; In any case, add TITLE to the front of the alist.
(defun imenu--split-menu (menulist title)
- (cons "Function menus"
- (mapcar
- (function
- (lambda (menu)
- (cons (format "(%s)" title) menu)))
- (imenu--split menulist imenu-max-items))))
-
-;;;
-;;; Find all items in this buffer that should be in the index.
-;;; Returns an alist on the form
-;;; ((NAME . POSITION) (NAME . POSITION) ...)
-;;;
-
-(defun imenu--make-index-alist ()
- ;; Create a list for this buffer only when needed.
- (or imenu--index-alist
- ;; Get the index
- (setq imenu--index-alist
- (save-excursion
- (funcall imenu-create-index-function))))
+ (let (keep-at-top tail)
+ (if (memq imenu--rescan-item menulist)
+ (setq keep-at-top (cons imenu--rescan-item nil)
+ menulist (delq imenu--rescan-item menulist)))
+ (setq tail menulist)
+ (while tail
+ (if (imenu--subalist-p (car tail))
+ (setq keep-at-top (cons (car tail) keep-at-top)
+ menulist (delq (car tail) menulist)))
+ (setq tail (cdr tail)))
+ (if imenu-sort-function
+ (setq menulist
+ (sort
+ (let ((res nil)
+ (oldlist menulist))
+ ;; Copy list method from the cl package `copy-list'
+ (while (consp oldlist) (push (pop oldlist) res))
+ (prog1 (nreverse res) (setcdr res oldlist)))
+ imenu-sort-function)))
+ (if (> (length menulist) imenu-max-items)
+ (let ((count 0))
+ (setq menulist
+ (mapcar
+ (function
+ (lambda (menu)
+ (cons (format "From: %s" (caar menu)) menu)))
+ (imenu--split menulist imenu-max-items)))))
+ (cons title
+ (nconc (nreverse keep-at-top) menulist))))
+
+;;; Split up each long alist that are nested within ALIST
+;;; into nested alists.
+(defun imenu--split-submenus (alist)
+ (mapcar (function (lambda (elt)
+ (if (and (consp elt)
+ (stringp (car elt))
+ (listp (cdr elt)))
+ (imenu--split-menu (cdr elt) (car elt))
+ elt)))
+ alist))
+
+;;; Truncate all strings in MENULIST to imenu-max-item-length
+(defun imenu--truncate-items (menulist)
+ (mapcar (function
+ (lambda (item)
+ (cond
+ ((consp (cdr item))
+ (imenu--truncate-items (cdr item)))
+ (t
+ ;; truncate if necessary
+ (if (and (numberp imenu-max-item-length)
+ (> (length (car item)) imenu-max-item-length))
+ (setcar item (substring (car item) 0 imenu-max-item-length)))))))
+ menulist))
+
+
+(defun imenu--make-index-alist (&optional noerror)
+ "Create an index-alist for the definitions in the current buffer.
+
+Simple elements in the alist look like (INDEX-NAME . INDEX-POSITION).
+Special elements look like (INDEX-NAME FUNCTION ARGUMENTS...).
+A nested sub-alist element looks like (INDEX-NAME SUB-ALIST).
+The function `imenu--subalist-p' tests an element and returns t
+ if it is a sub-alist.
+
+There is one simple element with negative POSITION; that's intended
+as a way for the user to ask to recalculate the buffer's 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; truncate if necessary
+ (progn
+ (setq imenu--index-alist
+ (save-excursion
+ (save-restriction
+ (widen)
+ (funcall imenu-create-index-function))))
+ (imenu--truncate-items imenu--index-alist)))
+ (or imenu--index-alist noerror
+ (error "No items suitable for an index found in this buffer"))
(or imenu--index-alist
- (error "No items suitable for an index found in this buffer."))
+ (setq imenu--index-alist (list nil)))
;; Add a rescan option to the index.
(cons imenu--rescan-item imenu--index-alist))
-;;;
+
;;; Find all markers in alist and makes
;;; them point nowhere.
-;;;
+;;; The top-level call uses nil as the argument;
+;;; non-nil arguments are in recursivecalls.
+(defvar imenu--cleanup-seen)
+
(defun imenu--cleanup (&optional alist)
- ;; Sets the markers in imenu--index-alist
- ;; point nowhere.
- ;; if alist is provided use that list.
- (or alist
- (setq alist imenu--index-alist))
+ ;; If alist is provided use that list.
+ ;; If not, empty the table of lists already seen
+ ;; and use imenu--index-alist.
+ (if alist
+ (setq imenu--cleanup-seen (cons alist imenu--cleanup-seen))
+ (setq alist imenu--index-alist imenu--cleanup-seen (list alist)))
+
(and alist
(mapcar
(function
(cond
((markerp (cdr item))
(set-marker (cdr item) nil))
- ((consp (cdr item))
+ ;; Don't process one alist twice.
+ ((memq (cdr item) imenu--cleanup-seen))
+ ((imenu--subalist-p item)
(imenu--cleanup (cdr item))))))
alist)
t))
+(defun imenu--create-keymap-2 (alist counter &optional commands)
+ (let ((map nil))
+ (mapcar
+ (function
+ (lambda (item)
+ (cond
+ ((imenu--subalist-p item)
+ (append (list (setq counter (1+ counter))
+ (car item) 'keymap (car item))
+ (imenu--create-keymap-2 (cdr item) (+ counter 10) commands)))
+ (t
+ (let ((end (if commands `(lambda () (interactive)
+ (imenu--menubar-select ',item))
+ (cons '(nil) item))))
+ (cons (car item)
+ (cons (car item) end))))
+ )))
+ alist)))
+
+;; If COMMANDS is non-nil, make a real keymap
+;; with a real command used as the definition.
+;; If it is nil, make something suitable for x-popup-menu.
+(defun imenu--create-keymap-1 (title alist &optional commands)
+ (append (list 'keymap title) (imenu--create-keymap-2 alist 0 commands)))
+
+
+(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))
+ ;; A nested ALIST element looks like
+ ;; (INDEX-NAME (INDEX-NAME . INDEX-POSITION) ...)
+ ;; while a bottom-level element looks like
+ ;; (INDEX-NAME . INDEX-POSITION)
+ ;; We are only interested in the bottom-level elements, so we need to
+ ;; recurse if TAIL is a list.
+ (cond ((listp tail)
+ (if (setq res (imenu--in-alist str tail))
+ (setq alist nil)))
+ ((string= str head)
+ (setq alist nil res elt))))
+ res))
+
(defun imenu-default-create-index-function ()
"*Wrapper for index searching functions.
(save-excursion
(setq name (funcall imenu-extract-index-name-function)))
(and (stringp name)
- (push (cons name (point)) index-alist)))
+ ;; [ydi] updated for imenu-use-markers
+ (push (cons name (if imenu-use-markers (point-marker) (point)))
+ index-alist)))
(imenu-progress-message prev-pos 100 t)
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))
+ (imenu--generic-function imenu-generic-expression))
(t
- (error "The mode \"%s\" does not take full advantage of imenu.el yet."
- mode-name))))
+ (error "This buffer cannot use `imenu-default-create-index-function'"))))
(defun imenu--replace-spaces (name replacement)
;; Replace all spaces in NAME with REPLACEMENT.
;;;
;;; 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)))
+ (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))
+ (function (cadddr pat))
+ (rest (cddddr 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
+ (let ((name
+ (buffer-substring-no-properties beg end)))
+ ;; [ydi] updated for imenu-use-markers
+ (if imenu-use-markers
+ (setq beg (set-marker (make-marker) beg)))
+ (if function
+ (nconc (list name beg function)
+ rest)
+ (cons name beg)))
+ (cdr
+ (or (assoc menu-title index-alist)
+ (car (push
+ (cons menu-title '())
+ index-alist))))))))))
+ patterns))))
(imenu-progress-message prev-pos 100 t)
- index-alist))
+ (let ((main-element (assq nil index-alist)))
+ (nconc (delq main-element (delq 'dummy index-alist))
+ (cdr main-element)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
t)
(t
(setq choice (assoc name prepared-index-alist))
- (if (listp (cdr choice))
+ (if (imenu--subalist-p choice)
(imenu--completion-buffer (cdr choice) prompt)
choice)))))
INDEX-ALIST is the buffer index and EVENT is a mouse event.
-Returns t for rescan and otherwise a position number."
- (let* ((menu (imenu--split-menu
- (if imenu-sort-function
- (sort
- (let ((res nil)
- (oldlist index-alist))
- ;; Copy list method from the cl package `copy-list'
- (while (consp oldlist) (push (pop oldlist) res))
- (prog1 (nreverse res) (setcdr res oldlist)))
- imenu-sort-function)
- index-alist)
+Returns t for rescan and otherwise an element or subelement of INDEX-ALIST."
+ (setq index-alist (imenu--split-submenus index-alist))
+ (let* ((menu (imenu--split-menu index-alist
(or title (buffer-name))))
position)
+ (setq menu (imenu--create-keymap-1 (car menu)
+ (if (< 1 (length (cdr menu)))
+ (cdr menu)
+ (cdr (car (cdr menu))))))
(setq position (x-popup-menu event menu))
- (cond
- ((eq position nil)
- position)
- ((listp position)
- (imenu--mouse-menu position event
- (if title
- (concat title imenu-level-separator
- (car (rassq position index-alist)))
- (car (rassq position index-alist)))))
- ((= position (cdr imenu--rescan-item))
- t)
- (t
- (rassq position index-alist)))))
+ (cond ((eq position nil)
+ position)
+ ;; If one call to x-popup-menu handled the nested menus,
+ ;; find the result by looking down the menus here.
+ ((and (listp position)
+ (numberp (car position))
+ (stringp (nth (1- (length position)) position)))
+ (let ((final menu))
+ (while position
+ (setq final (assoc (car position) final))
+ (setq position (cdr position)))
+ (or (string= (car final) (car imenu--rescan-item))
+ (cdr (cdr (cdr final))))))
+ ;; If x-popup-menu went just one level and found a leaf item,
+ ;; return the INDEX-ALIST element for that.
+ ((and (consp position)
+ (stringp (car position))
+ (null (cdr position)))
+ (or (string= (car position) (car imenu--rescan-item))
+ (assq (car position) index-alist)))
+ ;; If x-popup-menu went just one level
+ ;; and found a non-leaf item (a submenu),
+ ;; recurse to handle the rest.
+ ((listp position)
+ (imenu--mouse-menu position event
+ (if title
+ (concat title imenu-level-separator
+ (car (rassq position index-alist)))
+ (car (rassq position index-alist))))))))
(defun imenu-choose-buffer-index (&optional prompt alist)
"Let the user select from a buffer index and return the chosen index.
completion buffer is always used, no matter if the mouse was used or
not.
-The returned value is on the form (INDEX-NAME . INDEX-POSITION)."
+The returned value is of the form (INDEX-NAME . INDEX-POSITION)."
(let (index-alist
(mouse-triggered (listp last-nonmenu-event))
(result t) )
;; If selected by mouse, see to that the window where the mouse is
;; really is selected.
(and mouse-triggered
+ (not (equal last-nonmenu-event '(menu-bar)))
(let ((window (posn-window (event-start last-nonmenu-event))))
- (or (framep window) (select-window window))))
+ (or (framep window) (null window) (select-window window))))
;; Create a list for this buffer only when needed.
(while (eq result t)
(setq index-alist (if alist alist (imenu--make-index-alist)))
(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.
-NAME is the string naming the menu to be added.
-See 'imenu' for more information."
- (interactive "sMenu name: ")
- (and window-system
- (define-key (current-local-map) [menu-bar index]
- (cons name 'imenu))))
+ "Adds an `imenu' entry to the menu bar for the current buffer.
+NAME is a string used to name the menu bar item.
+See the command `imenu' for more information."
+ (interactive "sImenu menu item name: ")
+ (if (or (and (fboundp imenu-prev-index-position-function)
+ (fboundp imenu-extract-index-name-function))
+ (and imenu-generic-expression))
+ (let ((newmap (make-sparse-keymap))
+ (menu-bar (lookup-key (current-local-map) [menu-bar])))
+ (define-key newmap [menu-bar]
+ (append (make-sparse-keymap) menu-bar))
+ (define-key newmap [menu-bar index]
+ (cons name (nconc (make-sparse-keymap "Imenu")
+ (make-sparse-keymap))))
+ (use-local-map (append newmap (current-local-map)))
+ (add-hook 'menu-bar-update-hook 'imenu-update-menubar))
+ (error "The mode `%s' does not support Imenu" mode-name)))
+
+(defvar imenu-buffer-menubar nil)
+
+(defun imenu-update-menubar ()
+ (and (current-local-map)
+ (keymapp (lookup-key (current-local-map) [menu-bar index]))
+ (let ((index-alist (imenu--make-index-alist t)))
+ ;; Don't bother updating if the index-alist has not changed
+ ;; since the last time we did it.
+ (or (equal index-alist imenu--last-menubar-index-alist)
+ (let (menu menu1 old)
+ (setq imenu--last-menubar-index-alist index-alist)
+ (setq index-alist (imenu--split-submenus index-alist))
+ (setq menu (imenu--split-menu index-alist
+ (buffer-name)))
+ (setq menu1 (imenu--create-keymap-1 (car menu)
+ (if (< 1 (length (cdr menu)))
+ (cdr menu)
+ (cdr (car (cdr menu))))
+ t))
+ (setq old (lookup-key (current-local-map) [menu-bar index]))
+ (setcdr old (cdr menu1)))))))
+
+(defun imenu--menubar-select (item)
+ "Use Imenu to select the function or variable named in this menu item."
+ (if (equal item imenu--rescan-item)
+ (progn
+ (imenu--cleanup)
+ (setq imenu--index-alist nil)
+ (imenu-update-menubar))
+ (imenu item)))
+
+(defun imenu-default-goto-function (name position &optional rest)
+ "This function is used for moving the point to POSITION.
+The NAME and REST parameters are not used, they are here just to make
+this function have the same interface as a function placed in a special
+index-item."
+ (if (or (< position (point-min))
+ (> position (point-max)))
+ ;; widen if outside narrowing
+ (widen))
+ (goto-char position))
;;;###autoload
-(defun imenu ()
+(defun imenu (index-item)
"Jump to a place in the buffer chosen using a buffer menu or mouse menu.
See `imenu-choose-buffer-index' for more information."
- (interactive)
- (let ((index-item (save-restriction
- (widen)
- (imenu-choose-buffer-index))))
- (and index-item
- (progn
- (push-mark)
- (cond
- ((markerp (cdr index-item))
- (if (or ( > (marker-position (cdr index-item)) (point-min))
- ( < (marker-position (cdr index-item)) (point-max)))
- ;; widen if outside narrowing
- (widen))
- (goto-char (marker-position (cdr index-item))))
- (t
- (if (or ( > (cdr index-item) (point-min))
- ( < (cdr index-item) (point-max)))
- ;; widen if outside narrowing
- (widen))
- (goto-char (cdr index-item))))))))
+ (interactive (list (imenu-choose-buffer-index)))
+ ;; Convert a string to an alist element.
+ (if (stringp index-item)
+ (setq index-item (assoc index-item (imenu--make-index-alist))))
+ (and index-item
+ (progn
+ (push-mark)
+ (let* ((is-special-item (listp (cdr index-item)))
+ (function
+ (if is-special-item
+ (caddr index-item) imenu-default-goto-function))
+ (position (if is-special-item
+ (cadr index-item) (cdr index-item)))
+ (rest (if is-special-item (cddr index-item))))
+ (apply function (car index-item) position rest)))))
(provide 'imenu)