| blob | 2c304c15013c9552ce7094533d8510b2bad5be00 |
1 ;;; completion.el --- dynamic word-completion code
2 ;; Copyright (C) 1990, 1993, 1995 Free Software Foundation, Inc.
4 ;; Maintainer: FSF
5 ;; Keywords: abbrev
6 ;; Author: Jim Salem <salem@think.com> of Thinking Machines Inc.
7 ;; (ideas suggested by Brewster Kahle)
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software; you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation; either version 2, or (at your option)
14 ;; any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs; see the file COPYING. If not, write to
23 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
25 ;;; Commentary:
26 ;;;
27 ;;; What to put in .emacs
28 ;;;-----------------------
29 ;;; (load "completion")
30 ;;; (initialize-completions)
31 \f
32 ;;;---------------------------------------------------------------------------
33 ;;; Documentation [Slightly out of date]
34 ;;;---------------------------------------------------------------------------
35 ;;; (also check the documentation string of the functions)
36 ;;;
37 ;;; Introduction
38 ;;;---------------
39 ;;;
40 ;;; After you type a few characters, pressing the "complete" key inserts
41 ;;; the rest of the word you are likely to type.
42 ;;;
43 ;;; This watches all the words that you type and remembers them. When
44 ;;; typing a new word, pressing "complete" (meta-return) "completes" the
45 ;;; word by inserting the most recently used word that begins with the
46 ;;; same characters. If you press meta-return repeatedly, it cycles
47 ;;; through all the words it knows about.
48 ;;;
49 ;;; If you like the completion then just continue typing, it is as if you
50 ;;; entered the text by hand. If you want the inserted extra characters
51 ;;; to go away, type control-w or delete. More options are described below.
52 ;;;
53 ;;; The guesses are made in the order of the most recently "used". Typing
54 ;;; in a word and then typing a separator character (such as a space) "uses"
55 ;;; the word. So does moving a cursor over the word. If no words are found,
56 ;;; it uses an extended version of the dabbrev style completion.
57 ;;;
58 ;;; You automatically save the completions you use to a file between
59 ;;; sessions.
60 ;;;
61 ;;; Completion enables programmers to enter longer, more descriptive
62 ;;; variable names while typing fewer keystrokes than they normally would.
63 ;;;
64 ;;;
65 ;;; Full documentation
66 ;;;---------------------
67 ;;;
68 ;;; A "word" is any string containing characters with either word or symbol
69 ;;; syntax. [E.G. Any alphanumeric string with hyphens, underscores, etc.]
70 ;;; Unless you change the constants, you must type at least three characters
71 ;;; for the word to be recognized. Only words longer than 6 characters are
72 ;;; saved.
73 ;;;
74 ;;; When you load this file, completion will be on. I suggest you use the
75 ;;; compiled version (because it is noticeably faster).
76 ;;;
77 ;;; M-X completion-mode toggles whether or not new words are added to the
78 ;;; database by changing the value of enable-completion.
79 ;;;
80 ;;; SAVING/LOADING COMPLETIONS
81 ;;; Completions are automatically saved from one session to another
82 ;;; (unless save-completions-flag or enable-completion is nil).
83 ;;; Loading this file (or calling initialize-completions) causes EMACS
84 ;;; to load a completions database for a saved completions file
85 ;;; (default: ~/.completions). When you exit, EMACS saves a copy of the
86 ;;; completions that you
87 ;;; often use. When you next start, EMACS loads in the saved completion file.
88 ;;;
89 ;;; The number of completions saved depends loosely on
90 ;;; *saved-completions-decay-factor*. Completions that have never been
91 ;;; inserted via "complete" are not saved. You are encouraged to experiment
92 ;;; with different functions (see compute-completion-min-num-uses).
93 ;;;
94 ;;; Some completions are permanent and are always saved out. These
95 ;;; completions have their num-uses slot set to T. Use
96 ;;; add-permanent-completion to do this
97 ;;;
98 ;;; Completions are saved only if enable-completion is T. The number of old
99 ;;; versions kept of the saved completions file is controlled by
100 ;;; completions-file-versions-kept.
101 ;;;
102 ;;; COMPLETE KEY OPTIONS
103 ;;; The complete function takes a numeric arguments.
104 ;;; control-u :: leave the point at the beginning of the completion rather
105 ;;; than the middle.
106 ;;; a number :: rotate through the possible completions by that amount
107 ;;; `-' :: same as -1 (insert previous completion)
108 ;;;
109 ;;; HOW THE DATABASE IS MAINTAINED
110 ;;; <write>
111 ;;;
112 ;;; UPDATING THE DATABASE MANUALLY
113 ;;; m-x kill-completion
114 ;;; kills the completion at point.
115 ;;; m-x add-completion
116 ;;; m-x add-permanent-completion
117 ;;;
118 ;;; UPDATING THE DATABASE FROM A SOURCE CODE FILE
119 ;;; m-x add-completions-from-buffer
120 ;;; Parses all the definition names from a C or LISP mode buffer and
121 ;;; adds them to the completion database.
122 ;;;
123 ;;; m-x add-completions-from-lisp-file
124 ;;; Parses all the definition names from a C or Lisp mode file and
125 ;;; adds them to the completion database.
126 ;;;
127 ;;; UPDATING THE DATABASE FROM A TAGS TABLE
128 ;;; m-x add-completions-from-tags-table
129 ;;; Adds completions from the current tags-table-buffer.
130 ;;;
131 ;;; HOW A COMPLETION IS FOUND
132 ;;; <write>
133 ;;;
134 ;;; STRING CASING
135 ;;; Completion is string case independent if case-fold-search has its
136 ;;; normal default of T. Also when the completion is inserted the case of the
137 ;;; entry is coerced appropriately.
138 ;;; [E.G. APP --> APPROPRIATELY app --> appropriately
139 ;;; App --> Appropriately]
140 ;;;
141 ;;; INITIALIZATION
142 ;;; The form `(initialize-completions)' initializes the completion system by
143 ;;; trying to load in the user's completions. After the first cal, further
144 ;;; calls have no effect so one should be careful not to put the form in a
145 ;;; site's standard site-init file.
146 ;;;
147 ;;;---------------------------------------------------------------------------
148 ;;;
149 ;;;
150 \f
151 ;;;---------------------------------------------------------------------------
152 ;;; Functions you might like to call
153 ;;;---------------------------------------------------------------------------
154 ;;;
155 ;;; add-completion string &optional num-uses
156 ;;; Adds a new string to the database
157 ;;;
158 ;;; add-permanent-completion string
159 ;;; Adds a new string to the database with num-uses = T
160 ;;;
162 ;;; kill-completion string
163 ;;; Kills the completion from the database.
164 ;;;
165 ;;; clear-all-completions
166 ;;; Clears the database
167 ;;;
168 ;;; list-all-completions
169 ;;; Returns a list of all completions.
170 ;;;
171 ;;;
172 ;;; next-completion string &optional index
173 ;;; Returns a completion entry that starts with string.
174 ;;;
175 ;;; find-exact-completion string
176 ;;; Returns a completion entry that exactly matches string.
177 ;;;
178 ;;; complete
179 ;;; Inserts a completion at point
180 ;;;
181 ;;; initialize-completions
182 ;;; Loads the completions file and sets up so that exiting emacs will
183 ;;; save them.
184 ;;;
185 ;;; save-completions-to-file &optional filename
186 ;;; load-completions-from-file &optional filename
187 ;;;
188 ;;;-----------------------------------------------
189 ;;; Other functions
190 ;;;-----------------------------------------------
191 ;;;
192 ;;; get-completion-list string
193 ;;;
194 ;;; These things are for manipulating the structure
195 ;;; make-completion string num-uses
196 ;;; completion-num-uses completion
197 ;;; completion-string completion
198 ;;; set-completion-num-uses completion num-uses
199 ;;; set-completion-string completion string
200 ;;;
201 ;;;
202 \f
203 ;;;-----------------------------------------------
204 ;;; To Do :: (anybody ?)
205 ;;;-----------------------------------------------
206 ;;;
207 ;;; Implement Lookup and keyboard interface in C
208 ;;; Add package prefix smarts (for Common Lisp)
209 ;;; Add autoprompting of possible completions after every keystroke (fast
210 ;;; terminals only !)
211 ;;; Add doc. to texinfo
212 ;;;
213 ;;;
214 ;;;-----------------------------------------------
215 ;;; Change Log:
216 ;;;-----------------------------------------------
217 ;;; Sometime in '84 Brewster implemented a somewhat buggy version for
218 ;;; Symbolics LISPMs.
219 ;;; Jan. '85 Jim became enamored of the idea and implemented a faster,
220 ;;; more robust version.
221 ;;; With input from many users at TMC, (rose, craig, and gls come to mind),
222 ;;; the current style of interface was developed.
223 ;;; 9/87, Jim and Brewster took terminals home. Yuck. After
224 ;;; complaining for a while Brewester implemented a subset of the current
225 ;;; LISPM version for GNU Emacs.
226 ;;; 8/88 After complaining for a while (and with sufficient
227 ;;; promised rewards), Jim reimplemented a version of GNU completion
228 ;;; superior to that of the LISPM version.
229 ;;;
230 ;;;-----------------------------------------------
231 ;;; Acknowledgements
232 ;;;-----------------------------------------------
233 ;;; Cliff Lasser (cal@think.com), Kevin Herbert (kph@cisco.com),
234 ;;; eero@media-lab, kgk@cs.brown.edu, jla@ai.mit.edu,
235 ;;;
236 ;;;-----------------------------------------------
237 ;;; Change Log
238 ;;;-----------------------------------------------
239 ;;; From version 9 to 10
240 ;;; - Allowance for non-integral *completion-version* nos.
241 ;;; - Fix cmpl-apply-as-top-level for keyboard macros
242 ;;; - Fix broken completion merging (in save-completions-to-file)
243 ;;; - More misc. fixes for version 19.0 of emacs
244 ;;;
245 ;;; From Version 8 to 9
246 ;;; - Ported to version 19.0 of emacs (backcompatible with version 18)
247 ;;; - Added add-completions-from-tags-table (with thanks to eero@media-lab)
248 ;;;
249 ;;; From Version 7 to 8
250 ;;; - Misc. changes to comments
251 ;;; - new completion key bindings: c-x o, M->, M-<, c-a, c-e
252 ;;; - cdabbrev now checks all the visible window buffers and the "other buffer"
253 ;;; - `%' is now a symbol character rather than a separator (except in C mode)
254 ;;;
255 ;;; From Version 6 to 7
256 ;;; - Fixed bug with saving out .completion file the first time
257 ;;;
258 ;;; From Version 5 to 6
259 ;;; - removed statistics recording
260 ;;; - reworked advise to handle autoloads
261 ;;; - Fixed fortran mode support
262 ;;; - Added new cursor motion triggers
263 ;;;
264 ;;; From Version 4 to 5
265 ;;; - doesn't bother saving if nothing has changed
266 ;;; - auto-save if haven't used for a 1/2 hour
267 ;;; - save period extended to two weeks
268 ;;; - minor fix to capitalization code
269 ;;; - added *completion-auto-save-period* to variables recorded.
270 ;;; - added reenter protection to cmpl-record-statistics-filter
271 ;;; - added backup protection to save-completions-to-file (prevents
272 ;;; problems with disk full errors)
273 \f
274 ;;; Code:
276 ;;;---------------------------------------------------------------------------
277 ;;; User changeable parameters
278 ;;;---------------------------------------------------------------------------
281 "*Non-nil means enable recording and saving of completions.
285 "*Non-nil means save most-used completions when exiting Emacs.
292 "*Discard a completion if unused for this many hours.
293 \(1 day = 24, 1 week = 168). If this is 0, non-permanent completions
297 "*Non-nil means separator characters mark previous word as used.
307 "*If non-nil, the next completion prompt does a cdabbrev search.
311 "*How far to search in the buffer when looking for completions.
315 "*List of modes {`c' or `lisp'} for automatic completions merging.
316 Definitions from visited files which have these modes
319 ;;;(defvar *record-cmpl-statistics-p* nil
320 ;;; "*If non-nil, record completion statistics.")
322 ;;;(defvar *completion-auto-save-period* 1800
323 ;;; "*The period in seconds to wait for emacs to be idle before autosaving
324 ;;;the completions. Default is a 1/2 hour.")
327 "*The minimum length of a stored completion.
331 "*The maximum length of a stored completion.
335 "The minimum length of a completion search string.
339 ;; eval everything before expanding
346 "Generate a new uninterned symbol.
355 "(completion-dolist (VAR LIST [RESULT]) BODY...): loop over a list.
356 Evaluate BODY with VAR bound to each `car' from LIST, in turn.
357 Then evaluate RESULT to get return value, default nil."
370 ;; These vars. are defined at both compile and load time.
377 ;;;---------------------------------------------------------------------------
378 ;;; Internal Variables
379 ;;;---------------------------------------------------------------------------
382 "Set to t when the completion system is initialized.
386 "Set to t as soon as the first completion has been accepted.
392 \f
393 ;;;---------------------------------------------------------------------------
394 ;;; Low level tools
395 ;;;---------------------------------------------------------------------------
397 ;;;-----------------------------------------------
398 ;;; Misc.
399 ;;;-----------------------------------------------
402 "True iff the current window is the minibuffer."
405 ;; This used to be `(eval form)'. Eval FORM at run time now.
407 form)
409 ;;;-----------------------------------------------
410 ;;; String case coercion
411 ;;;-----------------------------------------------
414 "Returns :capitalized, :up, :down, :mixed, or :neither."
428 ))
430 ;;; Tests -
431 ;;; (cmpl-string-case-type "123ABCDEF456") --> :up
432 ;;; (cmpl-string-case-type "123abcdef456") --> :down
433 ;;; (cmpl-string-case-type "123aBcDeF456") --> :mixed
434 ;;; (cmpl-string-case-type "123456") --> :neither
435 ;;; (cmpl-string-case-type "Abcde123") --> :capitalized
443 string)
445 ))
449 )
451 ;; Found string is in a standard case. Coerce to a type based on
452 ;; the given string
455 )
457 ;; If the found string is in some unusual case, just insert it
458 ;; as is
459 string-to-coerce)
460 )))
462 ;;; Tests -
463 ;;; (cmpl-merge-string-cases "AbCdEf456" "abc") --> AbCdEf456
464 ;;; (cmpl-merge-string-cases "abcdef456" "ABC") --> ABCDEF456
465 ;;; (cmpl-merge-string-cases "ABCDEF456" "Abc") --> Abcdef456
466 ;;; (cmpl-merge-string-cases "ABCDEF456" "abc") --> abcdef456
468 \f
474 \f
475 ;;;---------------------------------------------------------------------------
476 ;;; "Symbol" parsing functions
477 ;;;---------------------------------------------------------------------------
478 ;;; The functions symbol-before-point, symbol-under-point, etc. quickly return
479 ;;; an appropriate symbol string. The strategy is to temporarily change
480 ;;; the syntax table to enable fast symbol searching. There are three classes
481 ;;; of syntax in these "symbol" syntax tables ::
482 ;;;
483 ;;; syntax (?_) - "symbol" chars (e.g. alphanumerics)
484 ;;; syntax (?w) - symbol chars to ignore at end of words (e.g. period).
485 ;;; syntax (? ) - everything else
486 ;;;
487 ;;; Thus by judicious use of scan-sexps and forward-word, we can get
488 ;;; the word we want relatively fast and without consing.
489 ;;;
490 ;;; Why do we need a separate category for "symbol chars to ignore at ends" ?
491 ;;; For example, in LISP we want starting :'s trimmed
492 ;;; so keyword argument specifiers also define the keyword completion. And,
493 ;;; for example, in C we want `.' appearing in a structure ref. to
494 ;;; be kept intact in order to store the whole structure ref.; however, if
495 ;;; it appears at the end of a symbol it should be discarded because it is
496 ;;; probably used as a period.
498 ;;; Here is the default completion syntax ::
499 ;;; Symbol chars :: A-Z a-z 0-9 @ / \ * + ~ $ < > %
500 ;;; Symbol chars to ignore at ends :: _ : . -
501 ;;; Separator chars. :: <tab> <space> ! ^ & ( ) = ` | { } [ ] ; " ' #
502 ;;; , ? <Everything else>
504 ;;; Mode specific differences and notes ::
505 ;;; LISP diffs ->
506 ;;; Symbol chars :: ! & ? = ^
507 ;;;
508 ;;; C diffs ->
509 ;;; Separator chars :: + * / : %
510 ;;; A note on the hyphen (`-'). Perhaps the hyphen should also be a separator
511 ;;; char., however, we wanted to have completion symbols include pointer
512 ;;; references. For example, "foo->bar" is a symbol as far as completion is
513 ;;; concerned.
514 ;;;
515 ;;; FORTRAN diffs ->
516 ;;; Separator chars :: + - * / :
517 ;;;
518 ;;; Pathname diffs ->
519 ;;; Symbol chars :: .
520 ;;; Of course there is no pathname "mode" and in fact we have not implemented
521 ;;; this table. However, if there was such a mode, this is what it would look
522 ;;; like.
524 ;;;-----------------------------------------------
525 ;;; Table definitions
526 ;;;-----------------------------------------------
530 i)
531 ;; alpha chars
537 ;; digit chars.
542 ;; Other ones
545 )
550 )
551 )
552 table))
559 )
562 table))
567 )
570 table))
575 )
578 table))
588 ;;;-----------------------------------------------
589 ;;; Installing the appropriate mode tables
590 ;;;-----------------------------------------------
605 ;;;-----------------------------------------------
606 ;;; Symbol functions
607 ;;;-----------------------------------------------
612 ;;; These are temp. vars. we use to avoid using let.
613 ;;; Why ? Small speed improvement.
618 "Returns the symbol that the point is currently on.
619 But only if it is longer than `completion-min-length'."
623 ;; Cursor is on following-char and after preceding-char
628 ;; remove chars to ignore at the start
634 ))
635 ;; remove chars to ignore at the end
641 ))
642 ;; restore state
644 ;; Return completion if the length is reasonable
650 )
652 ;; restore table if no symbol
654 nil)
655 ))
657 ;;; tests for symbol-under-point
658 ;;; `^' indicates cursor pos. where value is returned
659 ;;; simple-word-test
660 ;;; ^^^^^^^^^^^^^^^^ --> simple-word-test
661 ;;; _harder_word_test_
662 ;;; ^^^^^^^^^^^^^^^^^^ --> harder_word_test
663 ;;; .___.______.
664 ;;; --> nil
665 ;;; /foo/bar/quux.hello
666 ;;; ^^^^^^^^^^^^^^^^^^^ --> /foo/bar/quux.hello
667 ;;;
670 "Returns a string of the symbol immediately before point.
671 Returns nil if there isn't one longer than `completion-min-length'."
672 ;; This is called when a word separator is typed so it must be FAST !
675 ;; Cursor is on following-char and after preceding-char
677 ;; No chars. to ignore at end
680 )
681 ;; remove chars to ignore at the start
687 ))
688 ;; restore state
690 ;; return value if long enough
692 (+ cmpl-symbol-start
695 )
697 ;; chars to ignore at end
700 ;; take off chars. from end
703 ;; remove chars to ignore at the start
708 ))
709 ;; restore state
712 ;; Return completion if the length is reasonable
718 )
720 ;; restore table if no symbol
722 nil)
723 ))
725 ;;; tests for symbol-before-point
726 ;;; `^' indicates cursor pos. where value is returned
727 ;;; simple-word-test
728 ;;; ^ --> nil
729 ;;; ^ --> nil
730 ;;; ^ --> simple-w
731 ;;; ^ --> simple-word-test
732 ;;; _harder_word_test_
733 ;;; ^ --> harder_word_test
734 ;;; ^ --> harder_word_test
735 ;;; ^ --> harder
736 ;;; .___....
737 ;;; --> nil
740 ;;; This could be made slightly faster but it is better to avoid
741 ;;; copying all the code.
742 ;;; However, it is only used by the completion string prompter.
743 ;;; If it comes into common use, it could be rewritten.
752 ))
756 ;; "Returns a string of the symbol immediately before point
757 ;; or nil if there isn't one. Like symbol-before-point but doesn't trim the
758 ;; end chars."
759 ;; Cursor is on following-char and after preceding-char
766 )
767 ;; remove chars to ignore at the start
773 ))
774 ;; restore state
776 ;; Return completion if the length is reasonable
778 completion-prefix-min-length)
783 )
785 ;; restore table if no symbol
787 nil)
788 ))
790 ;;; tests for symbol-before-point-for-complete
791 ;;; `^' indicates cursor pos. where value is returned
792 ;;; simple-word-test
793 ;;; ^ --> nil
794 ;;; ^ --> nil
795 ;;; ^ --> simple-w
796 ;;; ^ --> simple-word-test
797 ;;; _harder_word_test_
798 ;;; ^ --> harder_word_test
799 ;;; ^ --> harder_word_test_
800 ;;; ^ --> harder_
801 ;;; .___....
802 ;;; --> nil
805 \f
806 ;;;---------------------------------------------------------------------------
807 ;;; Statistics Recording
808 ;;;---------------------------------------------------------------------------
810 ;;; Note that the guts of this has been turned off. The guts
811 ;;; are in completion-stats.el.
813 ;;;-----------------------------------------------
814 ;;; Conditionalizing code on *record-cmpl-statistics-p*
815 ;;;-----------------------------------------------
816 ;;; All statistics code outside this block should use this
818 ;;; "Only executes body if we are recording statistics."
819 ;;; (list 'cond
820 ;;; (list* '*record-cmpl-statistics-p* body)
821 ;;; ))
823 ;;;-----------------------------------------------
824 ;;; Completion Sources
825 ;;;-----------------------------------------------
827 ;; ID numbers
839 \f
840 ;;;---------------------------------------------------------------------------
841 ;;; Completion Method #2: dabbrev-expand style
842 ;;;---------------------------------------------------------------------------
843 ;;;
844 ;;; This method is used if there are no useful stored completions. It is
845 ;;; based on dabbrev-expand with these differences :
846 ;;; 1) Faster (we don't use regexps)
847 ;;; 2) case coercion handled correctly
848 ;;; This is called cdabbrev to differentiate it.
849 ;;; We simply search backwards through the file looking for words which
850 ;;; start with the same letters we are trying to complete.
851 ;;;
854 ;;; "A list of all the cdabbrev completions since the last reset.")
857 ;;; "The current point position the cdabbrev search is at.")
860 ;;; "The current window we are looking for cdabbrevs in. T if looking in
861 ;;; (other-buffer), NIL if no more cdabbrevs.")
864 ;;; "T if the cdabbrev search has wrapped around the file.")
870 ;;; Test strings for cdabbrev
871 ;;; cdat-upcase ;;same namestring
872 ;;; CDAT-UPCASE ;;ok
873 ;;; cdat2 ;;too short
874 ;;; cdat-1-2-3-4 ;;ok
875 ;;; a-cdat-1 ;;doesn't start correctly
876 ;;; cdat-simple ;;ok
880 "Resets the cdabbrev search to search for abbrev-string.
881 INITIAL-COMPLETIONS-TRIED is a list of downcased strings to ignore
882 during the search."
884 cdabbrev-completions-tried
886 )
888 )
891 ;; cdabbrev-current-window must not be NIL
895 )
899 "Resets the cdabbrev search to search for abbrev-string."
900 ;; Set the window
903 )
905 ;; Everything has failed
910 ;; No more windows, try other buffer.
912 )
917 cdabbrev-start-point cdabbrev-current-point
918 cdabbrev-stop-point
923 cdabbrev-wrapped-p nil)
924 )))
927 "Return the next possible cdabbrev expansion or nil if there isn't one.
928 `reset-cdabbrev' must've been called already.
929 This is sensitive to `case-fold-search'."
930 ;; note that case-fold-search affects the behavior of this function
931 ;; Bug: won't pick up an expansion that starts at the top of buffer
934 saved-syntax
936 downcase-expansion tried-list syntax saved-point-2)
940 ;; Switch to current completion buffer
942 ;; Save current buffer state
945 ;; Restore completion state
948 ;; Loop looking for completions
950 ;; This code returns t if it should loop again
954 ;; return nil if the completion is valid
957 ;; does it start with a separator char ?
960 ;; symbol char to ignore at end. Are we at end ?
967 ))))
968 ;; is the symbol long enough ?
970 ;; have we not tried this one before
972 ;; See if we've already used it
978 ;; Already tried, don't choose this one
980 )
981 ;; at this point tried-list will be nil if this
982 ;; expansion has not yet been tried
985 t)
986 ))))
987 ;; search failed
989 ;; If already wrapped, then we've failed completely
990 nil)
992 ;; need to wrap
999 ))
1000 ;; end of while loop
1002 ;; successful
1006 )
1009 ))
1010 ;; If no expansion, go to next window
1015 ;;; The following must be eval'd in the minibuffer ::
1016 ;;; (reset-cdabbrev "cdat")
1017 ;;; (next-cdabbrev) --> "cdat-simple"
1018 ;;; (next-cdabbrev) --> "cdat-1-2-3-4"
1019 ;;; (next-cdabbrev) --> "CDAT-UPCASE"
1020 ;;; (next-cdabbrev) --> "cdat-wrapping"
1021 ;;; (next-cdabbrev) --> "cdat_start_sym"
1022 ;;; (next-cdabbrev) --> nil
1023 ;;; (next-cdabbrev) --> nil
1024 ;;; (next-cdabbrev) --> nil
1026 ;;; _cdat_start_sym
1027 ;;; cdat-wrapping
1029 \f
1030 ;;;---------------------------------------------------------------------------
1031 ;;; Completion Database
1032 ;;;---------------------------------------------------------------------------
1034 ;;; We use two storage modes for the two search types ::
1035 ;;; 1) Prefix {cmpl-prefix-obarray} for looking up possible completions
1036 ;;; Used by search-completion-next
1037 ;;; the value of the symbol is nil or a cons of head and tail pointers
1038 ;;; 2) Interning {cmpl-obarray} to see if it's in the database
1039 ;;; Used by find-exact-completion, completion-in-database-p
1040 ;;; The value of the symbol is the completion entry
1042 ;;; bad things may happen if this length is changed due to the way
1043 ;;; GNU implements obarrays
1047 "An obarray used to store the downcased completion prefixes.
1051 "An obarray used to store the downcased completions.
1054 ;;;-----------------------------------------------
1055 ;;; Completion Entry Structure Definition
1056 ;;;-----------------------------------------------
1058 ;;; A completion entry is a LIST of string, prefix-symbol num-uses, and
1059 ;;; last-use-time (the time the completion was last used)
1060 ;;; last-use-time is T if the string should be kept permanently
1061 ;;; num-uses is incremented everytime the completion is used.
1063 ;;; We chose lists because (car foo) is faster than (aref foo 0) and the
1064 ;;; creation time is about the same.
1066 ;;; READER MACROS
1072 ;; "The number of times it has used. Used to decide whether to save
1073 ;; it."
1077 ;; "The time it was last used. In hours since origin. Used to decide
1078 ;; whether to save it. T if one should always save it."
1084 ;;; WRITER MACROS
1094 ;;; CONSTRUCTOR
1096 "Returns a list of a completion entry."
1099 ;; Obsolete
1100 ;;(defmacro cmpl-prefix-entry-symbol (completion-entry)
1101 ;; (list 'car (list 'cdr completion-entry)))
1104 \f
1105 ;;;-----------------------------------------------
1106 ;;; Prefix symbol entry definition
1107 ;;;-----------------------------------------------
1108 ;;; A cons of (head . tail)
1110 ;;; READER Macros
1118 ;;; WRITER Macros
1126 ;;; Constructor
1129 "Makes a new prefix entry containing only completion-entry."
1132 ;;;-----------------------------------------------
1133 ;;; Completion Database - Utilities
1134 ;;;-----------------------------------------------
1137 "Initializes the completion storage. All existing completions are lost."
1143 )
1148 "Returns a list of all the known completion entries."
1151 completions-list-return-value))
1157 completions-list-return-value))))
1160 "Return list of lists of known completion entries, organized by hash bucket."
1163 completions-list-return-value))
1169 completions-list-return-value))))
1171 \f
1172 ;;;-----------------------------------------------
1173 ;;; Updating the database
1174 ;;;-----------------------------------------------
1175 ;;;
1176 ;;; These are the internal functions used to update the datebase
1177 ;;;
1178 ;;;
1180 ;;"Set to a string that is pending its acceptance."
1181 ;; this checked by the top level reading functions
1184 ;; "Setup by find-exact-completion, etc. The given string, downcased."
1186 ;; "The interned symbol corresponding to cmpl-db-downcase-string.
1187 ;; Set up by cmpl-db-symbol."
1189 ;; "The interned prefix symbol corresponding to cmpl-db-downcase-string."
1194 ;;; READS
1196 "Returns the completion entry for string or nil.
1197 Sets up `cmpl-db-downcase-string' and `cmpl-db-symbol'."
1200 cmpl-obarray)))
1202 ))
1205 "Returns the prefix entry for string.
1206 Sets `cmpl-db-prefix-symbol'.
1207 Prefix-string must be exactly `completion-prefix-min-length' long
1208 and downcased. Sets up `cmpl-db-prefix-symbol'."
1214 ;; used to trap lossage in silent error correction
1217 "Locates the completion entry.
1218 Returns a pointer to the element before the completion entry or nil if
1219 the completion entry is at the head.
1220 Must be called after `find-exact-completion'."
1222 next-prefix-list
1223 )
1226 ;; not already at head
1230 )))
1233 prefix-list)
1234 ;; Didn't find it. Database is messed up.
1236 ;; not found, error if debug mode
1238 completion-string))
1240 ;; recursive error: really scrod
1243 ;; Patch out
1245 ;; Retry
1247 ))))))
1260 )
1262 ;; try again
1264 ;; still losing
1266 )))
1269 ;; recursive error: really scrod
1271 )
1273 ;;; WRITES
1275 "If STRING is not in the database add it to appropriate prefix list.
1276 STRING is added to the end of the appropriate prefix list with
1277 num-uses = 0. The database is unchanged if it is there. STRING must be
1278 longer than `completion-prefix-min-length'.
1279 This must be very fast.
1280 Returns the completion entry."
1282 ;; not there
1285 ;; setup the prefix
1289 completion-prefix-min-length))))
1290 )
1291 ;; The next two forms should happen as a unit (atomically) but
1292 ;; no fatal errors should result if that is not the case.
1294 ;; These two should be atomic, but nothing fatal will happen
1295 ;; if they're not.
1300 ))
1301 ;; statistics
1304 ;; set symbol
1306 )))
1309 "If COMPLETION-STRING is not in the database, add it to prefix list.
1310 We add COMPLETION-STRING to the head of the appropriate prefix list,
1311 or it to the head of the list.
1312 COMPLETION-STRING must be longer than `completion-prefix-min-length'.
1313 Updates the saved string with the supplied string.
1314 This must be very fast.
1315 Returns the completion entry."
1316 ;; Handle pending acceptance
1318 ;; test if already in database
1320 ;; found
1324 completion-prefix-min-length))))
1327 )
1328 ;; update entry
1330 ;; move to head (if necessary)
1332 ;; These should all execute atomically but it is not fatal if
1333 ;; they don't.
1334 ;; splice it out
1336 ;; fix up tail if necessary
1338 ;; splice in at head
1341 ))
1342 cmpl-db-entry)
1343 ;; not there
1346 ;; setup the prefix
1350 completion-prefix-min-length))))
1351 )
1353 ;; Splice in at head
1357 ;; Start new prefix entry
1359 ))
1360 ;; statistics
1363 ;; Add it to the symbol
1365 )))
1368 "Deletes the completion from the database.
1369 String must be longer than `completion-prefix-min-length'."
1370 ;; Handle pending acceptance
1373 ;; found
1377 completion-prefix-min-length))))
1379 )
1380 ;; delete symbol reference
1382 ;; remove from prefix list
1384 ;; not at head
1386 ;; fix up tail if necessary
1388 )
1390 ;; at head
1393 ;; List is now empty
1395 ))
1398 )
1400 ))
1402 ;;; Tests --
1403 ;;; - Add and Find -
1404 ;;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1405 ;;; (find-exact-completion "banana") --> ("banana" 0 nil 0)
1406 ;;; (find-exact-completion "bana") --> nil
1407 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1408 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1409 ;;; (add-completion-to-head "banish") --> ("banish" 0 nil 0)
1410 ;;; (find-exact-completion "banish") --> ("banish" 0 nil 0)
1411 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1412 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1413 ;;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1414 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1415 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1416 ;;;
1417 ;;; - Deleting -
1418 ;;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1419 ;;; (delete-completion "banner")
1420 ;;; (find-exact-completion "banner") --> nil
1421 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1422 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1423 ;;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1424 ;;; (delete-completion "banana")
1425 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banish" ...))
1426 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1427 ;;; (delete-completion "banner")
1428 ;;; (delete-completion "banish")
1429 ;;; (find-cmpl-prefix-entry "ban") --> nil
1430 ;;; (delete-completion "banner") --> error
1431 ;;;
1432 ;;; - Tail -
1433 ;;; (add-completion-to-tail-if-new "banana") --> ("banana" 0 nil 0)
1434 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1435 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1436 ;;; (add-completion-to-tail-if-new "banish") --> ("banish" 0 nil 0)
1437 ;;; (car (find-cmpl-prefix-entry "ban")) -->(("banana" ...) ("banish" ...))
1438 ;;; (cdr (find-cmpl-prefix-entry "ban")) -->(("banish" ...))
1439 ;;;
1441 \f
1442 ;;;---------------------------------------------------------------------------
1443 ;;; Database Update :: Interface level routines
1444 ;;;---------------------------------------------------------------------------
1445 ;;;
1446 ;;; These lie on top of the database ref. functions but below the standard
1447 ;;; user interface level
1456 )
1458 )
1461 ))
1466 string)
1470 "Add STRING to completion list, or move it to head of list.
1471 The completion is altered appropriately if num-uses and/or last-use-time is
1472 specified."
1476 cmpl-source-interactive
1477 current-completion-source))
1483 ))
1486 "Add STRING if it isn't already listed, and mark it permanent."
1490 cmpl-source-interactive
1491 current-completion-source))
1492 )
1494 ))
1500 )
1503 "Accepts the pending completion in `completion-to-accept'.
1504 This bumps num-uses. Called by `add-completion-to-head' and
1505 `completion-search-reset'."
1507 ;; if this is added afresh here, then it must be a cdabbrev
1509 entry
1510 )
1515 ))
1518 "Add the completion symbol underneath the point into the completion buffer."
1524 "Add the completion symbol before point into the completion buffer."
1530 "Add the completion symbol before point into the completion buffer."
1536 "Add the completion symbol before point into the completion buffer.
1537 Completions added this way will automatically be saved if
1538 `completion-on-separator-character' is non-nil."
1541 entry)
1544 )
1552 ))
1554 ;;; Tests --
1555 ;;; - Add and Find -
1556 ;;; (add-completion "banana" 5 10)
1557 ;;; (find-exact-completion "banana") --> ("banana" 5 10 0)
1558 ;;; (add-completion "banana" 6)
1559 ;;; (find-exact-completion "banana") --> ("banana" 6 10 0)
1560 ;;; (add-completion "banish")
1561 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1562 ;;;
1563 ;;; - Accepting -
1564 ;;; (setq completion-to-accept "banana")
1565 ;;; (accept-completion)
1566 ;;; (find-exact-completion "banana") --> ("banana" 7 10)
1567 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1568 ;;; (setq completion-to-accept "banish")
1569 ;;; (add-completion "banner")
1570 ;;; (car (find-cmpl-prefix-entry "ban"))
1571 ;;; --> (("banner" ...) ("banish" 1 ...) ("banana" 7 ...))
1572 ;;;
1573 ;;; - Deleting -
1574 ;;; (kill-completion "banish")
1575 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banana" ...))
1577 \f
1578 ;;;---------------------------------------------------------------------------
1579 ;;; Searching the database
1580 ;;;---------------------------------------------------------------------------
1581 ;;; Functions outside this block must call completion-search-reset followed
1582 ;;; by calls to completion-search-next or completion-search-peek
1583 ;;;
1585 ;;; Status variables
1586 ;; Commented out to improve loading speed
1588 ;; "The current string used by completion-search-next."
1590 ;; "The current regexp used by completion-search-next.
1591 ;; (derived from cmpl-test-string)"
1593 ;; "The last index that completion-search-next was called with."
1595 ;; "Set to t when cdabbrevs have been reset."
1597 ;; "A pointer to the element BEFORE the next set of possible completions.
1598 ;; cadr of this is the cmpl-next-possibility"
1600 ;; "The initial list of starting possibilities."
1602 ;; "The cached next possibility."
1604 ;; "A downcased list of all the completions we have tried."
1608 "Set up the for completion searching for STRING.
1609 STRING must be longer than `completion-prefix-min-length'."
1615 cmpl-test-string string
1618 )
1622 cmpl-next-possibility nil
1623 cmpl-cdabbrev-reset-p nil
1624 cmpl-last-index -1
1625 cmpl-tried-list nil
1626 ))
1629 "Return the next completion entry.
1630 If INDEX is out of sequence, reset and start from the top.
1631 If there are no more entries, try cdabbrev and returns only a string."
1638 ;; reverse the possibilities list
1640 ;; do a "normal" search
1644 )
1646 ;; If no more possibilities, leave it that way
1648 ;; next completion is at index 0. reset next-possibility list
1649 ;; to start at beginning
1652 ;; otherwise point to one before current
1656 cmpl-starting-possibilities))
1657 )))
1659 ;; non-negative index, reset and search
1660 ;;(prin1 'reset)
1666 ))
1667 )
1669 cmpl-next-possibility
1671 ))
1675 "Returns the next completion entry without actually moving the pointers.
1676 Calling this again or calling `completion-search-next' results in the same
1677 string being returned. Depends on `case-fold-search'.
1678 If there are no more entries, try cdabbrev and then return only a string."
1680 ;; return the cached value if we have it
1683 ;; still a few possibilities left
1689 ))
1690 cmpl-next-possibilities
1691 ))
1692 ;; successful match
1695 cmpl-tried-list)
1697 )
1698 cmpl-next-possibility)
1700 ;; unsuccessful, use cdabbrev
1704 ))
1706 )
1707 ;; Completely unsuccessful, return nil
1708 ))
1710 ;;; Tests --
1711 ;;; - Add and Find -
1712 ;;; (add-completion "banana")
1713 ;;; (completion-search-reset "ban")
1714 ;;; (completion-search-next 0) --> "banana"
1715 ;;;
1716 ;;; - Discrimination -
1717 ;;; (add-completion "cumberland")
1718 ;;; (add-completion "cumberbund")
1719 ;;; cumbering
1720 ;;; (completion-search-reset "cumb")
1721 ;;; (completion-search-peek t) --> "cumberbund"
1722 ;;; (completion-search-next 0) --> "cumberbund"
1723 ;;; (completion-search-peek t) --> "cumberland"
1724 ;;; (completion-search-next 1) --> "cumberland"
1725 ;;; (completion-search-peek nil) --> nil
1726 ;;; (completion-search-next 2) --> "cumbering" {cdabbrev}
1727 ;;; (completion-search-next 3) --> nil or "cumming"{depends on context}
1728 ;;; (completion-search-next 1) --> "cumberland"
1729 ;;; (completion-search-peek t) --> "cumbering" {cdabbrev}
1730 ;;;
1731 ;;; - Accepting -
1732 ;;; (completion-search-next 1) --> "cumberland"
1733 ;;; (setq completion-to-accept "cumberland")
1734 ;;; (completion-search-reset "foo")
1735 ;;; (completion-search-reset "cum")
1736 ;;; (completion-search-next 0) --> "cumberland"
1737 ;;;
1738 ;;; - Deleting -
1739 ;;; (kill-completion "cumberland")
1740 ;;; cummings
1741 ;;; (completion-search-reset "cum")
1742 ;;; (completion-search-next 0) --> "cumberbund"
1743 ;;; (completion-search-next 1) --> "cummings"
1744 ;;;
1745 ;;; - Ignoring Capitalization -
1746 ;;; (completion-search-reset "CuMb")
1747 ;;; (completion-search-next 0) --> "cumberbund"
1750 \f
1751 ;;;-----------------------------------------------
1752 ;;; COMPLETE
1753 ;;;-----------------------------------------------
1756 "Toggles whether or not to add new words to the completion database."
1760 )
1768 "Fill out a completion of the word before point.
1769 Point is left at end. Consecutive calls rotate through all possibilities.
1770 Prefix args ::
1771 control-u :: leave the point at the beginning of the completion rather
1772 than at the end.
1773 a number :: rotate through the possible completions by that amount
1774 `-' :: same as -1 (insert previous completion)
1775 {See the comments at the top of `completion.el' for more info.}"
1777 ;;; Set up variables
1779 ;; Undo last one
1781 ;; get next completion
1783 )
1790 )
1793 ))
1794 ;; get string
1799 completion-prefix-min-length)))
1800 ;; get index
1802 ;; statistics
1805 ;; reset database
1807 ;; erase what we've got
1809 ))
1811 ;; point is at the point to insert the new symbol
1812 ;; Get the next completion
1818 string
1819 )
1820 ;; entry is either a completion entry or a string (if cdabbrev)
1822 ;; If found, insert
1824 ;; Setup for proper case
1828 string cmpl-original-string))
1829 ;; insert
1831 ;; accept it
1833 ;; fixup and cache point
1839 )
1840 ;; statistics
1843 ;; Done ! cmpl-stat-complete-successful
1844 ;;display the next completion
1847 ;; This updates the display and only prints if there
1848 ;; is no typeahead
1852 completion-cdabbrev-prompt-flag)))
1856 string cmpl-original-string))
1858 ))
1859 )
1862 ;; Don't accept completions
1864 ;; print message
1865 ;; This used to call cmpl19-sit-for, an undefined function.
1866 ;; I hope that sit-for does the right thing; I don't know -- rms.
1870 ;; statistics
1873 ;; Pretend that we were never here
1875 ))))
1877 ;;;-----------------------------------------------
1878 ;;; "Complete" Key Keybindings
1879 ;;;-----------------------------------------------
1885 ;;; Tests -
1886 ;;; (add-completion "cumberland")
1887 ;;; (add-completion "cumberbund")
1888 ;;; cum
1889 ;;; Cumber
1890 ;;; cumbering
1891 ;;; cumb
1893 \f
1894 ;;;---------------------------------------------------------------------------
1895 ;;; Parsing definitions from files into the database
1896 ;;;---------------------------------------------------------------------------
1898 ;;;-----------------------------------------------
1899 ;;; Top Level functions ::
1900 ;;;-----------------------------------------------
1902 ;;; User interface
1904 "Parse possible completions from a file and add them to data base."
1909 )
1917 )
1927 mode
1928 )
1932 )
1936 )
1939 major-mode)
1940 ))
1945 start-num)))
1946 ))
1948 ;;; Find file hook
1953 )
1957 )
1959 )))
1960 ))
1964 ;;;-----------------------------------------------
1965 ;;; Tags Table Completions
1966 ;;;-----------------------------------------------
1969 ;; Inspired by eero@media-lab.media.mit.edu
1970 "Add completions from the current tags table."
1983 )
1985 ))))
1987 \f
1988 ;;;-----------------------------------------------
1989 ;;; Lisp File completion parsing
1990 ;;;-----------------------------------------------
1991 ;;; This merely looks for phrases beginning with (def.... or
1992 ;;; (package:def ... and takes the next word.
1993 ;;;
1994 ;;; We tried using forward-lines and explicit searches but the regexp technique
1995 ;;; was faster. (About 100K characters per second)
1996 ;;;
1999 "A regexp that searches for lisp definition form."
2000 )
2002 ;;; Tests -
2003 ;;; (and (string-match *lisp-def-regexp* "\n(defun foo") (match-end 0)) -> 8
2004 ;;; (and (string-match *lisp-def-regexp* "\n(si:def foo") (match-end 0)) -> 9
2005 ;;; (and (string-match *lisp-def-regexp* "\n(def-bar foo")(match-end 0)) -> 10
2006 ;;; (and (string-match *lisp-def-regexp* "\n(defun (foo") (match-end 0)) -> 9
2008 ;;; Parses all the definition names from a Lisp mode buffer and adds them to
2009 ;;; the completion database.
2011 ;;; Benchmarks
2012 ;;; Sun-3/280 - 1500 to 3000 lines of lisp code per second
2021 )
2023 ))))
2025 \f
2026 ;;;-----------------------------------------------
2027 ;;; C file completion parsing
2028 ;;;-----------------------------------------------
2029 ;;; C :
2030 ;;; Looks for #define or [<storage class>] [<type>] <name>{,<name>}
2031 ;;; or structure, array or pointer defs.
2032 ;;; It gets most of the definition names.
2033 ;;;
2034 ;;; As you might suspect by now, we use some symbol table hackery
2035 ;;;
2036 ;;; Symbol separator chars (have whitespace syntax) --> , ; * = (
2037 ;;; Opening char --> [ {
2038 ;;; Closing char --> ] }
2039 ;;; opening and closing must be skipped over
2040 ;;; Whitespace chars (have symbol syntax)
2041 ;;; Everything else has word syntax
2046 ;; unfortunately the ?( causes the parens to appear unbalanced
2048 ))
2049 i)
2050 ;; default syntax is whitespace
2063 table))
2067 ;;; Regexps
2069 ;; This stops on lines with possible definitions
2071 ;; This stops after the symbol to add.
2072 ;;"\n\\(#define\\s +.\\|\\(\\(\\w\\|\\s_\\)+\\b\\s *\\)+[(;,[*{=]\\)"
2073 ;; This stops before the symbol to add. {Test cases in parens. below}
2074 ;;"\n\\(\\(\\w\\|\\s_\\)+\\s *(\\|\\(\\(#define\\|auto\\|extern\\|register\\|static\\|int\\|long\\|short\\|unsigned\\|char\\|void\\|float\\|double\\|enum\\|struct\\|union\\|typedef\\)\\s +\\)+\\)"
2075 ;; this simple version picks up too much extraneous stuff
2076 ;; "\n\\(\\w\\|\\s_\\|#\\)\\B"
2077 "A regexp that searches for a definition form."
2078 )
2079 ;
2080 ;(defconst *c-cont-regexp*
2081 ; "\\(\\w\\|\\s_\\)+\\b\\s *\\({\\|\\(\\[[0-9\t ]*\\]\\s *\\)*,\\(*\\|\\s \\)*\\b\\)"
2082 ; "This regexp should be used in a looking-at to parse for lists of variables.")
2083 ;
2084 ;(defconst *c-struct-regexp*
2085 ; "\\(*\\|\\s \\)*\\b"
2086 ; "This regexp should be used to test whether a symbol follows a structure definition.")
2088 ;(defun test-c-def-regexp (regexp string)
2089 ; (and (eq 0 (string-match regexp string)) (match-end 0))
2090 ; )
2092 ;;; Tests -
2093 ;;; (test-c-def-regexp *c-def-regexp* "\n#define foo") -> 10 (9)
2094 ;;; (test-c-def-regexp *c-def-regexp* "\nfoo (x, y) {") -> 6 (6)
2095 ;;; (test-c-def-regexp *c-def-regexp* "\nint foo (x, y)") -> 10 (5)
2096 ;;; (test-c-def-regexp *c-def-regexp* "\n int foo (x, y)") -> nil
2097 ;;; (test-c-def-regexp *c-cont-regexp* "oo, bar") -> 4
2098 ;;; (test-c-def-regexp *c-cont-regexp* "oo, *bar") -> 5
2099 ;;; (test-c-def-regexp *c-cont-regexp* "a [5][6], bar") -> 10
2100 ;;; (test-c-def-regexp *c-cont-regexp* "oo(x,y)") -> nil
2101 ;;; (test-c-def-regexp *c-cont-regexp* "a [6] ,\t bar") -> 9
2102 ;;; (test-c-def-regexp *c-cont-regexp* "oo {trout =1} my_carp;") -> 14
2103 ;;; (test-c-def-regexp *c-cont-regexp* "truct_p complex foon") -> nil
2105 ;;; Parses all the definition names from a C mode buffer and adds them to the
2106 ;;; completion database.
2108 ;; Benchmark --
2109 ;; Sun 3/280-- 1250 lines/sec.
2113 )
2119 ;; we loop here only when scan-sexps fails
2120 ;; (i.e. unbalance exps.)
2127 ;; preprocessor macro, see if it's one we handle
2131 )
2132 ;; skip forward over definition symbol
2133 ;; and add it to database
2136 ;;(push string foo)
2138 ))))
2140 ;; C definition
2143 next-point
2144 ;; scan to next separator char.
2146 )
2147 ;; position the point on the word we want to add
2150 ;; handle pointer ref
2151 ;; move to next separator char.
2154 )
2156 ;; add to database
2158 ;; (push string foo)
2160 ;; Local TMC hack (useful for parsing paris.h)
2166 ))
2168 )
2169 )
2170 ;; go to next
2172 ;; (push (format "%c" (following-char)) foo)
2174 ;; if on an opening delimiter, go to end
2178 )
2180 ;; Current char is an end char.
2182 ))
2183 ))))
2186 )
2188 ;; Check for failure in scan-sexps
2192 ;; unbalanced paren., keep going
2193 ;;(ding)
2197 ))
2198 ))
2200 )))))
2202 \f
2203 ;;;---------------------------------------------------------------------------
2204 ;;; Init files
2205 ;;;---------------------------------------------------------------------------
2207 ;;; The version of save-completions-to-file called at kill-emacs time.
2216 ;; There is no point bothering to change this again
2217 ;; unless the package changes so much that it matters
2218 ;; for people that have saved completions.
2222 ";;; Completion Initialization file.
2223 ;;; Version = %s
2224 ;;; Format is (<string> . <last-use-time>)
2225 ;;; <string> is the completion
2226 ;;; <last-use-time> is the time the completion was last used
2227 ;;; If it is t, the completion will never be pruned from the file.
2228 ;;; Otherwise it is in hours since origin.
2235 "Save completions in init file FILENAME.
2236 If file name is not specified, use `save-completions-file-name'."
2248 last-use-time
2254 )
2263 ;; file has changed on disk. Bring us up-to-date
2268 ;; prepare the buffer to be modified
2271 ;; (/ 1 0)
2276 ;; Update num uses and maybe write completion to a file
2278 ;; permanent
2281 ;; or if
2283 ;; it's been used
2285 ;; or it was saved before and
2287 ;; save-completions-retention-time is nil
2289 ;; or time since last use is < ...retention-time*
2291 save-completions-retention-time))
2292 )))
2293 ;; write to file
2297 )))
2299 ;; write the buffer
2304 ;; If file exists . . .
2305 ;; Save a backup(so GNU doesn't screw us when we're out of disk)
2306 ;; (GNU leaves a 0 length file if it gets a disk full error!)
2308 ;; If backup doesn't exit, Rename current to backup
2309 ;; {If backup exists the primary file is probably messed up}
2312 ;; Copy the backup back to the current name
2313 ;; (so versioning works)
2315 ;; Save it
2318 ;; If successful, remove backup
2323 ))
2324 ;; Reset accepted-p flag
2326 )
2329 ))))
2331 ;;;(defun autosave-completions ()
2332 ;;; (if (and save-completions-flag enable-completion cmpl-initialized-p
2333 ;;; *completion-auto-save-period*
2334 ;;; (> cmpl-emacs-idle-time *completion-auto-save-period*)
2335 ;;; cmpl-completions-accepted-p)
2336 ;;; (save-completions-to-file)))
2338 ;;;(add-hook 'cmpl-emacs-idle-time-hooks 'autosave-completions)
2341 "Loads a completion init file FILENAME.
2342 If file is not specified, then use `save-completions-file-name'."
2347 )
2358 ;; prepare the buffer to be modified
2365 string num-uses entry last-use-time
2366 cmpl-entry cmpl-last-use-time
2372 )
2373 ;; insert the file into a buffer
2380 filename)))
2381 ;; parse it
2395 ;; handle case sensitivity
2401 ))
2402 ;; Valid entry
2403 ;; add it in
2408 ))
2413 ;; more recent
2415 ))
2416 ;; update last-use-time
2418 ))
2420 ;; Bad format
2423 ;; try to get back in sync
2425 )))
2428 )
2433 filename))
2435 ))
2436 )))
2440 total-in-file total-perm
2442 start-num)))
2444 ))))))
2447 "Load the default completions file.
2448 Also sets up so that exiting emacs will automatically save the file."
2452 ))
2454 )
2457 ;;;-----------------------------------------------
2458 ;;; Kill EMACS patch
2459 ;;;-----------------------------------------------
2466 \f
2467 ;;;-----------------------------------------------
2468 ;;; Kill region patch
2469 ;;;-----------------------------------------------
2472 "Kill between point and mark.
2473 The text is deleted but saved in the kill ring.
2477 This is the primitive for programs to kill text (as opposed to deleting it).
2478 Supply two arguments, character numbers indicating the stretch of text
2479 to be killed.
2481 If the previous command was also a kill command,
2482 the text killed this time appends to the text killed last time
2483 to make one entry in the kill ring.
2484 Patched to remove the most recent completion."
2496 \f
2497 ;;;-----------------------------------------------
2498 ;;; Patches to self-insert-command.
2499 ;;;-----------------------------------------------
2501 ;;; Need 2 versions: generic separator chars. and space (to get auto fill
2502 ;;; to work)
2504 ;;; All common separators (eg. space "(" ")" """) characters go through a
2505 ;;; function to add new words to the list of words to complete from:
2506 ;;; COMPLETION-SEPARATOR-SELF-INSERT-COMMAND (arg).
2507 ;;; If the character before this was an alpha-numeric then this adds the
2508 ;;; symbol before point to the completion list (using ADD-COMPLETION).
2514 )
2522 )
2524 ;;;-----------------------------------------------
2525 ;;; Wrapping Macro
2526 ;;;-----------------------------------------------
2528 ;;; Note that because of the way byte compiling works, none of
2529 ;;; the functions defined with this macro get byte compiled.
2532 "Add a call to update the completion database before function execution.
2533 TYPE is the type of the wrapper to be added. Can be :before or :under."
2563 ;; probably a failed completion if you have to back up
2568 ;; probably a failed completion if you have to back up
2578 ;;;---------------------------------------------------------------------------
2579 ;;; Patches to standard keymaps insert completions
2580 ;;;---------------------------------------------------------------------------
2582 ;;;-----------------------------------------------
2583 ;;; Separators
2584 ;;;-----------------------------------------------
2585 ;;; We've used the completion syntax table given as a guide.
2586 ;;;
2587 ;;; Global separator chars.
2588 ;;; We left out <tab> because there are too many special cases for it. Also,
2589 ;;; in normal coding it's rarely typed after a word.
2611 ;;; We include period and colon even though they are symbol chars because :
2612 ;;; - in text we want to pick up the last word in a sentence.
2613 ;;; - in C pointer refs. we want to pick up the first symbol
2614 ;;; - it won't make a difference for lisp mode (package names are short)
2618 ;;; Lisp Mode diffs
2626 ;;; C mode diffs.
2632 ;;; FORTRAN mode diffs. (these are defined when fortran is called)
2638 )
2640 ;;;-----------------------------------------------
2641 ;;; End of line chars.
2642 ;;;-----------------------------------------------
2649 ;;(def-completion-wrapper minibuffer-complete-and-exit :minibuffer)
2651 ;;;-----------------------------------------------
2652 ;;; Cursor movement
2653 ;;;-----------------------------------------------
2671 ;;; Tests --
2672 ;;; foobarbiz
2673 ;;; foobar
2674 ;;; fooquux
2675 ;;; fooper
2680 ;;; completion.el ends here