(other :tag "Always" t))
:group 'imenu)
+(defcustom imenu-after-jump-hook nil
+ "*Hooks called after jumping to a place in the buffer.
+
+Useful things to use here include `reposition-window', `recenter', and
+\(lambda () (recenter 0)) to show at top of screen."
+ :type 'hook
+ :group 'imenu)
+
+;;;###autoload
(defcustom imenu-sort-function nil
"*The function to use for sorting the index mouse-menu.
Set it to `imenu--sort-by-name' if you want alphabetic sorting.
-The function should take two arguments and return T if the first
+The function should take two arguments and return t if the first
element should come before the second. The arguments are cons cells;
\(NAME . POSITION). Look at `imenu--sort-by-name' for an example."
:type '(choice (const :tag "No sorting" nil)
- (const :tag "Sort by name" 'imenu--sort-by-name)
+ (const :tag "Sort by name" imenu--sort-by-name)
(function :tag "Another function"))
:group 'imenu)
(MENU-TITLE REGEXP INDEX FUNCTION ARGUMENTS...)
with zero or more ARGUMENTS. The former format creates a simple element in
the index alist when it matches; the latter creates a special element
-of the form (NAME FUNCTION POSITION-MARKER ARGUMENTS...)
-with FUNCTION and ARGUMENTS beiong copied from `imenu-generic-expression'.
+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.
;;;; Hooks
+;;;###autoload
(defvar imenu-create-index-function 'imenu-default-create-index-function
"The function to use for creating a buffer index.
This function is called within a `save-excursion'.
The variable is buffer-local.")
+;;;###autoload
(make-variable-buffer-local 'imenu-create-index-function)
+;;;###autoload
(defvar imenu-prev-index-position-function 'beginning-of-defun
"Function for finding the next index position.
index and it should return nil when it doesn't find another index.
This variable is local in all buffers.")
-
+;;;###autoload
(make-variable-buffer-local 'imenu-prev-index-position-function)
+;;;###autoload
(defvar imenu-extract-index-name-function nil
"Function for extracting the index item name, given a position.
It should return the name for that index item.
This variable is local in all buffers.")
-
+;;;###autoload
(make-variable-buffer-local 'imenu-extract-index-name-function)
+;;;###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
+arguments match\".
+
+This variable is local in all buffers.")
+;;;###autoload
+(make-variable-buffer-local 'imenu-name-lookup-function)
+
+;;;###autoload
(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.")
+;;;###autoload
(make-variable-buffer-local 'imenu-default-goto-function)
(make-variable-buffer-local 'imenu--index-alist)
-;; The latest buffer index used to update the menu bar menu.
-(defvar imenu--last-menubar-index-alist nil)
+(defvar imenu--last-menubar-index-alist nil
+ "The latest buffer index used to update the menu bar menu.")
+
(make-variable-buffer-local 'imenu--last-menubar-index-alist)
;; History list for 'jump-to-function-in-buffer'.
;;;
;;; Sort function
;;; Sorts the items depending on their index name.
-;;; An item look like (NAME . POSITION).
+;;; An item looks like (NAME . POSITION).
;;;
(defun imenu--sort-by-name (item1 item2)
(string-lessp (car item1) (car item2)))
+(defun imenu--sort-by-position (item1 item2)
+ (< (cdr item1) (cdr item2)))
+
(defun imenu--relative-position (&optional reverse)
;; Support function to calculate relative position in buffer
;; Beginning of buffer is 0 and end of buffer is 100
;; 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)))))))
+ (setcar item (substring (car item) 0
+ imenu-max-item-length)))))))
menulist))
(setq alist imenu--index-alist imenu--cleanup-seen (list alist)))
(and alist
- (mapcar
- (function
- (lambda (item)
- (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))))))
+ (mapc
+ (lambda (item)
+ (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)))))
alist)
t))
(defun imenu--create-keymap-2 (alist counter &optional commands)
(let ((map nil))
(mapcar
- (function
- (lambda (item)
- (cond
- ((imenu--subalist-p item)
- (append (list (setq counter (1+ counter))
- (car item) 'keymap (car item))
- (imenu--create-keymap-2 (cdr item) (+ counter 10) commands)))
- (t
- (let ((end (if commands `(lambda () (interactive)
- (imenu--menubar-select ',item))
- (cons '(nil) item))))
- (cons (car item)
- (cons (car item) end)))))))
+ (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)
- (append (list 'keymap title) (imenu--create-keymap-2 alist 0 commands)))
+ (cons 'keymap (cons title (imenu--create-keymap-2 alist 0 commands))))
(defun imenu--in-alist (str alist)
"Check whether the string STR is contained in multi-level ALIST."
(cond ((listp tail)
(if (setq res (imenu--in-alist str tail))
(setq alist nil)))
- ((string= str head)
+ ((if imenu-name-lookup-function
+ (funcall imenu-name-lookup-function str head)
+ (string= str head))
(setq alist nil res elt))))
res))
This is typically used to give word syntax to characters which
normally have symbol syntax to simplify `imenu-expression'
and speed-up matching.")
+;;;###autoload
(make-variable-buffer-local 'imenu-syntax-alist)
(defun imenu-default-create-index-function ()
(t
(error "This buffer cannot use `imenu-default-create-index-function'"))))
-(defun imenu--replace-spaces (name replacement)
- ;; Replace all spaces in NAME with REPLACEMENT.
- ;; That second argument should be a string.
- (mapconcat
- (function
- (lambda (ch)
- (if (char-equal ch ?\ )
- replacement
- (char-to-string ch))))
- name
- ""))
-
;; 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.
;; 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)
- (mapcar (function
- (lambda (c)
- (modify-syntax-entry c (cdar slist) table)))
- (caar slist)))
+ (dolist (c (caar slist))
+ (modify-syntax-entry c (cdar slist) table)))
(setq slist (cdr slist)))
(goto-char (point-max))
(imenu-progress-message prev-pos 0 t)
(set-syntax-table table)
;; map over the elements of imenu-generic-expression
;; (typically functions, variables ...)
- (mapcar
- (function
- (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 (set-marker (make-marker) beg)))
- (let ((item
- (if function
- (nconc (list (match-string-no-properties index)
- beg function)
- rest)
- (cons (match-string-no-properties index)
- beg)))
- (menu (cdr (assoc menu-title index-alist))))
- ;; avoid duplicates from, e.g. cc-mode patterns
- (unless (member item menu)
- ;; insert the item after the (sub-)menu title
- (setcdr (assoc menu-title index-alist)
- (cons item menu))))))))
+ (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)
(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))))
(let ((main-element (assq nil index-alist)))
(nconc (delq main-element (delq 'dummy index-alist))
(cdr main-element)))))
choice
(prepared-index-alist
(mapcar
- (function
- (lambda (item)
- (cons (imenu--replace-spaces (car item) imenu-space-replacement)
- (cdr item))))
+ (lambda (item)
+ (cons (subst-char-in-string ?\ (aref imenu-space-replacement 0)
+ (car item))
+ (cdr item)))
index-alist)))
(cond (prompt)
((and name (imenu--in-alist name prepared-index-alist))
(stringp (nth (1- (length position)) position)))
(let ((final menu))
(while position
- (setq final (assoc (car position) final))
+ (setq final (assq (car position) final))
(setq position (cdr position)))
(or (string= (car final) (car imenu--rescan-item))
(nthcdr 3 final))))
imenu-generic-expression
(not (eq imenu-create-index-function
'imenu-default-create-index-function)))
- (let ((newmap (make-sparse-keymap))
- (menu-bar (lookup-key (current-local-map) [menu-bar])))
- (define-key newmap [menu-bar]
- (append (make-sparse-keymap) menu-bar))
+ (let ((newmap (make-sparse-keymap)))
+ (set-keymap-parent newmap (current-local-map))
+ (setq imenu--last-menubar-index-alist nil)
(define-key newmap [menu-bar index]
- (cons name (nconc (make-sparse-keymap "Imenu")
- (make-sparse-keymap))))
- (use-local-map (append newmap (current-local-map)))
+ `(menu-item ,name ,(make-sparse-keymap "Imenu")))
+ (use-local-map newmap)
(add-hook 'menu-bar-update-hook 'imenu-update-menubar))
(error "The mode `%s' does not support Imenu" mode-name)))
(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)))))
+ (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$"
+ "^This buffer cannot use `imenu-default-create-index-function'$"
+ "^The mode `.*' does not support Imenu$"))
+ (add-to-list 'debug-ignored-errors mess))
(provide 'imenu)