1 ;;; semantic/complete.el --- Routines for performing tag completion
3 ;; Copyright (C) 2003-2005, 2007-2013 Free Software Foundation, Inc.
5 ;; Author: Eric M. Ludlam <zappo@gnu.org>
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software: you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation, either version 3 of the License, or
13 ;; (at your option) any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;; Completion of tags by name using tables of semantic generated tags.
27 ;; While it would be a simple matter of flattening all tag known
28 ;; tables to perform completion across them using `all-completions',
29 ;; or `try-completion', that process would be slow. In particular,
30 ;; when a system database is included in the mix, the potential for a
31 ;; ludicrous number of options becomes apparent.
33 ;; As such, dynamically searching across tables using a prefix,
34 ;; regular expression, or other feature is needed to help find symbols
35 ;; quickly without resorting to "show me every possible option now".
37 ;; In addition, some symbol names will appear in multiple locations.
38 ;; If it is important to distinguish, then a way to provide a choice
39 ;; over these locations is important as well.
41 ;; Beyond brute force offers for completion of plain strings,
42 ;; using the smarts of semantic-analyze to provide reduced lists of
43 ;; symbols, or fancy tabbing to zoom into files to show multiple hits
44 ;; of the same name can be provided.
48 ;; There are several parts of any completion engine. They are:
50 ;; A. Collection of possible hits
51 ;; B. Typing or selecting an option
52 ;; C. Displaying possible unique completions
53 ;; D. Using the result
55 ;; Here, we will treat each section separately (excluding D)
56 ;; They can then be strung together in user-visible commands to
57 ;; fulfill specific needs.
61 ;; A collector is an object which represents the means by which tags
62 ;; to complete on are collected. It's first job is to find all the
63 ;; tags which are to be completed against. It can also rename
64 ;; some tags if needed so long as `semantic-tag-clone' is used.
66 ;; Some collectors will gather all tags to complete against first
67 ;; (for in buffer queries, or other small list situations). It may
68 ;; choose to do a broad search on each completion request. Built in
69 ;; functionality automatically focuses the cache in as the user types.
71 ;; A collector choosing to create and rename tags could choose a
72 ;; plain name format, a postfix name such as method:class, or a
73 ;; prefix name such as class.method.
77 ;; A displayor is in charge if showing the user interesting things
78 ;; about available completions, and can optionally provide a focus.
79 ;; The simplest display just lists all available names in a separate
80 ;; window. It may even choose to show short names when there are
81 ;; many to choose from, or long names when there are fewer.
83 ;; A complex displayor could opt to help the user 'focus' on some
84 ;; range. For example, if 4 tags all have the same name, subsequent
85 ;; calls to the displayor may opt to show each tag one at a time in
86 ;; the buffer. When the user likes one, selection would cause the
87 ;; 'focus' item to be selected.
91 ;; The format of the tag lists used to perform the completions are in
92 ;; semanticdb "find" format, like this:
94 ;; ( ( DBTABLE1 TAG1 TAG2 ...)
95 ;; ( DBTABLE2 TAG1 TAG2 ...)
98 ;; INLINE vs MINIBUFFER
100 ;; Two major ways completion is used in Emacs is either through a
101 ;; minibuffer query, or via completion in a normal editing buffer,
102 ;; encompassing some small range of characters.
104 ;; Structure for both types of completion are provided here.
105 ;; `semantic-complete-read-tag-engine' will use the minibuffer.
106 ;; `semantic-complete-inline-tag-engine' will complete text in
109 (eval-when-compile (require 'cl
))
112 (require 'semantic
/analyze
)
113 (require 'semantic
/ctxt
)
114 (require 'semantic
/decorate
)
115 (require 'semantic
/format
)
116 (require 'semantic
/idle
)
119 ;; For the semantic-find-tags-for-completion macro.
120 (require 'semantic
/find
))
124 (defvar semantic-complete-inline-overlay nil
125 "The overlay currently active while completing inline.")
127 (defun semantic-completion-inline-active-p ()
128 "Non-nil if inline completion is active."
129 (when (and semantic-complete-inline-overlay
130 (not (semantic-overlay-live-p semantic-complete-inline-overlay
)))
131 (semantic-overlay-delete semantic-complete-inline-overlay
)
132 (setq semantic-complete-inline-overlay nil
))
133 semantic-complete-inline-overlay
)
135 ;;; ------------------------------------------------------------
136 ;;; MINIBUFFER or INLINE utils
138 (defun semantic-completion-text ()
139 "Return the text that is currently in the completion buffer.
140 For a minibuffer prompt, this is the minibuffer text.
141 For inline completion, this is the text wrapped in the inline completion
143 (if semantic-complete-inline-overlay
144 (semantic-complete-inline-text)
145 (minibuffer-contents)))
147 (defun semantic-completion-delete-text ()
148 "Delete the text that is actively being completed.
149 Presumably if you call this you will insert something new there."
150 (if semantic-complete-inline-overlay
151 (semantic-complete-inline-delete-text)
152 (delete-minibuffer-contents)))
154 (defun semantic-completion-message (fmt &rest args
)
155 "Display the string FMT formatted with ARGS at the end of the minibuffer."
156 (if semantic-complete-inline-overlay
157 (apply 'message fmt args
)
158 (message (concat (buffer-string) (apply 'format fmt args
)))))
160 ;;; ------------------------------------------------------------
161 ;;; MINIBUFFER: Option Selection harnesses
163 (defvar semantic-completion-collector-engine nil
164 "The tag collector for the current completion operation.
165 Value should be an object of a subclass of
166 `semantic-completion-engine-abstract'.")
168 (defvar semantic-completion-display-engine nil
169 "The tag display engine for the current completion operation.
170 Value should be a ... what?")
172 (defvar semantic-complete-key-map
173 (let ((km (make-sparse-keymap)))
174 (define-key km
" " 'semantic-complete-complete-space
)
175 (define-key km
"\t" 'semantic-complete-complete-tab
)
176 (define-key km
"\C-m" 'semantic-complete-done
)
177 (define-key km
"\C-g" 'abort-recursive-edit
)
178 (define-key km
"\M-n" 'next-history-element
)
179 (define-key km
"\M-p" 'previous-history-element
)
180 (define-key km
"\C-n" 'next-history-element
)
181 (define-key km
"\C-p" 'previous-history-element
)
182 ;; Add history navigation
184 "Keymap used while completing across a list of tags.")
186 (defvar semantic-completion-default-history nil
187 "Default history variable for any unhistoried prompt.
188 Keeps STRINGS only in the history.")
191 (defun semantic-complete-read-tag-engine (collector displayor prompt
192 default-tag initial-input
194 "Read a semantic tag, and return a tag for the selection.
195 Argument COLLECTOR is an object which can be used to calculate
196 a list of possible hits. See `semantic-completion-collector-engine'
197 for details on COLLECTOR.
198 Argument DISPLAYOR is an object used to display a list of possible
199 completions for a given prefix. See`semantic-completion-display-engine'
200 for details on DISPLAYOR.
201 PROMPT is a string to prompt with.
202 DEFAULT-TAG is a semantic tag or string to use as the default value.
203 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
204 HISTORY is a symbol representing a variable to story the history in."
205 (let* ((semantic-completion-collector-engine collector
)
206 (semantic-completion-display-engine displayor
)
207 (semantic-complete-active-default nil
)
208 (semantic-complete-current-matched-tag nil
)
209 (default-as-tag (semantic-complete-default-to-tag default-tag
))
210 (default-as-string (when (semantic-tag-p default-as-tag
)
211 (semantic-tag-name default-as-tag
)))
214 (when default-as-string
215 ;; Add this to the prompt.
217 ;; I really want to add a lookup of the symbol in those
218 ;; tags available to the collector and only add it if it
219 ;; is available as a possibility, but I'm too lazy right
223 ;; @todo - move from () to into the editable area
224 (if (string-match ":" prompt
)
226 (substring prompt
0 (match-beginning 0))
227 " (default " default-as-string
")"
228 (substring prompt
(match-beginning 0))))
229 (setq prompt
(concat prompt
" (" default-as-string
"): "))))
231 ;; Perform the Completion
234 (read-from-minibuffer prompt
236 semantic-complete-key-map
239 'semantic-completion-default-history
)
241 (semantic-collector-cleanup semantic-completion-collector-engine
)
242 (semantic-displayor-cleanup semantic-completion-display-engine
)
245 ;; Extract the tag from the completion machinery.
247 semantic-complete-current-matched-tag
251 ;;; Util for basic completion prompts
254 (defvar semantic-complete-active-default nil
255 "The current default tag calculated for this prompt.")
257 (defun semantic-complete-default-to-tag (default)
258 "Convert a calculated or passed in DEFAULT into a tag."
259 (if (semantic-tag-p default
)
260 ;; Just return what was passed in.
261 (setq semantic-complete-active-default default
)
262 ;; If none was passed in, guess.
264 (setq default
(semantic-ctxt-current-thing)))
268 ;; Turn default into something useful.
271 ;; Semantic-ctxt-current-symbol will return a list of
272 ;; strings. Technically, we should use the analyzer to
273 ;; fully extract what we need, but for now, just grab the
275 ((and (listp default
) (stringp (car default
)))
280 (symbol-name default
))
282 (signal 'wrong-type-argument
283 (list default
'semantic-tag-p
)))))
285 ;; Now that we have that symbol string, look it up using the active
286 ;; collector. If we get a match, use it.
288 (semantic-collector-calculate-completions
289 semantic-completion-collector-engine
291 ;; Do we have the perfect match???
292 (let ((ml (semantic-collector-current-exact-match
293 semantic-completion-collector-engine
)))
295 ;; We don't care about uniqueness. Just guess for convenience
296 (setq tag
(semanticdb-find-result-nth-in-buffer ml
0))))
298 (setq semantic-complete-active-default tag
)
299 ;; Return it.. .whatever it may be
303 ;;; Prompt Return Value
305 ;; Getting a return value out of this completion prompt is a bit
306 ;; challenging. The read command returns the string typed in.
307 ;; We need to convert this into a valid tag. We can exit the minibuffer
308 ;; for different reasons. If we purposely exit, we must make sure
309 ;; the focused tag is calculated... preferably once.
310 (defvar semantic-complete-current-matched-tag nil
311 "Variable used to pass the tags being matched to the prompt.")
313 ;; semantic-displayor-focus-abstract-child-p is part of the
314 ;; semantic-displayor-focus-abstract class, defined later in this
316 (declare-function semantic-displayor-focus-abstract-child-p
"semantic/complete"
319 (defun semantic-complete-current-match ()
320 "Calculate a match from the current completion environment.
321 Save this in our completion variable. Make sure that variable
322 is cleared if any other keypress is made.
324 tag - a single tag that has been matched.
325 string - a message to show in the minibuffer."
326 ;; Query the environment for an active completion.
327 (let ((collector semantic-completion-collector-engine
)
328 (displayor semantic-completion-display-engine
)
329 (contents (semantic-completion-text))
332 (if (string= contents
"")
333 ;; The user wants the defaults!
334 (setq answer semantic-complete-active-default
)
335 ;; This forces a full calculation of completion on CR.
337 (semantic-collector-calculate-completions collector contents nil
))
338 (semantic-complete-try-completion)
340 ;; Input match displayor focus entry
341 ((setq answer
(semantic-displayor-current-focus displayor
))
342 ;; We have answer, continue
344 ;; One match from the collector
345 ((setq matchlist
(semantic-collector-current-exact-match collector
))
346 (if (= (semanticdb-find-result-length matchlist
) 1)
347 (setq answer
(semanticdb-find-result-nth-in-buffer matchlist
0))
348 (if (semantic-displayor-focus-abstract-child-p displayor
)
349 ;; For focusing displayors, we can claim this is
350 ;; not unique. Multiple focuses can choose the correct
352 (setq answer
"Not Unique")
353 ;; If we don't have a focusing displayor, we need to do something
354 ;; graceful. First, see if all the matches have the same name.
356 (firstname (semantic-tag-name
358 (semanticdb-find-result-nth matchlist
0)))
361 (max (semanticdb-find-result-length matchlist
)))
362 (while (and allsame
(< cnt max
))
367 (semanticdb-find-result-nth matchlist cnt
)))))
371 ;; Now we know if they are all the same. If they are, just
372 ;; accept the first, otherwise complain.
374 (setq answer
(semanticdb-find-result-nth-in-buffer
376 (setq answer
"Not Unique"))
380 (setq answer
"No Match")))
382 ;; Set it into our completion target.
383 (when (semantic-tag-p answer
)
384 (setq semantic-complete-current-matched-tag answer
)
385 ;; Make sure it is up to date by clearing it if the user dares
386 ;; to touch the keyboard.
387 (add-hook 'pre-command-hook
388 (lambda () (setq semantic-complete-current-matched-tag nil
)))
397 ;; Keys are bound to perform completion using our mechanisms.
398 ;; Do that work here.
399 (defun semantic-complete-done ()
400 "Accept the current input."
402 (let ((ans (semantic-complete-current-match)))
404 (semantic-completion-message (concat " [" ans
"]"))
408 (defun semantic-complete-complete-space ()
409 "Complete the partial input in the minibuffer."
411 (semantic-complete-do-completion t
))
413 (defun semantic-complete-complete-tab ()
414 "Complete the partial input in the minibuffer as far as possible."
416 (semantic-complete-do-completion))
418 ;;; Completion Functions
420 ;; Thees routines are functional entry points to performing completion.
422 (defun semantic-complete-hack-word-boundaries (original new
)
423 "Return a string to use for completion.
424 ORIGINAL is the text in the minibuffer.
425 NEW is the new text to insert into the minibuffer.
426 Within the difference bounds of ORIGINAL and NEW, shorten NEW
427 to the nearest word boundary, and return that."
429 (let* ((diff (substring new
(length original
)))
430 (end (string-match "\\>" diff
))
431 (start (string-match "\\<" diff
)))
433 ((and start
(> start
0))
434 ;; If start is greater than 0, include only the new
436 (concat original
(substring diff
0 start
)))
438 (concat original
(substring diff
0 end
)))
441 (defun semantic-complete-try-completion (&optional partial
)
442 "Try a completion for the current minibuffer.
443 If PARTIAL, do partial completion stopping at spaces."
444 (let ((comp (semantic-collector-try-completion
445 semantic-completion-collector-engine
446 (semantic-completion-text))))
449 (semantic-completion-message " [No Match]")
453 (if (string= (semantic-completion-text) comp
)
455 ;; Minibuffer isn't changing AND the text is not unique.
456 ;; Test for partial completion over a word separator character.
457 ;; If there is one available, use that so that SPC can
458 ;; act like a SPC insert key.
459 (let ((newcomp (semantic-collector-current-whitespace-completion
460 semantic-completion-collector-engine
)))
462 (semantic-completion-delete-text)
466 (let ((orig (semantic-completion-text)))
467 ;; For partial completion, we stop and step over
468 ;; word boundaries. Use this nifty function to do
469 ;; that calculation for us.
471 (semantic-complete-hack-word-boundaries orig comp
))))
472 ;; Do the replacement.
473 (semantic-completion-delete-text)
476 ((and (listp comp
) (semantic-tag-p (car comp
)))
477 (unless (string= (semantic-completion-text)
478 (semantic-tag-name (car comp
)))
479 ;; A fully unique completion was available.
480 (semantic-completion-delete-text)
481 (insert (semantic-tag-name (car comp
))))
482 ;; The match is complete
483 (if (= (length comp
) 1)
484 (semantic-completion-message " [Complete]")
485 (semantic-completion-message " [Complete, but not unique]"))
489 (defun semantic-complete-do-completion (&optional partial inline
)
490 "Do a completion for the current minibuffer.
491 If PARTIAL, do partial completion stopping at spaces.
492 if INLINE, then completion is happening inline in a buffer."
493 (let* ((collector semantic-completion-collector-engine
)
494 (displayor semantic-completion-display-engine
)
495 (contents (semantic-completion-text))
499 (semantic-collector-calculate-completions collector contents partial
))
500 (let* ((na (semantic-complete-next-action partial
)))
502 ;; We're all done, but only from a very specific
503 ;; area of completion.
505 (semantic-completion-message " [Complete]")
507 ;; Perform completion
508 ((or (eq na
'complete
)
509 (eq na
'complete-whitespace
))
510 (semantic-complete-try-completion partial
)
511 (setq ans
'complete
))
512 ;; We need to display the completions.
513 ;; Set the completions into the display engine
514 ((or (eq na
'display
) (eq na
'displayend
))
515 (semantic-displayor-set-completions
518 ;; For the below - This caused problems for Chong Yidong
519 ;; when experimenting with the completion engine. I don't
520 ;; remember what the problem was though, and I wasn't sure why
521 ;; the below two lines were there since they obviously added
522 ;; some odd behavior. -EML
523 ;; (and (not (eq na 'displayend))
524 ;; (semantic-collector-current-exact-match collector))
525 (semantic-collector-all-completions collector contents
))
527 ;; Ask the displayor to display them.
528 (semantic-displayor-show-request displayor
))
530 (semantic-displayor-scroll-request displayor
)
533 (semantic-displayor-focus-next displayor
)
534 (semantic-displayor-focus-request displayor
)
537 (semantic-completion-message " [No Match]"))
542 ;;; ------------------------------------------------------------
543 ;;; INLINE: tag completion harness
545 ;; Unlike the minibuffer, there is no mode nor other traditional
546 ;; means of reading user commands in completion mode. Instead
547 ;; we use a pre-command-hook to inset in our commands, and to
548 ;; push ourselves out of this mode on alternate keypresses.
549 (defvar semantic-complete-inline-map
550 (let ((km (make-sparse-keymap)))
551 (define-key km
"\C-i" 'semantic-complete-inline-TAB
)
552 (define-key km
"\M-p" 'semantic-complete-inline-up
)
553 (define-key km
"\M-n" 'semantic-complete-inline-down
)
554 (define-key km
"\C-m" 'semantic-complete-inline-done
)
555 (define-key km
"\C-\M-c" 'semantic-complete-inline-exit
)
556 (define-key km
"\C-g" 'semantic-complete-inline-quit
)
558 (lambda () (interactive)
559 (describe-variable 'semantic-complete-inline-map
)))
561 "Keymap used while performing Semantic inline completion.")
563 (defface semantic-complete-inline-face
564 '((((class color
) (background dark
))
565 (:underline
"yellow"))
566 (((class color
) (background light
))
567 (:underline
"brown")))
568 "*Face used to show the region being completed inline.
569 The face is used in `semantic-complete-inline-tag-engine'."
570 :group
'semantic-faces
)
572 (defun semantic-complete-inline-text ()
573 "Return the text that is being completed inline.
574 Similar to `minibuffer-contents' when completing in the minibuffer."
575 (let ((s (semantic-overlay-start semantic-complete-inline-overlay
))
576 (e (semantic-overlay-end semantic-complete-inline-overlay
)))
579 (buffer-substring-no-properties s e
))))
581 (defun semantic-complete-inline-delete-text ()
582 "Delete the text currently being completed in the current buffer."
584 (semantic-overlay-start semantic-complete-inline-overlay
)
585 (semantic-overlay-end semantic-complete-inline-overlay
)))
587 (defun semantic-complete-inline-done ()
588 "This completion thing is DONE, OR, insert a newline."
590 (let* ((displayor semantic-completion-display-engine
)
591 (tag (semantic-displayor-current-focus displayor
)))
593 (let ((txt (semantic-completion-text)))
594 (insert (substring (semantic-tag-name tag
)
596 (semantic-complete-inline-exit))
598 ;; Get whatever binding RET usually has.
601 (lookup-key (current-active-maps) (this-command-keys))
603 ;; I don't know why, but for some reason the above
604 ;; throws an error sometimes.
605 (lookup-key (current-global-map) (this-command-keys))
611 (defun semantic-complete-inline-quit ()
612 "Quit an inline edit."
614 (semantic-complete-inline-exit)
617 (defun semantic-complete-inline-exit ()
618 "Exit inline completion mode."
620 ;; Remove this hook FIRST!
621 (remove-hook 'pre-command-hook
'semantic-complete-pre-command-hook
)
625 (when semantic-completion-collector-engine
626 (semantic-collector-cleanup semantic-completion-collector-engine
))
627 (when semantic-completion-display-engine
628 (semantic-displayor-cleanup semantic-completion-display-engine
))
630 (when semantic-complete-inline-overlay
631 (let ((wc (semantic-overlay-get semantic-complete-inline-overlay
632 'window-config-start
))
633 (buf (semantic-overlay-buffer semantic-complete-inline-overlay
))
635 (semantic-overlay-delete semantic-complete-inline-overlay
)
636 (setq semantic-complete-inline-overlay nil
)
637 ;; DONT restore the window configuration if we just
639 (when (eq buf
(current-buffer))
640 (set-window-configuration wc
))
643 (setq semantic-completion-collector-engine nil
644 semantic-completion-display-engine nil
))
647 ;; Remove this hook LAST!!!
648 ;; This will force us back through this function if there was
649 ;; some sort of error above.
650 (remove-hook 'post-command-hook
'semantic-complete-post-command-hook
)
652 ;;(message "Exiting inline completion.")
655 (defun semantic-complete-pre-command-hook ()
656 "Used to redefine what commands are being run while completing.
657 When installed as a `pre-command-hook' the special keymap
658 `semantic-complete-inline-map' is queried to replace commands normally run.
659 Commands which edit what is in the region of interest operate normally.
660 Commands which would take us out of the region of interest, or our
661 quit hook, will exit this completion mode."
662 (let ((fcn (lookup-key semantic-complete-inline-map
663 (this-command-keys) nil
)))
664 (cond ((commandp fcn
)
665 (setq this-command fcn
))
669 (defun semantic-complete-post-command-hook ()
670 "Used to determine if we need to exit inline completion mode.
671 If completion mode is active, check to see if we are within
672 the bounds of `semantic-complete-inline-overlay', or within
673 a reasonable distance."
675 ;; Exit if something bad happened.
676 (if (not semantic-complete-inline-overlay
)
678 ;;(message "Inline Hook installed, but overlay deleted.")
679 (semantic-complete-inline-exit))
680 ;; Exit if commands caused us to exit the area of interest
681 (let ((os (semantic-overlay-get semantic-complete-inline-overlay
'semantic-original-start
))
682 (s (semantic-overlay-start semantic-complete-inline-overlay
))
683 (e (semantic-overlay-end semantic-complete-inline-overlay
))
684 (b (semantic-overlay-buffer semantic-complete-inline-overlay
))
688 ;; EXIT when we are no longer in a good place.
689 ((or (not (eq b
(current-buffer)))
694 ;;(message "Exit: %S %S %S" s e (point))
695 (semantic-complete-inline-exit)
697 ;; Exit if the user typed in a character that is not part
698 ;; of the symbol being completed.
699 ((and (setq txt
(semantic-completion-text))
700 (not (string= txt
""))
704 (not (looking-at "\\(\\w\\|\\s_\\)")))))
705 ;;(message "Non symbol character.")
706 (semantic-complete-inline-exit))
707 ((lookup-key semantic-complete-inline-map
708 (this-command-keys) nil
)
709 ;; If the last command was one of our completion commands,
714 ;; Else, show completions now
715 (semantic-complete-inline-force-display)
717 ;; If something goes terribly wrong, clean up after ourselves.
718 (error (semantic-complete-inline-exit))))
720 (defun semantic-complete-inline-force-display ()
721 "Force the display of whatever the current completions are.
722 DO NOT CALL THIS IF THE INLINE COMPLETION ENGINE IS NOT ACTIVE."
725 (let ((collector semantic-completion-collector-engine
)
726 (displayor semantic-completion-display-engine
)
727 (contents (semantic-completion-text)))
729 (semantic-collector-calculate-completions
730 collector contents nil
)
731 (semantic-displayor-set-completions
733 (semantic-collector-all-completions collector contents
)
735 ;; Ask the displayor to display them.
736 (semantic-displayor-show-request displayor
))
738 (error (message "Bug Showing Completions: %S" e
))))
740 (defun semantic-complete-inline-tag-engine
741 (collector displayor buffer start end
)
742 "Perform completion based on semantic tags in a buffer.
743 Argument COLLECTOR is an object which can be used to calculate
744 a list of possible hits. See `semantic-completion-collector-engine'
745 for details on COLLECTOR.
746 Argument DISPLAYOR is an object used to display a list of possible
747 completions for a given prefix. See`semantic-completion-display-engine'
748 for details on DISPLAYOR.
749 BUFFER is the buffer in which completion will take place.
750 START is a location for the start of the full symbol.
751 If the symbol being completed is \"foo.ba\", then START
752 is on the \"f\" character.
753 END is at the end of the current symbol being completed."
754 ;; Set us up for doing completion
755 (setq semantic-completion-collector-engine collector
756 semantic-completion-display-engine displayor
)
758 (setq semantic-complete-inline-overlay
759 (semantic-make-overlay start end buffer nil t
))
760 (semantic-overlay-put semantic-complete-inline-overlay
762 'semantic-complete-inline-face
)
763 (semantic-overlay-put semantic-complete-inline-overlay
765 (current-window-configuration))
766 ;; Save the original start. We need to exit completion if START
768 (semantic-overlay-put semantic-complete-inline-overlay
769 'semantic-original-start start
)
770 ;; Install our command hooks
771 (add-hook 'pre-command-hook
'semantic-complete-pre-command-hook
)
772 (add-hook 'post-command-hook
'semantic-complete-post-command-hook
)
774 (semantic-complete-inline-force-display)
777 ;;; Inline Completion Keymap Functions
779 (defun semantic-complete-inline-TAB ()
780 "Perform inline completion."
782 (let ((cmpl (semantic-complete-do-completion nil t
)))
785 (semantic-complete-inline-force-display))
787 (semantic-complete-inline-done))
791 (defun semantic-complete-inline-down()
792 "Focus forwards through the displayor."
794 (let ((displayor semantic-completion-display-engine
))
795 (semantic-displayor-focus-next displayor
)
796 (semantic-displayor-focus-request displayor
)
799 (defun semantic-complete-inline-up ()
800 "Focus backwards through the displayor."
802 (let ((displayor semantic-completion-display-engine
))
803 (semantic-displayor-focus-previous displayor
)
804 (semantic-displayor-focus-request displayor
)
808 ;;; ------------------------------------------------------------
809 ;;; Interactions between collection and displaying
811 ;; Functional routines used to help collectors communicate with
812 ;; the current displayor, or for the previous section.
814 (defun semantic-complete-next-action (partial)
815 "Determine what the next completion action should be.
816 PARTIAL is non-nil if we are doing partial completion.
817 First, the collector can determine if we should perform a completion or not.
818 If there is nothing to complete, then the displayor determines if we are
819 to show a completion list, scroll, or perhaps do a focus (if it is capable.)
820 Expected return values are:
821 done -> We have a singular match
822 empty -> There are no matches to the current text
823 complete -> Perform a completion action
824 complete-whitespace -> Complete next whitespace type character.
825 display -> Show the list of completions
826 scroll -> The completions have been shown, and the user keeps hitting
827 the complete button. If possible, scroll the completions
828 focus -> The displayor knows how to shift focus among possible completions.
830 displayend -> Whatever options the displayor had for repeating options, there
831 are none left. Try something new."
832 (let ((ans1 (semantic-collector-next-action
833 semantic-completion-collector-engine
835 (ans2 (semantic-displayor-next-action
836 semantic-completion-display-engine
))
839 ;; No collector answer, use displayor answer.
842 ;; Displayor selection of 'scroll, 'display, or 'focus trumps
844 ((and (eq ans1
'done
) ans2
)
846 ;; Use ans1 when we have it.
852 ;;; ------------------------------------------------------------
853 ;;; Collection Engines
855 ;; Collection engines can scan tags from the current environment and
856 ;; provide lists of possible completions.
858 ;; General features of the abstract collector:
859 ;; * Cache completion lists between uses
860 ;; * Cache itself per buffer. Handle reparse hooks
862 ;; Key Interface Functions to implement:
863 ;; * semantic-collector-next-action
864 ;; * semantic-collector-calculate-completions
865 ;; * semantic-collector-try-completion
866 ;; * semantic-collector-all-completions
868 (defvar semantic-collector-per-buffer-list nil
869 "List of collectors active in this buffer.")
870 (make-variable-buffer-local 'semantic-collector-per-buffer-list
)
872 (defvar semantic-collector-list nil
873 "List of global collectors active this session.")
875 (defclass semantic-collector-abstract
()
876 ((buffer :initarg
:buffer
878 :documentation
"Originating buffer for this collector.
879 Some collectors use a given buffer as a starting place while looking up
882 :type
(or null semanticdb-find-result-with-nil
)
883 :documentation
"Cache of tags.
884 These tags are re-used during a completion session.
885 Sometimes these tags are cached between completion sessions.")
886 (last-all-completions :initarg nil
887 :type semanticdb-find-result-with-nil
888 :documentation
"Last result of `all-completions'.
889 This result can be used for refined completions as `last-prefix' gets
890 closer to a specific result.")
891 (last-prefix :type string
892 :protection
:protected
893 :documentation
"The last queried prefix.
894 This prefix can be used to cache intermediate completion offers.
895 making the action of homing in on a token faster.")
896 (last-completion :type
(or null string
)
897 :documentation
"The last calculated completion.
898 This completion is calculated and saved for future use.")
899 (last-whitespace-completion :type
(or null string
)
900 :documentation
"The last whitespace completion.
901 For partial completion, SPC will disambiguate over whitespace type
902 characters. This is the last calculated version.")
903 (current-exact-match :type list
904 :protection
:protected
905 :documentation
"The list of matched tags.
906 When tokens are matched, they are added to this list.")
908 "Root class for completion engines.
909 The baseclass provides basic functionality for interacting with
910 a completion displayor object, and tracking the current progress
914 ;;; Smart completion collector
915 (defclass semantic-collector-analyze-completions
(semantic-collector-abstract)
916 ((context :initarg
:context
917 :type semantic-analyze-context
918 :documentation
"An analysis context.
919 Specifies some context location from whence completion lists will be drawn."
921 (first-pass-completions :type list
922 :documentation
"List of valid completion tags.
923 This list of tags is generated when completion starts. All searches
924 derive from this list.")
926 "Completion engine that uses the context analyzer to provide options.
927 The only options available for completion are those which can be logically
928 inserted into the current context.")
930 (defmethod semantic-collector-calculate-completions-raw
931 ((obj semantic-collector-analyze-completions
) prefix completionlist
)
932 "calculate the completions for prefix from completionlist."
933 ;; if there are no completions yet, calculate them.
934 (if (not (slot-boundp obj
'first-pass-completions
))
935 (oset obj first-pass-completions
936 (semantic-analyze-possible-completions (oref obj context
))))
937 ;; search our cached completion list. make it look like a semanticdb
939 (list (cons (with-current-buffer (oref (oref obj context
) buffer
)
940 semanticdb-current-table
)
941 (semantic-find-tags-for-completion
943 (oref obj first-pass-completions
)))))
945 (defmethod semantic-collector-cleanup ((obj semantic-collector-abstract
))
946 "Clean up any mess this collector may have."
949 (defmethod semantic-collector-next-action
950 ((obj semantic-collector-abstract
) partial
)
951 "What should we do next? OBJ can be used to determine the next action.
952 PARTIAL indicates if we are doing a partial completion."
953 (if (and (slot-boundp obj
'last-completion
)
954 (string= (semantic-completion-text) (oref obj last-completion
)))
955 (let* ((cem (semantic-collector-current-exact-match obj
))
956 (cemlen (semanticdb-find-result-length cem
))
957 (cac (semantic-collector-all-completions
958 obj
(semantic-completion-text)))
959 (caclen (semanticdb-find-result-length cac
)))
960 (cond ((and cem
(= cemlen
1)
962 (eq last-command this-command
))
963 ;; Defer to the displayor...
965 ((and cem
(= cemlen
1))
967 ((and (not cem
) (not cac
))
969 ((and partial
(semantic-collector-try-completion-whitespace
970 obj
(semantic-completion-text)))
971 'complete-whitespace
)))
974 (defmethod semantic-collector-last-prefix= ((obj semantic-collector-abstract
)
976 "Return non-nil if OBJ's prefix matches PREFIX."
977 (and (slot-boundp obj
'last-prefix
)
978 (string= (oref obj last-prefix
) last-prefix
)))
980 (defmethod semantic-collector-get-cache ((obj semantic-collector-abstract
))
981 "Get the raw cache of tags for completion.
982 Calculate the cache if there isn't one."
984 (semantic-collector-calculate-cache obj
)))
986 (defmethod semantic-collector-calculate-completions-raw
987 ((obj semantic-collector-abstract
) prefix completionlist
)
988 "Calculate the completions for prefix from completionlist.
989 Output must be in semanticdb Find result format."
990 ;; Must output in semanticdb format
991 (let ((table (with-current-buffer (oref obj buffer
)
992 semanticdb-current-table
))
993 (result (semantic-find-tags-for-completion
995 ;; To do this kind of search with a pre-built completion
996 ;; list, we need to strip it first.
997 (semanticdb-strip-find-results completionlist
)))
1000 (list (cons table result
)))))
1002 (defmethod semantic-collector-calculate-completions
1003 ((obj semantic-collector-abstract
) prefix partial
)
1004 "Calculate completions for prefix as setup for other queries."
1005 (let* ((case-fold-search semantic-case-fold
)
1006 (same-prefix-p (semantic-collector-last-prefix= obj prefix
))
1007 (last-prefix (and (slot-boundp obj
'last-prefix
)
1008 (oref obj last-prefix
)))
1010 (cond ((or same-prefix-p
1011 (and last-prefix
(eq (compare-strings
1013 prefix
0 (length last-prefix
)) t
)))
1014 ;; We have the same prefix, or last-prefix is a
1015 ;; substring of the of new prefix, in which case we are
1016 ;; refining our symbol so just re-use cache.
1017 (oref obj last-all-completions
))
1019 (> (length prefix
) 1)
1020 (eq (compare-strings
1022 last-prefix
0 (length prefix
)) t
))
1023 ;; The new prefix is a substring of the old
1024 ;; prefix, and it's longer than one character.
1025 ;; Perform a full search to pull in additional
1027 (let ((context (semantic-analyze-current-context (point))))
1028 ;; Set new context and make first-pass-completions
1029 ;; unbound so that they are newly calculated.
1030 (oset obj context context
)
1031 (when (slot-boundp obj
'first-pass-completions
)
1032 (slot-makeunbound obj
'first-pass-completions
)))
1035 (answer (if same-prefix-p
1037 (semantic-collector-calculate-completions-raw
1038 obj prefix completionlist
)))
1040 (complete-not-uniq nil
)
1042 ;;(semanticdb-find-result-test answer)
1043 (when (not same-prefix-p
)
1044 ;; Save results if it is interesting and beneficial
1045 (oset obj last-prefix prefix
)
1046 (oset obj last-all-completions answer
))
1047 ;; Now calculate the completion.
1048 (setq completion
(try-completion
1050 (semanticdb-strip-find-results answer
)))
1051 (oset obj last-whitespace-completion nil
)
1052 (oset obj current-exact-match nil
)
1053 ;; Only do this if a completion was found. Letting a nil in
1054 ;; could cause a full semanticdb search by accident.
1056 (oset obj last-completion
1058 ;; Unique match in AC. Last completion is a match.
1059 ;; Also set the current-exact-match.
1061 (oset obj current-exact-match answer
)
1063 ;; It may be complete (a symbol) but still not unique.
1064 ;; We can capture a match
1065 ((setq complete-not-uniq
1066 (semanticdb-find-tags-by-name
1069 (oset obj current-exact-match
1073 ;; Non unique match, return the string that handles
1075 (t (or completion prefix
))
1079 (defmethod semantic-collector-try-completion-whitespace
1080 ((obj semantic-collector-abstract
) prefix
)
1081 "For OBJ, do whitespace completion based on PREFIX.
1082 This implies that if there are two completions, one matching
1083 the test \"prefix\\>\", and one not, the one matching the full
1084 word version of PREFIX will be chosen, and that text returned.
1085 This function requires that `semantic-collector-calculate-completions'
1086 has been run first."
1087 (let* ((ac (semantic-collector-all-completions obj prefix
))
1088 (matchme (concat "^" prefix
"\\>"))
1089 (compare (semanticdb-find-tags-by-name-regexp matchme ac
))
1090 (numtag (semanticdb-find-result-length compare
))
1094 (cutlen (1+ (length prefix
)))
1095 (twws (semanticdb-find-result-nth compare idx
)))
1096 ;; Is our tag with whitespace a match that has whitespace
1097 ;; after it, or just an already complete symbol?
1098 (while (and (< idx numtag
)
1099 (< (length (semantic-tag-name (car twws
))) cutlen
))
1101 twws
(semanticdb-find-result-nth compare idx
)))
1102 (when (and twws
(car-safe twws
))
1103 ;; If COMPARE has succeeded, then we should take the very
1104 ;; first match, and extend prefix by one character.
1105 (oset obj last-whitespace-completion
1106 (substring (semantic-tag-name (car twws
))
1111 (defmethod semantic-collector-current-exact-match ((obj semantic-collector-abstract
))
1112 "Return the active valid MATCH from the semantic collector.
1113 For now, just return the first element from our list of available
1114 matches. For semanticdb based results, make sure the file is loaded
1116 (when (slot-boundp obj
'current-exact-match
)
1117 (oref obj current-exact-match
)))
1119 (defmethod semantic-collector-current-whitespace-completion ((obj semantic-collector-abstract
))
1120 "Return the active whitespace completion value."
1121 (when (slot-boundp obj
'last-whitespace-completion
)
1122 (oref obj last-whitespace-completion
)))
1124 (defmethod semantic-collector-get-match ((obj semantic-collector-abstract
))
1125 "Return the active valid MATCH from the semantic collector.
1126 For now, just return the first element from our list of available
1127 matches. For semanticdb based results, make sure the file is loaded
1129 (when (slot-boundp obj
'current-exact-match
)
1130 (semanticdb-find-result-nth-in-buffer (oref obj current-exact-match
) 0)))
1132 (defmethod semantic-collector-all-completions
1133 ((obj semantic-collector-abstract
) prefix
)
1134 "For OBJ, retrieve all completions matching PREFIX.
1135 The returned list consists of all the tags currently
1137 (when (slot-boundp obj
'last-all-completions
)
1138 (oref obj last-all-completions
)))
1140 (defmethod semantic-collector-try-completion
1141 ((obj semantic-collector-abstract
) prefix
)
1142 "For OBJ, attempt to match PREFIX.
1143 See `try-completion' for details on how this works.
1144 Return nil for no match.
1145 Return a string for a partial match.
1146 For a unique match of PREFIX, return the list of all tags
1148 (if (slot-boundp obj
'last-completion
)
1149 (oref obj last-completion
)))
1151 (defmethod semantic-collector-calculate-cache
1152 ((obj semantic-collector-abstract
))
1153 "Calculate the completion cache for OBJ."
1157 (defmethod semantic-collector-flush ((this semantic-collector-abstract
))
1158 "Flush THIS collector object, clearing any caches and prefix."
1159 (oset this cache nil
)
1160 (slot-makeunbound this
'last-prefix
)
1161 (slot-makeunbound this
'last-completion
)
1162 (slot-makeunbound this
'last-all-completions
)
1163 (slot-makeunbound this
'current-exact-match
)
1168 (defclass semantic-collector-buffer-abstract
(semantic-collector-abstract)
1170 "Root class for per-buffer completion engines.
1171 These collectors track themselves on a per-buffer basis."
1174 (defmethod constructor :STATIC
((this semantic-collector-buffer-abstract
)
1175 newname
&rest fields
)
1176 "Reuse previously created objects of this type in buffer."
1178 (bl semantic-collector-per-buffer-list
))
1179 (while (and bl
(null old
))
1180 (if (eq (eieio-object-class (car bl
)) this
)
1181 (setq old
(car bl
))))
1183 (let ((new (call-next-method)))
1184 (add-to-list 'semantic-collector-per-buffer-list new
)
1186 (slot-makeunbound old
'last-completion
)
1187 (slot-makeunbound old
'last-prefix
)
1188 (slot-makeunbound old
'current-exact-match
)
1191 ;; Buffer specific collectors should flush themselves
1192 (defun semantic-collector-buffer-flush (newcache)
1193 "Flush all buffer collector objects.
1194 NEWCACHE is the new tag table, but we ignore it."
1196 (let ((l semantic-collector-per-buffer-list
))
1198 (if (car l
) (semantic-collector-flush (car l
)))
1202 (add-hook 'semantic-after-toplevel-cache-change-hook
1203 'semantic-collector-buffer-flush
)
1205 ;;; DEEP BUFFER SPECIFIC COMPLETION
1207 (defclass semantic-collector-buffer-deep
1208 (semantic-collector-buffer-abstract)
1210 "Completion engine for tags in the current buffer.
1211 When searching for a tag, uses semantic deep search functions.
1212 Basics search only in the current buffer.")
1214 (defmethod semantic-collector-calculate-cache
1215 ((obj semantic-collector-buffer-deep
))
1216 "Calculate the completion cache for OBJ.
1217 Uses `semantic-flatten-tags-table'"
1219 ;; Must create it in SEMANTICDB find format.
1220 ;; ( ( DBTABLE TAG TAG ... ) ... )
1222 (cons semanticdb-current-table
1223 (semantic-flatten-tags-table (oref obj buffer
))))))
1225 ;;; PROJECT SPECIFIC COMPLETION
1227 (defclass semantic-collector-project-abstract
(semantic-collector-abstract)
1228 ((path :initarg
:path
1230 :documentation
"List of database tables to search.
1231 At creation time, it can be anything accepted by
1232 `semanticdb-find-translate-path' as a PATH argument.")
1234 "Root class for project wide completion engines.
1235 Uses semanticdb for searching all tags in the current project."
1239 (defclass semantic-collector-project
(semantic-collector-project-abstract)
1241 "Completion engine for tags in a project.")
1244 (defmethod semantic-collector-calculate-completions-raw
1245 ((obj semantic-collector-project
) prefix completionlist
)
1246 "Calculate the completions for prefix from completionlist."
1247 (semanticdb-find-tags-for-completion prefix
(oref obj path
)))
1249 ;;; Brutish Project search
1250 (defclass semantic-collector-project-brutish
(semantic-collector-project-abstract)
1252 "Completion engine for tags in a project.")
1254 (declare-function semanticdb-brute-deep-find-tags-for-completion
1257 (defmethod semantic-collector-calculate-completions-raw
1258 ((obj semantic-collector-project-brutish
) prefix completionlist
)
1259 "Calculate the completions for prefix from completionlist."
1260 (require 'semantic
/db-find
)
1261 (semanticdb-brute-deep-find-tags-for-completion prefix
(oref obj path
)))
1263 ;;; Current Datatype member search.
1264 (defclass semantic-collector-local-members
(semantic-collector-project-abstract)
1265 ((scope :initform nil
1266 :type
(or null semantic-scope-cache
)
1268 "The scope the local members are being completed from."))
1269 "Completion engine for tags in a project.")
1271 (defmethod semantic-collector-calculate-completions-raw
1272 ((obj semantic-collector-local-members
) prefix completionlist
)
1273 "Calculate the completions for prefix from completionlist."
1274 (let* ((scope (or (oref obj scope
)
1275 (oset obj scope
(semantic-calculate-scope))))
1276 (localstuff (oref scope scope
)))
1280 (semantic-find-tags-for-completion prefix localstuff
)))))
1281 ;(semanticdb-brute-deep-find-tags-for-completion prefix (oref obj path))))
1284 ;;; ------------------------------------------------------------
1285 ;;; Tag List Display Engines
1287 ;; A typical displayor accepts a pre-determined list of completions
1288 ;; generated by a collector. This format is in semanticdb search
1289 ;; form. This vaguely standard form is a bit challenging to navigate
1290 ;; because the tags do not contain buffer info, but the file associated
1291 ;; with the tags precedes the tag in the list.
1293 ;; Basic displayors don't care, and can strip the results.
1294 ;; Advanced highlighting displayors need to know when they need
1295 ;; to load a file so that the tag in question can be highlighted.
1297 ;; Key interface methods to a displayor are:
1298 ;; * semantic-displayor-next-action
1299 ;; * semantic-displayor-set-completions
1300 ;; * semantic-displayor-current-focus
1301 ;; * semantic-displayor-show-request
1302 ;; * semantic-displayor-scroll-request
1303 ;; * semantic-displayor-focus-request
1305 (defclass semantic-displayor-abstract
()
1306 ((table :type
(or null semanticdb-find-result-with-nil
)
1308 :protection
:protected
1309 :documentation
"List of tags this displayor is showing.")
1310 (last-prefix :type string
1311 :protection
:protected
1312 :documentation
"Prefix associated with slot `table'")
1314 "Abstract displayor baseclass.
1315 Manages the display of some number of tags.
1316 Provides the basics for a displayor, including interacting with
1317 a collector, and tracking tables of completion to display."
1320 (defmethod semantic-displayor-cleanup ((obj semantic-displayor-abstract
))
1321 "Clean up any mess this displayor may have."
1324 (defmethod semantic-displayor-next-action ((obj semantic-displayor-abstract
))
1325 "The next action to take on the minibuffer related to display."
1326 (if (and (slot-boundp obj
'last-prefix
)
1327 (or (eq this-command
'semantic-complete-inline-TAB
)
1328 (and (string= (oref obj last-prefix
) (semantic-completion-text))
1329 (eq last-command this-command
))))
1333 (defmethod semantic-displayor-set-completions ((obj semantic-displayor-abstract
)
1335 "Set the list of tags to be completed over to TABLE."
1336 (oset obj table table
)
1337 (oset obj last-prefix prefix
))
1339 (defmethod semantic-displayor-show-request ((obj semantic-displayor-abstract
))
1340 "A request to show the current tags table."
1343 (defmethod semantic-displayor-focus-request ((obj semantic-displayor-abstract
))
1344 "A request to for the displayor to focus on some tag option."
1347 (defmethod semantic-displayor-scroll-request ((obj semantic-displayor-abstract
))
1348 "A request to for the displayor to scroll the completion list (if needed)."
1349 (scroll-other-window))
1351 (defmethod semantic-displayor-focus-previous ((obj semantic-displayor-abstract
))
1352 "Set the current focus to the previous item."
1355 (defmethod semantic-displayor-focus-next ((obj semantic-displayor-abstract
))
1356 "Set the current focus to the next item."
1359 (defmethod semantic-displayor-current-focus ((obj semantic-displayor-abstract
))
1360 "Return a single tag currently in focus.
1361 This object type doesn't do focus, so will never have a focus object."
1364 ;; Traditional displayor
1365 (defcustom semantic-completion-displayor-format-tag-function
1366 #'semantic-format-tag-name
1367 "*A Tag format function to use when showing completions."
1369 :type semantic-format-tag-custom-list
)
1371 (defclass semantic-displayor-traditional
(semantic-displayor-abstract)
1373 "Display options in *Completions* buffer.
1374 Traditional display mechanism for a list of possible completions.
1375 Completions are showin in a new buffer and listed with the ability
1376 to click on the items to aid in completion.")
1378 (defmethod semantic-displayor-show-request ((obj semantic-displayor-traditional
))
1379 "A request to show the current tags table."
1381 ;; NOTE TO SELF. Find the character to type next, and emphasize it.
1383 (with-output-to-temp-buffer "*Completions*"
1384 (display-completion-list
1385 (mapcar semantic-completion-displayor-format-tag-function
1386 (semanticdb-strip-find-results (oref obj table
))))
1390 ;;; Abstract baseclass for any displayor which supports focus
1391 (defclass semantic-displayor-focus-abstract
(semantic-displayor-abstract)
1392 ((focus :type number
1393 :protection
:protected
1394 :documentation
"A tag index from `table' which has focus.
1395 Multiple calls to the display function can choose to focus on a
1396 given tag, by highlighting its location.")
1401 "Non-nil if focusing requires a tag's buffer be in memory.")
1403 "Abstract displayor supporting `focus'.
1404 A displayor which has the ability to focus in on one tag.
1405 Focusing is a way of differentiating among multiple tags
1406 which have the same name."
1409 (defmethod semantic-displayor-next-action ((obj semantic-displayor-focus-abstract
))
1410 "The next action to take on the minibuffer related to display."
1411 (if (and (slot-boundp obj
'last-prefix
)
1412 (string= (oref obj last-prefix
) (semantic-completion-text))
1413 (eq last-command this-command
))
1415 (slot-boundp obj
'focus
)
1416 (slot-boundp obj
'table
)
1417 (<= (semanticdb-find-result-length (oref obj table
))
1418 (1+ (oref obj focus
))))
1419 ;; We are at the end of the focus road.
1421 ;; Focus on some item.
1425 (defmethod semantic-displayor-set-completions ((obj semantic-displayor-focus-abstract
)
1427 "Set the list of tags to be completed over to TABLE."
1429 (slot-makeunbound obj
'focus
))
1431 (defmethod semantic-displayor-focus-previous ((obj semantic-displayor-focus-abstract
))
1432 "Set the current focus to the previous item.
1433 Not meaningful return value."
1434 (when (and (slot-boundp obj
'table
) (oref obj table
))
1435 (with-slots (table) obj
1436 (if (or (not (slot-boundp obj
'focus
))
1437 (<= (oref obj focus
) 0))
1438 (oset obj focus
(1- (semanticdb-find-result-length table
)))
1439 (oset obj focus
(1- (oref obj focus
)))
1443 (defmethod semantic-displayor-focus-next ((obj semantic-displayor-focus-abstract
))
1444 "Set the current focus to the next item.
1445 Not meaningful return value."
1446 (when (and (slot-boundp obj
'table
) (oref obj table
))
1447 (with-slots (table) obj
1448 (if (not (slot-boundp obj
'focus
))
1450 (oset obj focus
(1+ (oref obj focus
)))
1452 (if (<= (semanticdb-find-result-length table
) (oref obj focus
))
1456 (defmethod semantic-displayor-focus-tag ((obj semantic-displayor-focus-abstract
))
1457 "Return the next tag OBJ should focus on."
1458 (when (and (slot-boundp obj
'table
) (oref obj table
))
1459 (with-slots (table) obj
1460 (semanticdb-find-result-nth table
(oref obj focus
)))))
1462 (defmethod semantic-displayor-current-focus ((obj semantic-displayor-focus-abstract
))
1463 "Return the tag currently in focus, or call parent method."
1464 (if (and (slot-boundp obj
'focus
)
1465 (slot-boundp obj
'table
)
1466 ;; Only return the current focus IFF the minibuffer reflects
1467 ;; the list this focus was derived from.
1468 (slot-boundp obj
'last-prefix
)
1469 (string= (semantic-completion-text) (oref obj last-prefix
))
1472 (if (oref obj find-file-focus
)
1473 (semanticdb-find-result-nth-in-buffer (oref obj table
) (oref obj focus
))
1474 ;; result-nth returns a cons with car being the tag, and cdr the
1476 (car (semanticdb-find-result-nth (oref obj table
) (oref obj focus
))))
1478 (call-next-method)))
1480 ;;; Simple displayor which performs traditional display completion,
1481 ;; and also focuses with highlighting.
1482 (defclass semantic-displayor-traditional-with-focus-highlight
1483 (semantic-displayor-focus-abstract semantic-displayor-traditional
)
1484 ((find-file-focus :initform t
))
1485 "Display completions in *Completions* buffer, with focus highlight.
1486 A traditional displayor which can focus on a tag by showing it.
1487 Same as `semantic-displayor-traditional', but with selection between
1488 multiple tags with the same name done by 'focusing' on the source
1489 location of the different tags to differentiate them.")
1491 (defmethod semantic-displayor-focus-request
1492 ((obj semantic-displayor-traditional-with-focus-highlight
))
1493 "Focus in on possible tag completions.
1494 Focus is performed by cycling through the tags and highlighting
1495 one in the source buffer."
1496 (let* ((tablelength (semanticdb-find-result-length (oref obj table
)))
1497 (focus (semantic-displayor-focus-tag obj
))
1500 (rtable (cdr focus
))
1502 (nt (semanticdb-normalize-one-tag rtable rtag
))
1505 (curwin (selected-window)))
1506 ;; If we fail to normalize, reset.
1507 (when (not tag
) (setq table rtable tag rtag
))
1509 (let ((buf (or (semantic-tag-buffer tag
)
1510 (and table
(semanticdb-get-buffer table
)))))
1511 ;; If no buffer is provided, then we can make up a summary buffer.
1513 (with-current-buffer (get-buffer-create "*Completion Focus*")
1515 (insert "Focus on tag: \n")
1516 (insert (semantic-format-tag-summarize tag nil t
) "\n\n")
1518 (insert "From table: \n")
1519 (insert (eieio-object-name table
) "\n\n"))
1521 (insert "In buffer: \n\n")
1522 (insert (format "%S" buf
)))
1523 (setq buf
(current-buffer))))
1524 ;; Show the tag in the buffer.
1525 (if (get-buffer-window buf
)
1526 (select-window (get-buffer-window buf
))
1527 (switch-to-buffer-other-window buf t
)
1528 (select-window (get-buffer-window buf
)))
1529 ;; Now do some positioning
1530 (when (semantic-tag-with-position-p tag
)
1531 ;; Full tag positional information available
1532 (goto-char (semantic-tag-start tag
))
1533 ;; This avoids a dangerous problem if we just loaded a tag
1534 ;; from a file, but the original position was not updated
1535 ;; in the TAG variable we are currently using.
1536 (semantic-momentary-highlight-tag (semantic-current-tag)))
1537 (select-window curwin
)
1538 ;; Calculate text difference between contents and the focus item.
1539 (let* ((mbc (semantic-completion-text))
1540 (ftn (semantic-tag-name tag
))
1541 (diff (substring ftn
(length mbc
))))
1542 (semantic-completion-message
1543 (format "%s [%d of %d matches]" diff
(1+ (oref obj focus
)) tablelength
)))
1547 ;;; Tooltip completion lister
1549 ;; Written and contributed by Masatake YAMATO <jet@gyve.org>
1551 ;; Modified by Eric Ludlam for
1552 ;; * Safe compatibility for tooltip free systems.
1553 ;; * Don't use 'avoid package for tooltip positioning.
1556 (defcustom semantic-displayor-tooltip-mode
'standard
1557 "Mode for the tooltip inline completion.
1559 Standard: Show only `semantic-displayor-tooltip-initial-max-tags'
1560 number of completions initially. Pressing TAB will show the
1563 Quiet: Only show completions when we have narrowed all
1564 possibilities down to a maximum of
1565 `semantic-displayor-tooltip-initial-max-tags' tags. Pressing TAB
1566 multiple times will also show completions.
1568 Verbose: Always show all completions available.
1570 The absolute maximum number of completions for all mode is
1571 determined through `semantic-displayor-tooltip-max-tags'."
1574 :type
'(choice (const :tag
"Standard" standard
)
1575 (const :tag
"Quiet" quiet
)
1576 (const :tag
"Verbose" verbose
)))
1579 (defcustom semantic-displayor-tooltip-initial-max-tags
5
1580 "Maximum number of tags to be displayed initially.
1581 See doc-string of `semantic-displayor-tooltip-mode' for details."
1586 (defcustom semantic-displayor-tooltip-max-tags
25
1587 "The maximum number of tags to be displayed.
1588 Maximum number of completions where we have activated the
1589 extended completion list through typing TAB or SPACE multiple
1590 times. This limit needs to fit on your screen!
1592 Note: If available, customizing this variable increases
1593 `x-max-tooltip-size' to force over-sized tooltips when necessary.
1594 This will not happen if you directly set this variable via `setq'."
1598 :set
'(lambda (sym var
)
1599 (set-default sym var
)
1600 (when (boundp 'x-max-tooltip-size
)
1601 (setcdr x-max-tooltip-size
(max (1+ var
) (cdr x-max-tooltip-size
))))))
1604 (defclass semantic-displayor-tooltip
(semantic-displayor-traditional)
1605 ((mode :initarg
:mode
1607 (symbol-value 'semantic-displayor-tooltip-mode
)
1609 "See `semantic-displayor-tooltip-mode'.")
1610 (max-tags-initial :initarg max-tags-initial
1612 (symbol-value 'semantic-displayor-tooltip-initial-max-tags
)
1614 "See `semantic-displayor-tooltip-initial-max-tags'.")
1615 (typing-count :type integer
1618 "Counter holding how many times the user types space or tab continuously before showing tags.")
1619 (shown :type boolean
1622 "Flag representing whether tooltip has been shown yet.")
1624 "Display completions options in a tooltip.
1625 Display mechanism using tooltip for a list of possible completions.")
1627 (defmethod initialize-instance :AFTER
((obj semantic-displayor-tooltip
) &rest args
)
1628 "Make sure we have tooltips required."
1634 (defmethod semantic-displayor-show-request ((obj semantic-displayor-tooltip
))
1635 "A request to show the current tags table."
1636 (if (or (not (featurep 'tooltip
)) (not tooltip-mode
))
1637 ;; If we cannot use tooltips, then go to the normal mode with
1638 ;; a traditional completion buffer.
1640 (let* ((tablelong (semanticdb-strip-find-results (oref obj table
)))
1641 (table (semantic-unique-tag-table-by-name tablelong
))
1642 (completions (mapcar semantic-completion-displayor-format-tag-function table
))
1643 (numcompl (length completions
))
1644 (typing-count (oref obj typing-count
))
1645 (mode (oref obj mode
))
1646 (max-tags (oref obj max-tags-initial
))
1647 (matchtxt (semantic-completion-text))
1649 ;; Keep a count of the consecutive completion commands entered by the user.
1650 (if (and (stringp (this-command-keys))
1651 (string= (this-command-keys) "\C-i"))
1652 (oset obj typing-count
(1+ (oref obj typing-count
)))
1653 (oset obj typing-count
0))
1656 ;; Switch back to standard mode if user presses key more than 5 times.
1657 (when (>= (oref obj typing-count
) 5)
1658 (oset obj mode
'standard
)
1659 (setq mode
'standard
)
1660 (message "Resetting inline-mode to 'standard'."))
1661 (when (and (> numcompl max-tags
)
1662 (< (oref obj typing-count
) 2))
1663 ;; Discretely hint at completion availability.
1666 ;; Always show extended match set.
1667 (oset obj max-tags semantic-displayor-tooltip-max-tags
)
1668 (setq max-tags semantic-displayor-tooltip-max-tags
)))
1672 ((> numcompl max-tags
)
1673 ;; We have too many items, be brave and truncate 'completions'.
1674 (setcdr (nthcdr (1- max-tags
) completions
) nil
)
1675 (if (= max-tags semantic-displayor-tooltip-initial-max-tags
)
1676 (setq msg-tail
(concat "\n[<TAB> " (number-to-string (- numcompl max-tags
)) " more]"))
1677 (setq msg-tail
(concat "\n[<n/a> " (number-to-string (- numcompl max-tags
)) " more]"))
1678 (when (>= (oref obj typing-count
) 2)
1679 (message "Refine search to display results beyond the '%s' limit"
1680 (symbol-name 'semantic-complete-inline-max-tags-extended
)))))
1682 ;; two possible cases
1683 ;; 1. input text != single match - we found a unique completion!
1684 ;; 2. input text == single match - we found no additional matches, it's just the input text!
1685 (when (string= matchtxt
(semantic-tag-name (car table
)))
1686 (setq msg
"[COMPLETE]\n")))
1688 (oset obj shown nil
)
1689 ;; No matches, say so if in verbose mode!
1690 (when semantic-idle-scheduler-verbose-flag
1691 (setq msg
"[NO MATCH]"))))
1692 ;; Create the tooltip text.
1693 (setq msg
(concat msg
(mapconcat 'identity completions
"\n"))))
1694 ;; Add any tail info.
1695 (setq msg
(concat msg msg-tail
))
1697 (when (not (eq msg
""))
1698 (semantic-displayor-tooltip-show msg
)))))
1703 (if (fboundp 'window-inside-edges
)
1705 (defalias 'semantic-displayor-window-edges
1706 'window-inside-edges
)
1708 (defalias 'semantic-displayor-window-edges
1712 (defun semantic-displayor-point-position ()
1713 "Return the location of POINT as positioned on the selected frame.
1714 Return a cons cell (X . Y)"
1715 (let* ((frame (selected-frame))
1716 (left (or (car-safe (cdr-safe (frame-parameter frame
'left
)))
1717 (frame-parameter frame
'left
)))
1718 (top (or (car-safe (cdr-safe (frame-parameter frame
'top
)))
1719 (frame-parameter frame
'top
)))
1720 (point-pix-pos (posn-x-y (posn-at-point)))
1721 (edges (window-inside-pixel-edges (selected-window))))
1722 (cons (+ (car point-pix-pos
) (car edges
) left
)
1723 (+ (cdr point-pix-pos
) (cadr edges
) top
))))
1726 (defun semantic-displayor-tooltip-show (text)
1727 "Display a tooltip with TEXT near cursor."
1728 (let ((point-pix-pos (semantic-displayor-point-position))
1729 (tooltip-frame-parameters
1730 (append tooltip-frame-parameters nil
)))
1732 (cons 'left
(+ (car point-pix-pos
) (frame-char-width)))
1733 tooltip-frame-parameters
)
1735 (cons 'top
(+ (cdr point-pix-pos
) (frame-char-height)))
1736 tooltip-frame-parameters
)
1737 (tooltip-show text
)))
1739 (defmethod semantic-displayor-scroll-request ((obj semantic-displayor-tooltip
))
1740 "A request to for the displayor to scroll the completion list (if needed)."
1741 ;; Do scrolling in the tooltip.
1742 (oset obj max-tags-initial
30)
1743 (semantic-displayor-show-request obj
)
1746 ;; End code contributed by Masatake YAMATO <jet@gyve.org>
1749 ;;; Ghost Text displayor
1751 (defclass semantic-displayor-ghost
(semantic-displayor-focus-abstract)
1753 ((ghostoverlay :type overlay
1755 "The overlay the ghost text is displayed in.")
1756 (first-show :initform t
1758 "Non nil if we have not seen our first show request.")
1760 "Cycle completions inline with ghost text.
1761 Completion displayor using ghost chars after point for focus options.
1762 Whichever completion is currently in focus will be displayed as ghost
1763 text using overlay options.")
1765 (defmethod semantic-displayor-next-action ((obj semantic-displayor-ghost
))
1766 "The next action to take on the inline completion related to display."
1767 (let ((ans (call-next-method))
1768 (table (when (slot-boundp obj
'table
)
1770 (if (and (eq ans
'displayend
)
1772 (= (semanticdb-find-result-length table
) 1)
1777 (defmethod semantic-displayor-cleanup ((obj semantic-displayor-ghost
))
1778 "Clean up any mess this displayor may have."
1779 (when (slot-boundp obj
'ghostoverlay
)
1780 (semantic-overlay-delete (oref obj ghostoverlay
)))
1783 (defmethod semantic-displayor-set-completions ((obj semantic-displayor-ghost
)
1785 "Set the list of tags to be completed over to TABLE."
1788 (semantic-displayor-cleanup obj
)
1792 (defmethod semantic-displayor-show-request ((obj semantic-displayor-ghost
))
1793 "A request to show the current tags table."
1794 ; (if (oref obj first-show)
1796 ; (oset obj first-show nil)
1797 (semantic-displayor-focus-next obj
)
1798 (semantic-displayor-focus-request obj
)
1800 ;; Only do the traditional thing if the first show request
1801 ;; has been seen. Use the first one to start doing the ghost
1803 ; (call-next-method)
1807 (defmethod semantic-displayor-focus-request
1808 ((obj semantic-displayor-ghost
))
1809 "Focus in on possible tag completions.
1810 Focus is performed by cycling through the tags and showing a possible
1811 completion text in ghost text."
1812 (let* ((tablelength (semanticdb-find-result-length (oref obj table
)))
1813 (focus (semantic-displayor-focus-tag obj
))
1817 (semantic-completion-message "No tags to focus on.")
1818 ;; Display the focus completion as ghost text after the current
1820 (when (or (not (slot-boundp obj
'ghostoverlay
))
1821 (not (semantic-overlay-live-p (oref obj ghostoverlay
))))
1822 (oset obj ghostoverlay
1823 (semantic-make-overlay (point) (1+ (point)) (current-buffer) t
)))
1825 (let* ((lp (semantic-completion-text))
1826 (os (substring (semantic-tag-name tag
) (length lp
)))
1827 (ol (oref obj ghostoverlay
))
1830 (put-text-property 0 (length os
) 'face
'region os
)
1832 (semantic-overlay-put
1833 ol
'display
(concat os
(buffer-substring (point) (1+ (point)))))
1835 ;; Calculate text difference between contents and the focus item.
1836 (let* ((mbc (semantic-completion-text))
1837 (ftn (concat (semantic-tag-name tag
)))
1839 (put-text-property (length mbc
) (length ftn
) 'face
1841 (semantic-completion-message
1842 (format "%s [%d of %d matches]" ftn
(1+ (oref obj focus
)) tablelength
)))
1846 ;;; ------------------------------------------------------------
1847 ;;; Specific queries
1849 (defvar semantic-complete-inline-custom-type
1853 (let* ((C (intern (car class
)))
1854 (doc (documentation-property C
'variable-documentation
))
1855 (doc1 (car (split-string doc
"\n")))
1860 (eieio-build-class-alist semantic-displayor-abstract t
))
1862 "Possible options for inline completion displayors.
1863 Use this to enable custom editing.")
1865 (defcustom semantic-complete-inline-analyzer-displayor-class
1866 'semantic-displayor-traditional
1867 "*Class for displayor to use with inline completion."
1869 :type semantic-complete-inline-custom-type
1872 (defun semantic-complete-read-tag-buffer-deep (prompt &optional
1876 "Ask for a tag by name from the current buffer.
1877 Available tags are from the current buffer, at any level.
1878 Completion options are presented in a traditional way, with highlighting
1879 to resolve same-name collisions.
1880 PROMPT is a string to prompt with.
1881 DEFAULT-TAG is a semantic tag or string to use as the default value.
1882 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1883 HISTORY is a symbol representing a variable to store the history in."
1884 (semantic-complete-read-tag-engine
1885 (semantic-collector-buffer-deep prompt
:buffer
(current-buffer))
1886 (semantic-displayor-traditional-with-focus-highlight "simple")
1887 ;;(semantic-displayor-tooltip "simple")
1894 (defun semantic-complete-read-tag-local-members (prompt &optional
1898 "Ask for a tag by name from the local type members.
1899 Available tags are from the current scope.
1900 Completion options are presented in a traditional way, with highlighting
1901 to resolve same-name collisions.
1902 PROMPT is a string to prompt with.
1903 DEFAULT-TAG is a semantic tag or string to use as the default value.
1904 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1905 HISTORY is a symbol representing a variable to store the history in."
1906 (semantic-complete-read-tag-engine
1907 (semantic-collector-local-members prompt
:buffer
(current-buffer))
1908 (semantic-displayor-traditional-with-focus-highlight "simple")
1909 ;;(semantic-displayor-tooltip "simple")
1916 (defun semantic-complete-read-tag-project (prompt &optional
1920 "Ask for a tag by name from the current project.
1921 Available tags are from the current project, at the top level.
1922 Completion options are presented in a traditional way, with highlighting
1923 to resolve same-name collisions.
1924 PROMPT is a string to prompt with.
1925 DEFAULT-TAG is a semantic tag or string to use as the default value.
1926 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1927 HISTORY is a symbol representing a variable to store the history in."
1928 (semantic-complete-read-tag-engine
1929 (semantic-collector-project-brutish prompt
1930 :buffer
(current-buffer)
1931 :path
(current-buffer)
1933 (semantic-displayor-traditional-with-focus-highlight "simple")
1940 (defun semantic-complete-inline-tag-project ()
1941 "Complete a symbol name by name from within the current project.
1942 This is similar to `semantic-complete-read-tag-project', except
1943 that the completion interaction is in the buffer where the context
1944 was calculated from.
1945 Customize `semantic-complete-inline-analyzer-displayor-class'
1946 to control how completion options are displayed.
1947 See `semantic-complete-inline-tag-engine' for details on how
1949 (let* ((collector (semantic-collector-project-brutish
1951 :buffer
(current-buffer)
1952 :path
(current-buffer)))
1953 (sbounds (semantic-ctxt-current-symbol-and-bounds))
1954 (syms (car sbounds
))
1955 (start (car (nth 2 sbounds
)))
1956 (end (cdr (nth 2 sbounds
)))
1957 (rsym (reverse syms
))
1958 (thissym (nth 1 sbounds
))
1959 (nextsym (car-safe (cdr rsym
)))
1961 (when (and thissym
(or (not (string= thissym
""))
1963 ;; Do a quick calcuation of completions.
1964 (semantic-collector-calculate-completions
1965 collector thissym nil
)
1966 ;; Get the master list
1967 (setq complst
(semanticdb-strip-find-results
1968 (semantic-collector-all-completions collector thissym
)))
1970 (setq complst
(semantic-unique-tag-table-by-name complst
))
1971 (if (or (and (= (length complst
) 1)
1972 ;; Check to see if it is the same as what is there.
1973 ;; if so, we can offer to complete.
1974 (let ((compname (semantic-tag-name (car complst
))))
1975 (not (string= compname thissym
))))
1976 (> (length complst
) 1))
1977 ;; There are several options. Do the completion.
1978 (semantic-complete-inline-tag-engine
1980 (funcall semantic-complete-inline-analyzer-displayor-class
1982 ;;(semantic-displayor-tooltip "simple")
1987 (defun semantic-complete-read-tag-analyzer (prompt &optional
1990 "Ask for a tag by name based on the current context.
1991 The function `semantic-analyze-current-context' is used to
1992 calculate the context. `semantic-analyze-possible-completions' is used
1993 to generate the list of possible completions.
1994 PROMPT is the first part of the prompt. Additional prompt
1995 is added based on the contexts full prefix.
1996 CONTEXT is the semantic analyzer context to start with.
1997 HISTORY is a symbol representing a variable to store the history in.
1998 usually a default-tag and initial-input are available for completion
1999 prompts. these are calculated from the CONTEXT variable passed in."
2000 (if (not context
) (setq context
(semantic-analyze-current-context (point))))
2001 (let* ((syms (semantic-ctxt-current-symbol (point)))
2002 (inp (car (reverse syms
))))
2003 (setq syms
(nreverse (cdr (nreverse syms
))))
2004 (semantic-complete-read-tag-engine
2005 (semantic-collector-analyze-completions
2007 :buffer
(oref context buffer
)
2009 (semantic-displayor-traditional-with-focus-highlight "simple")
2010 (with-current-buffer (oref context buffer
)
2011 (goto-char (cdr (oref context bounds
)))
2012 (concat prompt
(mapconcat 'identity syms
".")
2019 (defun semantic-complete-inline-analyzer (context)
2020 "Complete a symbol name by name based on the current context.
2021 This is similar to `semantic-complete-read-tag-analyze', except
2022 that the completion interaction is in the buffer where the context
2023 was calculated from.
2024 CONTEXT is the semantic analyzer context to start with.
2025 Customize `semantic-complete-inline-analyzer-displayor-class'
2026 to control how completion options are displayed.
2028 See `semantic-complete-inline-tag-engine' for details on how
2030 (if (not context
) (setq context
(semantic-analyze-current-context (point))))
2031 (if (not context
) (error "Nothing to complete on here"))
2032 (let* ((collector (semantic-collector-analyze-completions
2034 :buffer
(oref context buffer
)
2036 (syms (semantic-ctxt-current-symbol (point)))
2037 (rsym (reverse syms
))
2038 (thissym (car rsym
))
2039 (nextsym (car-safe (cdr rsym
)))
2041 (when (and thissym
(or (not (string= thissym
""))
2043 ;; Do a quick calcuation of completions.
2044 (semantic-collector-calculate-completions
2045 collector thissym nil
)
2046 ;; Get the master list
2047 (setq complst
(semanticdb-strip-find-results
2048 (semantic-collector-all-completions collector thissym
)))
2050 (setq complst
(semantic-unique-tag-table-by-name complst
))
2051 (if (or (and (= (length complst
) 1)
2052 ;; Check to see if it is the same as what is there.
2053 ;; if so, we can offer to complete.
2054 (let ((compname (semantic-tag-name (car complst
))))
2055 (not (string= compname thissym
))))
2056 (> (length complst
) 1))
2057 ;; There are several options. Do the completion.
2058 (semantic-complete-inline-tag-engine
2060 (funcall semantic-complete-inline-analyzer-displayor-class
2062 ;;(semantic-displayor-tooltip "simple")
2063 (oref context buffer
)
2064 (car (oref context bounds
))
2065 (cdr (oref context bounds
))
2069 (defcustom semantic-complete-inline-analyzer-idle-displayor-class
2070 'semantic-displayor-ghost
2071 "*Class for displayor to use with inline completion at idle time."
2073 :type semantic-complete-inline-custom-type
2076 (defun semantic-complete-inline-analyzer-idle (context)
2077 "Complete a symbol name by name based on the current context for idle time.
2078 CONTEXT is the semantic analyzer context to start with.
2079 This function is used from `semantic-idle-completions-mode'.
2081 This is the same as `semantic-complete-inline-analyzer', except that
2082 it uses `semantic-complete-inline-analyzer-idle-displayor-class'
2083 to control how completions are displayed.
2085 See `semantic-complete-inline-tag-engine' for details on how
2087 (let ((semantic-complete-inline-analyzer-displayor-class
2088 semantic-complete-inline-analyzer-idle-displayor-class
))
2089 (semantic-complete-inline-analyzer context
)
2094 (defun semantic-complete-jump-local ()
2095 "Jump to a local semantic symbol."
2097 (semantic-error-if-unparsed)
2098 (let ((tag (semantic-complete-read-tag-buffer-deep "Jump to symbol: ")))
2099 (when (semantic-tag-p tag
)
2101 (goto-char (semantic-tag-start tag
))
2102 (semantic-momentary-highlight-tag tag
)
2104 (semantic-tag-class tag
)
2105 (semantic-tag-name tag
)))))
2108 (defun semantic-complete-jump ()
2109 "Jump to a semantic symbol."
2111 (semantic-error-if-unparsed)
2112 (let* ((tag (semantic-complete-read-tag-project "Jump to symbol: ")))
2113 (when (semantic-tag-p tag
)
2115 (semantic-go-to-tag tag
)
2116 (switch-to-buffer (current-buffer))
2117 (semantic-momentary-highlight-tag tag
)
2119 (semantic-tag-class tag
)
2120 (semantic-tag-name tag
)))))
2123 (defun semantic-complete-jump-local-members ()
2124 "Jump to a semantic symbol."
2126 (semantic-error-if-unparsed)
2127 (let* ((tag (semantic-complete-read-tag-local-members "Jump to symbol: ")))
2128 (when (semantic-tag-p tag
)
2129 (let ((start (condition-case nil
(semantic-tag-start tag
)
2132 (error "Tag %s has no location" (semantic-format-tag-prototype tag
)))
2135 (semantic-momentary-highlight-tag tag
)
2137 (semantic-tag-class tag
)
2138 (semantic-tag-name tag
))))))
2141 (defun semantic-complete-analyze-and-replace ()
2142 "Perform prompt completion to do in buffer completion.
2143 `semantic-analyze-possible-completions' is used to determine the
2145 The minibuffer is used to perform the completion.
2146 The result is inserted as a replacement of the text that was there."
2148 (let* ((c (semantic-analyze-current-context (point)))
2149 (tag (save-excursion (semantic-complete-read-tag-analyzer "" c
))))
2150 ;; Take tag, and replace context bound with its name.
2151 (goto-char (car (oref c bounds
)))
2152 (delete-region (point) (cdr (oref c bounds
)))
2153 (insert (semantic-tag-name tag
))
2154 (message "%S" (semantic-format-tag-summarize tag
))))
2157 (defun semantic-complete-analyze-inline ()
2158 "Perform prompt completion to do in buffer completion.
2159 `semantic-analyze-possible-completions' is used to determine the
2161 The function returns immediately, leaving the buffer in a mode that
2162 will perform the completion.
2163 Configure `semantic-complete-inline-analyzer-displayor-class' to change
2164 how completion options are displayed."
2166 ;; Only do this if we are not already completing something.
2167 (if (not (semantic-completion-inline-active-p))
2168 (semantic-complete-inline-analyzer
2169 (semantic-analyze-current-context (point))))
2170 ;; Report a message if things didn't startup.
2171 (if (and (called-interactively-p 'any
)
2172 (not (semantic-completion-inline-active-p)))
2173 (message "Inline completion not needed.")
2174 ;; Since this is most likely bound to something, and not used
2175 ;; at idle time, throw in a TAB for good measure.
2176 (semantic-complete-inline-TAB)))
2179 (defun semantic-complete-analyze-inline-idle ()
2180 "Perform prompt completion to do in buffer completion.
2181 `semantic-analyze-possible-completions' is used to determine the
2183 The function returns immediately, leaving the buffer in a mode that
2184 will perform the completion.
2185 Configure `semantic-complete-inline-analyzer-idle-displayor-class'
2186 to change how completion options are displayed."
2188 ;; Only do this if we are not already completing something.
2189 (if (not (semantic-completion-inline-active-p))
2190 (semantic-complete-inline-analyzer-idle
2191 (semantic-analyze-current-context (point))))
2192 ;; Report a message if things didn't startup.
2193 (if (and (called-interactively-p 'interactive
)
2194 (not (semantic-completion-inline-active-p)))
2195 (message "Inline completion not needed.")))
2198 (defun semantic-complete-self-insert (arg)
2199 "Like `self-insert-command', but does completion afterwards.
2200 ARG is passed to `self-insert-command'. If ARG is nil,
2201 use `semantic-complete-analyze-inline' to complete."
2203 ;; If we are already in a completion scenario, exit now, and then start over.
2204 (semantic-complete-inline-exit)
2207 (self-insert-command arg
)
2209 ;; Prepare for doing completion, but exit quickly if there is keyboard
2211 (when (save-window-excursion
2213 (and (not (semantic-exit-on-input 'csi
2214 (semantic-fetch-tags)
2215 (semantic-throw-on-input 'csi
)
2218 (not (semantic-exit-on-input 'csi
2219 (semantic-analyze-current-context)
2220 (semantic-throw-on-input 'csi
)
2223 (semantic-complete-analyze-inline)
2224 ;; Ignore errors. Seems likely that we'll get some once in a while.
2229 (defun semantic-complete-inline-project ()
2230 "Perform inline completion for any symbol in the current project.
2231 `semantic-analyze-possible-completions' is used to determine the
2233 The function returns immediately, leaving the buffer in a mode that
2234 will perform the completion."
2236 ;; Only do this if we are not already completing something.
2237 (if (not (semantic-completion-inline-active-p))
2238 (semantic-complete-inline-tag-project))
2239 ;; Report a message if things didn't startup.
2240 (if (and (called-interactively-p 'interactive
)
2241 (not (semantic-completion-inline-active-p)))
2242 (message "Inline completion not needed."))
2245 (provide 'semantic
/complete
)
2248 ;; generated-autoload-file: "loaddefs.el"
2249 ;; generated-autoload-load-name: "semantic/complete"
2252 ;;; semantic/complete.el ends here