-;;; imenu.el --- Framework for mode-specific buffer indexes.
+;;; imenu.el --- framework for mode-specific buffer indexes
-;; Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1996, 1997, 1998, 2002, 2003, 2004,
+;; 2005, 2006 Free Software Foundation, Inc.
;; Author: Ake Stenhoff <etxaksf@aom.ericsson.se>
;; Lars Lindberg <lli@sypro.cap.se>
;; You should have received a copy of the GNU General Public License
;; 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.
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; [christian] - Christian Egli Christian.Egli@hcsd.hac.com
;; [karl] - Karl Fogel kfogel@floss.life.uiuc.edu
-;;; Code
+;;; Code:
(eval-when-compile (require 'cl))
: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.
-
-`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)
+(defvar imenu-always-use-completion-buffer-p nil)
+(make-obsolete-variable 'imenu-always-use-completion-buffer-p
+ 'imenu-use-popup-menu "22.1")
+
+(defcustom imenu-use-popup-menu
+ (if imenu-always-use-completion-buffer-p
+ (not (eq imenu-always-use-completion-buffer-p 'never))
+ 'on-mouse)
+ "Use a popup menu rather than a minibuffer prompt.
+If nil, always use a minibuffer prompt.
+If t, always use a popup menu,
+If `on-mouse' use a popup menu when `imenu' was invoked with the mouse."
+ :type '(choice (const :tag "On Mouse" on-mouse)
+ (const :tag "Never" nil)
(other :tag "Always" t))
:group 'imenu)
+(defcustom imenu-eager-completion-buffer
+ (not (eq imenu-always-use-completion-buffer-p 'never))
+ "If non-nil, eagerly popup the completion buffer."
+ :type 'boolean
+ :group 'imenu
+ :version "22.1")
+
(defcustom imenu-after-jump-hook nil
"*Hooks called after jumping to a place in the buffer.
:type 'integer
:group 'imenu)
-(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.
-
-Relevant only if the mode-specific function that creates the buffer
-index use `imenu-progress-message', and not useful if that is fast, in
-which case you might as well set this to nil."
- :type '(choice string
- (const :tag "None" nil))
- :group 'imenu)
+;; No longer used. KFS 2004-10-27
+;; (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.
+;;
+;; Relevant only if the mode-specific function that creates the buffer
+;; index use `imenu-progress-message', and not useful if that is fast, in
+;; which case you might as well set this to nil."
+;; :type '(choice string
+;; (const :tag "None" nil))
+;; :group 'imenu)
(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."
- :type 'string
+ :type '(choice string (const nil))
:group 'imenu)
(defcustom imenu-level-separator ":"
(defvar imenu-generic-expression nil
"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 POSITION-MARKER FUNCTION ARGUMENTS...)
-with FUNCTION and ARGUMENTS 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.
-
-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.
-
-The variable is buffer-local.
+If non-nil this pattern is passed to `imenu--generic-function' to
+create a buffer index. Look there for the documentation of this
+pattern's structure.
-The variable `imenu-case-fold-search' determines whether or not the
-regexp matches are case sensitive. and `imenu-syntax-alist' can be
-used to alter the syntax table for the search.
-
-For example, see the value of `lisp-imenu-generic-expression' used by
-`lisp-mode' and `emacs-lisp-mode' with `imenu-syntax-alist' set
-locally to give the characters which normally have \"punctuation\"
-syntax \"word\" syntax during matching.")
+For example, see the value of `fortran-imenu-generic-expression' used by
+`fortran-mode' with `imenu-syntax-alist' set locally to give the
+characters which normally have \"symbol\" syntax \"word\" syntax
+during matching.")
;;;###autoload
(make-variable-buffer-local 'imenu-generic-expression)
;;;###autoload
(defvar imenu-create-index-function 'imenu-default-create-index-function
- "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.
-
-Simple elements in the alist look like (INDEX-NAME . INDEX-POSITION).
-Special elements look like (INDEX-NAME INDEX-POSITION 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.
+ "The function to use for creating an index alist of the current buffer.
-This function is called within a `save-excursion'.
+It should be a function that takes no arguments and returns
+an index alist of the current buffer. The function is
+called within a `save-excursion'.
-The variable is buffer-local.")
+See `imenu--index-alist' for the format of the buffer index alist.")
;;;###autoload
(make-variable-buffer-local 'imenu-create-index-function)
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.
-
-This variable is local in all buffers.")
+index and it should return nil when it doesn't find another index.")
;;;###autoload
(make-variable-buffer-local 'imenu-prev-index-position-function)
This function is called after `imenu-prev-index-position-function'
finds a position for an index item, with point at that position.
-It should return the name for that index item.
-
-This variable is local in all buffers.")
+It should return the name for that index item.")
;;;###autoload
(make-variable-buffer-local 'imenu-extract-index-name-function)
If nil, comparison is done with `string='.
Set this to some other function for more advanced comparisons,
such as \"begins with\" or \"name matches and number of
-arguments match\".
-
-This variable is local in all buffers.")
+arguments match\".")
;;;###autoload
(make-variable-buffer-local 'imenu-name-lookup-function)
;; 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))))))
+
+;; Made obsolete/empty, as computers are now faster than the eye, and
+;; it had problems updating the messages correctly, and could shadow
+;; more important messages/prompts in the minibuffer. KFS 2004-10-27.
+
+;; `(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)))))
+)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Return the current/previous sexp and the location of the sexp (its
-;; beginning) without moving the point.
+;; FIXME: This is the only imenu-example-* definition that's actually used,
+;; and it seems to only be used by cperl-mode.el. We should just move it to
+;; cperl-mode.el and remove the rest.
(defun imenu-example--name-and-position ()
+ "Return the current/previous sexp and its (beginning) location.
+Don't move point."
(save-excursion
(forward-sexp -1)
;; [ydi] modified for imenu-use-markers
;; The latest buffer index.
;; Buffer local.
(defvar imenu--index-alist nil
- "The buffer index computed for this buffer in Imenu.
-Simple elements in the alist look like (INDEX-NAME . INDEX-POSITION).
-Special elements look like (INDEX-NAME INDEX-POSITION FUNCTION ARGUMENTS...).
+ "The buffer index alist computed for this buffer in Imenu.
+
+Simple elements in the alist look like (INDEX-NAME . POSITION).
+POSITION is the buffer position of the item; to go to the item
+is simply to move point to that position.
+
+Special elements look like (INDEX-NAME POSITION FUNCTION ARGUMENTS...).
+To \"go to\" a special element means applying FUNCTION
+to INDEX-NAME, POSITION, and the 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 variable is local in all buffers, once set.")
+There is one simple element with negative POSITION; selecting that
+element recalculates the buffer's index alist.")
(make-variable-buffer-local 'imenu--index-alist)
(defvar imenu--last-menubar-index-alist nil
- "The latest buffer index used to update the menu bar menu.")
+ "The latest buffer index alist used to update the menu bar menu.")
(make-variable-buffer-local 'imenu--last-menubar-index-alist)
(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)))
+ (dolist (item tail)
+ (when (imenu--subalist-p item)
+ (push item keep-at-top)
+ (setq menulist (delq item menulist))))
(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))
- (if res ; in case, e.g. no functions defined
- (prog1 (nreverse res) (setcdr res oldlist))))
- imenu-sort-function)))
+ (setq menulist (sort (copy-sequence menulist) 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)))))
+ (setq menulist
+ (mapcar
+ (lambda (menu)
+ (cons (format "From: %s" (caar menu)) menu))
+ (imenu--split menulist imenu-max-items))))
(cons title
(nconc (nreverse keep-at-top) menulist))))
(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)))))))
+ ;; truncate if necessary
+ ((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.
-
+ "Create an index alist for the definitions in the current buffer.
+This works by using the hook function `imenu-create-index-function'.
Report an error if the list is empty unless NOERROR is supplied and
non-nil.
-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."
+See `imenu--index-alist' for the format of the index alist."
(or (and imenu--index-alist
(or (not imenu-auto-rescan)
(and imenu-auto-rescan
alist)
t))
-(defun imenu--create-keymap-2 (alist counter &optional commands)
- (let ((map nil))
- (mapcar
- (lambda (item)
- (cond
- ((imenu--subalist-p item)
- (nconc (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)
- (list 'menu-item (car item) end :key-sequence nil))))))
- 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)
- (cons 'keymap (cons title (imenu--create-keymap-2 alist 0 commands))))
+(defun imenu--create-keymap (title alist &optional cmd)
+ (list* 'keymap title
+ (mapcar
+ (lambda (item)
+ (list* (car item) (car item)
+ (cond
+ ((imenu--subalist-p item)
+ (imenu--create-keymap (car item) (cdr item) cmd))
+ (t
+ `(lambda () (interactive)
+ ,(if cmd `(,cmd ',item) (list 'quote item)))))))
+ alist)))
(defun imenu--in-alist (str alist)
"Check whether the string STR is contained in multi-level ALIST."
res))
(defvar imenu-syntax-alist nil
- "Alist of syntax table modifiers to use while executing `imenu--generic-function'.
+ "Alist of syntax table modifiers to use while in `imenu--generic-function'.
The car of the assocs may be either a character or a string and the
-cdr is a syntax description appropriate fo `modify-syntax-entry'. For
+cdr is a syntax description appropriate for `modify-syntax-entry'. For
a string, all the characters in the string get the specified syntax.
This is typically used to give word syntax to characters which
(make-variable-buffer-local 'imenu-syntax-alist)
(defun imenu-default-create-index-function ()
- "*Wrapper for index searching functions.
+ "*Default function to create an index alist of the current buffer.
-Moves point to end of buffer and then repeatedly calls
+The most general method is to move point to end of buffer, then repeatedly call
`imenu-prev-index-position-function' and `imenu-extract-index-name-function'.
-Their results are gathered into an index alist."
+All the results returned by the latter are gathered into an index alist.
+This method is used if those two variables are non-nil.
+
+The alternate method, which is the one most often used, is to call
+`imenu--generic-function' with `imenu-generic-expression' as argument."
;; These should really be done by setting imenu-create-index-function
;; in these major modes. But save that change for later.
(cond ((and imenu-prev-index-position-function
(t
(error "This buffer cannot use `imenu-default-create-index-function'"))))
-;; Not used and would require cl at run time
-;;; (defun imenu--flatten-index-alist (index-alist &optional concat-names prefix)
-;;; ;; Takes a nested INDEX-ALIST and returns a flat index alist.
-;;; ;; If optional CONCAT-NAMES is non-nil, then a nested index has its
-;;; ;; name and a space concatenated to the names of the children.
-;;; ;; Third argument PREFIX is for internal use only.
-;;; (mapcan
-;;; (lambda (item)
-;;; (let* ((name (car item))
-;;; (pos (cdr item))
-;;; (new-prefix (and concat-names
-;;; (if prefix
-;;; (concat prefix imenu-level-separator name)
-;;; name))))
-;;; (cond
-;;; ((or (markerp pos) (numberp pos))
-;;; (list (cons new-prefix pos)))
-;;; (t
-;;; (imenu--flatten-index-alist pos new-prefix)))))
-;;; index-alist))
-
;;;
;;; Generic index gathering function.
;;;
(defvar imenu-case-fold-search t
"Defines whether `imenu--generic-function' should fold case when matching.
-This buffer-local variable should be set (only) by initialization code
-for modes which use `imenu--generic-function'. If it is not set, that
-function will use the current value of `case-fold-search' to match
-patterns.")
+This variable should be set (only) by initialization code
+for modes which use `imenu--generic-function'. If it is not set, but
+`font-lock-defaults' is set, then font-lock's setting is used.")
;;;###autoload
(make-variable-buffer-local 'imenu-case-fold-search)
-;; Originally "Built on some ideas that Erik Naggum <erik@naggum.no>
-;; once posted to comp.emacs" but since substantially re-written.
+;; This function can be called with quitting disabled,
+;; so it needs to be careful never to loop!
(defun imenu--generic-function (patterns)
- "Return an index of the current buffer as an alist.
+ "Return an index alist of the current buffer based on PATTERNS.
PATTERNS 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.
+ (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 (INDEX-NAME POSITION-MARKER FUNCTION
+ARGUMENTS...) with FUNCTION and ARGUMENTS copied from PATTERNS.
+
+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. REGEXP may also be a function, called without
+arguments. It is expected to search backwards. It shall return
+true and set `match-data' iff it finds another element.
+
+INDEX points to the substring in REGEXP that contains the
+name (of the function, variable or type) that is to appear in the
+menu.
-INDEX points to the substring in REGEXP that contains the name (of the
-function, variable or type) that is to appear in the menu.
+The variable `imenu-case-fold-search' determines whether or not the
+regexp matches are case sensitive, and `imenu-syntax-alist' can be
+used to alter the syntax table for the search.
See `lisp-imenu-generic-expression' for an example of PATTERNS.
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
-PATTERNS."
+the alist look like:
+ (INDEX-NAME . INDEX-POSITION)
+or like:
+ (INDEX-NAME INDEX-POSITION FUNCTION ARGUMENTS...)
+They may also be nested index alists like:
+ (INDEX-NAME . INDEX-ALIST)
+depending on PATTERNS."
(let ((index-alist (list 'dummy))
- prev-pos beg
- (case-fold-search imenu-case-fold-search)
+ prev-pos
+ (case-fold-search (if (or (local-variable-p 'imenu-case-fold-search)
+ (not (local-variable-p 'font-lock-defaults)))
+ imenu-case-fold-search
+ (nth 2 font-lock-defaults)))
(old-table (syntax-table))
(table (copy-syntax-table (syntax-table)))
(slist imenu-syntax-alist))
;; Modify the syntax table used while matching regexps.
- (while slist
+ (dolist (syn slist)
;; The character(s) to modify may be a single char or a string.
- (if (numberp (caar slist))
- (modify-syntax-entry (caar slist) (cdar slist) table)
- (dolist (c (caar slist))
- (modify-syntax-entry c (cdar slist) table)))
- (setq slist (cdr slist)))
+ (if (numberp (car syn))
+ (modify-syntax-entry (car syn) (cdr syn) table)
+ (mapc (lambda (c)
+ (modify-syntax-entry c (cdr syn) table))
+ (car syn))))
(goto-char (point-max))
(imenu-progress-message prev-pos 0 t)
(unwind-protect ; for syntax table
(save-match-data
(set-syntax-table table)
+
;; map over the elements of imenu-generic-expression
;; (typically functions, variables ...)
- (mapc
- (lambda (pat)
- (let ((menu-title (car pat))
- (regexp (nth 1 pat))
- (index (nth 2 pat))
- (function (nth 3 pat))
- (rest (nthcdr 4 pat)))
- ;; Go backwards for convenience of adding items in order.
- (goto-char (point-max))
- (while (re-search-backward regexp nil t)
- (imenu-progress-message prev-pos nil t)
- (setq beg (match-beginning index))
- ;; Add this sort of submenu only when we've found an
- ;; item for it, avoiding empty, duff menus.
- (unless (assoc menu-title index-alist)
- (push (list menu-title) index-alist))
- (if imenu-use-markers
- (setq beg (copy-marker beg)))
- (let ((item
- (if function
- (nconc (list (match-string-no-properties index)
- beg function)
- rest)
- (cons (match-string-no-properties index)
- beg)))
- ;; This is the desired submenu,
- ;; starting with its title (or nil).
- (menu (assoc menu-title index-alist)))
- ;; Insert the item unless it is already present.
- (unless (member item (cdr menu))
- (setcdr menu
- (cons item (cdr menu))))))))
- patterns)
+ (dolist (pat patterns)
+ (let ((menu-title (car pat))
+ (regexp (nth 1 pat))
+ (index (nth 2 pat))
+ (function (nth 3 pat))
+ (rest (nthcdr 4 pat))
+ start beg)
+ ;; Go backwards for convenience of adding items in order.
+ (goto-char (point-max))
+ (while (and (if (functionp regexp)
+ (funcall regexp)
+ (re-search-backward regexp nil t))
+ ;; Exit the loop if we get an empty match,
+ ;; because it means a bad regexp was specified.
+ (not (= (match-beginning 0) (match-end 0))))
+ (setq start (point))
+ ;; Record the start of the line in which the match starts.
+ ;; That's the official position of this definition.
+ (goto-char (match-beginning index))
+ (beginning-of-line)
+ (setq beg (point))
+ (imenu-progress-message prev-pos nil t)
+ ;; Add this sort of submenu only when we've found an
+ ;; item for it, avoiding empty, duff menus.
+ (unless (assoc menu-title index-alist)
+ (push (list menu-title) index-alist))
+ (if imenu-use-markers
+ (setq beg (copy-marker beg)))
+ (let ((item
+ (if function
+ (nconc (list (match-string-no-properties index)
+ beg function)
+ rest)
+ (cons (match-string-no-properties index)
+ beg)))
+ ;; This is the desired submenu,
+ ;; starting with its title (or nil).
+ (menu (assoc menu-title index-alist)))
+ ;; Insert the item unless it is already present.
+ (unless (member item (cdr menu))
+ (setcdr menu
+ (cons item (cdr menu)))))
+ ;; Go to the start of the match, to make sure we
+ ;; keep making progress backwards.
+ (goto-char start))))
(set-syntax-table old-table)))
(imenu-progress-message prev-pos 100 t)
;; Sort each submenu by position.
;; This is in case one submenu gets items from two different regexps.
- (let ((tail index-alist))
- (while tail
- (if (listp (car tail))
- (setcdr (car tail)
- (sort (cdr (car tail)) 'imenu--sort-by-position)))
- (setq tail (cdr tail))))
+ (dolist (item index-alist)
+ (when (listp item)
+ (setcdr item (sort (cdr item) 'imenu--sort-by-position))))
(let ((main-element (assq nil index-alist)))
(nconc (delq main-element (delq 'dummy index-alist))
(cdr main-element)))))
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; See also info-lookup-find-item
+(defun imenu-find-default (guess completions)
+ "Fuzzily find an item based on GUESS inside the alist COMPLETIONS."
+ (catch 'found
+ (let ((case-fold-search t))
+ (if (assoc guess completions) guess
+ (dolist (re (list (concat "\\`" (regexp-quote guess) "\\'")
+ (concat "\\`" (regexp-quote guess))
+ (concat (regexp-quote guess) "\\'")
+ (regexp-quote guess)))
+ (dolist (x completions)
+ (if (string-match re (car x)) (throw 'found (car x)))))))))
+
(defun imenu--completion-buffer (index-alist &optional prompt)
"Let the user select from INDEX-ALIST in a completion buffer with PROMPT.
-Returns t for rescan and otherwise a position number."
+Return one of the entries in index-alist or nil."
;; Create a list for this buffer only when needed.
(let ((name (thing-at-point 'symbol))
choice
(prepared-index-alist
- (mapcar
- (lambda (item)
- (cons (subst-char-in-string ?\ (aref imenu-space-replacement 0)
- (car item))
- (cdr item)))
- index-alist)))
+ (if (not imenu-space-replacement) index-alist
+ (mapcar
+ (lambda (item)
+ (cons (subst-char-in-string ?\s (aref imenu-space-replacement 0)
+ (car item))
+ (cdr item)))
+ index-alist))))
+ (when (stringp name)
+ (setq name (or (imenu-find-default name prepared-index-alist) name)))
(cond (prompt)
((and name (imenu--in-alist name prepared-index-alist))
(setq prompt (format "Index item (default %s): " name)))
(t (setq prompt "Index item: ")))
- (if (eq imenu-always-use-completion-buffer-p 'never)
- (setq name (completing-read prompt
- prepared-index-alist
- nil t nil 'imenu--history-list name))
- (save-window-excursion
- ;; Display the completion buffer
- (with-output-to-temp-buffer "*Completions*"
- (display-completion-list
- (all-completions "" prepared-index-alist )))
- (let ((minibuffer-setup-hook
- (function
- (lambda ()
- (let ((buffer (current-buffer)))
- (save-excursion
- (set-buffer "*Completions*")
- (setq completion-reference-buffer buffer)))))))
- ;; Make a completion question
- (setq name (completing-read prompt
- prepared-index-alist
- nil t nil 'imenu--history-list name)))))
- (cond ((not (stringp name))
- nil)
- ((string= name (car imenu--rescan-item))
- t)
- (t
- (setq choice (assoc name prepared-index-alist))
- (if (imenu--subalist-p choice)
- (imenu--completion-buffer (cdr choice) prompt)
- choice)))))
+ (let ((minibuffer-setup-hook minibuffer-setup-hook))
+ ;; Display the completion buffer.
+ (if (not imenu-eager-completion-buffer)
+ (add-hook 'minibuffer-setup-hook 'minibuffer-completion-help))
+ (setq name (completing-read prompt
+ prepared-index-alist
+ nil t nil 'imenu--history-list name)))
+
+ (when (stringp name)
+ (setq choice (assoc name prepared-index-alist))
+ (if (imenu--subalist-p choice)
+ (imenu--completion-buffer (cdr choice) prompt)
+ choice))))
(defun imenu--mouse-menu (index-alist event &optional title)
"Let the user select from a buffer index from a mouse menu.
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)
- ;; 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 (assq (car position) final))
- (setq position (cdr position)))
- (or (string= (car final) (car imenu--rescan-item))
- (nthcdr 3 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))))))))
+ (let* ((menu (imenu--split-menu index-alist (or title (buffer-name))))
+ (map (imenu--create-keymap (car menu)
+ (cdr (if (< 1 (length (cdr menu)))
+ menu
+ (car (cdr menu)))))))
+ (popup-menu map event)))
(defun imenu-choose-buffer-index (&optional prompt alist)
"Let the user select from a buffer index and return the chosen index.
With no index alist ALIST, it calls `imenu--make-index-alist' to
create the index alist.
-If `imenu-always-use-completion-buffer-p' is non-nil, then the
+If `imenu-use-popup-menu' is non-nil, then the
completion buffer is always used, no matter if the mouse was used or
not.
The returned value is of the form (INDEX-NAME . INDEX-POSITION)."
(let (index-alist
(mouse-triggered (listp last-nonmenu-event))
- (result t) )
+ (result t))
;; If selected by mouse, see to that the window where the mouse is
;; really is selected.
(and mouse-triggered
(while (eq result t)
(setq index-alist (if alist alist (imenu--make-index-alist)))
(setq result
- (if (and mouse-triggered
- (not imenu-always-use-completion-buffer-p))
+ (if (and imenu-use-popup-menu
+ (or (eq imenu-use-popup-menu t) mouse-triggered))
(imenu--mouse-menu index-alist last-nonmenu-event)
(imenu--completion-buffer index-alist prompt)))
- (and (eq result t)
+ (and (equal result imenu--rescan-item)
(imenu--cleanup)
- (setq imenu--index-alist nil)))
+ (setq result t imenu--index-alist nil)))
result))
;;;###autoload
(defvar imenu-buffer-menubar nil)
+(defvar imenu-menubar-modified-tick 0
+ "The value of (buffer-modified-tick) as of last call to `imenu-update-menubar'.")
+(make-variable-buffer-local 'imenu-menubar-modified-tick)
+
(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)))))))
+ (when (and (current-local-map)
+ (keymapp (lookup-key (current-local-map) [menu-bar index]))
+ (not (eq (buffer-modified-tick)
+ imenu-menubar-modified-tick)))
+ (setq imenu-menubar-modified-tick (buffer-modified-tick))
+ (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.
+ (unless (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 (car menu)
+ (cdr (if (< 1 (length (cdr menu)))
+ menu
+ (car (cdr menu))))
+ 'imenu--menubar-select))
+ (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."
+ "Use Imenu to select the function or variable named in this menu ITEM."
(if (equal item imenu--rescan-item)
(progn
(imenu--cleanup)
+ ;; Make sure imenu-update-menubar redoes everything.
+ (setq imenu-menubar-modified-tick -1)
(setq imenu--index-alist nil)
- (imenu-update-menubar))
- (imenu item)))
+ (setq imenu--last-menubar-index-alist nil)
+ (imenu-update-menubar)
+ t)
+ (imenu item)
+ nil))
(defun imenu-default-goto-function (name position &optional rest)
- "Move the point to the given position.
+ "Move to the given position.
NAME is ignored. POSITION is where to move. REST is also ignored.
The ignored args just make this function have the same interface as a
;; 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
- (nth 2 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))))
- (run-hooks 'imenu-after-jump-hook))
+ (when index-item
+ (push-mark)
+ (let* ((is-special-item (listp (cdr index-item)))
+ (function
+ (if is-special-item
+ (nth 2 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))
+ (run-hooks 'imenu-after-jump-hook)))
(dolist (mess
'("^No items suitable for an index found in this buffer$"
(provide 'imenu)
+;; arch-tag: 98a2f5f5-4b91-4704-b18c-3aacf77d77a7
;;; imenu.el ends here