Mercurial > emacs
comparison lisp/cedet/semantic/imenu.el @ 107497:b09401cc9d96
* cedet/semantic/imenu.el: New file from the CEDET repository (Bug#5412).
author | Chong Yidong <cyd@stupidchicken.com> |
---|---|
date | Sat, 13 Mar 2010 10:49:54 -0500 |
parents | |
children | 1fadb1dea1be |
comparison
equal
deleted
inserted
replaced
107496:893b1b725ad5 | 107497:b09401cc9d96 |
---|---|
1 ;;; semantic/imenu.el --- Use Semantic as an imenu tag generator | |
2 | |
3 ;;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010 | |
4 ;; Free Software Foundation, Inc. | |
5 | |
6 ;; Author: Eric M. Ludlam <zappo@gnu.org> | |
7 ;; Maintainer: Eric Ludlam | |
8 | |
9 ;; This file is not part of GNU Emacs. | |
10 | |
11 ;; This file is part of GNU Emacs. | |
12 | |
13 ;; GNU Emacs is free software: you can redistribute it and/or modify | |
14 ;; it under the terms of the GNU General Public License as published by | |
15 ;; the Free Software Foundation, either version 3 of the License, or | |
16 ;; (at your option) any later version. | |
17 | |
18 ;; GNU Emacs is distributed in the hope that it will be useful, | |
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
21 ;; GNU General Public License for more details. | |
22 | |
23 ;; You should have received a copy of the GNU General Public License | |
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. | |
25 | |
26 ;;; Commentary: | |
27 ;; | |
28 ;; This support function can be used in any buffer which supports | |
29 ;; the bovinator to create the imenu index. | |
30 ;; | |
31 ;; To use this in a buffer, do this in a hook. | |
32 ;; | |
33 ;; (add-hook 'mode-hook | |
34 ;; (lambda () | |
35 ;; (setq imenu-create-index-function 'semantic-create-imenu-index) | |
36 ;; )) | |
37 | |
38 (require 'semantic) | |
39 (require 'semantic/format) | |
40 (require 'semantic/db) | |
41 (require 'semantic/db-file) | |
42 (require 'semantic/sort) | |
43 (require 'imenu) | |
44 | |
45 (declare-function pulse-momentary-highlight-one-line "pulse" (o &optional face)) | |
46 (declare-function semanticdb-semantic-init-hook-fcn "db-mode") | |
47 | |
48 ;; Because semantic imenu tags will hose the current imenu handling | |
49 ;; code in speedbar, force semantic/sb in. | |
50 (if (featurep 'speedbar) | |
51 (require 'semantic/sb) | |
52 (add-hook 'speedbar-load-hook (lambda () (require 'semantic/sb)))) | |
53 | |
54 (defgroup semantic-imenu nil | |
55 "Semantic interface to Imenu." | |
56 :group 'semantic | |
57 :group 'imenu | |
58 ) | |
59 | |
60 ;;;###autoload | |
61 (defcustom semantic-imenu-summary-function 'semantic-format-tag-abbreviate | |
62 "*Function to use when creating items in Imenu. | |
63 Some useful functions are found in `semantic-format-tag-functions'." | |
64 :group 'semantic-imenu | |
65 :type semantic-format-tag-custom-list) | |
66 (make-variable-buffer-local 'semantic-imenu-summary-function) | |
67 | |
68 ;;;###autoload | |
69 (defcustom semantic-imenu-bucketize-file t | |
70 "*Non-nil if tags in a file are to be grouped into buckets." | |
71 :group 'semantic-imenu | |
72 :type 'boolean) | |
73 (make-variable-buffer-local 'semantic-imenu-bucketize-file) | |
74 | |
75 (defcustom semantic-imenu-adopt-external-members t | |
76 "*Non-nil if types in a file should adopt externally defined members. | |
77 C++ and CLOS can define methods that are not in the body of a class | |
78 definition." | |
79 :group 'semantic-imenu | |
80 :type 'boolean) | |
81 | |
82 (defcustom semantic-imenu-buckets-to-submenu t | |
83 "*Non-nil if buckets of tags are to be turned into submenus. | |
84 This option is ignored if `semantic-imenu-bucketize-file' is nil." | |
85 :group 'semantic-imenu | |
86 :type 'boolean) | |
87 (make-variable-buffer-local 'semantic-imenu-buckets-to-submenu) | |
88 | |
89 ;;;###autoload | |
90 (defcustom semantic-imenu-expand-type-members t | |
91 "*Non-nil if types should have submenus with members in them." | |
92 :group 'semantic-imenu | |
93 :type 'boolean) | |
94 (make-variable-buffer-local 'semantic-imenu-expand-type-members) | |
95 (semantic-varalias-obsolete 'semantic-imenu-expand-type-parts | |
96 'semantic-imenu-expand-type-members "23.2") | |
97 | |
98 (defcustom semantic-imenu-bucketize-type-members t | |
99 "*Non-nil if members of a type should be grouped into buckets. | |
100 nil means to keep them in the same order. | |
101 Overriden to nil if `semantic-imenu-bucketize-file' is nil." | |
102 :group 'semantic-imenu | |
103 :type 'boolean) | |
104 (make-variable-buffer-local 'semantic-imenu-bucketize-type-parts) | |
105 (semantic-varalias-obsolete 'semantic-imenu-bucketize-type-parts | |
106 'semantic-imenu-bucketize-type-members "23.2") | |
107 | |
108 (defcustom semantic-imenu-sort-bucket-function nil | |
109 "*Function to use when sorting tags in the buckets of functions. | |
110 See `semantic-bucketize' and the FILTER argument for more details on this function." | |
111 :group 'semantic-imenu | |
112 :type '(radio (const :tag "No Sorting" nil) | |
113 (const semantic-sort-tags-by-name-increasing) | |
114 (const semantic-sort-tags-by-name-decreasing) | |
115 (const semantic-sort-tags-by-type-increasing) | |
116 (const semantic-sort-tags-by-type-decreasing) | |
117 (const semantic-sort-tags-by-name-increasing-ci) | |
118 (const semantic-sort-tags-by-name-decreasing-ci) | |
119 (const semantic-sort-tags-by-type-increasing-ci) | |
120 (const semantic-sort-tags-by-type-decreasing-ci) | |
121 (function))) | |
122 (make-variable-buffer-local 'semantic-imenu-sort-bucket-function) | |
123 | |
124 (defcustom semantic-imenu-index-directory nil | |
125 "*Non nil to index the entire directory for tags. | |
126 Doesn't actually parse the entire directory, but displays tags for all files | |
127 currently listed in the current Semantic database. | |
128 This variable has no meaning if semanticdb is not active." | |
129 :group 'semantic-imenu | |
130 :type 'boolean) | |
131 | |
132 (defcustom semantic-imenu-auto-rebuild-directory-indexes nil | |
133 "*If non-nil automatically rebuild directory index imenus. | |
134 That is when a directory index imenu is updated, automatically rebuild | |
135 other buffer local ones based on the same semanticdb." | |
136 :group 'semantic-imenu | |
137 :type 'boolean) | |
138 | |
139 (defvar semantic-imenu-directory-current-file nil | |
140 "When building a file index, this is the file name currently being built.") | |
141 | |
142 (defvar semantic-imenu-auto-rebuild-running nil | |
143 "Non-nil if `semantic-imenu-rebuild-directory-indexes' is running.") | |
144 | |
145 ;;;###autoload | |
146 (defvar semantic-imenu-expandable-tag-classes '(type) | |
147 "List of expandable tag classes. | |
148 Tags of those classes will be given submenu with children. | |
149 By default, a `type' has interesting children. In Texinfo, however, a | |
150 `section' has interesting children.") | |
151 (make-variable-buffer-local 'semantic-imenu-expandable-tag-classes) | |
152 (semantic-varalias-obsolete 'semantic-imenu-expandable-token | |
153 'semantic-imenu-expandable-tag-classes "23.2") | |
154 | |
155 ;;; Code: | |
156 (defun semantic-imenu-tag-overlay (tag) | |
157 "Return the overlay belonging to tag. | |
158 If TAG doesn't have an overlay, and instead as a vector of positions, | |
159 concoct a combination of file name, and position." | |
160 (let ((o (semantic-tag-overlay tag))) | |
161 (if (not (semantic-overlay-p o)) | |
162 (let ((v (make-vector 3 nil))) | |
163 (aset v 0 semantic-imenu-directory-current-file) | |
164 (aset v 1 (aref o 0)) | |
165 (aset v 2 (aref o 1)) | |
166 v) | |
167 o))) | |
168 | |
169 | |
170 (defun semantic-imenu-goto-function (name position &optional rest) | |
171 "Move point associated with NAME to POSITION. | |
172 Used to override function `imenu-default-goto-function' so that we can continue | |
173 to use overlays to maintain the current position. | |
174 Optional argument REST is some extra stuff." | |
175 (require 'pulse) | |
176 (if (semantic-overlay-p position) | |
177 (let ((os (semantic-overlay-start position)) | |
178 (ob (semantic-overlay-buffer position))) | |
179 (if os | |
180 (progn | |
181 (if (not (eq ob (current-buffer))) | |
182 (switch-to-buffer ob)) | |
183 (imenu-default-goto-function name os rest) | |
184 (pulse-momentary-highlight-one-line (point)) | |
185 ) | |
186 ;; This should never happen, but check anyway. | |
187 (message "Imenu is out of date, try again. (internal bug)") | |
188 (setq imenu--index-alist nil))) | |
189 ;; When the POSITION is actually a pair of numbers in an array, then | |
190 ;; the file isn't loaded into the current buffer. | |
191 (if (vectorp position) | |
192 (let ((file (aref position 0)) | |
193 (pos (aref position 1))) | |
194 (and file (find-file file)) | |
195 (imenu-default-goto-function name pos rest) | |
196 (pulse-momentary-highlight-one-line (point)) | |
197 ) | |
198 ;; When the POSITION is the symbol 'file-only' it means that this | |
199 ;; is a directory index entry and there is no tags in this | |
200 ;; file. So just jump to the beginning of the file. | |
201 (if (eq position 'file-only) | |
202 (progn | |
203 (find-file name) | |
204 (imenu-default-goto-function name (point-min) rest) | |
205 (pulse-momentary-highlight-one-line (point)) | |
206 ) | |
207 ;; Probably POSITION don't came from a semantic imenu. Try | |
208 ;; the default imenu goto function. | |
209 (condition-case nil | |
210 (progn | |
211 (imenu-default-goto-function name position rest) | |
212 (pulse-momentary-highlight-one-line (point)) | |
213 ) | |
214 (error | |
215 (message "Semantic Imenu override problem. (Internal bug)") | |
216 (setq imenu--index-alist nil))))) | |
217 )) | |
218 | |
219 (defun semantic-imenu-flush-fcn (&optional ignore) | |
220 "This function is called as a hook to clear the imenu cache. | |
221 It is cleared after any parsing. | |
222 IGNORE arguments." | |
223 (if (eq imenu-create-index-function 'semantic-create-imenu-index) | |
224 (setq imenu--index-alist nil | |
225 imenu-menubar-modified-tick 0)) | |
226 (remove-hook 'semantic-after-toplevel-cache-change-hook | |
227 'semantic-imenu-flush-fcn t) | |
228 (remove-hook 'semantic-after-partial-cache-change-hook | |
229 'semantic-imenu-flush-fcn t) | |
230 ) | |
231 | |
232 ;;;###autoload | |
233 (defun semantic-create-imenu-index (&optional stream) | |
234 "Create an imenu index for any buffer which supports Semantic. | |
235 Uses the output of the Semantic parser to create the index. | |
236 Optional argument STREAM is an optional stream of tags used to create menus." | |
237 (setq imenu-default-goto-function 'semantic-imenu-goto-function) | |
238 (prog1 | |
239 (if (and semantic-imenu-index-directory | |
240 (featurep 'semanticdb) | |
241 (semanticdb-minor-mode-p)) | |
242 (semantic-create-imenu-directory-index | |
243 (or stream (semantic-fetch-tags-fast))) | |
244 (semantic-create-imenu-index-1 | |
245 (or stream (semantic-fetch-tags-fast)) nil)) | |
246 (semantic-make-local-hook 'semantic-after-toplevel-cache-change-hook) | |
247 (add-hook 'semantic-after-toplevel-cache-change-hook | |
248 'semantic-imenu-flush-fcn nil t) | |
249 (semantic-make-local-hook 'semantic-after-partial-cache-change-hook) | |
250 (add-hook 'semantic-after-partial-cache-change-hook | |
251 'semantic-imenu-flush-fcn nil t))) | |
252 | |
253 (defun semantic-create-imenu-directory-index (&optional stream) | |
254 "Create an IMENU tag index based on all files active in semanticdb. | |
255 Optional argument STREAM is the stream of tags for the current buffer." | |
256 (if (not semanticdb-current-database) | |
257 (semantic-create-imenu-index-1 stream nil) | |
258 ;; We have a database, list all files, with the current file on top. | |
259 (let ((index (list | |
260 (cons (oref semanticdb-current-table file) | |
261 (or (semantic-create-imenu-index-1 stream nil) | |
262 ;; No tags in this file | |
263 'file-only)))) | |
264 (tables (semanticdb-get-database-tables semanticdb-current-database))) | |
265 (while tables | |
266 (let ((semantic-imenu-directory-current-file | |
267 (oref (car tables) file)) | |
268 tags) | |
269 (when (and (not (eq (car tables) semanticdb-current-table)) | |
270 (semanticdb-live-p (car tables)) | |
271 (semanticdb-equivalent-mode (car tables)) | |
272 ) | |
273 (setq tags (oref (car tables) tags) | |
274 index (cons (cons semantic-imenu-directory-current-file | |
275 (or (and tags | |
276 ;; don't pass nil stream because | |
277 ;; it will use the current | |
278 ;; buffer | |
279 (semantic-create-imenu-index-1 | |
280 (oref (car tables) tags) | |
281 nil)) | |
282 ;; no tags in the file | |
283 'file-only)) | |
284 index))) | |
285 (setq tables (cdr tables)))) | |
286 | |
287 ;; If enabled automatically rebuild other imenu directory | |
288 ;; indexes based on the same Semantic database | |
289 (or (not semantic-imenu-auto-rebuild-directory-indexes) | |
290 ;; If auto rebuild already in progress does nothing | |
291 semantic-imenu-auto-rebuild-running | |
292 (unwind-protect | |
293 (progn | |
294 (setq semantic-imenu-auto-rebuild-running t) | |
295 (semantic-imenu-rebuild-directory-indexes | |
296 semanticdb-current-database)) | |
297 (setq semantic-imenu-auto-rebuild-running nil))) | |
298 | |
299 (nreverse index)))) | |
300 | |
301 (defun semantic-create-imenu-index-1 (stream &optional parent) | |
302 "Create an imenu index for any buffer which supports Semantic. | |
303 Uses the output of the Semantic parser to create the index. | |
304 STREAM is a stream of tags used to create menus. | |
305 Optional argument PARENT is a tag parent of STREAM." | |
306 (let ((tags stream) | |
307 (semantic-imenu-adopt-external-members | |
308 semantic-imenu-adopt-external-members)) | |
309 ;; If we should regroup, do so. | |
310 (if semantic-imenu-adopt-external-members | |
311 (setq tags (semantic-adopt-external-members tags) | |
312 ;; Don't allow recursion here. | |
313 semantic-imenu-adopt-external-members nil)) | |
314 ;; Test for bucketing vs not. | |
315 (if semantic-imenu-bucketize-file | |
316 (let ((buckets (semantic-bucketize | |
317 tags parent | |
318 semantic-imenu-sort-bucket-function)) | |
319 item name | |
320 index) | |
321 (cond | |
322 ((null buckets) | |
323 nil) | |
324 ((or (cdr-safe buckets) ;; if buckets has more than one item in it. | |
325 (not semantic-imenu-buckets-to-submenu)) ;; to force separators between buckets | |
326 (while buckets | |
327 (setq name (car (car buckets)) | |
328 item (cdr (car buckets))) | |
329 (if semantic-imenu-buckets-to-submenu | |
330 (progn | |
331 ;; Make submenus | |
332 (if item | |
333 (setq index | |
334 (cons (cons name | |
335 (semantic-create-imenu-subindex item)) | |
336 index)))) | |
337 ;; Glom everything together with "---" between | |
338 (if item | |
339 (setq index | |
340 (append index | |
341 ;; do not create a menu separator in the parent menu | |
342 ;; when creating a sub-menu | |
343 (if (memq (semantic-tag-class (car item)) | |
344 semantic-imenu-expandable-tag-classes) | |
345 (semantic-create-imenu-subindex item) | |
346 (cons | |
347 '("---") | |
348 (semantic-create-imenu-subindex item))))) | |
349 )) | |
350 (setq buckets (cdr buckets))) | |
351 (if semantic-imenu-buckets-to-submenu | |
352 (nreverse index) | |
353 index)) | |
354 (t | |
355 (setq name (car (car buckets)) | |
356 item (cdr (car buckets))) | |
357 (semantic-create-imenu-subindex item)))) | |
358 ;; Else, group everything together | |
359 (semantic-create-imenu-subindex tags)))) | |
360 | |
361 (defun semantic-create-imenu-subindex (tags) | |
362 "From TAGS, create an imenu index of interesting things." | |
363 (let ((notypecheck (not semantic-imenu-expand-type-members)) | |
364 children index tag parts) | |
365 (while tags | |
366 (setq tag (car tags) | |
367 children (semantic-tag-components-with-overlays tag)) | |
368 (if (and (not notypecheck) | |
369 (memq (semantic-tag-class tag) | |
370 semantic-imenu-expandable-tag-classes) | |
371 children | |
372 ) | |
373 ;; to keep an homogeneous menu organisation, type menu items | |
374 ;; always have a sub-menu with at least the *definition* | |
375 ;; item (even if the tag has no type components) | |
376 (progn | |
377 (setq parts children) | |
378 ;; There is options which create the submenu | |
379 ;; * Type has an overlay, but children do. | |
380 ;; The type doesn't have to have it's own overlay, | |
381 ;; but a type with no overlay and no children should be | |
382 ;; invalid. | |
383 (setq index | |
384 (cons | |
385 (cons | |
386 (funcall semantic-imenu-summary-function tag) | |
387 ;; Add a menu for getting at the type definitions | |
388 (if (and parts | |
389 ;; Note to self: enable menu items for | |
390 ;; sub parts even if they are not proper | |
391 ;; tags. | |
392 (semantic-tag-p (car parts))) | |
393 (let ((submenu | |
394 (if (and semantic-imenu-bucketize-type-members | |
395 semantic-imenu-bucketize-file) | |
396 (semantic-create-imenu-index-1 parts tag) | |
397 (semantic-create-imenu-subindex parts)))) | |
398 ;; Only add a *definition* if we have a postion | |
399 ;; in that type tag. | |
400 (if (semantic-tag-with-position-p tag) | |
401 (cons | |
402 (cons "*definition*" | |
403 (semantic-imenu-tag-overlay tag)) | |
404 submenu) | |
405 submenu)) | |
406 ;; There were no parts, or something like that, so | |
407 ;; instead just put the definition here. | |
408 (if (semantic-tag-with-position-p tag) | |
409 (semantic-imenu-tag-overlay tag) | |
410 nil) | |
411 )) | |
412 index))) | |
413 (if (semantic-tag-with-position-p tag) | |
414 (setq index (cons | |
415 (cons | |
416 (funcall semantic-imenu-summary-function tag) | |
417 (semantic-imenu-tag-overlay tag)) | |
418 index)))) | |
419 (setq tags (cdr tags))) | |
420 ;; `imenu--split-submenus' sort submenus according to | |
421 ;; `imenu-sort-function' setting and split them up if they are | |
422 ;; longer than `imenu-max-items'. | |
423 (imenu--split-submenus (nreverse index)))) | |
424 | |
425 ;;; directory imenu rebuilding. | |
426 ;; | |
427 (defun semantic-imenu-rebuild-directory-indexes (db) | |
428 "Rebuild directory index imenus based on Semantic database DB." | |
429 (let ((l (buffer-list)) | |
430 b) | |
431 (while l | |
432 (setq b (car l) | |
433 l (cdr l)) | |
434 (if (and (not (eq b (current-buffer))) | |
435 (buffer-live-p b)) | |
436 (with-current-buffer b | |
437 ;; If there is a buffer local Semantic index directory | |
438 ;; imenu | |
439 (when (and (eq imenu-create-index-function | |
440 'semantic-create-imenu-index) | |
441 semanticdb-current-database | |
442 (eq semanticdb-current-database db)) | |
443 ;; Rebuild the imenu | |
444 (imenu--cleanup) | |
445 (setq imenu--index-alist nil) | |
446 (funcall | |
447 (if (fboundp 'imenu-menu-filter) | |
448 ;; XEmacs imenu | |
449 'imenu-menu-filter | |
450 ;; Emacs imenu | |
451 'imenu-update-menubar)))))))) | |
452 | |
453 (defun semantic-imenu-semanticdb-hook () | |
454 "Function to be called from `semanticdb-mode-hook'. | |
455 Clears all imenu menus that may be depending on the database." | |
456 (require 'semantic/db-mode) | |
457 (semantic-map-buffers | |
458 #'(lambda () | |
459 ;; Set up semanticdb environment if enabled. | |
460 (if (semanticdb-minor-mode-p) | |
461 (semanticdb-semantic-init-hook-fcn)) | |
462 ;; Clear imenu cache to redraw the imenu. | |
463 (semantic-imenu-flush-fcn)))) | |
464 | |
465 (add-hook 'semanticdb-mode-hook 'semantic-imenu-semanticdb-hook) | |
466 | |
467 ;;; Interactive Utilities | |
468 ;; | |
469 (defun semantic-imenu-toggle-bucketize-file () | |
470 "Toggle the ability of imenu to bucketize the current file." | |
471 (interactive) | |
472 (setq semantic-imenu-bucketize-file (not semantic-imenu-bucketize-file)) | |
473 ;; Force a rescan | |
474 (setq imenu--index-alist nil)) | |
475 | |
476 (defun semantic-imenu-toggle-buckets-to-submenu () | |
477 "Toggle the ability of imenu to turn buckets into submenus." | |
478 (interactive) | |
479 (setq semantic-imenu-buckets-to-submenu (not semantic-imenu-buckets-to-submenu)) | |
480 ;; Force a rescan | |
481 (setq imenu--index-alist nil)) | |
482 | |
483 (defun semantic-imenu-toggle-bucketize-type-parts () | |
484 "Toggle the ability of imenu to bucketize the current file." | |
485 (interactive) | |
486 (setq semantic-imenu-bucketize-type-members (not semantic-imenu-bucketize-type-members)) | |
487 ;; Force a rescan | |
488 (setq imenu--index-alist nil)) | |
489 | |
490 ;;; Which function support | |
491 ;; | |
492 ;; The which-function library will display the current function in the | |
493 ;; mode line. It tries do do this through imenu. With a semantic parsed | |
494 ;; buffer, there is a much more efficient way of doing this. | |
495 ;; Advise `which-function' so that we optionally use semantic tags | |
496 ;; instead, and get better stuff. | |
497 (require 'advice) | |
498 | |
499 (defvar semantic-which-function 'semantic-default-which-function | |
500 "Function to convert semantic tags into `which-function' text.") | |
501 | |
502 (defcustom semantic-which-function-use-color nil | |
503 "*Use color when displaying the current function with `which-function'." | |
504 :group 'semantic-imenu | |
505 :type 'boolean) | |
506 | |
507 (defun semantic-default-which-function (taglist) | |
508 "Convert TAGLIST into a string usable by `which-function'. | |
509 Returns the first tag name in the list, unless it is a type, | |
510 in which case it concatenates them together." | |
511 (cond ((eq (length taglist) 1) | |
512 (semantic-format-tag-abbreviate | |
513 (car taglist) nil semantic-which-function-use-color)) | |
514 ((memq (semantic-tag-class (car taglist)) | |
515 semantic-imenu-expandable-tag-classes) | |
516 (concat (semantic-format-tag-name | |
517 (car taglist) nil semantic-which-function-use-color) | |
518 (car semantic-type-relation-separator-character) | |
519 ;; recurse until we no longer have a type | |
520 ;; or any tags left. | |
521 (semantic-default-which-function (cdr taglist)))) | |
522 (t (semantic-format-tag-abbreviate | |
523 (car taglist) nil semantic-which-function-use-color)))) | |
524 | |
525 ;; (defadvice which-function (around semantic-which activate) | |
526 ;; "Choose the function to display via semantic if it is currently active." | |
527 ;; (if (and (featurep 'semantic) semantic--buffer-cache) | |
528 ;; (let ((ol (semantic-find-tag-by-overlay))) | |
529 ;; (setq ad-return-value (funcall semantic-which-function ol))) | |
530 ;; ad-do-it)) | |
531 | |
532 (provide 'semantic/imenu) | |
533 | |
534 ;; Local variables: | |
535 ;; generated-autoload-file: "loaddefs.el" | |
536 ;; generated-autoload-load-name: "semantic/imenu" | |
537 ;; End: | |
538 | |
539 ;;; semantic/imenu.el ends here |