1 ;;; completion.el --- dynamic word-completion code
3 ;; Copyright (C) 1990, 1993, 1995, 1997 Free Software Foundation, Inc.
6 ;; Keywords: abbrev convenience
7 ;; Author: Jim Salem <alem@bbnplanet.com> of Thinking Machines Inc.
8 ;; (ideas suggested by Brewster Kahle)
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
29 ;; What to put in .emacs
30 ;;-----------------------
31 ;; (load "completion")
32 ;; (initialize-completions)
34 ;;---------------------------------------------------------------------------
35 ;; Documentation [Slightly out of date]
36 ;;---------------------------------------------------------------------------
37 ;; (also check the documentation string of the functions)
42 ;; After you type a few characters, pressing the "complete" key inserts
43 ;; the rest of the word you are likely to type.
45 ;; This watches all the words that you type and remembers them. When
46 ;; typing a new word, pressing "complete" (meta-return) "completes" the
47 ;; word by inserting the most recently used word that begins with the
48 ;; same characters. If you press meta-return repeatedly, it cycles
49 ;; through all the words it knows about.
51 ;; If you like the completion then just continue typing, it is as if you
52 ;; entered the text by hand. If you want the inserted extra characters
53 ;; to go away, type control-w or delete. More options are described below.
55 ;; The guesses are made in the order of the most recently "used". Typing
56 ;; in a word and then typing a separator character (such as a space) "uses"
57 ;; the word. So does moving a cursor over the word. If no words are found,
58 ;; it uses an extended version of the dabbrev style completion.
60 ;; You automatically save the completions you use to a file between
63 ;; Completion enables programmers to enter longer, more descriptive
64 ;; variable names while typing fewer keystrokes than they normally would.
68 ;;---------------------
70 ;; A "word" is any string containing characters with either word or symbol
71 ;; syntax. [E.G. Any alphanumeric string with hyphens, underscores, etc.]
72 ;; Unless you change the constants, you must type at least three characters
73 ;; for the word to be recognized. Only words longer than 6 characters are
76 ;; When you load this file, completion will be on. I suggest you use the
77 ;; compiled version (because it is noticeably faster).
79 ;; M-X completion-mode toggles whether or not new words are added to the
80 ;; database by changing the value of enable-completion.
82 ;; SAVING/LOADING COMPLETIONS
83 ;; Completions are automatically saved from one session to another
84 ;; (unless save-completions-flag or enable-completion is nil).
85 ;; Loading this file (or calling initialize-completions) causes EMACS
86 ;; to load a completions database for a saved completions file
87 ;; (default: ~/.completions). When you exit, EMACS saves a copy of the
88 ;; completions that you
89 ;; often use. When you next start, EMACS loads in the saved completion file.
91 ;; The number of completions saved depends loosely on
92 ;; *saved-completions-decay-factor*. Completions that have never been
93 ;; inserted via "complete" are not saved. You are encouraged to experiment
94 ;; with different functions (see compute-completion-min-num-uses).
96 ;; Some completions are permanent and are always saved out. These
97 ;; completions have their num-uses slot set to T. Use
98 ;; add-permanent-completion to do this
100 ;; Completions are saved only if enable-completion is T. The number of old
101 ;; versions kept of the saved completions file is controlled by
102 ;; completions-file-versions-kept.
104 ;; COMPLETE KEY OPTIONS
105 ;; The complete function takes a numeric arguments.
106 ;; control-u :: leave the point at the beginning of the completion rather
108 ;; a number :: rotate through the possible completions by that amount
109 ;; `-' :: same as -1 (insert previous completion)
111 ;; HOW THE DATABASE IS MAINTAINED
114 ;; UPDATING THE DATABASE MANUALLY
115 ;; m-x kill-completion
116 ;; kills the completion at point.
117 ;; m-x add-completion
118 ;; m-x add-permanent-completion
120 ;; UPDATING THE DATABASE FROM A SOURCE CODE FILE
121 ;; m-x add-completions-from-buffer
122 ;; Parses all the definition names from a C or LISP mode buffer and
123 ;; adds them to the completion database.
125 ;; m-x add-completions-from-lisp-file
126 ;; Parses all the definition names from a C or Lisp mode file and
127 ;; adds them to the completion database.
129 ;; UPDATING THE DATABASE FROM A TAGS TABLE
130 ;; m-x add-completions-from-tags-table
131 ;; Adds completions from the current tags-table-buffer.
133 ;; HOW A COMPLETION IS FOUND
137 ;; Completion is string case independent if case-fold-search has its
138 ;; normal default of T. Also when the completion is inserted the case of the
139 ;; entry is coerced appropriately.
140 ;; [E.G. APP --> APPROPRIATELY app --> appropriately
141 ;; App --> Appropriately]
144 ;; The form `(initialize-completions)' initializes the completion system by
145 ;; trying to load in the user's completions. After the first cal, further
146 ;; calls have no effect so one should be careful not to put the form in a
147 ;; site's standard site-init file.
149 ;;---------------------------------------------------------------------------
153 ;;---------------------------------------------------------------------------
154 ;; Functions you might like to call
155 ;;---------------------------------------------------------------------------
157 ;; add-completion string &optional num-uses
158 ;; Adds a new string to the database
160 ;; add-permanent-completion string
161 ;; Adds a new string to the database with num-uses = T
164 ;; kill-completion string
165 ;; Kills the completion from the database.
167 ;; clear-all-completions
168 ;; Clears the database
170 ;; list-all-completions
171 ;; Returns a list of all completions.
174 ;; next-completion string &optional index
175 ;; Returns a completion entry that starts with string.
177 ;; find-exact-completion string
178 ;; Returns a completion entry that exactly matches string.
181 ;; Inserts a completion at point
183 ;; initialize-completions
184 ;; Loads the completions file and sets up so that exiting emacs will
187 ;; save-completions-to-file &optional filename
188 ;; load-completions-from-file &optional filename
190 ;;-----------------------------------------------
192 ;;-----------------------------------------------
194 ;; get-completion-list string
196 ;; These things are for manipulating the structure
197 ;; make-completion string num-uses
198 ;; completion-num-uses completion
199 ;; completion-string completion
200 ;; set-completion-num-uses completion num-uses
201 ;; set-completion-string completion string
205 ;;-----------------------------------------------
206 ;; To Do :: (anybody ?)
207 ;;-----------------------------------------------
209 ;; Implement Lookup and keyboard interface in C
210 ;; Add package prefix smarts (for Common Lisp)
211 ;; Add autoprompting of possible completions after every keystroke (fast
213 ;; Add doc. to texinfo
216 ;;-----------------------------------------------
218 ;;-----------------------------------------------
219 ;; Sometime in '84 Brewster implemented a somewhat buggy version for
221 ;; Jan. '85 Jim became enamored of the idea and implemented a faster,
222 ;; more robust version.
223 ;; With input from many users at TMC, (rose, craig, and gls come to mind),
224 ;; the current style of interface was developed.
225 ;; 9/87, Jim and Brewster took terminals home. Yuck. After
226 ;; complaining for a while Brewster implemented a subset of the current
227 ;; LISPM version for GNU Emacs.
228 ;; 8/88 After complaining for a while (and with sufficient
229 ;; promised rewards), Jim reimplemented a version of GNU completion
230 ;; superior to that of the LISPM version.
232 ;;-----------------------------------------------
234 ;;-----------------------------------------------
235 ;; Cliff Lasser (cal@think.com), Kevin Herbert (kph@cisco.com),
236 ;; eero@media-lab, kgk@cs.brown.edu, jla@ai.mit.edu,
238 ;;-----------------------------------------------
240 ;;-----------------------------------------------
241 ;; From version 9 to 10
242 ;; - Allowance for non-integral *completion-version* nos.
243 ;; - Fix cmpl-apply-as-top-level for keyboard macros
244 ;; - Fix broken completion merging (in save-completions-to-file)
245 ;; - More misc. fixes for version 19.0 of emacs
247 ;; From Version 8 to 9
248 ;; - Ported to version 19.0 of emacs (backcompatible with version 18)
249 ;; - Added add-completions-from-tags-table (with thanks to eero@media-lab)
251 ;; From Version 7 to 8
252 ;; - Misc. changes to comments
253 ;; - new completion key bindings: c-x o, M->, M-<, c-a, c-e
254 ;; - cdabbrev now checks all the visible window buffers and the "other buffer"
255 ;; - `%' is now a symbol character rather than a separator (except in C mode)
257 ;; From Version 6 to 7
258 ;; - Fixed bug with saving out .completion file the first time
260 ;; From Version 5 to 6
261 ;; - removed statistics recording
262 ;; - reworked advise to handle autoloads
263 ;; - Fixed fortran mode support
264 ;; - Added new cursor motion triggers
266 ;; From Version 4 to 5
267 ;; - doesn't bother saving if nothing has changed
268 ;; - auto-save if haven't used for a 1/2 hour
269 ;; - save period extended to two weeks
270 ;; - minor fix to capitalization code
271 ;; - added *completion-auto-save-period* to variables recorded.
272 ;; - added reenter protection to cmpl-record-statistics-filter
273 ;; - added backup protection to save-completions-to-file (prevents
274 ;; problems with disk full errors)
278 ;;---------------------------------------------------------------------------
279 ;; User changeable parameters
280 ;;---------------------------------------------------------------------------
282 (defgroup completion nil
283 "Dynamic word-completion code."
288 (defcustom enable-completion t
289 "*Non-nil means enable recording and saving of completions.
290 If nil, no new words added to the database or saved to the init file."
294 (defcustom save-completions-flag t
295 "*Non-nil means save most-used completions when exiting Emacs.
296 See also `save-completions-retention-time'."
300 (defcustom save-completions-file-name (convert-standard-filename "~/.completions")
301 "*The filename to save completions to."
305 (defcustom save-completions-retention-time 336
306 "*Discard a completion if unused for this many hours.
307 \(1 day = 24, 1 week = 168). If this is 0, non-permanent completions
308 will not be saved unless these are used. Default is two weeks."
312 (defcustom completion-on-separator-character nil
313 "*Non-nil means separator characters mark previous word as used.
314 This means the word will be saved as a completion."
318 (defcustom completions-file-versions-kept kept-new-versions
319 "*Number of versions to keep for the saved completions file."
323 (defcustom completion-prompt-speed-threshold 4800
324 "*Minimum output speed at which to display next potential completion."
328 (defcustom completion-cdabbrev-prompt-flag nil
329 "*If non-nil, the next completion prompt does a cdabbrev search.
330 This can be time consuming."
334 (defcustom completion-search-distance 15000
335 "*How far to search in the buffer when looking for completions.
336 In number of characters. If nil, search the whole buffer."
340 (defcustom completions-merging-modes '(lisp c)
341 "*List of modes {`c' or `lisp'} for automatic completions merging.
342 Definitions from visited files which have these modes
343 are automatically added to the completion database."
344 :type '(set (const lisp) (const c))
347 ;;(defvar *record-cmpl-statistics-p* nil
348 ;; "*If non-nil, record completion statistics.")
350 ;;(defvar *completion-auto-save-period* 1800
351 ;; "*The period in seconds to wait for emacs to be idle before autosaving
352 ;;the completions. Default is a 1/2 hour.")
354 (defconst completion-min-length nil ;; defined below in eval-when
355 "*The minimum length of a stored completion.
356 DON'T CHANGE WITHOUT RECOMPILING ! This is used by macros.")
358 (defconst completion-max-length nil ;; defined below in eval-when
359 "*The maximum length of a stored completion.
360 DON'T CHANGE WITHOUT RECOMPILING ! This is used by macros.")
362 (defconst completion-prefix-min-length nil ;; defined below in eval-when
363 "The minimum length of a completion search string.
364 DON'T CHANGE WITHOUT RECOMPILING ! This is used by macros.")
366 (defmacro eval-when-compile-load-eval (&rest body)
367 ;; eval everything before expanding
372 (defvar completion-gensym-counter 0)
373 (defun completion-gensym (&optional arg)
374 "Generate a new uninterned symbol.
375 The name is made by appending a number to PREFIX, default \"G\"."
376 (let ((prefix (if (stringp arg) arg "G"))
377 (num (if (integerp arg) arg
378 (prog1 completion-gensym-counter
379 (setq completion-gensym-counter (1+ completion-gensym-counter))))))
380 (make-symbol (format "%s%d" prefix num)))))
382 (defmacro completion-dolist (spec &rest body)
383 "(completion-dolist (VAR LIST [RESULT]) BODY...): loop over a list.
384 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
385 Then evaluate RESULT to get return value, default nil."
386 (let ((temp (completion-gensym "--dolist-temp--")))
387 (append (list 'let (list (list temp (nth 1 spec)) (car spec))
388 (append (list 'while temp
389 (list 'setq (car spec) (list 'car temp)))
390 body (list (list 'setq temp
393 (cons (list 'setq (car spec) nil) (cdr (cdr spec)))
396 (defun completion-eval-when ()
397 (eval-when-compile-load-eval
398 ;; These vars. are defined at both compile and load time.
399 (setq completion-min-length 6)
400 (setq completion-max-length 200)
401 (setq completion-prefix-min-length 3)))
403 (completion-eval-when)
405 ;;---------------------------------------------------------------------------
406 ;; Internal Variables
407 ;;---------------------------------------------------------------------------
409 (defvar cmpl-initialized-p nil
410 "Set to t when the completion system is initialized.
411 Indicates that the old completion file has been read in.")
413 (defvar cmpl-completions-accepted-p nil
414 "Set to t as soon as the first completion has been accepted.
415 Used to decide whether to save completions.")
417 (defvar cmpl-preceding-syntax)
419 (defvar completion-string)
421 ;;---------------------------------------------------------------------------
423 ;;---------------------------------------------------------------------------
425 ;;-----------------------------------------------
427 ;;-----------------------------------------------
429 (defun minibuffer-window-selected-p ()
430 "True iff the current window is the minibuffer."
431 (window-minibuffer-p (selected-window)))
433 ;; This used to be `(eval form)'. Eval FORM at run time now.
434 (defmacro cmpl-read-time-eval (form)
437 ;;-----------------------------------------------
438 ;; String case coercion
439 ;;-----------------------------------------------
441 (defun cmpl-string-case-type (string)
442 "Returns :capitalized, :up, :down, :mixed, or :neither."
443 (let ((case-fold-search nil))
444 (cond ((string-match "[a-z]" string)
445 (cond ((string-match "[A-Z]" string)
446 (cond ((and (> (length string) 1)
447 (null (string-match "[A-Z]" string 1)))
453 (cond ((string-match "[A-Z]" string)
459 ;; (cmpl-string-case-type "123ABCDEF456") --> :up
460 ;; (cmpl-string-case-type "123abcdef456") --> :down
461 ;; (cmpl-string-case-type "123aBcDeF456") --> :mixed
462 ;; (cmpl-string-case-type "123456") --> :neither
463 ;; (cmpl-string-case-type "Abcde123") --> :capitalized
465 (defun cmpl-coerce-string-case (string case-type)
466 (cond ((eq case-type ':down) (downcase string))
467 ((eq case-type ':up) (upcase string))
468 ((eq case-type ':capitalized)
469 (setq string (downcase string))
470 (aset string 0 (logand ?\337 (aref string 0)))
475 (defun cmpl-merge-string-cases (string-to-coerce given-string)
476 (let ((string-case-type (cmpl-string-case-type string-to-coerce))
478 (cond ((memq string-case-type '(:down :up :capitalized))
479 ;; Found string is in a standard case. Coerce to a type based on
481 (cmpl-coerce-string-case string-to-coerce
482 (cmpl-string-case-type given-string))
485 ;; If the found string is in some unusual case, just insert it
491 ;; (cmpl-merge-string-cases "AbCdEf456" "abc") --> AbCdEf456
492 ;; (cmpl-merge-string-cases "abcdef456" "ABC") --> ABCDEF456
493 ;; (cmpl-merge-string-cases "ABCDEF456" "Abc") --> Abcdef456
494 ;; (cmpl-merge-string-cases "ABCDEF456" "abc") --> abcdef456
497 (defun cmpl-hours-since-origin ()
498 (let ((time (current-time)))
499 (floor (+ (* 65536.0 (nth 0 time)) (nth 1 time)) 3600)))
501 ;;---------------------------------------------------------------------------
502 ;; "Symbol" parsing functions
503 ;;---------------------------------------------------------------------------
504 ;; The functions symbol-before-point, symbol-under-point, etc. quickly return
505 ;; an appropriate symbol string. The strategy is to temporarily change
506 ;; the syntax table to enable fast symbol searching. There are three classes
507 ;; of syntax in these "symbol" syntax tables ::
509 ;; syntax (?_) - "symbol" chars (e.g. alphanumerics)
510 ;; syntax (?w) - symbol chars to ignore at end of words (e.g. period).
511 ;; syntax (? ) - everything else
513 ;; Thus by judicious use of scan-sexps and forward-word, we can get
514 ;; the word we want relatively fast and without consing.
516 ;; Why do we need a separate category for "symbol chars to ignore at ends" ?
517 ;; For example, in LISP we want starting :'s trimmed
518 ;; so keyword argument specifiers also define the keyword completion. And,
519 ;; for example, in C we want `.' appearing in a structure ref. to
520 ;; be kept intact in order to store the whole structure ref.; however, if
521 ;; it appears at the end of a symbol it should be discarded because it is
522 ;; probably used as a period.
524 ;; Here is the default completion syntax ::
525 ;; Symbol chars :: A-Z a-z 0-9 @ / \ * + ~ $ < > %
526 ;; Symbol chars to ignore at ends :: _ : . -
527 ;; Separator chars. :: <tab> <space> ! ^ & ( ) = ` | { } [ ] ; " ' #
528 ;; , ? <Everything else>
530 ;; Mode specific differences and notes ::
532 ;; Symbol chars :: ! & ? = ^
535 ;; Separator chars :: + * / : %
536 ;; A note on the hyphen (`-'). Perhaps the hyphen should also be a separator
537 ;; char., however, we wanted to have completion symbols include pointer
538 ;; references. For example, "foo->bar" is a symbol as far as completion is
542 ;; Separator chars :: + - * / :
546 ;; Of course there is no pathname "mode" and in fact we have not implemented
547 ;; this table. However, if there was such a mode, this is what it would look
550 ;;-----------------------------------------------
552 ;;-----------------------------------------------
554 (defun cmpl-make-standard-completion-syntax-table ()
555 (let ((table (make-syntax-table))
557 ;; Default syntax is whitespace.
560 (modify-syntax-entry i " " table)
565 (modify-syntax-entry (+ ?a i) "_" table)
566 (modify-syntax-entry (+ ?A i) "_" table)
571 (modify-syntax-entry (+ ?0 i) "_" table)
574 (let ((symbol-chars '(?@ ?/ ?\\ ?* ?+ ?~ ?$ ?< ?> ?%))
575 (symbol-chars-ignore '(?_ ?- ?: ?.))
577 (completion-dolist (char symbol-chars)
578 (modify-syntax-entry char "_" table))
579 (completion-dolist (char symbol-chars-ignore)
580 (modify-syntax-entry char "w" table)
585 (defconst cmpl-standard-syntax-table (cmpl-make-standard-completion-syntax-table))
587 (defun cmpl-make-lisp-completion-syntax-table ()
588 (let ((table (copy-syntax-table cmpl-standard-syntax-table))
589 (symbol-chars '(?! ?& ?? ?= ?^))
591 (completion-dolist (char symbol-chars)
592 (modify-syntax-entry char "_" table))
595 (defun cmpl-make-c-completion-syntax-table ()
596 (let ((table (copy-syntax-table cmpl-standard-syntax-table))
597 (separator-chars '(?+ ?* ?/ ?: ?%))
599 (completion-dolist (char separator-chars)
600 (modify-syntax-entry char " " table))
603 (defun cmpl-make-fortran-completion-syntax-table ()
604 (let ((table (copy-syntax-table cmpl-standard-syntax-table))
605 (separator-chars '(?+ ?- ?* ?/ ?:))
607 (completion-dolist (char separator-chars)
608 (modify-syntax-entry char " " table))
611 (defconst cmpl-lisp-syntax-table (cmpl-make-lisp-completion-syntax-table))
612 (defconst cmpl-c-syntax-table (cmpl-make-c-completion-syntax-table))
613 (defconst cmpl-fortran-syntax-table (cmpl-make-fortran-completion-syntax-table))
615 (defvar cmpl-syntax-table cmpl-standard-syntax-table
616 "This variable holds the current completion syntax table.")
617 (make-variable-buffer-local 'cmpl-syntax-table)
619 ;;-----------------------------------------------
620 ;; Installing the appropriate mode tables
621 ;;-----------------------------------------------
623 (add-hook 'lisp-mode-hook
625 (setq cmpl-syntax-table cmpl-lisp-syntax-table)))
627 (add-hook 'c-mode-hook
629 (setq cmpl-syntax-table cmpl-c-syntax-table)))
631 (add-hook 'fortran-mode-hook
633 (setq cmpl-syntax-table cmpl-fortran-syntax-table)
634 (completion-setup-fortran-mode)))
636 ;;-----------------------------------------------
638 ;;-----------------------------------------------
639 (defvar cmpl-symbol-start nil
640 "Holds first character of symbol, after any completion symbol function.")
641 (defvar cmpl-symbol-end nil
642 "Holds last character of symbol, after any completion symbol function.")
643 ;; These are temp. vars. we use to avoid using let.
644 ;; Why ? Small speed improvement.
645 (defvar cmpl-saved-syntax nil)
646 (defvar cmpl-saved-point nil)
648 (defun symbol-under-point ()
649 "Returns the symbol that the point is currently on.
650 But only if it is longer than `completion-min-length'."
651 (setq cmpl-saved-syntax (syntax-table))
654 (set-syntax-table cmpl-syntax-table)
656 ;; Cursor is on following-char and after preceding-char
657 ((memq (char-syntax (following-char)) '(?w ?_))
658 (setq cmpl-saved-point (point)
659 cmpl-symbol-start (scan-sexps (1+ cmpl-saved-point) -1)
660 cmpl-symbol-end (scan-sexps cmpl-saved-point 1))
661 ;; Remove chars to ignore at the start.
662 (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
663 (goto-char cmpl-symbol-start)
665 (setq cmpl-symbol-start (point))
666 (goto-char cmpl-saved-point)
668 ;; Remove chars to ignore at the end.
669 (cond ((= (char-syntax (char-after (1- cmpl-symbol-end))) ?w)
670 (goto-char cmpl-symbol-end)
672 (setq cmpl-symbol-end (point))
673 (goto-char cmpl-saved-point)
675 ;; Return completion if the length is reasonable.
676 (if (and (<= (cmpl-read-time-eval completion-min-length)
677 (- cmpl-symbol-end cmpl-symbol-start))
678 (<= (- cmpl-symbol-end cmpl-symbol-start)
679 (cmpl-read-time-eval completion-max-length)))
680 (buffer-substring cmpl-symbol-start cmpl-symbol-end)))))
681 (set-syntax-table cmpl-saved-syntax)))
683 ;; tests for symbol-under-point
684 ;; `^' indicates cursor pos. where value is returned
686 ;; ^^^^^^^^^^^^^^^^ --> simple-word-test
687 ;; _harder_word_test_
688 ;; ^^^^^^^^^^^^^^^^^^ --> harder_word_test
691 ;; /foo/bar/quux.hello
692 ;; ^^^^^^^^^^^^^^^^^^^ --> /foo/bar/quux.hello
695 (defun symbol-before-point ()
696 "Returns a string of the symbol immediately before point.
697 Returns nil if there isn't one longer than `completion-min-length'."
698 ;; This is called when a word separator is typed so it must be FAST !
699 (setq cmpl-saved-syntax (syntax-table))
702 (set-syntax-table cmpl-syntax-table)
703 ;; Cursor is on following-char and after preceding-char
704 (cond ((= (setq cmpl-preceding-syntax (char-syntax (preceding-char))) ?_)
705 ;; Number of chars to ignore at end.
706 (setq cmpl-symbol-end (point)
707 cmpl-symbol-start (scan-sexps cmpl-symbol-end -1)
709 ;; Remove chars to ignore at the start.
710 (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
711 (goto-char cmpl-symbol-start)
713 (setq cmpl-symbol-start (point))
714 (goto-char cmpl-symbol-end)
716 ;; Return value if long enough.
717 (if (>= cmpl-symbol-end
719 (cmpl-read-time-eval completion-min-length)))
720 (buffer-substring cmpl-symbol-start cmpl-symbol-end))
722 ((= cmpl-preceding-syntax ?w)
723 ;; chars to ignore at end
724 (setq cmpl-saved-point (point)
725 cmpl-symbol-start (scan-sexps cmpl-saved-point -1))
726 ;; take off chars. from end
728 (setq cmpl-symbol-end (point))
729 ;; remove chars to ignore at the start
730 (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
731 (goto-char cmpl-symbol-start)
733 (setq cmpl-symbol-start (point))
736 (goto-char cmpl-saved-point)
737 ;; Return completion if the length is reasonable
738 (if (and (<= (cmpl-read-time-eval completion-min-length)
739 (- cmpl-symbol-end cmpl-symbol-start))
740 (<= (- cmpl-symbol-end cmpl-symbol-start)
741 (cmpl-read-time-eval completion-max-length)))
742 (buffer-substring cmpl-symbol-start cmpl-symbol-end)))))
743 (set-syntax-table cmpl-saved-syntax)))
745 ;; tests for symbol-before-point
746 ;; `^' indicates cursor pos. where value is returned
751 ;; ^ --> simple-word-test
752 ;; _harder_word_test_
753 ;; ^ --> harder_word_test
754 ;; ^ --> harder_word_test
759 (defun symbol-under-or-before-point ()
760 ;; This could be made slightly faster but it is better to avoid
761 ;; copying all the code.
762 ;; However, it is only used by the completion string prompter.
763 ;; If it comes into common use, it could be rewritten.
765 (setq cmpl-saved-syntax (syntax-table))
768 (set-syntax-table cmpl-syntax-table)
769 (char-syntax (following-char)))
770 (set-syntax-table cmpl-saved-syntax)))
772 (symbol-under-point))
774 (symbol-before-point))))
777 (defun symbol-before-point-for-complete ()
778 ;; "Returns a string of the symbol immediately before point
779 ;; or nil if there isn't one. Like symbol-before-point but doesn't trim the
781 ;; Cursor is on following-char and after preceding-char
782 (setq cmpl-saved-syntax (syntax-table))
785 (set-syntax-table cmpl-syntax-table)
786 (cond ((memq (setq cmpl-preceding-syntax (char-syntax (preceding-char)))
788 (setq cmpl-symbol-end (point)
789 cmpl-symbol-start (scan-sexps cmpl-symbol-end -1)
791 ;; Remove chars to ignore at the start.
792 (cond ((= (char-syntax (char-after cmpl-symbol-start)) ?w)
793 (goto-char cmpl-symbol-start)
795 (setq cmpl-symbol-start (point))
796 (goto-char cmpl-symbol-end)
798 ;; Return completion if the length is reasonable.
799 (if (and (<= (cmpl-read-time-eval
800 completion-prefix-min-length)
801 (- cmpl-symbol-end cmpl-symbol-start))
802 (<= (- cmpl-symbol-end cmpl-symbol-start)
803 (cmpl-read-time-eval completion-max-length)))
804 (buffer-substring cmpl-symbol-start cmpl-symbol-end)))))
805 ;; Restore syntax table.
806 (set-syntax-table cmpl-saved-syntax)))
808 ;; tests for symbol-before-point-for-complete
809 ;; `^' indicates cursor pos. where value is returned
814 ;; ^ --> simple-word-test
815 ;; _harder_word_test_
816 ;; ^ --> harder_word_test
817 ;; ^ --> harder_word_test_
824 ;;---------------------------------------------------------------------------
825 ;; Statistics Recording
826 ;;---------------------------------------------------------------------------
828 ;; Note that the guts of this has been turned off. The guts
829 ;; are in completion-stats.el.
831 ;;-----------------------------------------------
832 ;; Conditionalizing code on *record-cmpl-statistics-p*
833 ;;-----------------------------------------------
834 ;; All statistics code outside this block should use this
835 (defmacro cmpl-statistics-block (&rest body))
836 ;; "Only executes body if we are recording statistics."
838 ;; (list* '*record-cmpl-statistics-p* body)
841 ;;-----------------------------------------------
842 ;; Completion Sources
843 ;;-----------------------------------------------
846 (defconst cmpl-source-unknown 0)
847 (defconst cmpl-source-init-file 1)
848 (defconst cmpl-source-file-parsing 2)
849 (defconst cmpl-source-separator 3)
850 (defconst cmpl-source-cursor-moves 4)
851 (defconst cmpl-source-interactive 5)
852 (defconst cmpl-source-cdabbrev 6)
853 (defconst num-cmpl-sources 7)
854 (defvar current-completion-source cmpl-source-unknown)
858 ;;---------------------------------------------------------------------------
859 ;; Completion Method #2: dabbrev-expand style
860 ;;---------------------------------------------------------------------------
862 ;; This method is used if there are no useful stored completions. It is
863 ;; based on dabbrev-expand with these differences :
864 ;; 1) Faster (we don't use regexps)
865 ;; 2) case coercion handled correctly
866 ;; This is called cdabbrev to differentiate it.
867 ;; We simply search backwards through the file looking for words which
868 ;; start with the same letters we are trying to complete.
871 (defvar cdabbrev-completions-tried nil)
872 ;; "A list of all the cdabbrev completions since the last reset.")
874 (defvar cdabbrev-current-point 0)
875 ;; "The current point position the cdabbrev search is at.")
877 (defvar cdabbrev-current-window nil)
878 ;; "The current window we are looking for cdabbrevs in. T if looking in
879 ;; (other-buffer), NIL if no more cdabbrevs.")
881 (defvar cdabbrev-wrapped-p nil)
882 ;; "T if the cdabbrev search has wrapped around the file.")
884 (defvar cdabbrev-abbrev-string "")
885 (defvar cdabbrev-start-point 0)
886 (defvar cdabbrev-stop-point)
888 ;; Test strings for cdabbrev
889 ;; cdat-upcase ;;same namestring
893 ;; a-cdat-1 ;;doesn't start correctly
897 (defun reset-cdabbrev (abbrev-string &optional initial-completions-tried)
898 "Resets the cdabbrev search to search for abbrev-string.
899 INITIAL-COMPLETIONS-TRIED is a list of downcased strings to ignore
901 (setq cdabbrev-abbrev-string abbrev-string
902 cdabbrev-completions-tried
903 (cons (downcase abbrev-string) initial-completions-tried)
905 (reset-cdabbrev-window t)
908 (defun set-cdabbrev-buffer ()
909 ;; cdabbrev-current-window must not be NIL
910 (set-buffer (if (eq cdabbrev-current-window t)
912 (window-buffer cdabbrev-current-window)))
916 (defun reset-cdabbrev-window (&optional initializep)
917 "Resets the cdabbrev search to search for abbrev-string."
920 (setq cdabbrev-current-window (selected-window))
922 ((eq cdabbrev-current-window t)
923 ;; Everything has failed
924 (setq cdabbrev-current-window nil))
925 (cdabbrev-current-window
926 (setq cdabbrev-current-window (next-window cdabbrev-current-window))
927 (if (eq cdabbrev-current-window (selected-window))
928 ;; No more windows, try other buffer.
929 (setq cdabbrev-current-window t)))
931 (if cdabbrev-current-window
933 (set-cdabbrev-buffer)
934 (setq cdabbrev-current-point (point)
935 cdabbrev-start-point cdabbrev-current-point
937 (if completion-search-distance
939 (- cdabbrev-start-point completion-search-distance))
941 cdabbrev-wrapped-p nil)
944 (defun next-cdabbrev ()
945 "Return the next possible cdabbrev expansion or nil if there isn't one.
946 `reset-cdabbrev' must've been called already.
947 This is sensitive to `case-fold-search'."
948 ;; note that case-fold-search affects the behavior of this function
949 ;; Bug: won't pick up an expansion that starts at the top of buffer
950 (if cdabbrev-current-window
954 downcase-expansion tried-list syntax saved-point-2)
958 ;; Switch to current completion buffer
959 (set-cdabbrev-buffer)
960 ;; Save current buffer state
961 (setq saved-point (point)
962 saved-syntax (syntax-table))
963 ;; Restore completion state
964 (set-syntax-table cmpl-syntax-table)
965 (goto-char cdabbrev-current-point)
966 ;; Loop looking for completions
968 ;; This code returns t if it should loop again
970 (;; search for the string
971 (search-backward cdabbrev-abbrev-string cdabbrev-stop-point t)
972 ;; return nil if the completion is valid
975 ;; does it start with a separator char ?
976 (or (= (setq syntax (char-syntax (preceding-char))) ? )
978 ;; symbol char to ignore at end. Are we at end ?
980 (setq saved-point-2 (point))
983 (= (char-syntax (preceding-char)) ? )
984 (goto-char saved-point-2)
986 ;; is the symbol long enough ?
987 (setq expansion (symbol-under-point))
988 ;; have we not tried this one before
990 ;; See if we've already used it
991 (setq tried-list cdabbrev-completions-tried
992 downcase-expansion (downcase expansion))
993 (while (and tried-list
994 (not (string-equal downcase-expansion
996 ;; Already tried, don't choose this one
997 (setq tried-list (cdr tried-list))
999 ;; at this point tried-list will be nil if this
1000 ;; expansion has not yet been tried
1002 (setq expansion nil)
1007 ;; If already wrapped, then we've failed completely
1011 (goto-char (setq cdabbrev-current-point
1012 (if completion-search-distance
1013 (min (point-max) (+ cdabbrev-start-point completion-search-distance))
1016 (setq cdabbrev-wrapped-p t))
1018 ;; end of while loop
1021 (setq cdabbrev-completions-tried
1022 (cons downcase-expansion cdabbrev-completions-tried)
1023 cdabbrev-current-point (point))))
1025 (set-syntax-table saved-syntax)
1026 (goto-char saved-point)
1028 ;; If no expansion, go to next window
1030 (t (reset-cdabbrev-window)
1031 (next-cdabbrev))))))
1033 ;; The following must be eval'd in the minibuffer ::
1034 ;; (reset-cdabbrev "cdat")
1035 ;; (next-cdabbrev) --> "cdat-simple"
1036 ;; (next-cdabbrev) --> "cdat-1-2-3-4"
1037 ;; (next-cdabbrev) --> "CDAT-UPCASE"
1038 ;; (next-cdabbrev) --> "cdat-wrapping"
1039 ;; (next-cdabbrev) --> "cdat_start_sym"
1040 ;; (next-cdabbrev) --> nil
1041 ;; (next-cdabbrev) --> nil
1042 ;; (next-cdabbrev) --> nil
1048 ;;---------------------------------------------------------------------------
1049 ;; Completion Database
1050 ;;---------------------------------------------------------------------------
1052 ;; We use two storage modes for the two search types ::
1053 ;; 1) Prefix {cmpl-prefix-obarray} for looking up possible completions
1054 ;; Used by search-completion-next
1055 ;; the value of the symbol is nil or a cons of head and tail pointers
1056 ;; 2) Interning {cmpl-obarray} to see if it's in the database
1057 ;; Used by find-exact-completion, completion-in-database-p
1058 ;; The value of the symbol is the completion entry
1060 ;; bad things may happen if this length is changed due to the way
1061 ;; GNU implements obarrays
1062 (defconst cmpl-obarray-length 511)
1064 (defvar cmpl-prefix-obarray (make-vector cmpl-obarray-length 0)
1065 "An obarray used to store the downcased completion prefixes.
1066 Each symbol is bound to a list of completion entries.")
1068 (defvar cmpl-obarray (make-vector cmpl-obarray-length 0)
1069 "An obarray used to store the downcased completions.
1070 Each symbol is bound to a single completion entry.")
1072 ;;-----------------------------------------------
1073 ;; Completion Entry Structure Definition
1074 ;;-----------------------------------------------
1076 ;; A completion entry is a LIST of string, prefix-symbol num-uses, and
1077 ;; last-use-time (the time the completion was last used)
1078 ;; last-use-time is T if the string should be kept permanently
1079 ;; num-uses is incremented every time the completion is used.
1081 ;; We chose lists because (car foo) is faster than (aref foo 0) and the
1082 ;; creation time is about the same.
1086 (defmacro completion-string (completion-entry)
1087 (list 'car completion-entry))
1089 (defmacro completion-num-uses (completion-entry)
1090 ;; "The number of times it has used. Used to decide whether to save
1092 (list 'car (list 'cdr completion-entry)))
1094 (defmacro completion-last-use-time (completion-entry)
1095 ;; "The time it was last used. In hours since origin. Used to decide
1096 ;; whether to save it. T if one should always save it."
1097 (list 'nth 2 completion-entry))
1099 (defmacro completion-source (completion-entry)
1100 (list 'nth 3 completion-entry))
1103 (defmacro set-completion-string (completion-entry string)
1104 (list 'setcar completion-entry string))
1106 (defmacro set-completion-num-uses (completion-entry num-uses)
1107 (list 'setcar (list 'cdr completion-entry) num-uses))
1109 (defmacro set-completion-last-use-time (completion-entry last-use-time)
1110 (list 'setcar (list 'cdr (list 'cdr completion-entry)) last-use-time))
1113 (defun make-completion (string)
1114 "Returns a list of a completion entry."
1115 (list (list string 0 nil current-completion-source)))
1118 ;;(defmacro cmpl-prefix-entry-symbol (completion-entry)
1119 ;; (list 'car (list 'cdr completion-entry)))
1123 ;;-----------------------------------------------
1124 ;; Prefix symbol entry definition
1125 ;;-----------------------------------------------
1126 ;; A cons of (head . tail)
1130 (defmacro cmpl-prefix-entry-head (prefix-entry)
1131 (list 'car prefix-entry))
1133 (defmacro cmpl-prefix-entry-tail (prefix-entry)
1134 (list 'cdr prefix-entry))
1138 (defmacro set-cmpl-prefix-entry-head (prefix-entry new-head)
1139 (list 'setcar prefix-entry new-head))
1141 (defmacro set-cmpl-prefix-entry-tail (prefix-entry new-tail)
1142 (list 'setcdr prefix-entry new-tail))
1146 (defun make-cmpl-prefix-entry (completion-entry-list)
1147 "Makes a new prefix entry containing only completion-entry."
1148 (cons completion-entry-list completion-entry-list))
1150 ;;-----------------------------------------------
1151 ;; Completion Database - Utilities
1152 ;;-----------------------------------------------
1154 (defun clear-all-completions ()
1155 "Initializes the completion storage. All existing completions are lost."
1157 (setq cmpl-prefix-obarray (make-vector cmpl-obarray-length 0))
1158 (setq cmpl-obarray (make-vector cmpl-obarray-length 0))
1159 (cmpl-statistics-block
1160 (record-clear-all-completions))
1163 (defvar completions-list-return-value)
1165 (defun list-all-completions ()
1166 "Returns a list of all the known completion entries."
1167 (let ((completions-list-return-value nil))
1168 (mapatoms 'list-all-completions-1 cmpl-prefix-obarray)
1169 completions-list-return-value))
1171 (defun list-all-completions-1 (prefix-symbol)
1172 (if (boundp prefix-symbol)
1173 (setq completions-list-return-value
1174 (append (cmpl-prefix-entry-head (symbol-value prefix-symbol))
1175 completions-list-return-value))))
1177 (defun list-all-completions-by-hash-bucket ()
1178 "Return list of lists of known completion entries, organized by hash bucket."
1179 (let ((completions-list-return-value nil))
1180 (mapatoms 'list-all-completions-by-hash-bucket-1 cmpl-prefix-obarray)
1181 completions-list-return-value))
1183 (defun list-all-completions-by-hash-bucket-1 (prefix-symbol)
1184 (if (boundp prefix-symbol)
1185 (setq completions-list-return-value
1186 (cons (cmpl-prefix-entry-head (symbol-value prefix-symbol))
1187 completions-list-return-value))))
1190 ;;-----------------------------------------------
1191 ;; Updating the database
1192 ;;-----------------------------------------------
1194 ;; These are the internal functions used to update the datebase
1197 (defvar completion-to-accept nil)
1198 ;;"Set to a string that is pending its acceptance."
1199 ;; this checked by the top level reading functions
1201 (defvar cmpl-db-downcase-string nil)
1202 ;; "Setup by find-exact-completion, etc. The given string, downcased."
1203 (defvar cmpl-db-symbol nil)
1204 ;; "The interned symbol corresponding to cmpl-db-downcase-string.
1205 ;; Set up by cmpl-db-symbol."
1206 (defvar cmpl-db-prefix-symbol nil)
1207 ;; "The interned prefix symbol corresponding to cmpl-db-downcase-string."
1208 (defvar cmpl-db-entry nil)
1209 (defvar cmpl-db-debug-p nil
1210 "Set to T if you want to debug the database.")
1213 (defun find-exact-completion (string)
1214 "Returns the completion entry for string or nil.
1215 Sets up `cmpl-db-downcase-string' and `cmpl-db-symbol'."
1216 (and (boundp (setq cmpl-db-symbol
1217 (intern (setq cmpl-db-downcase-string (downcase string))
1219 (symbol-value cmpl-db-symbol)
1222 (defun find-cmpl-prefix-entry (prefix-string)
1223 "Returns the prefix entry for string.
1224 Sets `cmpl-db-prefix-symbol'.
1225 Prefix-string must be exactly `completion-prefix-min-length' long
1226 and downcased. Sets up `cmpl-db-prefix-symbol'."
1227 (and (boundp (setq cmpl-db-prefix-symbol
1228 (intern prefix-string cmpl-prefix-obarray)))
1229 (symbol-value cmpl-db-prefix-symbol)))
1231 (defvar inside-locate-completion-entry nil)
1232 ;; used to trap lossage in silent error correction
1234 (defun locate-completion-entry (completion-entry prefix-entry)
1235 "Locates the completion entry.
1236 Returns a pointer to the element before the completion entry or nil if
1237 the completion entry is at the head.
1238 Must be called after `find-exact-completion'."
1239 (let ((prefix-list (cmpl-prefix-entry-head prefix-entry))
1243 ((not (eq (car prefix-list) completion-entry))
1244 ;; not already at head
1245 (while (and prefix-list
1246 (not (eq completion-entry
1247 (car (setq next-prefix-list (cdr prefix-list)))
1249 (setq prefix-list next-prefix-list))
1252 ;; Didn't find it. Database is messed up.
1254 ;; not found, error if debug mode
1255 (error "Completion entry exists but not on prefix list - %s"
1257 (inside-locate-completion-entry
1258 ;; recursive error: really scrod
1259 (locate-completion-db-error))
1262 (set cmpl-db-symbol nil)
1264 (locate-completion-entry-retry completion-entry)
1267 (defun locate-completion-entry-retry (old-entry)
1268 (let ((inside-locate-completion-entry t))
1269 (add-completion (completion-string old-entry)
1270 (completion-num-uses old-entry)
1271 (completion-last-use-time old-entry))
1272 (let* ((cmpl-entry (find-exact-completion (completion-string old-entry)))
1275 (find-cmpl-prefix-entry
1276 (substring cmpl-db-downcase-string
1277 0 completion-prefix-min-length))))
1279 (if (and cmpl-entry pref-entry)
1281 (locate-completion-entry cmpl-entry pref-entry)
1283 (locate-completion-db-error))
1286 (defun locate-completion-db-error ()
1287 ;; recursive error: really scrod
1288 (error "Completion database corrupted. Try M-x clear-all-completions. Send bug report.")
1292 (defun add-completion-to-tail-if-new (string)
1293 "If STRING is not in the database add it to appropriate prefix list.
1294 STRING is added to the end of the appropriate prefix list with
1295 num-uses = 0. The database is unchanged if it is there. STRING must be
1296 longer than `completion-prefix-min-length'.
1297 This must be very fast.
1298 Returns the completion entry."
1299 (or (find-exact-completion string)
1301 (let (;; create an entry
1302 (entry (make-completion string))
1304 (prefix-entry (find-cmpl-prefix-entry
1305 (substring cmpl-db-downcase-string 0
1306 (cmpl-read-time-eval
1307 completion-prefix-min-length))))
1309 ;; The next two forms should happen as a unit (atomically) but
1310 ;; no fatal errors should result if that is not the case.
1312 ;; These two should be atomic, but nothing fatal will happen
1314 (setcdr (cmpl-prefix-entry-tail prefix-entry) entry)
1315 (set-cmpl-prefix-entry-tail prefix-entry entry))
1317 (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))
1320 (cmpl-statistics-block
1321 (note-added-completion))
1323 (set cmpl-db-symbol (car entry))
1326 (defun add-completion-to-head (completion-string)
1327 "If COMPLETION-STRING is not in the database, add it to prefix list.
1328 We add COMPLETION-STRING to the head of the appropriate prefix list,
1329 or it to the head of the list.
1330 COMPLETION-STRING must be longer than `completion-prefix-min-length'.
1331 Updates the saved string with the supplied string.
1332 This must be very fast.
1333 Returns the completion entry."
1334 ;; Handle pending acceptance
1335 (if completion-to-accept (accept-completion))
1336 ;; test if already in database
1337 (if (setq cmpl-db-entry (find-exact-completion completion-string))
1339 (let* ((prefix-entry (find-cmpl-prefix-entry
1340 (substring cmpl-db-downcase-string 0
1341 (cmpl-read-time-eval
1342 completion-prefix-min-length))))
1343 (splice-ptr (locate-completion-entry cmpl-db-entry prefix-entry))
1344 (cmpl-ptr (cdr splice-ptr))
1347 (set-completion-string cmpl-db-entry completion-string)
1348 ;; move to head (if necessary)
1350 ;; These should all execute atomically but it is not fatal if
1353 (or (setcdr splice-ptr (cdr cmpl-ptr))
1354 ;; fix up tail if necessary
1355 (set-cmpl-prefix-entry-tail prefix-entry splice-ptr))
1356 ;; splice in at head
1357 (setcdr cmpl-ptr (cmpl-prefix-entry-head prefix-entry))
1358 (set-cmpl-prefix-entry-head prefix-entry cmpl-ptr)
1362 (let (;; create an entry
1363 (entry (make-completion completion-string))
1365 (prefix-entry (find-cmpl-prefix-entry
1366 (substring cmpl-db-downcase-string 0
1367 (cmpl-read-time-eval
1368 completion-prefix-min-length))))
1371 ;; Splice in at head
1372 (setcdr entry (cmpl-prefix-entry-head prefix-entry))
1373 (set-cmpl-prefix-entry-head prefix-entry entry))
1375 ;; Start new prefix entry
1376 (set cmpl-db-prefix-symbol (make-cmpl-prefix-entry entry))
1379 (cmpl-statistics-block
1380 (note-added-completion))
1381 ;; Add it to the symbol
1382 (set cmpl-db-symbol (car entry))
1385 (defun delete-completion (completion-string)
1386 "Deletes the completion from the database.
1387 String must be longer than `completion-prefix-min-length'."
1388 ;; Handle pending acceptance
1389 (if completion-to-accept (accept-completion))
1390 (if (setq cmpl-db-entry (find-exact-completion completion-string))
1392 (let* ((prefix-entry (find-cmpl-prefix-entry
1393 (substring cmpl-db-downcase-string 0
1394 (cmpl-read-time-eval
1395 completion-prefix-min-length))))
1396 (splice-ptr (locate-completion-entry cmpl-db-entry prefix-entry))
1398 ;; delete symbol reference
1399 (set cmpl-db-symbol nil)
1400 ;; remove from prefix list
1403 (or (setcdr splice-ptr (cdr (cdr splice-ptr)))
1404 ;; fix up tail if necessary
1405 (set-cmpl-prefix-entry-tail prefix-entry splice-ptr))
1409 (or (set-cmpl-prefix-entry-head
1410 prefix-entry (cdr (cmpl-prefix-entry-head prefix-entry)))
1411 ;; List is now empty
1412 (set cmpl-db-prefix-symbol nil))
1414 (cmpl-statistics-block
1415 (note-completion-deleted))
1417 (error "Unknown completion `%s'" completion-string)
1422 ;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1423 ;; (find-exact-completion "banana") --> ("banana" 0 nil 0)
1424 ;; (find-exact-completion "bana") --> nil
1425 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1426 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1427 ;; (add-completion-to-head "banish") --> ("banish" 0 nil 0)
1428 ;; (find-exact-completion "banish") --> ("banish" 0 nil 0)
1429 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1430 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1431 ;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1432 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1433 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1436 ;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1437 ;; (delete-completion "banner")
1438 ;; (find-exact-completion "banner") --> nil
1439 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1440 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1441 ;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1442 ;; (delete-completion "banana")
1443 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banish" ...))
1444 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1445 ;; (delete-completion "banner")
1446 ;; (delete-completion "banish")
1447 ;; (find-cmpl-prefix-entry "ban") --> nil
1448 ;; (delete-completion "banner") --> error
1451 ;; (add-completion-to-tail-if-new "banana") --> ("banana" 0 nil 0)
1452 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1453 ;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1454 ;; (add-completion-to-tail-if-new "banish") --> ("banish" 0 nil 0)
1455 ;; (car (find-cmpl-prefix-entry "ban")) -->(("banana" ...) ("banish" ...))
1456 ;; (cdr (find-cmpl-prefix-entry "ban")) -->(("banish" ...))
1460 ;;---------------------------------------------------------------------------
1461 ;; Database Update :: Interface level routines
1462 ;;---------------------------------------------------------------------------
1464 ;; These lie on top of the database ref. functions but below the standard
1465 ;; user interface level
1468 (defun interactive-completion-string-reader (prompt)
1469 (let* ((default (symbol-under-or-before-point))
1472 (format "%s: (default: %s) " prompt default)
1473 (format "%s: " prompt))
1475 (read (completing-read new-prompt cmpl-obarray))
1477 (if (zerop (length read)) (setq read (or default "")))
1481 (defun check-completion-length (string)
1482 (if (< (length string) completion-min-length)
1483 (error "The string `%s' is too short to be saved as a completion"
1487 (defun add-completion (string &optional num-uses last-use-time)
1488 "Add STRING to completion list, or move it to head of list.
1489 The completion is altered appropriately if num-uses and/or last-use-time is
1491 (interactive (interactive-completion-string-reader "Completion to add"))
1492 (check-completion-length string)
1493 (let* ((current-completion-source (if (interactive-p)
1494 cmpl-source-interactive
1495 current-completion-source))
1496 (entry (add-completion-to-head string)))
1498 (if num-uses (set-completion-num-uses entry num-uses))
1500 (set-completion-last-use-time entry last-use-time))
1503 (defun add-permanent-completion (string)
1504 "Add STRING if it isn't already listed, and mark it permanent."
1506 (interactive-completion-string-reader "Completion to add permanently"))
1507 (let ((current-completion-source (if (interactive-p)
1508 cmpl-source-interactive
1509 current-completion-source))
1511 (add-completion string nil t)
1514 (defun kill-completion (string)
1515 (interactive (interactive-completion-string-reader "Completion to kill"))
1516 (check-completion-length string)
1517 (delete-completion string)
1520 (defun accept-completion ()
1521 "Accepts the pending completion in `completion-to-accept'.
1522 This bumps num-uses. Called by `add-completion-to-head' and
1523 `completion-search-reset'."
1524 (let ((string completion-to-accept)
1525 ;; if this is added afresh here, then it must be a cdabbrev
1526 (current-completion-source cmpl-source-cdabbrev)
1529 (setq completion-to-accept nil)
1530 (setq entry (add-completion-to-head string))
1531 (set-completion-num-uses entry (1+ (completion-num-uses entry)))
1532 (setq cmpl-completions-accepted-p t)
1535 (defun use-completion-under-point ()
1536 "Add the completion symbol underneath the point into the completion buffer."
1537 (let ((string (and enable-completion (symbol-under-point)))
1538 (current-completion-source cmpl-source-cursor-moves))
1539 (if string (add-completion-to-head string))))
1541 (defun use-completion-before-point ()
1542 "Add the completion symbol before point into the completion buffer."
1543 (let ((string (and enable-completion (symbol-before-point)))
1544 (current-completion-source cmpl-source-cursor-moves))
1545 (if string (add-completion-to-head string))))
1547 (defun use-completion-under-or-before-point ()
1548 "Add the completion symbol before point into the completion buffer."
1549 (let ((string (and enable-completion (symbol-under-or-before-point)))
1550 (current-completion-source cmpl-source-cursor-moves))
1551 (if string (add-completion-to-head string))))
1553 (defun use-completion-before-separator ()
1554 "Add the completion symbol before point into the completion buffer.
1555 Completions added this way will automatically be saved if
1556 `completion-on-separator-character' is non-nil."
1557 (let ((string (and enable-completion (symbol-before-point)))
1558 (current-completion-source cmpl-source-separator)
1560 (cmpl-statistics-block
1561 (note-separator-character string)
1564 (setq entry (add-completion-to-head string))
1565 (if (and completion-on-separator-character
1566 (zerop (completion-num-uses entry)))
1568 (set-completion-num-uses entry 1)
1569 (setq cmpl-completions-accepted-p t)))))
1574 ;; (add-completion "banana" 5 10)
1575 ;; (find-exact-completion "banana") --> ("banana" 5 10 0)
1576 ;; (add-completion "banana" 6)
1577 ;; (find-exact-completion "banana") --> ("banana" 6 10 0)
1578 ;; (add-completion "banish")
1579 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1582 ;; (setq completion-to-accept "banana")
1583 ;; (accept-completion)
1584 ;; (find-exact-completion "banana") --> ("banana" 7 10)
1585 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1586 ;; (setq completion-to-accept "banish")
1587 ;; (add-completion "banner")
1588 ;; (car (find-cmpl-prefix-entry "ban"))
1589 ;; --> (("banner" ...) ("banish" 1 ...) ("banana" 7 ...))
1592 ;; (kill-completion "banish")
1593 ;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banana" ...))
1596 ;;---------------------------------------------------------------------------
1597 ;; Searching the database
1598 ;;---------------------------------------------------------------------------
1599 ;; Functions outside this block must call completion-search-reset followed
1600 ;; by calls to completion-search-next or completion-search-peek
1604 ;; Commented out to improve loading speed
1605 (defvar cmpl-test-string "")
1606 ;; "The current string used by completion-search-next."
1607 (defvar cmpl-test-regexp "")
1608 ;; "The current regexp used by completion-search-next.
1609 ;; (derived from cmpl-test-string)"
1610 (defvar cmpl-last-index 0)
1611 ;; "The last index that completion-search-next was called with."
1612 (defvar cmpl-cdabbrev-reset-p nil)
1613 ;; "Set to t when cdabbrevs have been reset."
1614 (defvar cmpl-next-possibilities nil)
1615 ;; "A pointer to the element BEFORE the next set of possible completions.
1616 ;; cadr of this is the cmpl-next-possibility"
1617 (defvar cmpl-starting-possibilities nil)
1618 ;; "The initial list of starting possibilities."
1619 (defvar cmpl-next-possibility nil)
1620 ;; "The cached next possibility."
1621 (defvar cmpl-tried-list nil)
1622 ;; "A downcased list of all the completions we have tried."
1625 (defun completion-search-reset (string)
1626 "Set up the for completion searching for STRING.
1627 STRING must be longer than `completion-prefix-min-length'."
1628 (if completion-to-accept (accept-completion))
1629 (setq cmpl-starting-possibilities
1630 (cmpl-prefix-entry-head
1631 (find-cmpl-prefix-entry
1632 (downcase (substring string 0 completion-prefix-min-length))))
1633 cmpl-test-string string
1634 cmpl-test-regexp (concat (regexp-quote string) "."))
1635 (completion-search-reset-1)
1638 (defun completion-search-reset-1 ()
1639 (setq cmpl-next-possibilities cmpl-starting-possibilities
1640 cmpl-next-possibility nil
1641 cmpl-cdabbrev-reset-p nil
1646 (defun completion-search-next (index)
1647 "Return the next completion entry.
1648 If INDEX is out of sequence, reset and start from the top.
1649 If there are no more entries, try cdabbrev and returns only a string."
1651 ((= index (setq cmpl-last-index (1+ cmpl-last-index)))
1652 (completion-search-peek t))
1654 (completion-search-reset-1)
1655 (setq cmpl-last-index index)
1656 ;; reverse the possibilities list
1657 (setq cmpl-next-possibilities (reverse cmpl-starting-possibilities))
1658 ;; do a "normal" search
1659 (while (and (completion-search-peek nil)
1660 (< (setq index (1+ index)) 0))
1661 (setq cmpl-next-possibility nil)
1663 (cond ((not cmpl-next-possibilities))
1664 ;; If no more possibilities, leave it that way
1665 ((= -1 cmpl-last-index)
1666 ;; next completion is at index 0. reset next-possibility list
1667 ;; to start at beginning
1668 (setq cmpl-next-possibilities cmpl-starting-possibilities))
1670 ;; otherwise point to one before current
1671 (setq cmpl-next-possibilities
1672 (nthcdr (- (length cmpl-starting-possibilities)
1673 (length cmpl-next-possibilities))
1674 cmpl-starting-possibilities))
1677 ;; non-negative index, reset and search
1679 (completion-search-reset-1)
1680 (setq cmpl-last-index index)
1681 (while (and (completion-search-peek t)
1682 (not (< (setq index (1- index)) 0)))
1683 (setq cmpl-next-possibility nil)
1687 cmpl-next-possibility
1688 (setq cmpl-next-possibility nil)
1692 (defun completion-search-peek (use-cdabbrev)
1693 "Returns the next completion entry without actually moving the pointers.
1694 Calling this again or calling `completion-search-next' results in the same
1695 string being returned. Depends on `case-fold-search'.
1696 If there are no more entries, try cdabbrev and then return only a string."
1698 ;; return the cached value if we have it
1699 (cmpl-next-possibility)
1700 ((and cmpl-next-possibilities
1701 ;; still a few possibilities left
1704 (and (not (eq 0 (string-match cmpl-test-regexp
1705 (completion-string (car cmpl-next-possibilities)))))
1706 (setq cmpl-next-possibilities (cdr cmpl-next-possibilities))
1708 cmpl-next-possibilities
1711 (setq cmpl-next-possibility (car cmpl-next-possibilities)
1712 cmpl-tried-list (cons (downcase (completion-string cmpl-next-possibility))
1714 cmpl-next-possibilities (cdr cmpl-next-possibilities)
1716 cmpl-next-possibility)
1718 ;; unsuccessful, use cdabbrev
1719 (cond ((not cmpl-cdabbrev-reset-p)
1720 (reset-cdabbrev cmpl-test-string cmpl-tried-list)
1721 (setq cmpl-cdabbrev-reset-p t)
1723 (setq cmpl-next-possibility (next-cdabbrev))
1725 ;; Completely unsuccessful, return nil
1730 ;; (add-completion "banana")
1731 ;; (completion-search-reset "ban")
1732 ;; (completion-search-next 0) --> "banana"
1734 ;; - Discrimination -
1735 ;; (add-completion "cumberland")
1736 ;; (add-completion "cumberbund")
1738 ;; (completion-search-reset "cumb")
1739 ;; (completion-search-peek t) --> "cumberbund"
1740 ;; (completion-search-next 0) --> "cumberbund"
1741 ;; (completion-search-peek t) --> "cumberland"
1742 ;; (completion-search-next 1) --> "cumberland"
1743 ;; (completion-search-peek nil) --> nil
1744 ;; (completion-search-next 2) --> "cumbering" {cdabbrev}
1745 ;; (completion-search-next 3) --> nil or "cumming"{depends on context}
1746 ;; (completion-search-next 1) --> "cumberland"
1747 ;; (completion-search-peek t) --> "cumbering" {cdabbrev}
1750 ;; (completion-search-next 1) --> "cumberland"
1751 ;; (setq completion-to-accept "cumberland")
1752 ;; (completion-search-reset "foo")
1753 ;; (completion-search-reset "cum")
1754 ;; (completion-search-next 0) --> "cumberland"
1757 ;; (kill-completion "cumberland")
1759 ;; (completion-search-reset "cum")
1760 ;; (completion-search-next 0) --> "cumberbund"
1761 ;; (completion-search-next 1) --> "cummings"
1763 ;; - Ignoring Capitalization -
1764 ;; (completion-search-reset "CuMb")
1765 ;; (completion-search-next 0) --> "cumberbund"
1769 ;;-----------------------------------------------
1771 ;;-----------------------------------------------
1773 (defun completion-mode ()
1774 "Toggles whether or not to add new words to the completion database."
1776 (setq enable-completion (not enable-completion))
1777 (message "Completion mode is now %s." (if enable-completion "ON" "OFF"))
1780 (defvar cmpl-current-index 0)
1781 (defvar cmpl-original-string nil)
1782 (defvar cmpl-last-insert-location -1)
1783 (defvar cmpl-leave-point-at-start nil)
1785 (defun complete (&optional arg)
1786 "Fill out a completion of the word before point.
1787 Point is left at end. Consecutive calls rotate through all possibilities.
1789 control-u :: leave the point at the beginning of the completion rather
1791 a number :: rotate through the possible completions by that amount
1792 `-' :: same as -1 (insert previous completion)
1793 {See the comments at the top of `completion.el' for more info.}"
1795 ;;; Set up variables
1796 (cond ((eq last-command this-command)
1798 (delete-region cmpl-last-insert-location (point))
1799 ;; get next completion
1800 (setq cmpl-current-index (+ cmpl-current-index (or arg 1)))
1803 (if (not cmpl-initialized-p)
1804 (initialize-completions)) ;; make sure everything's loaded
1805 (cond ((consp current-prefix-arg) ;; control-u
1807 (setq cmpl-leave-point-at-start t)
1810 (setq cmpl-leave-point-at-start nil)
1813 (setq cmpl-original-string (symbol-before-point-for-complete))
1814 (cond ((not cmpl-original-string)
1815 (setq this-command 'failed-complete)
1816 (error "To complete, point must be after a symbol at least %d character long"
1817 completion-prefix-min-length)))
1819 (setq cmpl-current-index (if current-prefix-arg arg 0))
1821 (cmpl-statistics-block
1822 (note-complete-entered-afresh cmpl-original-string))
1824 (completion-search-reset cmpl-original-string)
1825 ;; erase what we've got
1826 (delete-region cmpl-symbol-start cmpl-symbol-end)
1829 ;; point is at the point to insert the new symbol
1830 ;; Get the next completion
1831 (let* ((print-status-p
1832 (and (>= baud-rate completion-prompt-speed-threshold)
1833 (not (minibuffer-window-selected-p))))
1834 (insert-point (point))
1835 (entry (completion-search-next cmpl-current-index))
1838 ;; entry is either a completion entry or a string (if cdabbrev)
1842 ;; Setup for proper case
1843 (setq string (if (stringp entry)
1844 entry (completion-string entry)))
1845 (setq string (cmpl-merge-string-cases
1846 string cmpl-original-string))
1850 (setq completion-to-accept string)
1851 ;; fixup and cache point
1852 (cond (cmpl-leave-point-at-start
1853 (setq cmpl-last-insert-location (point))
1854 (goto-char insert-point))
1856 (setq cmpl-last-insert-location insert-point))
1859 (cmpl-statistics-block
1860 (note-complete-inserted entry cmpl-current-index))
1861 ;; Done ! cmpl-stat-complete-successful
1862 ;;display the next completion
1864 ((and print-status-p
1865 ;; This updates the display and only prints if there
1869 (completion-search-peek
1870 completion-cdabbrev-prompt-flag)))
1871 (setq string (if (stringp entry)
1872 entry (completion-string entry)))
1873 (setq string (cmpl-merge-string-cases
1874 string cmpl-original-string))
1875 (message "Next completion: %s" string)
1878 (t;; none found, insert old
1879 (insert cmpl-original-string)
1880 ;; Don't accept completions
1881 (setq completion-to-accept nil)
1883 ;; This used to call cmpl19-sit-for, an undefined function.
1884 ;; I hope that sit-for does the right thing; I don't know -- rms.
1885 (if (and print-status-p (sit-for 0))
1886 (message "No %scompletions."
1887 (if (eq this-command last-command) "more " "")))
1889 (cmpl-statistics-block
1890 (record-complete-failed cmpl-current-index))
1891 ;; Pretend that we were never here
1892 (setq this-command 'failed-complete)
1895 ;;-----------------------------------------------
1896 ;; "Complete" Key Keybindings
1897 ;;-----------------------------------------------
1899 (global-set-key "\M-\r" 'complete)
1900 (global-set-key [?\C-\r] 'complete)
1901 (define-key function-key-map [C-return] [?\C-\r])
1904 ;; (add-completion "cumberland")
1905 ;; (add-completion "cumberbund")
1912 ;;---------------------------------------------------------------------------
1913 ;; Parsing definitions from files into the database
1914 ;;---------------------------------------------------------------------------
1916 ;;-----------------------------------------------
1917 ;; Top Level functions ::
1918 ;;-----------------------------------------------
1921 (defun add-completions-from-file (file)
1922 "Parse possible completions from a file and add them to data base."
1923 (interactive "fFile: ")
1924 (setq file (expand-file-name file))
1925 (let* ((buffer (get-file-buffer file))
1926 (buffer-already-there-p buffer)
1928 (if (not buffer-already-there-p)
1929 (let ((completions-merging-modes nil))
1930 (setq buffer (find-file-noselect file))))
1934 (add-completions-from-buffer)
1936 (if (not buffer-already-there-p)
1937 (kill-buffer buffer)))))
1939 (defun add-completions-from-buffer ()
1941 (let ((current-completion-source cmpl-source-file-parsing)
1943 (cmpl-statistics-block
1944 (aref completion-add-count-vector cmpl-source-file-parsing)))
1947 (cond ((memq major-mode '(emacs-lisp-mode lisp-mode))
1948 (add-completions-from-lisp-buffer)
1951 ((memq major-mode '(c-mode))
1952 (add-completions-from-c-buffer)
1956 (error "Cannot parse completions in %s buffers"
1959 (cmpl-statistics-block
1960 (record-cmpl-parse-file
1962 (- (aref completion-add-count-vector cmpl-source-file-parsing)
1967 (defun cmpl-find-file-hook ()
1968 (cond (enable-completion
1969 (cond ((and (memq major-mode '(emacs-lisp-mode lisp-mode))
1970 (memq 'lisp completions-merging-modes)
1972 (add-completions-from-buffer))
1973 ((and (memq major-mode '(c-mode))
1974 (memq 'c completions-merging-modes)
1976 (add-completions-from-buffer)
1980 (add-hook 'find-file-hooks 'cmpl-find-file-hook)
1982 ;;-----------------------------------------------
1983 ;; Tags Table Completions
1984 ;;-----------------------------------------------
1986 (defun add-completions-from-tags-table ()
1987 ;; Inspired by eero@media-lab.media.mit.edu
1988 "Add completions from the current tags table."
1990 (visit-tags-table-buffer) ;this will prompt if no tags-table
1992 (goto-char (point-min))
1996 (search-forward "\177")
1998 (and (setq string (symbol-under-point))
1999 (add-completion-to-tail-if-new string))
2006 ;;-----------------------------------------------
2007 ;; Lisp File completion parsing
2008 ;;-----------------------------------------------
2009 ;; This merely looks for phrases beginning with (def.... or
2010 ;; (package:def ... and takes the next word.
2012 ;; We tried using forward-lines and explicit searches but the regexp technique
2013 ;; was faster. (About 100K characters per second)
2015 (defconst *lisp-def-regexp*
2016 "\n(\\(\\w*:\\)?def\\(\\w\\|\\s_\\)*\\s +(*"
2017 "A regexp that searches for lisp definition form."
2021 ;; (and (string-match *lisp-def-regexp* "\n(defun foo") (match-end 0)) -> 8
2022 ;; (and (string-match *lisp-def-regexp* "\n(si:def foo") (match-end 0)) -> 9
2023 ;; (and (string-match *lisp-def-regexp* "\n(def-bar foo")(match-end 0)) -> 10
2024 ;; (and (string-match *lisp-def-regexp* "\n(defun (foo") (match-end 0)) -> 9
2026 ;; Parses all the definition names from a Lisp mode buffer and adds them to
2027 ;; the completion database.
2028 (defun add-completions-from-lisp-buffer ()
2030 ;;; Sun-3/280 - 1500 to 3000 lines of lisp code per second
2033 (goto-char (point-min))
2036 (re-search-forward *lisp-def-regexp*)
2037 (and (setq string (symbol-under-point))
2038 (add-completion-to-tail-if-new string))
2044 ;;-----------------------------------------------
2045 ;; C file completion parsing
2046 ;;-----------------------------------------------
2048 ;; Looks for #define or [<storage class>] [<type>] <name>{,<name>}
2049 ;; or structure, array or pointer defs.
2050 ;; It gets most of the definition names.
2052 ;; As you might suspect by now, we use some symbol table hackery
2054 ;; Symbol separator chars (have whitespace syntax) --> , ; * = (
2055 ;; Opening char --> [ {
2056 ;; Closing char --> ] }
2057 ;; opening and closing must be skipped over
2058 ;; Whitespace chars (have symbol syntax)
2059 ;; Everything else has word syntax
2061 (defun cmpl-make-c-def-completion-syntax-table ()
2062 (let ((table (make-syntax-table))
2063 (whitespace-chars '(? ?\n ?\t ?\f ?\v ?\r))
2064 ;; unfortunately the ?( causes the parens to appear unbalanced
2065 (separator-chars '(?, ?* ?= ?\( ?\;
2068 ;; default syntax is whitespace
2071 (modify-syntax-entry i "w" table)
2073 (completion-dolist (char whitespace-chars)
2074 (modify-syntax-entry char "_" table))
2075 (completion-dolist (char separator-chars)
2076 (modify-syntax-entry char " " table))
2077 (modify-syntax-entry ?\[ "(]" table)
2078 (modify-syntax-entry ?\{ "(}" table)
2079 (modify-syntax-entry ?\] ")[" table)
2080 (modify-syntax-entry ?\} "){" table)
2083 (defconst cmpl-c-def-syntax-table (cmpl-make-c-def-completion-syntax-table))
2086 (defconst *c-def-regexp*
2087 ;; This stops on lines with possible definitions
2089 ;; This stops after the symbol to add.
2090 ;;"\n\\(#define\\s +.\\|\\(\\(\\w\\|\\s_\\)+\\b\\s *\\)+[(;,[*{=]\\)"
2091 ;; This stops before the symbol to add. {Test cases in parens. below}
2092 ;;"\n\\(\\(\\w\\|\\s_\\)+\\s *(\\|\\(\\(#define\\|auto\\|extern\\|register\\|static\\|int\\|long\\|short\\|unsigned\\|char\\|void\\|float\\|double\\|enum\\|struct\\|union\\|typedef\\)\\s +\\)+\\)"
2093 ;; this simple version picks up too much extraneous stuff
2094 ;; "\n\\(\\w\\|\\s_\\|#\\)\\B"
2095 "A regexp that searches for a definition form."
2098 ;(defconst *c-cont-regexp*
2099 ; "\\(\\w\\|\\s_\\)+\\b\\s *\\({\\|\\(\\[[0-9\t ]*\\]\\s *\\)*,\\(*\\|\\s \\)*\\b\\)"
2100 ; "This regexp should be used in a looking-at to parse for lists of variables.")
2102 ;(defconst *c-struct-regexp*
2103 ; "\\(*\\|\\s \\)*\\b"
2104 ; "This regexp should be used to test whether a symbol follows a structure definition.")
2106 ;(defun test-c-def-regexp (regexp string)
2107 ; (and (eq 0 (string-match regexp string)) (match-end 0))
2111 ;; (test-c-def-regexp *c-def-regexp* "\n#define foo") -> 10 (9)
2112 ;; (test-c-def-regexp *c-def-regexp* "\nfoo (x, y) {") -> 6 (6)
2113 ;; (test-c-def-regexp *c-def-regexp* "\nint foo (x, y)") -> 10 (5)
2114 ;; (test-c-def-regexp *c-def-regexp* "\n int foo (x, y)") -> nil
2115 ;; (test-c-def-regexp *c-cont-regexp* "oo, bar") -> 4
2116 ;; (test-c-def-regexp *c-cont-regexp* "oo, *bar") -> 5
2117 ;; (test-c-def-regexp *c-cont-regexp* "a [5][6], bar") -> 10
2118 ;; (test-c-def-regexp *c-cont-regexp* "oo(x,y)") -> nil
2119 ;; (test-c-def-regexp *c-cont-regexp* "a [6] ,\t bar") -> 9
2120 ;; (test-c-def-regexp *c-cont-regexp* "oo {trout =1} my_carp;") -> 14
2121 ;; (test-c-def-regexp *c-cont-regexp* "truct_p complex foon") -> nil
2123 ;; Parses all the definition names from a C mode buffer and adds them to the
2124 ;; completion database.
2125 (defun add-completions-from-c-buffer ()
2127 ;; Sun 3/280-- 1250 lines/sec.
2129 (let (string next-point char
2130 (saved-syntax (syntax-table))
2133 (goto-char (point-min))
2134 (catch 'finish-add-completions
2137 ;; we loop here only when scan-sexps fails
2138 ;; (i.e. unbalance exps.)
2139 (set-syntax-table cmpl-c-def-syntax-table)
2142 (re-search-forward *c-def-regexp*)
2144 ((= (preceding-char) ?#)
2145 ;; preprocessor macro, see if it's one we handle
2146 (setq string (buffer-substring (point) (+ (point) 6)))
2147 (cond ((or (string-equal string "define")
2148 (string-equal string "ifdef ")
2150 ;; skip forward over definition symbol
2151 ;; and add it to database
2152 (and (forward-word 2)
2153 (setq string (symbol-before-point))
2155 (add-completion-to-tail-if-new string)
2159 (setq next-point (point))
2162 ;; scan to next separator char.
2163 (setq next-point (scan-sexps next-point 1))
2165 ;; position the point on the word we want to add
2166 (goto-char next-point)
2167 (while (= (setq char (following-char)) ?*)
2168 ;; handle pointer ref
2169 ;; move to next separator char.
2171 (setq next-point (scan-sexps (point) 1)))
2175 (if (setq string (symbol-under-point))
2176 ;; (push string foo)
2177 (add-completion-to-tail-if-new string)
2178 ;; Local TMC hack (useful for parsing paris.h)
2179 (if (and (looking-at "_AP") ;; "ansi prototype"
2183 (symbol-under-point))
2185 (add-completion-to-tail-if-new string)
2189 (goto-char next-point)
2190 ;; (push (format "%c" (following-char)) foo)
2191 (if (= (char-syntax char) ?\()
2192 ;; if on an opening delimiter, go to end
2193 (while (= (char-syntax char) ?\()
2194 (setq next-point (scan-sexps next-point 1)
2195 char (char-after next-point))
2198 ;; Current char is an end char.
2199 (setq next-point nil)
2202 (search-failed ;;done
2203 (throw 'finish-add-completions t)
2206 ;; Check for failure in scan-sexps
2207 (if (or (string-equal (nth 1 e)
2208 "Containing expression ends prematurely")
2209 (string-equal (nth 1 e) "Unbalanced parentheses"))
2210 ;; unbalanced paren., keep going
2213 (message "Error parsing C buffer for completions--please send bug report")
2214 (throw 'finish-add-completions t)
2217 (set-syntax-table saved-syntax)
2221 ;;---------------------------------------------------------------------------
2223 ;;---------------------------------------------------------------------------
2225 ;; The version of save-completions-to-file called at kill-emacs time.
2226 (defun kill-emacs-save-completions ()
2227 (if (and save-completions-flag enable-completion cmpl-initialized-p)
2229 ((not cmpl-completions-accepted-p)
2230 (message "Completions database has not changed - not writing."))
2232 (save-completions-to-file)))))
2234 ;; There is no point bothering to change this again
2235 ;; unless the package changes so much that it matters
2236 ;; for people that have saved completions.
2237 (defconst completion-version "11")
2239 (defconst saved-cmpl-file-header
2240 ";;; Completion Initialization file.
2242 ;; Format is (<string> . <last-use-time>)
2243 ;; <string> is the completion
2244 ;; <last-use-time> is the time the completion was last used
2245 ;; If it is t, the completion will never be pruned from the file.
2246 ;; Otherwise it is in hours since origin.
2249 (defun completion-backup-filename (filename)
2250 (concat filename ".BAK"))
2252 (defun save-completions-to-file (&optional filename)
2253 "Save completions in init file FILENAME.
2254 If file name is not specified, use `save-completions-file-name'."
2256 (setq filename (expand-file-name (or filename save-completions-file-name)))
2257 (if (file-writable-p filename)
2259 (if (not cmpl-initialized-p)
2260 (initialize-completions));; make sure everything's loaded
2261 (message "Saving completions to file %s" filename)
2263 (let* ((delete-old-versions t)
2264 (kept-old-versions 0)
2265 (kept-new-versions completions-file-versions-kept)
2267 (current-time (cmpl-hours-since-origin))
2271 (backup-filename (completion-backup-filename filename))
2275 (get-buffer-create " *completion-save-buffer*")
2276 (set-buffer " *completion-save-buffer*")
2277 (setq buffer-file-name filename)
2279 (if (not (verify-visited-file-modtime (current-buffer)))
2281 ;; file has changed on disk. Bring us up-to-date
2282 (message "Completion file has changed. Merging. . .")
2283 (load-completions-from-file filename t)
2284 (message "Merging finished. Saving completions to file %s" filename)))
2286 ;; prepare the buffer to be modified
2287 (clear-visited-file-modtime)
2290 (insert (format saved-cmpl-file-header completion-version))
2291 (completion-dolist (completion (list-all-completions))
2292 (setq total-in-db (1+ total-in-db))
2293 (setq last-use-time (completion-last-use-time completion))
2294 ;; Update num uses and maybe write completion to a file
2295 (cond ((or;; Write to file if
2297 (and (eq last-use-time t)
2298 (setq total-perm (1+ total-perm)))
2300 (if (> (completion-num-uses completion) 0)
2302 (setq last-use-time current-time)
2303 ;; or it was saved before and
2305 ;; save-completions-retention-time is nil
2306 (or (not save-completions-retention-time)
2307 ;; or time since last use is < ...retention-time*
2308 (< (- current-time last-use-time)
2309 save-completions-retention-time))
2312 (setq total-saved (1+ total-saved))
2313 (insert (prin1-to-string (cons (completion-string completion)
2314 last-use-time)) "\n")
2319 (let ((file-exists-p (file-exists-p filename)))
2322 ;; If file exists . . .
2323 ;; Save a backup(so GNU doesn't screw us when we're out of disk)
2324 ;; (GNU leaves a 0 length file if it gets a disk full error!)
2326 ;; If backup doesn't exit, Rename current to backup
2327 ;; {If backup exists the primary file is probably messed up}
2328 (or (file-exists-p backup-filename)
2329 (rename-file filename backup-filename))
2330 ;; Copy the backup back to the current name
2331 ;; (so versioning works)
2332 (copy-file backup-filename filename t)))
2336 ;; If successful, remove backup
2337 (delete-file backup-filename)))
2339 (set-buffer-modified-p nil)
2340 (message "Couldn't save completion file `%s'" filename)
2342 ;; Reset accepted-p flag
2343 (setq cmpl-completions-accepted-p nil)
2345 (cmpl-statistics-block
2346 (record-save-completions total-in-db total-perm total-saved))
2349 ;;(defun autosave-completions ()
2350 ;; (if (and save-completions-flag enable-completion cmpl-initialized-p
2351 ;; *completion-auto-save-period*
2352 ;; (> cmpl-emacs-idle-time *completion-auto-save-period*)
2353 ;; cmpl-completions-accepted-p)
2354 ;; (save-completions-to-file)))
2356 ;;(add-hook 'cmpl-emacs-idle-time-hooks 'autosave-completions)
2358 (defun load-completions-from-file (&optional filename no-message-p)
2359 "Loads a completion init file FILENAME.
2360 If file is not specified, then use `save-completions-file-name'."
2362 (setq filename (expand-file-name (or filename save-completions-file-name)))
2363 (let* ((backup-filename (completion-backup-filename filename))
2364 (backup-readable-p (file-readable-p backup-filename))
2366 (if backup-readable-p (setq filename backup-filename))
2367 (if (file-readable-p filename)
2369 (if (not no-message-p)
2370 (message "Loading completions from %sfile %s . . ."
2371 (if backup-readable-p "backup " "") filename))
2373 (get-buffer-create " *completion-save-buffer*")
2374 (set-buffer " *completion-save-buffer*")
2375 (setq buffer-file-name filename)
2376 ;; prepare the buffer to be modified
2377 (clear-visited-file-modtime)
2380 (let ((insert-okay-p nil)
2381 (buffer (current-buffer))
2382 (current-time (cmpl-hours-since-origin))
2383 string num-uses entry last-use-time
2384 cmpl-entry cmpl-last-use-time
2385 (current-completion-source cmpl-source-init-file)
2387 (cmpl-statistics-block
2388 (aref completion-add-count-vector cmpl-source-file-parsing)))
2389 (total-in-file 0) (total-perm 0)
2391 ;; insert the file into a buffer
2393 (progn (insert-file-contents filename t)
2394 (setq insert-okay-p t))
2397 (message "File error trying to load completion file %s."
2402 (goto-char (point-min))
2406 (setq entry (read buffer))
2407 (setq total-in-file (1+ total-in-file))
2410 (stringp (setq string (car entry)))
2412 ((eq (setq last-use-time (cdr entry)) 'T)
2413 ;; handle case sensitivity
2414 (setq total-perm (1+ total-perm))
2415 (setq last-use-time t))
2416 ((eq last-use-time t)
2417 (setq total-perm (1+ total-perm)))
2418 ((integerp last-use-time))
2422 (setq cmpl-last-use-time
2423 (completion-last-use-time
2425 (add-completion-to-tail-if-new string))
2427 (if (or (eq last-use-time t)
2428 (and (> last-use-time 1000);;backcompatibility
2429 (not (eq cmpl-last-use-time t))
2430 (or (not cmpl-last-use-time)
2432 (> last-use-time cmpl-last-use-time))
2434 ;; update last-use-time
2435 (set-completion-last-use-time cmpl-entry last-use-time)
2439 (message "Error: invalid saved completion - %s"
2440 (prin1-to-string entry))
2441 ;; try to get back in sync
2442 (search-forward "\n(")
2445 (message "End of file while reading completions.")
2448 (if (= (point) (point-max))
2449 (if (not no-message-p)
2450 (message "Loading completions from file %s . . . Done."
2452 (message "End of file while reading completions.")
2456 (cmpl-statistics-block
2457 (record-load-completions
2458 total-in-file total-perm
2459 (- (aref completion-add-count-vector cmpl-source-init-file)
2464 (defun initialize-completions ()
2465 "Load the default completions file.
2466 Also sets up so that exiting emacs will automatically save the file."
2468 (cond ((not cmpl-initialized-p)
2469 (load-completions-from-file)
2471 (setq cmpl-initialized-p t)
2475 ;;-----------------------------------------------
2477 ;;-----------------------------------------------
2479 (add-hook 'kill-emacs-hook
2481 (kill-emacs-save-completions)
2482 (cmpl-statistics-block
2483 (record-cmpl-kill-emacs))))
2485 ;;-----------------------------------------------
2486 ;; Kill region patch
2487 ;;-----------------------------------------------
2489 (defun completion-kill-region (&optional beg end)
2490 "Kill between point and mark.
2491 The text is deleted but saved in the kill ring.
2492 The command \\[yank] can retrieve it from there.
2493 /(If you want to kill and then yank immediately, use \\[copy-region-as-kill].)
2495 This is the primitive for programs to kill text (as opposed to deleting it).
2496 Supply two arguments, character numbers indicating the stretch of text
2498 Any command that calls this function is a \"kill command\".
2499 If the previous command was also a kill command,
2500 the text killed this time appends to the text killed last time
2501 to make one entry in the kill ring.
2502 Patched to remove the most recent completion."
2504 (cond ((eq last-command 'complete)
2505 (delete-region (point) cmpl-last-insert-location)
2506 (insert cmpl-original-string)
2507 (setq completion-to-accept nil)
2508 (cmpl-statistics-block
2509 (record-complete-failed)))
2511 (kill-region beg end))))
2513 (global-set-key "\C-w" 'completion-kill-region)
2515 ;;-----------------------------------------------
2516 ;; Patches to self-insert-command.
2517 ;;-----------------------------------------------
2519 ;; Need 2 versions: generic separator chars. and space (to get auto fill
2522 ;; All common separators (eg. space "(" ")" """) characters go through a
2523 ;; function to add new words to the list of words to complete from:
2524 ;; COMPLETION-SEPARATOR-SELF-INSERT-COMMAND (arg).
2525 ;; If the character before this was an alpha-numeric then this adds the
2526 ;; symbol before point to the completion list (using ADD-COMPLETION).
2528 (defun completion-separator-self-insert-command (arg)
2530 (use-completion-before-separator)
2531 (self-insert-command arg)
2534 (defun completion-separator-self-insert-autofilling (arg)
2536 (use-completion-before-separator)
2537 (self-insert-command arg)
2538 (and auto-fill-function
2539 (funcall auto-fill-function))
2542 ;;-----------------------------------------------
2544 ;;-----------------------------------------------
2546 ;; Note that because of the way byte compiling works, none of
2547 ;; the functions defined with this macro get byte compiled.
2549 (defmacro def-completion-wrapper (function-name type &optional new-name)
2550 "Add a call to update the completion database before function execution.
2551 TYPE is the type of the wrapper to be added. Can be :before or :under."
2552 (cond ((eq type ':separator)
2553 (list 'put (list 'quote function-name) ''completion-function
2554 ''use-completion-before-separator))
2556 (list 'put (list 'quote function-name) ''completion-function
2557 ''use-completion-before-point))
2558 ((eq type ':backward-under)
2559 (list 'put (list 'quote function-name) ''completion-function
2560 ''use-completion-backward-under))
2561 ((eq type ':backward)
2562 (list 'put (list 'quote function-name) ''completion-function
2563 ''use-completion-backward))
2565 (list 'put (list 'quote function-name) ''completion-function
2566 ''use-completion-under-point))
2567 ((eq type ':under-or-before)
2568 (list 'put (list 'quote function-name) ''completion-function
2569 ''use-completion-under-or-before-point))
2570 ((eq type ':minibuffer-separator)
2571 (list 'put (list 'quote function-name) ''completion-function
2572 ''use-completion-minibuffer-separator))))
2574 (defun use-completion-minibuffer-separator ()
2575 (let ((cmpl-syntax-table cmpl-standard-syntax-table))
2576 (use-completion-before-separator)))
2578 (defun use-completion-backward-under ()
2579 (use-completion-under-point)
2580 (if (eq last-command 'complete)
2581 ;; probably a failed completion if you have to back up
2582 (cmpl-statistics-block (record-complete-failed))))
2584 (defun use-completion-backward ()
2585 (if (eq last-command 'complete)
2586 ;; probably a failed completion if you have to back up
2587 (cmpl-statistics-block (record-complete-failed))))
2589 (defun completion-before-command ()
2590 (funcall (or (and (symbolp this-command)
2591 (get this-command 'completion-function))
2592 'use-completion-under-or-before-point)))
2593 (add-hook 'pre-command-hook 'completion-before-command)
2596 ;;---------------------------------------------------------------------------
2597 ;; Patches to standard keymaps insert completions
2598 ;;---------------------------------------------------------------------------
2600 ;;-----------------------------------------------
2602 ;;-----------------------------------------------
2603 ;; We've used the completion syntax table given as a guide.
2605 ;; Global separator chars.
2606 ;; We left out <tab> because there are too many special cases for it. Also,
2607 ;; in normal coding it's rarely typed after a word.
2608 (global-set-key " " 'completion-separator-self-insert-autofilling)
2609 (global-set-key "!" 'completion-separator-self-insert-command)
2610 (global-set-key "%" 'completion-separator-self-insert-command)
2611 (global-set-key "^" 'completion-separator-self-insert-command)
2612 (global-set-key "&" 'completion-separator-self-insert-command)
2613 (global-set-key "(" 'completion-separator-self-insert-command)
2614 (global-set-key ")" 'completion-separator-self-insert-command)
2615 (global-set-key "=" 'completion-separator-self-insert-command)
2616 (global-set-key "`" 'completion-separator-self-insert-command)
2617 (global-set-key "|" 'completion-separator-self-insert-command)
2618 (global-set-key "{" 'completion-separator-self-insert-command)
2619 (global-set-key "}" 'completion-separator-self-insert-command)
2620 (global-set-key "[" 'completion-separator-self-insert-command)
2621 (global-set-key "]" 'completion-separator-self-insert-command)
2622 (global-set-key ";" 'completion-separator-self-insert-command)
2623 (global-set-key "\"" 'completion-separator-self-insert-command)
2624 (global-set-key "'" 'completion-separator-self-insert-command)
2625 (global-set-key "#" 'completion-separator-self-insert-command)
2626 (global-set-key "," 'completion-separator-self-insert-command)
2627 (global-set-key "?" 'completion-separator-self-insert-command)
2629 ;; We include period and colon even though they are symbol chars because :
2630 ;; - in text we want to pick up the last word in a sentence.
2631 ;; - in C pointer refs. we want to pick up the first symbol
2632 ;; - it won't make a difference for lisp mode (package names are short)
2633 (global-set-key "." 'completion-separator-self-insert-command)
2634 (global-set-key ":" 'completion-separator-self-insert-command)
2637 (define-key lisp-mode-map "!" 'self-insert-command)
2638 (define-key lisp-mode-map "&" 'self-insert-command)
2639 (define-key lisp-mode-map "%" 'self-insert-command)
2640 (define-key lisp-mode-map "?" 'self-insert-command)
2641 (define-key lisp-mode-map "=" 'self-insert-command)
2642 (define-key lisp-mode-map "^" 'self-insert-command)
2646 (defvar fortran-mode-map)
2649 (defun completion-c-mode-hook ()
2650 (def-completion-wrapper electric-c-semi :separator)
2651 (define-key c-mode-map "+" 'completion-separator-self-insert-command)
2652 (define-key c-mode-map "*" 'completion-separator-self-insert-command)
2653 (define-key c-mode-map "/" 'completion-separator-self-insert-command))
2654 ;; Do this either now or whenever C mode is loaded.
2655 (if (featurep 'cc-mode)
2656 (completion-c-mode-hook)
2657 (add-hook 'c-mode-hook 'completion-c-mode-hook))
2659 ;; FORTRAN mode diffs. (these are defined when fortran is called)
2660 (defun completion-setup-fortran-mode ()
2661 (define-key fortran-mode-map "+" 'completion-separator-self-insert-command)
2662 (define-key fortran-mode-map "-" 'completion-separator-self-insert-command)
2663 (define-key fortran-mode-map "*" 'completion-separator-self-insert-command)
2664 (define-key fortran-mode-map "/" 'completion-separator-self-insert-command)
2667 ;;-----------------------------------------------
2668 ;; End of line chars.
2669 ;;-----------------------------------------------
2670 (def-completion-wrapper newline :separator)
2671 (def-completion-wrapper newline-and-indent :separator)
2672 (def-completion-wrapper comint-send-input :separator)
2673 (def-completion-wrapper exit-minibuffer :minibuffer-separator)
2674 (def-completion-wrapper eval-print-last-sexp :separator)
2675 (def-completion-wrapper eval-last-sexp :separator)
2676 ;;(def-completion-wrapper minibuffer-complete-and-exit :minibuffer)
2678 ;;-----------------------------------------------
2680 ;;-----------------------------------------------
2682 (def-completion-wrapper next-line :under-or-before)
2683 (def-completion-wrapper previous-line :under-or-before)
2684 (def-completion-wrapper beginning-of-buffer :under-or-before)
2685 (def-completion-wrapper end-of-buffer :under-or-before)
2686 (def-completion-wrapper beginning-of-line :under-or-before)
2687 (def-completion-wrapper end-of-line :under-or-before)
2688 (def-completion-wrapper forward-char :under-or-before)
2689 (def-completion-wrapper forward-word :under-or-before)
2690 (def-completion-wrapper forward-sexp :under-or-before)
2691 (def-completion-wrapper backward-char :backward-under)
2692 (def-completion-wrapper backward-word :backward-under)
2693 (def-completion-wrapper backward-sexp :backward-under)
2695 (def-completion-wrapper delete-backward-char :backward)
2696 (def-completion-wrapper delete-backward-char-untabify :backward)
2704 (cmpl-statistics-block
2705 (record-completion-file-loaded))
2707 (provide 'completion)
2709 ;;; completion.el ends here