2012-05-08 14:19:08 +00:00
|
|
|
;;; imenu.el --- framework for mode-specific buffer indexes -*- lexical-binding: t -*-
|
1994-03-07 03:00:30 +00:00
|
|
|
|
2020-01-01 00:19:43 +00:00
|
|
|
;; Copyright (C) 1994-1998, 2001-2020 Free Software Foundation, Inc.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
;; Author: Ake Stenhoff <etxaksf@aom.ericsson.se>
|
|
|
|
;; Lars Lindberg <lli@sypro.cap.se>
|
2019-05-25 20:43:06 +00:00
|
|
|
;; Maintainer: emacs-devel@gnu.org
|
1994-03-07 03:00:30 +00:00
|
|
|
;; Created: 8 Feb 1994
|
1998-05-26 09:23:23 +00:00
|
|
|
;; Keywords: tools convenience
|
1996-01-14 07:34:30 +00:00
|
|
|
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
|
2008-05-06 08:06:51 +00:00
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
1994-03-07 03:00:30 +00:00
|
|
|
;; it under the terms of the GNU General Public License as published by
|
2008-05-06 08:06:51 +00:00
|
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
|
|
;; (at your option) any later version.
|
1996-01-14 07:34:30 +00:00
|
|
|
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
1994-03-07 03:00:30 +00:00
|
|
|
;; 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.
|
1996-01-14 07:34:30 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
;; You should have received a copy of the GNU General Public License
|
2017-09-13 22:52:52 +00:00
|
|
|
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
;;; Commentary:
|
1996-01-14 07:34:30 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
;; Purpose of this package:
|
|
|
|
;; To present a framework for mode-specific buffer indexes.
|
|
|
|
;; A buffer index is an alist of names and buffer positions.
|
|
|
|
;; For instance all functions in a C-file and their positions.
|
|
|
|
;;
|
1998-04-30 00:05:06 +00:00
|
|
|
;; It is documented in the Emacs Lisp manual.
|
|
|
|
;;
|
1994-03-07 03:00:30 +00:00
|
|
|
;; How it works:
|
|
|
|
|
|
|
|
;; A mode-specific function is called to generate the index. It is
|
|
|
|
;; then presented to the user, who can choose from this index.
|
|
|
|
;;
|
|
|
|
;; The package comes with a set of example functions for how to
|
|
|
|
;; utilize this package.
|
|
|
|
|
1995-06-27 06:23:43 +00:00
|
|
|
;; 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.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1998-04-30 00:05:06 +00:00
|
|
|
;;; History:
|
|
|
|
;; Thanks go to
|
1994-03-07 23:24:02 +00:00
|
|
|
;; [simon] - Simon Leinen simon@lia.di.epfl.ch
|
|
|
|
;; [dean] - Dean Andrews ada@unison.com
|
1998-04-30 00:05:06 +00:00
|
|
|
;; [alon] - Alon Albert al@mercury.co.il
|
1994-09-29 06:32:06 +00:00
|
|
|
;; [greg] - Greg Thompson gregt@porsche.visix.COM
|
1994-11-30 20:50:33 +00:00
|
|
|
;; [wolfgang] - Wolfgang Bangerth zcg51122@rpool1.rus.uni-stuttgart.de
|
1994-11-24 11:26:41 +00:00
|
|
|
;; [kai] - Kai Grossjohann grossjoh@linus.informatik.uni-dortmund.de
|
1994-12-23 05:05:22 +00:00
|
|
|
;; [david] - David M. Smith dsmith@stats.adelaide.edu.au
|
1995-06-27 06:23:43 +00:00
|
|
|
;; [christian] - Christian Egli Christian.Egli@hcsd.hac.com
|
|
|
|
;; [karl] - Karl Fogel kfogel@floss.life.uiuc.edu
|
|
|
|
|
2001-07-15 16:15:35 +00:00
|
|
|
;;; Code:
|
1996-01-14 07:34:30 +00:00
|
|
|
|
2018-07-07 16:59:53 +00:00
|
|
|
(require 'cl-lib)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;
|
|
|
|
;;; Customizable variables
|
|
|
|
;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
1995-06-27 06:23:43 +00:00
|
|
|
|
1997-05-03 19:53:57 +00:00
|
|
|
(defgroup imenu nil
|
|
|
|
"Mode-specific buffer indexes."
|
|
|
|
:group 'matching
|
1998-04-30 00:05:06 +00:00
|
|
|
:group 'frames
|
1998-05-26 09:23:23 +00:00
|
|
|
:group 'convenience
|
1998-04-30 00:05:06 +00:00
|
|
|
:link '(custom-manual "(elisp)Imenu"))
|
1997-05-03 19:53:57 +00:00
|
|
|
|
|
|
|
(defcustom imenu-use-markers t
|
2008-12-03 05:48:14 +00:00
|
|
|
"Non-nil means use markers instead of integers for Imenu buffer positions.
|
1998-04-30 00:05:06 +00:00
|
|
|
|
|
|
|
Setting this to nil makes Imenu work a little faster but editing the
|
|
|
|
buffer will make the generated index positions wrong.
|
1997-04-05 21:41:59 +00:00
|
|
|
|
1997-05-03 19:53:57 +00:00
|
|
|
This might not yet be honored by all index-building functions."
|
|
|
|
:type 'boolean
|
|
|
|
:group 'imenu)
|
|
|
|
|
1997-04-05 21:41:59 +00:00
|
|
|
|
1997-05-03 19:53:57 +00:00
|
|
|
(defcustom imenu-max-item-length 60
|
2008-12-03 05:48:14 +00:00
|
|
|
"If a number, truncate Imenu entries to that length."
|
1998-04-30 00:05:06 +00:00
|
|
|
:type '(choice integer
|
|
|
|
(const :tag "Unlimited"))
|
1997-05-03 19:53:57 +00:00
|
|
|
:group 'imenu)
|
1997-04-05 21:41:59 +00:00
|
|
|
|
1997-05-05 23:41:56 +00:00
|
|
|
(defcustom imenu-auto-rescan nil
|
2008-12-03 05:48:14 +00:00
|
|
|
"Non-nil means Imenu should always rescan the buffers."
|
1997-05-03 19:53:57 +00:00
|
|
|
:type 'boolean
|
|
|
|
:group 'imenu)
|
1995-06-27 06:23:43 +00:00
|
|
|
|
2018-08-31 13:05:06 +00:00
|
|
|
(defcustom imenu-auto-rescan-maxout 600000
|
|
|
|
"Imenu auto-rescan is disabled in buffers larger than this size (in bytes)."
|
1997-05-03 19:53:57 +00:00
|
|
|
:type 'integer
|
2018-08-31 13:05:06 +00:00
|
|
|
:group 'imenu
|
|
|
|
:version "26.2")
|
1994-03-07 03:00:30 +00:00
|
|
|
|
Remove many items obsolete since Emacs 22.1
Emacs 22.1 was five major releases and over decade ago.
In bug reporting statistics, it's been absent for around 5 years.
Ref: https://debbugs.gnu.org/stats/emacs.html
This list can be reviewed before to the next release, but for
now hopefully this motivates any needed external updates.
* lisp/arc-mode.el (archive-mouse-extract):
* lisp/bookmark.el (bookmark-exit-hooks):
* lisp/comint.el (comint-use-prompt-regexp-instead-of-fields):
* lisp/cus-edit.el (custom-face-save-command):
* lisp/descr-text.el (describe-char-after):
* lisp/desktop.el (desktop-enable, desktop-basefilename)
(desktop-buffer-modes-to-save, desktop-buffer-misc-functions)
(desktop-buffer-handlers, desktop-load-default):
* lisp/dired-x.el (dired-omit-files-p):
* lisp/frame.el (new-frame, set-default-font, delete-frame-hook)
(blink-cursor):
* lisp/generic-x.el (generic-define-mswindows-modes)
(generic-define-unix-modes):
* lisp/help.el (describe-project, view-todo):
* lisp/hilit-chg.el (highlight-changes-colours):
* lisp/ibuffer.el (ibuffer-elide-long-columns, ibuffer-hooks)
(ibuffer-mode-hooks):
* lisp/imenu.el (imenu-always-use-completion-buffer-p):
* lisp/isearch.el (isearch-lazy-highlight-cleanup)
(isearch-lazy-highlight-initial-delay)
(isearch-lazy-highlight-interval)
(isearch-lazy-highlight-max-at-a-time)
(isearch-lazy-highlight-cleanup):
* lisp/mwheel.el (mouse-wheel-down-button)
(mouse-wheel-up-button, mouse-wheel-click-button):
* lisp/novice.el (disabled-command-hook):
* lisp/recentf.el (recentf-menu-append-commands-p):
* lisp/savehist.el (savehist-load):
* lisp/speedbar.el (speedbar-ignored-path-expressions)
(speedbar-ignored-path-regexp, speedbar-add-ignored-path-regexp)
(speedbar-line-path, speedbar-buffers-line-path, speedbar-path-line):
* lisp/subr.el (assoc-ignore-case, assoc-ignore-representation)
(x-lost-selection-hooks, x-sent-selection-hooks)
(process-kill-without-query):
* lisp/calendar/icalendar.el (icalendar-convert-diary-to-ical)
(icalendar-extract-ical-from-buffer):
* lisp/emacs-lisp/autoload.el (update-autoloads-from-directories):
* lisp/emacs-lisp/derived.el (derived-mode-class):
* lisp/emacs-lisp/generic.el (generic-font-lock-defaults):
* lisp/emacs-lisp/timer.el (timer-set-time-with-usecs):
* lisp/gnus/spam.el (spam-list-of-processors):
* lisp/international/latin1-disp.el (latin1-char-displayable-p):
* lisp/mail/rmail.el (rmail-pop-password, rmail-pop-password-required):
* lisp/net/goto-addr.el (goto-address-at-mouse):
* lisp/net/net-utils.el (ipconfig-program, ipconfig-program-options):
* lisp/obsolete/iswitchb.el (iswitchb-use-fonts):
* lisp/play/dunnet.el (dungeon-mode-map):
* lisp/progmodes/compile.el (compilation-finish-function)
* lisp/progmodes/cperl-mode.el (cperl-vc-header-alist)
* lisp/progmodes/gud.el (tooltip-gud-modes, tooltip-gud-display)
(tooltip-gud-toggle-dereference):
* lisp/progmodes/pascal.el (pascal-outline):
* lisp/progmodes/perl-mode.el (electric-perl-terminator):
* lisp/textmodes/nroff-mode.el (count-text-lines)
(forward-text-line, backward-text-line, electric-nroff-newline)
(electric-nroff-mode):
* lisp/vc/log-edit.el (vc-comment-ring, vc-comment-ring-index)
(vc-previous-comment, vc-next-comment)
(vc-comment-search-reverse, vc-comment-search-forward)
(vc-comment-to-change-log):
* lisp/vc/pcvs-info.el (cvs-display-full-path)
(cvs-fileinfo->full-path):
* lisp/vc/vc.el (vc-diff-switches-list):
Remove items, obsolete since Emacs 22.1.
* lisp/ibuffer.el (ibuffer-cached-elide-long-columns):
Remove internal variable.
(ibuffer-compile-make-eliding-form, ibuffer-check-formats):
(ibuffer-mode): Remove support for ibuffer-elide-long-columns.
* lisp/cedet/semantic/sb.el (semantic-sb-token-jump):
Remove support for speedbar-line-path.
* lisp/emacs-lisp/unsafep.el (assoc-ignore-case):
Stop marking as side-effect-free.
* lisp/gnus/spam.el (spam-group-processor-p):
Remove support for spam-list-of-processors.
* lisp/progmodes/compile.el (define-compilation-mode)
(compilation-handle-exit):
Remove support for compilation-finish-function.
* lisp/progmodes/cperl-mode.el (cperl-mode):
Remove support for cperl-vc-header-alist.
; * lisp/files.el: Comments.
; * etc/NEWS: List removed items.
2018-03-11 03:15:56 +00:00
|
|
|
(defcustom imenu-use-popup-menu 'on-mouse
|
2002-08-15 00:12:30 +00:00
|
|
|
"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)
|
2005-05-19 19:06:19 +00:00
|
|
|
(other :tag "Always" t))
|
|
|
|
:group 'imenu)
|
2002-08-15 00:12:30 +00:00
|
|
|
|
Remove many items obsolete since Emacs 22.1
Emacs 22.1 was five major releases and over decade ago.
In bug reporting statistics, it's been absent for around 5 years.
Ref: https://debbugs.gnu.org/stats/emacs.html
This list can be reviewed before to the next release, but for
now hopefully this motivates any needed external updates.
* lisp/arc-mode.el (archive-mouse-extract):
* lisp/bookmark.el (bookmark-exit-hooks):
* lisp/comint.el (comint-use-prompt-regexp-instead-of-fields):
* lisp/cus-edit.el (custom-face-save-command):
* lisp/descr-text.el (describe-char-after):
* lisp/desktop.el (desktop-enable, desktop-basefilename)
(desktop-buffer-modes-to-save, desktop-buffer-misc-functions)
(desktop-buffer-handlers, desktop-load-default):
* lisp/dired-x.el (dired-omit-files-p):
* lisp/frame.el (new-frame, set-default-font, delete-frame-hook)
(blink-cursor):
* lisp/generic-x.el (generic-define-mswindows-modes)
(generic-define-unix-modes):
* lisp/help.el (describe-project, view-todo):
* lisp/hilit-chg.el (highlight-changes-colours):
* lisp/ibuffer.el (ibuffer-elide-long-columns, ibuffer-hooks)
(ibuffer-mode-hooks):
* lisp/imenu.el (imenu-always-use-completion-buffer-p):
* lisp/isearch.el (isearch-lazy-highlight-cleanup)
(isearch-lazy-highlight-initial-delay)
(isearch-lazy-highlight-interval)
(isearch-lazy-highlight-max-at-a-time)
(isearch-lazy-highlight-cleanup):
* lisp/mwheel.el (mouse-wheel-down-button)
(mouse-wheel-up-button, mouse-wheel-click-button):
* lisp/novice.el (disabled-command-hook):
* lisp/recentf.el (recentf-menu-append-commands-p):
* lisp/savehist.el (savehist-load):
* lisp/speedbar.el (speedbar-ignored-path-expressions)
(speedbar-ignored-path-regexp, speedbar-add-ignored-path-regexp)
(speedbar-line-path, speedbar-buffers-line-path, speedbar-path-line):
* lisp/subr.el (assoc-ignore-case, assoc-ignore-representation)
(x-lost-selection-hooks, x-sent-selection-hooks)
(process-kill-without-query):
* lisp/calendar/icalendar.el (icalendar-convert-diary-to-ical)
(icalendar-extract-ical-from-buffer):
* lisp/emacs-lisp/autoload.el (update-autoloads-from-directories):
* lisp/emacs-lisp/derived.el (derived-mode-class):
* lisp/emacs-lisp/generic.el (generic-font-lock-defaults):
* lisp/emacs-lisp/timer.el (timer-set-time-with-usecs):
* lisp/gnus/spam.el (spam-list-of-processors):
* lisp/international/latin1-disp.el (latin1-char-displayable-p):
* lisp/mail/rmail.el (rmail-pop-password, rmail-pop-password-required):
* lisp/net/goto-addr.el (goto-address-at-mouse):
* lisp/net/net-utils.el (ipconfig-program, ipconfig-program-options):
* lisp/obsolete/iswitchb.el (iswitchb-use-fonts):
* lisp/play/dunnet.el (dungeon-mode-map):
* lisp/progmodes/compile.el (compilation-finish-function)
* lisp/progmodes/cperl-mode.el (cperl-vc-header-alist)
* lisp/progmodes/gud.el (tooltip-gud-modes, tooltip-gud-display)
(tooltip-gud-toggle-dereference):
* lisp/progmodes/pascal.el (pascal-outline):
* lisp/progmodes/perl-mode.el (electric-perl-terminator):
* lisp/textmodes/nroff-mode.el (count-text-lines)
(forward-text-line, backward-text-line, electric-nroff-newline)
(electric-nroff-mode):
* lisp/vc/log-edit.el (vc-comment-ring, vc-comment-ring-index)
(vc-previous-comment, vc-next-comment)
(vc-comment-search-reverse, vc-comment-search-forward)
(vc-comment-to-change-log):
* lisp/vc/pcvs-info.el (cvs-display-full-path)
(cvs-fileinfo->full-path):
* lisp/vc/vc.el (vc-diff-switches-list):
Remove items, obsolete since Emacs 22.1.
* lisp/ibuffer.el (ibuffer-cached-elide-long-columns):
Remove internal variable.
(ibuffer-compile-make-eliding-form, ibuffer-check-formats):
(ibuffer-mode): Remove support for ibuffer-elide-long-columns.
* lisp/cedet/semantic/sb.el (semantic-sb-token-jump):
Remove support for speedbar-line-path.
* lisp/emacs-lisp/unsafep.el (assoc-ignore-case):
Stop marking as side-effect-free.
* lisp/gnus/spam.el (spam-group-processor-p):
Remove support for spam-list-of-processors.
* lisp/progmodes/compile.el (define-compilation-mode)
(compilation-handle-exit):
Remove support for compilation-finish-function.
* lisp/progmodes/cperl-mode.el (cperl-mode):
Remove support for cperl-vc-header-alist.
; * lisp/files.el: Comments.
; * etc/NEWS: List removed items.
2018-03-11 03:15:56 +00:00
|
|
|
(defcustom imenu-eager-completion-buffer t
|
2002-08-15 00:12:30 +00:00
|
|
|
"If non-nil, eagerly popup the completion buffer."
|
2004-11-04 10:00:53 +00:00
|
|
|
:type 'boolean
|
|
|
|
:group 'imenu
|
2005-02-09 15:50:47 +00:00
|
|
|
:version "22.1")
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1999-09-24 13:55:29 +00:00
|
|
|
(defcustom imenu-after-jump-hook nil
|
2008-12-03 05:48:14 +00:00
|
|
|
"Hooks called after jumping to a place in the buffer.
|
1999-09-24 13:55:29 +00:00
|
|
|
|
|
|
|
Useful things to use here include `reposition-window', `recenter', and
|
|
|
|
\(lambda () (recenter 0)) to show at top of screen."
|
|
|
|
:type 'hook
|
|
|
|
:group 'imenu)
|
|
|
|
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1997-05-03 19:53:57 +00:00
|
|
|
(defcustom imenu-sort-function nil
|
2008-12-03 05:48:14 +00:00
|
|
|
"The function to use for sorting the index mouse-menu.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
Affects only the mouse index menu.
|
|
|
|
|
|
|
|
Set this to nil if you don't want any sorting (faster).
|
|
|
|
The items in the menu are then presented in the order they were found
|
|
|
|
in the buffer.
|
|
|
|
|
1994-04-16 02:38:40 +00:00
|
|
|
Set it to `imenu--sort-by-name' if you want alphabetic sorting.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1998-09-30 19:21:01 +00:00
|
|
|
The function should take two arguments and return t if the first
|
1994-03-07 03:00:30 +00:00
|
|
|
element should come before the second. The arguments are cons cells;
|
1997-05-03 19:53:57 +00:00
|
|
|
\(NAME . POSITION). Look at `imenu--sort-by-name' for an example."
|
1998-04-30 00:05:06 +00:00
|
|
|
:type '(choice (const :tag "No sorting" nil)
|
1999-01-31 07:20:12 +00:00
|
|
|
(const :tag "Sort by name" imenu--sort-by-name)
|
1998-04-30 00:05:06 +00:00
|
|
|
(function :tag "Another function"))
|
1997-05-03 19:53:57 +00:00
|
|
|
:group 'imenu)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1997-05-03 19:53:57 +00:00
|
|
|
(defcustom imenu-max-items 25
|
2008-12-03 05:48:14 +00:00
|
|
|
"Maximum number of elements in a mouse menu for Imenu."
|
1997-05-03 19:53:57 +00:00
|
|
|
:type 'integer
|
|
|
|
:group 'imenu)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
2004-10-28 14:11:32 +00:00
|
|
|
;; No longer used. KFS 2004-10-27
|
|
|
|
;; (defcustom imenu-scanning-message "Scanning buffer for index (%3d%%)"
|
2010-09-24 02:59:16 +00:00
|
|
|
;; "Progress message during the index scanning of the buffer.
|
2004-10-28 14:11:32 +00:00
|
|
|
;; 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)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1998-06-27 19:45:22 +00:00
|
|
|
(defcustom imenu-space-replacement "."
|
2008-12-03 05:48:14 +00:00
|
|
|
"The replacement string for spaces in index names.
|
1998-06-27 19:45:22 +00:00
|
|
|
Used when presenting the index in a completion buffer to make the
|
1997-05-03 19:53:57 +00:00
|
|
|
names work as tokens."
|
2002-08-15 00:12:30 +00:00
|
|
|
:type '(choice string (const nil))
|
1997-05-03 19:53:57 +00:00
|
|
|
:group 'imenu)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1997-05-03 19:53:57 +00:00
|
|
|
(defcustom imenu-level-separator ":"
|
2008-12-03 05:48:14 +00:00
|
|
|
"The separator between index names of different levels.
|
1994-03-07 03:00:30 +00:00
|
|
|
Used for making mouse-menu titles and for flattening nested indexes
|
1997-05-03 19:53:57 +00:00
|
|
|
with name concatenation."
|
|
|
|
:type 'string
|
|
|
|
:group 'imenu)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
2013-11-24 21:23:47 +00:00
|
|
|
(defcustom imenu-generic-skip-comments-and-strings t
|
|
|
|
"When non-nil, ignore text inside comments and strings.
|
2018-06-30 09:22:05 +00:00
|
|
|
Only affects `imenu-default-create-index-function' (and any
|
|
|
|
alternative implementation of `imenu-create-index-function' that
|
|
|
|
uses `imenu--generic-function')."
|
2013-11-24 21:23:47 +00:00
|
|
|
:type 'boolean
|
|
|
|
:group 'imenu
|
|
|
|
:version "24.4")
|
|
|
|
|
1995-06-27 06:23:43 +00:00
|
|
|
;;;###autoload
|
1994-11-30 20:50:33 +00:00
|
|
|
(defvar imenu-generic-expression nil
|
2012-08-05 14:14:54 +00:00
|
|
|
"List of definition matchers for creating an Imenu index.
|
|
|
|
Each element of this list should have the form
|
|
|
|
|
|
|
|
(MENU-TITLE REGEXP INDEX [FUNCTION] [ARGUMENTS...])
|
|
|
|
|
|
|
|
MENU-TITLE should be nil (in which case the matches for this
|
|
|
|
element are put in the top level of the buffer index) or a
|
|
|
|
string (which specifies the title of a submenu into which the
|
|
|
|
matches are put).
|
|
|
|
REGEXP is a regular expression matching a definition construct
|
|
|
|
which is to be displayed in the menu. REGEXP may also be a
|
2018-07-07 09:34:26 +00:00
|
|
|
function of no arguments. If REGEXP is a function, it is
|
|
|
|
expected to search backwards, return non-nil if it finds a
|
|
|
|
definition construct, and set `match-data' for that construct.
|
2012-08-05 14:14:54 +00:00
|
|
|
INDEX is an integer specifying which subexpression of REGEXP
|
|
|
|
matches the definition's name; this subexpression is displayed as
|
|
|
|
the menu item.
|
|
|
|
FUNCTION, if present, specifies a function to call when the index
|
|
|
|
item is selected by the user. This function is called with
|
|
|
|
arguments consisting of the item name, the buffer position, and
|
|
|
|
the ARGUMENTS.
|
|
|
|
|
|
|
|
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.
|
1995-06-27 06:23:43 +00:00
|
|
|
|
2005-05-21 02:44:29 +00:00
|
|
|
If non-nil this pattern is passed to `imenu--generic-function' to
|
2012-08-05 14:14:54 +00:00
|
|
|
create a buffer index.
|
1998-04-30 00:05:06 +00:00
|
|
|
|
2012-08-05 14:14:54 +00:00
|
|
|
For example, see the value of `fortran-imenu-generic-expression'
|
2018-01-31 03:58:21 +00:00
|
|
|
used by `fortran-mode' with `imenu-syntax-alist' set locally so that
|
|
|
|
characters which normally have \"symbol\" syntax are considered to have
|
2012-08-05 14:14:54 +00:00
|
|
|
\"word\" syntax during matching.")
|
2009-08-26 03:07:25 +00:00
|
|
|
;;;###autoload(put 'imenu-generic-expression 'risky-local-variable t)
|
1995-06-27 06:23:43 +00:00
|
|
|
|
1996-03-17 15:37:36 +00:00
|
|
|
;;;###autoload
|
1995-07-25 21:13:10 +00:00
|
|
|
(make-variable-buffer-local 'imenu-generic-expression)
|
1994-11-30 20:50:33 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
;;;; Hooks
|
|
|
|
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-03-07 03:00:30 +00:00
|
|
|
(defvar imenu-create-index-function 'imenu-default-create-index-function
|
2006-04-18 21:22:33 +00:00
|
|
|
"The function to use for creating an index alist of the current buffer.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
2006-04-18 21:22:33 +00:00
|
|
|
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'.
|
1996-09-21 22:32:10 +00:00
|
|
|
|
2006-04-18 21:22:33 +00:00
|
|
|
See `imenu--index-alist' for the format of the buffer index alist.")
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-03-07 03:00:30 +00:00
|
|
|
(make-variable-buffer-local 'imenu-create-index-function)
|
|
|
|
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-05-04 21:34:13 +00:00
|
|
|
(defvar imenu-prev-index-position-function 'beginning-of-defun
|
1994-03-07 03:00:30 +00:00
|
|
|
"Function for finding the next index position.
|
|
|
|
|
1994-04-16 02:38:40 +00:00
|
|
|
If `imenu-create-index-function' is set to
|
|
|
|
`imenu-default-create-index-function', then you must set this variable
|
1994-03-07 03:00:30 +00:00
|
|
|
to a function that will find the next index, looking backwards in the
|
|
|
|
file.
|
|
|
|
|
|
|
|
The function should leave point at the place to be connected to the
|
2004-07-26 21:16:08 +00:00
|
|
|
index and it should return nil when it doesn't find another index.")
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-05-04 21:34:13 +00:00
|
|
|
(make-variable-buffer-local 'imenu-prev-index-position-function)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-05-04 21:34:13 +00:00
|
|
|
(defvar imenu-extract-index-name-function nil
|
1998-04-30 00:05:06 +00:00
|
|
|
"Function for extracting the index item name, given a position.
|
1998-02-06 21:55:42 +00:00
|
|
|
|
|
|
|
This function is called after `imenu-prev-index-position-function'
|
|
|
|
finds a position for an index item, with point at that position.
|
2004-07-26 21:16:08 +00:00
|
|
|
It should return the name for that index item.")
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1994-05-04 21:34:13 +00:00
|
|
|
(make-variable-buffer-local 'imenu-extract-index-name-function)
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1999-09-24 13:55:29 +00:00
|
|
|
;;;###autoload
|
|
|
|
(defvar imenu-name-lookup-function nil
|
|
|
|
"Function to compare string with index item.
|
|
|
|
|
|
|
|
This function will be called with two strings, and should return
|
|
|
|
non-nil if they match.
|
|
|
|
|
|
|
|
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
|
2004-07-26 21:16:08 +00:00
|
|
|
arguments match\".")
|
1999-09-24 13:55:29 +00:00
|
|
|
;;;###autoload
|
|
|
|
(make-variable-buffer-local 'imenu-name-lookup-function)
|
|
|
|
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1997-03-22 23:42:48 +00:00
|
|
|
(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.")
|
1998-07-22 02:29:27 +00:00
|
|
|
;;;###autoload
|
1997-03-22 23:42:48 +00:00
|
|
|
(make-variable-buffer-local 'imenu-default-goto-function)
|
|
|
|
|
|
|
|
|
1996-09-21 22:32:10 +00:00
|
|
|
(defun imenu--subalist-p (item)
|
2013-11-29 03:38:20 +00:00
|
|
|
(and (consp item)
|
|
|
|
(consp (cdr item))
|
|
|
|
(listp (cadr item))
|
|
|
|
(not (functionp (cadr item)))))
|
1996-09-21 22:32:10 +00:00
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(defmacro imenu-progress-message (_prevpos &optional _relpos _reverse)
|
|
|
|
"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."
|
2012-04-19 21:34:49 +00:00
|
|
|
|
|
|
|
;; 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)))))
|
|
|
|
)
|
|
|
|
|
1994-11-30 20:50:33 +00:00
|
|
|
|
|
|
|
;;;
|
|
|
|
;;; Lisp
|
1998-04-30 00:05:06 +00:00
|
|
|
;;;
|
1994-11-30 20:50:33 +00:00
|
|
|
|
2015-08-30 01:06:13 +00:00
|
|
|
(define-error 'imenu-unavailable "imenu unavailable")
|
|
|
|
|
|
|
|
(defun imenu-unavailable-error (format &rest args)
|
|
|
|
(signal 'imenu-unavailable
|
|
|
|
(list (apply #'format-message format args))))
|
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;
|
|
|
|
;;; Internal variables
|
|
|
|
;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
|
|
;; The item to use in the index for rescanning the buffer.
|
|
|
|
(defconst imenu--rescan-item '("*Rescan*" . -99))
|
|
|
|
|
|
|
|
;; The latest buffer index.
|
2012-05-08 14:19:08 +00:00
|
|
|
(defvar-local imenu--index-alist nil
|
2006-04-18 21:22:33 +00:00
|
|
|
"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.
|
|
|
|
|
2016-04-30 22:10:57 +00:00
|
|
|
POSITION is passed to `imenu-default-goto-function', so it can be
|
|
|
|
a non-number if that variable has been changed (e.g. Semantic
|
|
|
|
uses overlays for POSITIONs).
|
|
|
|
|
|
|
|
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.
|
2006-04-18 21:22:33 +00:00
|
|
|
|
2013-11-29 14:31:20 +00:00
|
|
|
A nested sub-alist element looks like (INDEX-NAME . SUB-ALIST).
|
2006-04-18 21:22:33 +00:00
|
|
|
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; selecting that
|
2006-04-18 22:49:21 +00:00
|
|
|
element recalculates the buffer's index alist.")
|
2009-08-26 03:07:25 +00:00
|
|
|
;;;###autoload(put 'imenu--index-alist 'risky-local-variable t)
|
1998-02-06 21:55:42 +00:00
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(defvar-local imenu--last-menubar-index-alist nil
|
2006-04-18 21:22:33 +00:00
|
|
|
"The latest buffer index alist used to update the menu bar menu.")
|
1999-02-06 21:50:53 +00:00
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(defvar imenu--history-list nil
|
|
|
|
;; Making this buffer local caused it not to work!
|
2015-08-21 00:33:48 +00:00
|
|
|
"History list for `jump-to-function-in-buffer'.")
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;
|
|
|
|
;;; Internal support functions
|
|
|
|
;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
|
|
(defun imenu--sort-by-name (item1 item2)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Comparison function to sort items depending on their index name.
|
|
|
|
An item looks like (NAME . POSITION)."
|
1994-03-07 03:00:30 +00:00
|
|
|
(string-lessp (car item1) (car item2)))
|
|
|
|
|
1998-09-30 19:21:01 +00:00
|
|
|
(defun imenu--sort-by-position (item1 item2)
|
2017-04-12 05:35:56 +00:00
|
|
|
"Comparison function to sort items depending on their position.
|
|
|
|
Return non-nil if and only if ITEM1's position is lower than ITEM2's
|
|
|
|
position."
|
|
|
|
(if (listp (cdr item1))
|
|
|
|
(< (cadr item1) (cadr item2))
|
|
|
|
(< (cdr item1) (cdr item2))))
|
1998-09-30 19:21:01 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
(defun imenu--relative-position (&optional reverse)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Support function to calculate relative position in buffer.
|
|
|
|
Beginning of buffer is 0 and end of buffer is 100
|
|
|
|
If REVERSE is non-nil then the beginning is 100 and the end is 0."
|
1994-03-07 03:00:30 +00:00
|
|
|
(let ((pos (point))
|
|
|
|
(total (buffer-size)))
|
|
|
|
(and reverse (setq pos (- total pos)))
|
2015-07-31 17:12:37 +00:00
|
|
|
(floor (* 100.0 (1- pos)) (max total 1))))
|
1994-03-07 03:00:30 +00:00
|
|
|
|
|
|
|
(defun imenu--split (list n)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Split LIST into sublists of max length N.
|
2015-11-17 23:28:50 +00:00
|
|
|
Example (imenu--split \\='(1 2 3 4 5 6 7 8) 3) => ((1 2 3) (4 5 6) (7 8))
|
2012-05-08 14:19:08 +00:00
|
|
|
The returned list DOES NOT share structure with LIST."
|
1994-03-07 03:00:30 +00:00
|
|
|
(let ((remain list)
|
|
|
|
(result '())
|
|
|
|
(sublist '())
|
|
|
|
(i 0))
|
|
|
|
(while remain
|
|
|
|
(push (pop remain) sublist)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
(cl-incf i)
|
1994-03-07 03:00:30 +00:00
|
|
|
(and (= i n)
|
|
|
|
;; We have finished a sublist
|
|
|
|
(progn (push (nreverse sublist) result)
|
|
|
|
(setq i 0)
|
|
|
|
(setq sublist '()))))
|
|
|
|
;; There might be a sublist (if the length of LIST mod n is != 0)
|
|
|
|
;; that has to be added to the result list.
|
|
|
|
(and sublist
|
|
|
|
(push (nreverse sublist) result))
|
|
|
|
(nreverse result)))
|
|
|
|
|
|
|
|
(defun imenu--split-menu (menulist title)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Split the alist MENULIST into a nested alist, if it is long enough.
|
|
|
|
In any case, add TITLE to the front of the alist.
|
|
|
|
If IMENU--RESCAN-ITEM is present in MENULIST, it is moved to the
|
|
|
|
beginning of the returned alist.
|
|
|
|
The returned alist DOES NOT share structure with MENULIST."
|
2008-09-30 03:38:42 +00:00
|
|
|
(let ((menulist (copy-sequence menulist))
|
2012-05-08 14:19:08 +00:00
|
|
|
keep-at-top)
|
1996-09-21 23:00:40 +00:00
|
|
|
(if (memq imenu--rescan-item menulist)
|
2008-09-30 03:38:42 +00:00
|
|
|
(setq keep-at-top (list imenu--rescan-item)
|
1996-09-21 23:00:40 +00:00
|
|
|
menulist (delq imenu--rescan-item menulist)))
|
2012-05-08 14:19:08 +00:00
|
|
|
(dolist (item menulist)
|
2003-05-16 21:12:25 +00:00
|
|
|
(when (imenu--subalist-p item)
|
|
|
|
(push item keep-at-top)
|
|
|
|
(setq menulist (delq item menulist))))
|
1996-09-21 23:00:40 +00:00
|
|
|
(if imenu-sort-function
|
2008-09-30 03:38:42 +00:00
|
|
|
(setq menulist (sort menulist imenu-sort-function)))
|
1996-09-21 23:00:40 +00:00
|
|
|
(if (> (length menulist) imenu-max-items)
|
2003-05-16 21:12:25 +00:00
|
|
|
(setq menulist
|
|
|
|
(mapcar
|
|
|
|
(lambda (menu)
|
|
|
|
(cons (format "From: %s" (caar menu)) menu))
|
|
|
|
(imenu--split menulist imenu-max-items))))
|
1996-09-21 23:00:40 +00:00
|
|
|
(cons title
|
|
|
|
(nconc (nreverse keep-at-top) menulist))))
|
1996-03-01 18:09:57 +00:00
|
|
|
|
|
|
|
(defun imenu--split-submenus (alist)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Split up each long alist that are nested within ALIST into nested alists.
|
|
|
|
Return a split and sorted copy of ALIST. The returned alist DOES
|
|
|
|
NOT share structure with ALIST."
|
|
|
|
(mapcar (lambda (elt)
|
2012-11-15 02:02:00 +00:00
|
|
|
(if (imenu--subalist-p elt)
|
2012-05-08 14:19:08 +00:00
|
|
|
(imenu--split-menu (cdr elt) (car elt))
|
|
|
|
elt))
|
1996-03-01 18:09:57 +00:00
|
|
|
alist))
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1997-04-05 21:41:59 +00:00
|
|
|
(defun imenu--truncate-items (menulist)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Truncate all strings in MENULIST to `imenu-max-item-length'."
|
2013-01-30 17:57:54 +00:00
|
|
|
(mapc (lambda (item)
|
2013-02-28 17:15:08 +00:00
|
|
|
;; Truncate if necessary.
|
2013-01-30 17:57:54 +00:00
|
|
|
(when (and (numberp imenu-max-item-length)
|
|
|
|
(> (length (car item)) imenu-max-item-length))
|
|
|
|
(setcar item (substring (car item) 0 imenu-max-item-length)))
|
|
|
|
(when (imenu--subalist-p item)
|
|
|
|
(imenu--truncate-items (cdr item))))
|
|
|
|
menulist))
|
1997-04-05 21:41:59 +00:00
|
|
|
|
1995-12-21 17:47:08 +00:00
|
|
|
(defun imenu--make-index-alist (&optional noerror)
|
2006-04-18 21:22:33 +00:00
|
|
|
"Create an index alist for the definitions in the current buffer.
|
|
|
|
This works by using the hook function `imenu-create-index-function'.
|
1998-04-30 00:05:06 +00:00
|
|
|
Report an error if the list is empty unless NOERROR is supplied and
|
|
|
|
non-nil.
|
|
|
|
|
2006-04-18 21:22:33 +00:00
|
|
|
See `imenu--index-alist' for the format of the index alist."
|
1995-06-27 06:23:43 +00:00
|
|
|
(or (and imenu--index-alist
|
|
|
|
(or (not imenu-auto-rescan)
|
|
|
|
(and imenu-auto-rescan
|
|
|
|
(> (buffer-size) imenu-auto-rescan-maxout))))
|
2013-02-28 17:15:08 +00:00
|
|
|
;; Get the index; truncate if necessary.
|
1997-04-05 21:41:59 +00:00
|
|
|
(progn
|
|
|
|
(setq imenu--index-alist
|
|
|
|
(save-excursion
|
|
|
|
(save-restriction
|
|
|
|
(widen)
|
|
|
|
(funcall imenu-create-index-function))))
|
|
|
|
(imenu--truncate-items imenu--index-alist)))
|
1995-12-21 17:47:08 +00:00
|
|
|
(or imenu--index-alist noerror
|
2015-08-30 01:06:13 +00:00
|
|
|
(imenu-unavailable-error
|
|
|
|
"No items suitable for an index found in this buffer"))
|
1995-12-21 17:47:08 +00:00
|
|
|
(or imenu--index-alist
|
|
|
|
(setq imenu--index-alist (list nil)))
|
2019-09-20 13:01:47 +00:00
|
|
|
(if imenu-auto-rescan
|
|
|
|
imenu--index-alist
|
2019-09-16 23:39:37 +00:00
|
|
|
;; Add a rescan option to the index.
|
|
|
|
(cons imenu--rescan-item imenu--index-alist)))
|
1996-09-24 22:50:24 +00:00
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(defvar imenu--cleanup-seen nil)
|
1996-09-24 22:50:24 +00:00
|
|
|
|
1994-08-01 07:11:43 +00:00
|
|
|
(defun imenu--cleanup (&optional alist)
|
2012-05-08 14:19:08 +00:00
|
|
|
"Find all markers in ALIST and make them point nowhere.
|
|
|
|
If ALIST is nil (the normal case), use `imenu--index-alist'.
|
|
|
|
Non-nil arguments are in recursive calls."
|
1998-04-30 00:05:06 +00:00
|
|
|
;; If alist is provided use that list.
|
1996-09-24 22:50:24 +00:00
|
|
|
;; 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)))
|
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(when alist
|
|
|
|
(dolist (item alist)
|
|
|
|
(cond
|
|
|
|
((markerp (cdr item)) (set-marker (cdr item) nil))
|
|
|
|
;; Don't process one alist twice.
|
|
|
|
((memq (cdr item) imenu--cleanup-seen))
|
|
|
|
((imenu--subalist-p item) (imenu--cleanup (cdr item)))))
|
|
|
|
t))
|
1994-11-30 20:50:33 +00:00
|
|
|
|
2003-05-16 21:12:25 +00:00
|
|
|
(defun imenu--create-keymap (title alist &optional cmd)
|
Reduce use of (require 'cl).
* admin/bzrmerge.el: Use cl-lib.
* leim/quail/hangul.el: Don't require CL.
* leim/quail/ipa.el: Use cl-lib.
* vc/smerge-mode.el, vc/pcvs.el, vc/pcvs-util.el, vc/pcvs-info.el:
* vc/diff-mode.el, vc/cvs-status.el, uniquify.el, scroll-bar.el:
* register.el, progmodes/sh-script.el, net/gnutls.el, net/dbus.el:
* msb.el, mpc.el, minibuffer.el, international/ucs-normalize.el:
* international/quail.el, info-xref.el, imenu.el, image-mode.el:
* font-lock.el, filesets.el, edmacro.el, doc-view.el, bookmark.el:
* battery.el, avoid.el, abbrev.el: Use cl-lib.
* vc/pcvs-parse.el, vc/pcvs-defs.el, vc/log-view.el, vc/log-edit.el:
* vc/diff.el, simple.el, pcomplete.el, lpr.el, comint.el, loadhist.el:
* jit-lock.el, international/iso-ascii.el, info.el, frame.el, bs.el:
* emulation/crisp.el, electric.el, dired.el, cus-dep.el, composite.el:
* calculator.el, autorevert.el, apropos.el: Don't require CL.
* emacs-bytecomp.el (byte-recompile-directory, display-call-tree)
(byte-compile-unfold-bcf, byte-compile-check-variable):
* emacs-byte-opt.el (byte-compile-trueconstp)
(byte-compile-nilconstp):
* emacs-autoload.el (make-autoload): Use pcase.
* face-remap.el (text-scale-adjust): Simplify pcase patterns.
2012-07-10 11:51:54 +00:00
|
|
|
`(keymap ,title
|
|
|
|
,@(mapcar
|
|
|
|
(lambda (item)
|
|
|
|
`(,(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)))
|
1995-06-27 06:23:43 +00:00
|
|
|
|
|
|
|
(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
|
1998-04-30 00:05:06 +00:00
|
|
|
(setq elt (car alist)
|
1995-06-27 06:23:43 +00:00
|
|
|
tail (cdr elt)
|
1998-04-30 00:05:06 +00:00
|
|
|
alist (cdr alist)
|
|
|
|
head (car elt))
|
1996-08-26 00:08:21 +00:00
|
|
|
;; A nested ALIST element looks like
|
|
|
|
;; (INDEX-NAME (INDEX-NAME . INDEX-POSITION) ...)
|
|
|
|
;; while a bottom-level element looks like
|
|
|
|
;; (INDEX-NAME . INDEX-POSITION)
|
2013-11-29 03:38:20 +00:00
|
|
|
;; or
|
|
|
|
;; (INDEX-NAME INDEX-POSITION FUNCTION ARGUMENTS...)
|
1996-08-26 00:08:21 +00:00
|
|
|
;; We are only interested in the bottom-level elements, so we need to
|
2013-11-29 03:38:20 +00:00
|
|
|
;; recurse if TAIL is a nested ALIST.
|
|
|
|
(cond ((imenu--subalist-p elt)
|
1996-08-26 00:08:21 +00:00
|
|
|
(if (setq res (imenu--in-alist str tail))
|
|
|
|
(setq alist nil)))
|
1999-09-24 13:55:29 +00:00
|
|
|
((if imenu-name-lookup-function
|
|
|
|
(funcall imenu-name-lookup-function str head)
|
|
|
|
(string= str head))
|
1996-08-26 00:08:21 +00:00
|
|
|
(setq alist nil res elt))))
|
1995-06-27 06:23:43 +00:00
|
|
|
res))
|
|
|
|
|
1998-01-25 23:06:37 +00:00
|
|
|
(defvar imenu-syntax-alist nil
|
2001-11-20 00:17:25 +00:00
|
|
|
"Alist of syntax table modifiers to use while in `imenu--generic-function'.
|
1998-01-25 23:06:37 +00:00
|
|
|
|
|
|
|
The car of the assocs may be either a character or a string and the
|
2002-08-20 20:35:56 +00:00
|
|
|
cdr is a syntax description appropriate for `modify-syntax-entry'. For
|
1998-01-25 23:06:37 +00:00
|
|
|
a string, all the characters in the string get the specified syntax.
|
|
|
|
|
|
|
|
This is typically used to give word syntax to characters which
|
1998-05-27 13:37:11 +00:00
|
|
|
normally have symbol syntax to simplify `imenu-expression'
|
1998-01-25 23:06:37 +00:00
|
|
|
and speed-up matching.")
|
2001-01-29 15:50:53 +00:00
|
|
|
;;;###autoload
|
1998-01-25 23:06:37 +00:00
|
|
|
(make-variable-buffer-local 'imenu-syntax-alist)
|
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
(defun imenu-default-create-index-function ()
|
2008-12-03 05:48:14 +00:00
|
|
|
"Default function to create an index alist of the current buffer.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
2006-04-18 21:22:33 +00:00
|
|
|
The most general method is to move point to end of buffer, then repeatedly call
|
1994-05-04 21:34:13 +00:00
|
|
|
`imenu-prev-index-position-function' and `imenu-extract-index-name-function'.
|
2006-04-18 21:22:33 +00:00
|
|
|
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."
|
1994-05-06 06:06:08 +00:00
|
|
|
;; These should really be done by setting imenu-create-index-function
|
|
|
|
;; in these major modes. But save that change for later.
|
1997-11-11 03:54:00 +00:00
|
|
|
(cond ((and imenu-prev-index-position-function
|
|
|
|
imenu-extract-index-name-function)
|
2013-02-01 08:23:47 +00:00
|
|
|
(let ((index-alist '()) (pos (point-max))
|
lisp/*: Add declarations, remove unused bindings, mark unused args.
* lisp/avoid.el (mouse-avoidance-mode): Mark unused arg.
(mouse-avoidance-nudge-mouse): Remove unused binding.
* lisp/imenu.el (imenu-default-goto-function): Mark unused args.
(imenu-progress-message): Remove obsolete macro; all callers changed.
* lisp/mouse.el (mouse-menu-major-mode-map):
* lisp/emacs-lisp/authors.el (authors-scan-change-log)
(authors-add-to-author-list):
* lisp/emacs-lisp/avl-tree.el (avl-tree--enter-balance):
* lisp/emacs-lisp/smie.el (smie-auto-fill):
* lisp/mail/sendmail.el (mail-bury):
* lisp/mail/unrmail.el (unrmail):
* lisp/net/tls.el (open-tls-stream):
* lisp/textmodes/picture.el (picture-mouse-set-point):
Remove unused bindings.
* lisp/subr.el (keymap-canonicalize): Remove unused binding.
(read-passwd): Mark unused arg.
* lisp/tutorial.el (tutorial--display-changes): Remove unused binding.
(tutorial--save-tutorial-to): Remove unused variable.
* lisp/emacs-lisp/package.el (define-package, package-menu-mark-delete)
(package-menu-mark-install, package-menu-mark-unmark): Mark unused args.
(package-generate-autoloads, package-menu--generate)
(package-menu--find-upgrades): Remove unused bindings.
* lisp/emulation/cua-rect.el (cua-restrict-regexp-rectangle)
(cua-restrict-prefix-rectangle): Doc fixes. Remove unused bindings.
(cua--mouse-ignore, cua--delete-rectangle, cua--extract-rectangle)
(cua--indent-rectangle, cua-open-rectangle, cua-close-rectangle)
(cua-blank-rectangle, cua-string-rectangle, cua-replace-in-rectangle)
(cua-incr-rectangle, cua-sequence-rectangle, cua--convert-rectangle-as)
(cua--rectangle-aux-replace, cua--left-fill-rectangle)
(cua-scroll-rectangle-up, cua-scroll-rectangle-down)
(cua-delete-char-rectangle): Mark unused args.
(cua-align-rectangle): Remove unused binding.
* lisp/mail/rmail.el (compilation--message->loc)
(epa--find-coding-system-for-mime-charset): Declare.
* lisp/net/dbus.el (dbus-register-service): Declare.
(dbus-name-owner-changed-handler): Remove unused binding.
* lisp/nxml/nxml-mode.el (nxml-electric-slash, nxml-in-mixed-content-p)
(nxml-compute-indent-from-matching-start-tag): Remove unused variables.
(nxml-scan-backward-within): Mark unused arg.
(nxml-dynamic-markup-word): Remove unused binding.
2012-04-19 17:20:26 +00:00
|
|
|
name)
|
2013-02-01 08:23:47 +00:00
|
|
|
(goto-char pos)
|
1994-05-06 06:06:08 +00:00
|
|
|
;; Search for the function
|
1998-04-30 00:05:06 +00:00
|
|
|
(while (funcall imenu-prev-index-position-function)
|
2013-02-01 08:23:47 +00:00
|
|
|
(unless (< (point) pos)
|
2013-01-30 07:46:28 +00:00
|
|
|
(error "Infinite loop at %s:%d: imenu-prev-index-position-function does not move point" (buffer-name) pos))
|
2010-01-11 20:53:23 +00:00
|
|
|
(setq pos (point))
|
1994-05-06 06:06:08 +00:00
|
|
|
(save-excursion
|
|
|
|
(setq name (funcall imenu-extract-index-name-function)))
|
|
|
|
(and (stringp name)
|
2013-02-28 17:15:08 +00:00
|
|
|
;; [ydi] Updated for imenu-use-markers.
|
|
|
|
(push (cons name
|
|
|
|
(if imenu-use-markers (point-marker) (point)))
|
1997-04-05 21:41:59 +00:00
|
|
|
index-alist)))
|
1994-11-30 20:50:33 +00:00
|
|
|
index-alist))
|
|
|
|
;; Use generic expression if possible.
|
|
|
|
((and imenu-generic-expression)
|
1998-04-30 00:05:06 +00:00
|
|
|
(imenu--generic-function imenu-generic-expression))
|
1994-11-30 20:50:33 +00:00
|
|
|
(t
|
2015-08-30 01:06:13 +00:00
|
|
|
(imenu-unavailable-error "This buffer cannot use `imenu-default-create-index-function'"))))
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1994-11-30 20:50:33 +00:00
|
|
|
;;;
|
|
|
|
;;; Generic index gathering function.
|
|
|
|
;;;
|
1995-06-27 06:23:43 +00:00
|
|
|
|
1998-01-25 22:55:08 +00:00
|
|
|
(defvar imenu-case-fold-search t
|
|
|
|
"Defines whether `imenu--generic-function' should fold case when matching.
|
|
|
|
|
2001-11-20 00:17:25 +00:00
|
|
|
This variable should be set (only) by initialization code
|
2003-05-06 15:16:27 +00:00
|
|
|
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.")
|
1998-04-30 00:05:06 +00:00
|
|
|
;;;###autoload
|
1998-01-25 22:55:08 +00:00
|
|
|
(make-variable-buffer-local 'imenu-case-fold-search)
|
|
|
|
|
2004-11-25 02:57:47 +00:00
|
|
|
;; This function can be called with quitting disabled,
|
|
|
|
;; so it needs to be careful never to loop!
|
1995-06-27 06:23:43 +00:00
|
|
|
(defun imenu--generic-function (patterns)
|
2006-04-18 21:22:33 +00:00
|
|
|
"Return an index alist of the current buffer based on PATTERNS.
|
2018-06-30 09:22:05 +00:00
|
|
|
PATTERNS should be an alist of the same form as `imenu-generic-expression'.
|
2014-02-22 21:20:49 +00:00
|
|
|
|
|
|
|
If `imenu-generic-skip-comments-and-strings' is non-nil, this ignores
|
|
|
|
text inside comments and strings.
|
|
|
|
|
|
|
|
If `imenu-case-fold-search' is non-nil, this ignores case.
|
1995-06-27 06:23:43 +00:00
|
|
|
|
2012-08-05 14:14:54 +00:00
|
|
|
The return value is an alist of the form
|
2003-10-02 09:45:16 +00:00
|
|
|
(INDEX-NAME . INDEX-POSITION)
|
2012-08-05 14:14:54 +00:00
|
|
|
or
|
2003-10-02 09:45:16 +00:00
|
|
|
(INDEX-NAME INDEX-POSITION FUNCTION ARGUMENTS...)
|
2012-08-05 14:14:54 +00:00
|
|
|
The return value may also consist of nested index alists like:
|
2003-10-02 09:45:16 +00:00
|
|
|
(INDEX-NAME . INDEX-ALIST)
|
|
|
|
depending on PATTERNS."
|
1995-06-27 06:23:43 +00:00
|
|
|
(let ((index-alist (list 'dummy))
|
2003-05-06 15:16:27 +00:00
|
|
|
(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)))
|
1998-01-25 23:06:37 +00:00
|
|
|
(old-table (syntax-table))
|
|
|
|
(table (copy-syntax-table (syntax-table)))
|
|
|
|
(slist imenu-syntax-alist))
|
|
|
|
;; Modify the syntax table used while matching regexps.
|
2001-11-20 00:17:25 +00:00
|
|
|
(dolist (syn slist)
|
1998-04-30 00:05:06 +00:00
|
|
|
;; The character(s) to modify may be a single char or a string.
|
2001-11-20 00:17:25 +00:00
|
|
|
(if (numberp (car syn))
|
|
|
|
(modify-syntax-entry (car syn) (cdr syn) table)
|
2002-08-20 20:23:25 +00:00
|
|
|
(mapc (lambda (c)
|
|
|
|
(modify-syntax-entry c (cdr syn) table))
|
|
|
|
(car syn))))
|
1994-11-30 20:50:33 +00:00
|
|
|
(goto-char (point-max))
|
2013-02-28 17:15:08 +00:00
|
|
|
(unwind-protect ; For syntax table.
|
1998-04-30 00:05:06 +00:00
|
|
|
(save-match-data
|
|
|
|
(set-syntax-table table)
|
2004-11-25 02:57:47 +00:00
|
|
|
|
2013-02-28 17:15:08 +00:00
|
|
|
;; Map over the elements of imenu-generic-expression
|
|
|
|
;; (typically functions, variables ...).
|
2001-11-20 00:17:25 +00:00
|
|
|
(dolist (pat patterns)
|
|
|
|
(let ((menu-title (car pat))
|
|
|
|
(regexp (nth 1 pat))
|
|
|
|
(index (nth 2 pat))
|
|
|
|
(function (nth 3 pat))
|
2004-10-26 21:38:09 +00:00
|
|
|
(rest (nthcdr 4 pat))
|
2005-04-23 16:43:30 +00:00
|
|
|
start beg)
|
2001-11-20 00:17:25 +00:00
|
|
|
;; Go backwards for convenience of adding items in order.
|
|
|
|
(goto-char (point-max))
|
2005-05-21 02:44:29 +00:00
|
|
|
(while (and (if (functionp regexp)
|
|
|
|
(funcall regexp)
|
2012-04-12 20:00:24 +00:00
|
|
|
(and
|
|
|
|
(re-search-backward regexp nil t)
|
|
|
|
;; Do not count invisible definitions.
|
|
|
|
(let ((invis (invisible-p (point))))
|
|
|
|
(or (not invis)
|
|
|
|
(progn
|
|
|
|
(while (and invis
|
|
|
|
(not (bobp)))
|
|
|
|
(setq invis (not (re-search-backward
|
|
|
|
regexp nil 'move))))
|
|
|
|
(not invis))))))
|
2004-11-25 02:57:47 +00:00
|
|
|
;; Exit the loop if we get an empty match,
|
|
|
|
;; because it means a bad regexp was specified.
|
|
|
|
(not (= (match-beginning 0) (match-end 0))))
|
2004-11-20 23:31:55 +00:00
|
|
|
(setq start (point))
|
2005-04-23 16:43:30 +00:00
|
|
|
;; Record the start of the line in which the match starts.
|
2005-01-15 18:09:16 +00:00
|
|
|
;; That's the official position of this definition.
|
2005-04-23 16:43:30 +00:00
|
|
|
(goto-char (match-beginning index))
|
|
|
|
(beginning-of-line)
|
|
|
|
(setq beg (point))
|
2004-12-03 00:21:37 +00:00
|
|
|
;; 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
|
2005-04-23 16:43:30 +00:00
|
|
|
(setq beg (copy-marker beg)))
|
2004-12-03 00:21:37 +00:00
|
|
|
(let ((item
|
|
|
|
(if function
|
|
|
|
(nconc (list (match-string-no-properties index)
|
2005-04-23 16:43:30 +00:00
|
|
|
beg function)
|
2004-12-03 00:21:37 +00:00
|
|
|
rest)
|
|
|
|
(cons (match-string-no-properties index)
|
2005-04-23 16:43:30 +00:00
|
|
|
beg)))
|
2004-12-03 00:21:37 +00:00
|
|
|
;; 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.
|
2013-11-24 21:23:47 +00:00
|
|
|
(unless (or (member item (cdr menu))
|
|
|
|
(and imenu-generic-skip-comments-and-strings
|
2018-07-07 16:20:45 +00:00
|
|
|
(save-excursion
|
|
|
|
(goto-char start) (nth 8 (syntax-ppss)))))
|
2004-12-03 00:21:37 +00:00
|
|
|
(setcdr menu
|
2005-04-23 16:43:30 +00:00
|
|
|
(cons item (cdr menu)))))
|
|
|
|
;; Go to the start of the match, to make sure we
|
|
|
|
;; keep making progress backwards.
|
|
|
|
(goto-char start))))
|
1998-04-30 00:05:06 +00:00
|
|
|
(set-syntax-table old-table)))
|
1998-09-30 19:21:01 +00:00
|
|
|
;; Sort each submenu by position.
|
|
|
|
;; This is in case one submenu gets items from two different regexps.
|
2001-11-20 00:17:25 +00:00
|
|
|
(dolist (item index-alist)
|
|
|
|
(when (listp item)
|
|
|
|
(setcdr item (sort (cdr item) 'imenu--sort-by-position))))
|
2018-07-07 16:20:45 +00:00
|
|
|
;; Remove any empty menus. That can happen because of skipping
|
|
|
|
;; things inside comments or strings.
|
2018-07-18 13:11:47 +00:00
|
|
|
(setq index-alist (cl-delete-if
|
|
|
|
(lambda (it) (and (consp it) (null (cdr it))))
|
|
|
|
index-alist))
|
|
|
|
(let ((main-element (assq nil index-alist)))
|
|
|
|
(nconc (delq main-element (delq 'dummy index-alist))
|
|
|
|
(cdr main-element)))))
|
1994-11-30 20:50:33 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
;;;
|
|
|
|
;;; The main functions for this package!
|
|
|
|
;;;
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
2001-11-20 00:17:25 +00:00
|
|
|
;; 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)))))))))
|
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
(defun imenu--completion-buffer (index-alist &optional prompt)
|
|
|
|
"Let the user select from INDEX-ALIST in a completion buffer with PROMPT.
|
|
|
|
|
2004-10-10 03:17:52 +00:00
|
|
|
Return one of the entries in index-alist or nil."
|
1994-03-07 03:00:30 +00:00
|
|
|
;; Create a list for this buffer only when needed.
|
1998-04-30 00:05:06 +00:00
|
|
|
(let ((name (thing-at-point 'symbol))
|
|
|
|
choice
|
|
|
|
(prepared-index-alist
|
2002-08-15 00:12:30 +00:00
|
|
|
(if (not imenu-space-replacement) index-alist
|
|
|
|
(mapcar
|
|
|
|
(lambda (item)
|
2005-06-29 13:49:08 +00:00
|
|
|
(cons (subst-char-in-string ?\s (aref imenu-space-replacement 0)
|
2002-08-15 00:12:30 +00:00
|
|
|
(car item))
|
|
|
|
(cdr item)))
|
|
|
|
index-alist))))
|
2001-11-20 00:17:25 +00:00
|
|
|
(when (stringp name)
|
|
|
|
(setq name (or (imenu-find-default name prepared-index-alist) name)))
|
Use `format-prompt' when prompting with default values
* lisp/woman.el (woman-file-name):
* lisp/wid-edit.el (widget-file-prompt-value)
(widget-coding-system-prompt-value):
* lisp/w32-fns.el (w32-set-system-coding-system):
* lisp/vc/vc.el (vc-print-root-log):
* lisp/vc/vc-annotate.el (vc-annotate):
* lisp/vc/emerge.el (emerge-read-file-name):
* lisp/vc/ediff.el (ediff-directories)
(ediff-directory-revisions, ediff-directories3)
(ediff-merge-directories, )
(ediff-merge-directories-with-ancestor)
(ediff-merge-directory-revisions)
(ediff-merge-directory-revisions-with-ancestor)
(ediff-merge-revisions, ediff-merge-revisions-with-ancestor)
(ediff-revision):
* lisp/vc/ediff-util.el (ediff-toggle-regexp-match):
* lisp/vc/ediff-mult.el (ediff-filegroup-action):
* lisp/vc/add-log.el (prompt-for-change-log-name):
* lisp/textmodes/table.el (table-insert-row-column)
(table-span-cell, table-split-cell-horizontally)
(table-split-cell, table-justify, table-generate-source)
(table-insert-sequence, table-capture)
(table--read-from-minibuffer, table--query-justification):
* lisp/textmodes/sgml-mode.el (sgml-tag, sgml-tag-help):
* lisp/textmodes/reftex-ref.el (reftex-goto-label):
* lisp/textmodes/refer.el (refer-get-bib-files):
* lisp/textmodes/css-mode.el (css-lookup-symbol):
* lisp/term.el (serial-read-name, serial-read-speed):
* lisp/speedbar.el (speedbar-change-initial-expansion-list):
* lisp/simple.el (previous-matching-history-element)
(set-variable):
* lisp/ses.el (ses-read-cell, ses-set-column-width):
* lisp/replace.el (query-replace-read-from)
(occur-read-primary-args):
* lisp/rect.el (string-rectangle, string-insert-rectangle):
* lisp/progmodes/tcl.el (tcl-help-on-word):
* lisp/progmodes/sh-script.el (sh-set-shell):
* lisp/progmodes/python.el (python-eldoc-at-point):
* lisp/progmodes/octave.el (octave-completing-read)
(octave-update-function-file-comment, octave-insert-defun):
* lisp/progmodes/inf-lisp.el (lisp-symprompt):
* lisp/progmodes/cperl-mode.el (cperl-info-on-command)
(cperl-perldoc):
* lisp/progmodes/compile.el (compilation-find-file):
* lisp/net/rcirc.el (rcirc-prompt-for-encryption):
* lisp/net/eww.el (eww):
* lisp/net/browse-url.el (browse-url-with-browser-kind):
* lisp/man.el (man):
* lisp/mail/sendmail.el (sendmail-query-user-about-smtp):
* lisp/mail/mailalias.el (build-mail-aliases):
* lisp/mail/mailabbrev.el (merge-mail-abbrevs)
(rebuild-mail-abbrevs):
* lisp/locate.el (locate-prompt-for-search-string):
* lisp/isearch.el (isearch-occur):
* lisp/international/ogonek.el (ogonek-read-encoding)
(ogonek-read-prefix):
* lisp/international/mule.el (read-buffer-file-coding-system)
(set-terminal-coding-system, set-keyboard-coding-system)
(set-next-selection-coding-system, recode-region):
* lisp/international/mule-cmds.el ()
(universal-coding-system-argument, search-unencodable-char)
(select-safe-coding-system-interactively):
* lisp/info.el (Info-search, Info-search-backward, Info-menu):
* lisp/info-look.el (info-lookup-interactive-arguments):
* lisp/imenu.el (imenu--completion-buffer):
* lisp/ibuf-ext.el (mode, used-mode, ibuffer-mark-by-mode):
* lisp/hi-lock.el (hi-lock-unface-buffer)
(hi-lock-read-face-name):
* lisp/help.el (view-emacs-news, where-is):
* lisp/help-fns.el (describe-variable, describe-symbol)
(describe-keymap):
* lisp/gnus/mm-decode.el (mm-save-part):
* lisp/gnus/gnus-sum.el (gnus-summary-browse-url):
* lisp/gnus/gnus-group.el (gnus-group--read-bug-ids)
(gnus-group-set-current-level):
* lisp/frame.el (make-frame-on-monitor)
(close-display-connection, select-frame-by-name):
* lisp/format.el (format-encode-buffer, format-encode-region):
* lisp/files.el (recode-file-name):
* lisp/files-x.el (read-file-local-variable)
(read-file-local-variable-value, )
(read-file-local-variable-mode):
* lisp/ffap.el (ffap-menu-ask):
* lisp/faces.el (face-read-string):
* lisp/facemenu.el (facemenu-set-charset):
* lisp/erc/erc-dcc.el (erc-dcc-do-GET-command):
* lisp/emulation/edt-mapper.el (edt-mapper):
* lisp/emacs-lisp/trace.el (trace--read-args)
(trace-function-foreground, trace-function-background):
* lisp/emacs-lisp/smie.el (smie-config-set-indent):
* lisp/emacs-lisp/re-builder.el (reb-change-syntax):
* lisp/emacs-lisp/package.el (describe-package):
* lisp/emacs-lisp/find-func.el (read-library-name)
(find-function-read):
* lisp/emacs-lisp/ert.el (ert-read-test-name)
(ert-run-tests-interactively):
* lisp/emacs-lisp/disass.el (disassemble):
* lisp/emacs-lisp/debug.el (debug-on-entry)
(debug-on-variable-change):
* lisp/emacs-lisp/advice.el (ad-read-advised-function)
(ad-read-advice-class, ad-read-advice-name, ad-read-regexp):
* lisp/dired-x.el (dired--mark-suffix-interactive-spec):
* lisp/dired-aux.el (dired-diff):
* lisp/cus-edit.el (custom-variable-prompt, customize-mode)
(customize-changed-options):
* lisp/completion.el (interactive-completion-string-reader):
* lisp/calendar/timeclock.el (timeclock-ask-for-project):
* lisp/calc/calcalg3.el (calc-get-fit-variables):
* lisp/calc/calc-store.el (calc-edit-variable):
* lisp/calc/calc-bin.el (calc-word-size):
* lisp/bookmark.el (bookmark-set-internal):
* lisp/abbrev.el (read-abbrev-file): Use `format-prompt' for
prompting (bug#12443).
2020-09-06 14:56:44 +00:00
|
|
|
(unless prompt
|
|
|
|
(setq prompt (format-prompt
|
|
|
|
"Index item"
|
|
|
|
(and name
|
|
|
|
(imenu--in-alist name prepared-index-alist)
|
|
|
|
;; Default to `name' if it's in the alist.
|
|
|
|
name))))
|
2002-08-15 00:12:30 +00:00
|
|
|
(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)))
|
2004-05-29 14:35:20 +00:00
|
|
|
|
2004-10-10 03:17:52 +00:00
|
|
|
(when (stringp name)
|
|
|
|
(setq choice (assoc name prepared-index-alist))
|
|
|
|
(if (imenu--subalist-p choice)
|
|
|
|
(imenu--completion-buffer (cdr choice) prompt)
|
|
|
|
choice))))
|
1994-05-04 21:34:13 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
(defun imenu--mouse-menu (index-alist event &optional title)
|
|
|
|
"Let the user select from a buffer index from a mouse menu.
|
|
|
|
|
|
|
|
INDEX-ALIST is the buffer index and EVENT is a mouse event.
|
|
|
|
|
1996-09-10 17:57:05 +00:00
|
|
|
Returns t for rescan and otherwise an element or subelement of INDEX-ALIST."
|
1996-03-01 18:09:57 +00:00
|
|
|
(setq index-alist (imenu--split-submenus index-alist))
|
2001-11-20 00:17:25 +00:00
|
|
|
(let* ((menu (imenu--split-menu index-alist (or title (buffer-name))))
|
2003-05-16 21:12:25 +00:00
|
|
|
(map (imenu--create-keymap (car menu)
|
|
|
|
(cdr (if (< 1 (length (cdr menu)))
|
|
|
|
menu
|
|
|
|
(car (cdr menu)))))))
|
2001-11-20 00:17:25 +00:00
|
|
|
(popup-menu map event)))
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1994-03-07 23:24:02 +00:00
|
|
|
(defun imenu-choose-buffer-index (&optional prompt alist)
|
1994-03-07 03:00:30 +00:00
|
|
|
"Let the user select from a buffer index and return the chosen index.
|
|
|
|
|
|
|
|
If the user originally activated this function with the mouse, a mouse
|
|
|
|
menu is used. Otherwise a completion buffer is used and the user is
|
|
|
|
prompted with PROMPT.
|
|
|
|
|
1994-03-07 23:24:02 +00:00
|
|
|
If you call this function with index alist ALIST, then it lets the user
|
|
|
|
select from ALIST.
|
|
|
|
|
1994-04-16 02:38:40 +00:00
|
|
|
With no index alist ALIST, it calls `imenu--make-index-alist' to
|
1994-03-07 23:24:02 +00:00
|
|
|
create the index alist.
|
|
|
|
|
2006-07-09 01:59:34 +00:00
|
|
|
If `imenu-use-popup-menu' is nil, then the completion buffer
|
|
|
|
is always used, no matter if the mouse was used or not.
|
1994-03-07 03:00:30 +00:00
|
|
|
|
1996-09-30 23:38:43 +00:00
|
|
|
The returned value is of the form (INDEX-NAME . INDEX-POSITION)."
|
1994-03-07 03:00:30 +00:00
|
|
|
(let (index-alist
|
1994-07-20 07:41:16 +00:00
|
|
|
(mouse-triggered (listp last-nonmenu-event))
|
2001-11-20 00:17:25 +00:00
|
|
|
(result t))
|
1994-03-07 03:00:30 +00:00
|
|
|
;; If selected by mouse, see to that the window where the mouse is
|
|
|
|
;; really is selected.
|
|
|
|
(and mouse-triggered
|
1995-06-27 10:05:22 +00:00
|
|
|
(not (equal last-nonmenu-event '(menu-bar)))
|
1994-07-20 07:41:16 +00:00
|
|
|
(let ((window (posn-window (event-start last-nonmenu-event))))
|
1995-07-21 12:40:55 +00:00
|
|
|
(or (framep window) (null window) (select-window window))))
|
1994-03-07 03:00:30 +00:00
|
|
|
;; Create a list for this buffer only when needed.
|
|
|
|
(while (eq result t)
|
1994-03-07 23:24:02 +00:00
|
|
|
(setq index-alist (if alist alist (imenu--make-index-alist)))
|
1994-03-07 03:00:30 +00:00
|
|
|
(setq result
|
2002-08-15 00:12:30 +00:00
|
|
|
(if (and imenu-use-popup-menu
|
|
|
|
(or (eq imenu-use-popup-menu t) mouse-triggered))
|
1994-07-20 07:41:16 +00:00
|
|
|
(imenu--mouse-menu index-alist last-nonmenu-event)
|
1994-03-07 03:00:30 +00:00
|
|
|
(imenu--completion-buffer index-alist prompt)))
|
2004-10-10 03:17:52 +00:00
|
|
|
(and (equal result imenu--rescan-item)
|
1994-08-01 07:11:43 +00:00
|
|
|
(imenu--cleanup)
|
2004-10-10 03:17:52 +00:00
|
|
|
(setq result t imenu--index-alist nil)))
|
1994-03-07 03:00:30 +00:00
|
|
|
result))
|
|
|
|
|
2014-10-21 01:33:44 +00:00
|
|
|
(defvar-local imenu--menubar-keymap nil)
|
|
|
|
|
1995-06-27 06:23:43 +00:00
|
|
|
;;;###autoload
|
1994-08-01 07:11:43 +00:00
|
|
|
(defun imenu-add-to-menubar (name)
|
1998-04-30 00:05:06 +00:00
|
|
|
"Add an `imenu' entry to the menu bar for the current buffer.
|
1995-12-21 17:47:08 +00:00
|
|
|
NAME is a string used to name the menu bar item.
|
1996-02-24 01:42:31 +00:00
|
|
|
See the command `imenu' for more information."
|
1995-12-21 17:47:08 +00:00
|
|
|
(interactive "sImenu menu item name: ")
|
1997-11-11 03:54:00 +00:00
|
|
|
(if (or (and imenu-prev-index-position-function
|
|
|
|
imenu-extract-index-name-function)
|
|
|
|
imenu-generic-expression
|
|
|
|
(not (eq imenu-create-index-function
|
|
|
|
'imenu-default-create-index-function)))
|
2012-04-11 21:37:13 +00:00
|
|
|
(unless (and (current-local-map)
|
|
|
|
(keymapp (lookup-key (current-local-map) [menu-bar index])))
|
2012-03-15 01:38:40 +00:00
|
|
|
(let ((newmap (make-sparse-keymap)))
|
|
|
|
(set-keymap-parent newmap (current-local-map))
|
|
|
|
(setq imenu--last-menubar-index-alist nil)
|
2014-10-21 01:33:44 +00:00
|
|
|
(setq imenu--menubar-keymap (make-sparse-keymap "Imenu"))
|
2012-03-15 01:38:40 +00:00
|
|
|
(define-key newmap [menu-bar index]
|
2014-10-21 01:33:44 +00:00
|
|
|
`(menu-item ,name ,imenu--menubar-keymap))
|
2012-03-15 01:38:40 +00:00
|
|
|
(use-local-map newmap)
|
|
|
|
(add-hook 'menu-bar-update-hook 'imenu-update-menubar)))
|
2015-08-30 01:06:13 +00:00
|
|
|
(imenu-unavailable-error "The mode `%s' does not support Imenu"
|
|
|
|
(format-mode-line mode-name))))
|
1995-12-21 17:47:08 +00:00
|
|
|
|
1998-04-30 00:05:06 +00:00
|
|
|
;;;###autoload
|
|
|
|
(defun imenu-add-menubar-index ()
|
|
|
|
"Add an Imenu \"Index\" entry on the menu bar for the current buffer.
|
|
|
|
|
|
|
|
A trivial interface to `imenu-add-to-menubar' suitable for use in a hook."
|
|
|
|
(interactive)
|
|
|
|
(imenu-add-to-menubar "Index"))
|
|
|
|
|
1996-02-21 21:44:28 +00:00
|
|
|
(defvar imenu-buffer-menubar nil)
|
|
|
|
|
2012-05-08 14:19:08 +00:00
|
|
|
(defvar-local imenu-menubar-modified-tick 0
|
2006-09-01 13:30:55 +00:00
|
|
|
"The value of (buffer-chars-modified-tick) as of the last call
|
|
|
|
to `imenu-update-menubar'.")
|
2002-03-11 09:16:37 +00:00
|
|
|
|
1995-12-21 17:47:08 +00:00
|
|
|
(defun imenu-update-menubar ()
|
2002-03-18 04:27:30 +00:00
|
|
|
(when (and (current-local-map)
|
2014-10-21 01:33:44 +00:00
|
|
|
imenu--menubar-keymap
|
2006-09-01 13:30:55 +00:00
|
|
|
(/= (buffer-chars-modified-tick) imenu-menubar-modified-tick))
|
|
|
|
(setq imenu-menubar-modified-tick (buffer-chars-modified-tick))
|
2002-03-18 04:27:30 +00:00
|
|
|
(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)
|
2014-10-21 01:33:44 +00:00
|
|
|
(setq imenu--last-menubar-index-alist index-alist)
|
|
|
|
(setq index-alist (imenu--split-submenus index-alist))
|
|
|
|
(let* ((menu (imenu--split-menu index-alist
|
|
|
|
(buffer-name)))
|
2020-03-30 19:25:40 +00:00
|
|
|
(menu1 (imenu--create-keymap
|
|
|
|
(car menu)
|
|
|
|
(cdr (if (or (< 1 (length (cdr menu)))
|
|
|
|
;; Have we a non-nested single entry?
|
|
|
|
(atom (cdadr menu))
|
|
|
|
(atom (cadadr menu)))
|
|
|
|
menu
|
|
|
|
(car (cdr menu))))
|
|
|
|
'imenu--menubar-select)))
|
2014-10-21 01:33:44 +00:00
|
|
|
(setcdr imenu--menubar-keymap (cdr menu1)))))))
|
1995-12-21 17:47:08 +00:00
|
|
|
|
|
|
|
(defun imenu--menubar-select (item)
|
2001-11-20 00:17:25 +00:00
|
|
|
"Use Imenu to select the function or variable named in this menu ITEM."
|
1997-03-22 23:42:48 +00:00
|
|
|
(if (equal item imenu--rescan-item)
|
1996-03-08 21:51:22 +00:00
|
|
|
(progn
|
|
|
|
(imenu--cleanup)
|
2004-05-29 14:35:20 +00:00
|
|
|
;; Make sure imenu-update-menubar redoes everything.
|
|
|
|
(setq imenu-menubar-modified-tick -1)
|
1996-03-08 21:51:22 +00:00
|
|
|
(setq imenu--index-alist nil)
|
2004-05-29 14:35:20 +00:00
|
|
|
(setq imenu--last-menubar-index-alist nil)
|
2001-11-20 00:17:25 +00:00
|
|
|
(imenu-update-menubar)
|
|
|
|
t)
|
|
|
|
(imenu item)
|
|
|
|
nil))
|
1994-08-01 07:11:43 +00:00
|
|
|
|
2014-10-05 00:58:38 +00:00
|
|
|
(defun imenu-default-goto-function (_name position &rest _rest)
|
2004-10-10 03:17:52 +00:00
|
|
|
"Move to the given position.
|
1998-04-30 00:05:06 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
function placed in a special index-item."
|
1997-04-05 21:41:59 +00:00
|
|
|
(if (or (< position (point-min))
|
|
|
|
(> position (point-max)))
|
2013-02-28 17:15:08 +00:00
|
|
|
;; Widen if outside narrowing.
|
1997-03-22 23:42:48 +00:00
|
|
|
(widen))
|
1997-04-05 21:41:59 +00:00
|
|
|
(goto-char position))
|
1997-03-22 23:42:48 +00:00
|
|
|
|
1994-05-04 21:34:13 +00:00
|
|
|
;;;###autoload
|
1995-07-25 21:13:10 +00:00
|
|
|
(defun imenu (index-item)
|
1994-05-04 21:34:13 +00:00
|
|
|
"Jump to a place in the buffer chosen using a buffer menu or mouse menu.
|
1998-04-30 00:05:06 +00:00
|
|
|
INDEX-ITEM specifies the position. See `imenu-choose-buffer-index'
|
|
|
|
for more information."
|
1996-12-16 07:39:34 +00:00
|
|
|
(interactive (list (imenu-choose-buffer-index)))
|
1995-12-21 17:47:08 +00:00
|
|
|
;; Convert a string to an alist element.
|
|
|
|
(if (stringp index-item)
|
|
|
|
(setq index-item (assoc index-item (imenu--make-index-alist))))
|
2001-11-20 00:17:25 +00:00
|
|
|
(when index-item
|
2014-10-06 03:59:38 +00:00
|
|
|
(pcase index-item
|
|
|
|
(`(,name ,pos ,fn . ,args)
|
|
|
|
(push-mark nil t)
|
|
|
|
(apply fn name pos args)
|
|
|
|
(run-hooks 'imenu-after-jump-hook))
|
|
|
|
(`(,name . ,pos) (imenu (list name pos imenu-default-goto-function)))
|
|
|
|
(_ (error "Unknown imenu item: %S" index-item)))))
|
1994-08-01 07:11:43 +00:00
|
|
|
|
1994-03-07 03:00:30 +00:00
|
|
|
(provide 'imenu)
|
|
|
|
|
|
|
|
;;; imenu.el ends here
|