| blob | 9d478e78630053485735b43ddbc18636547ea63d |
1 ;;; This is a Completion system for GNU Emacs
2 ;;;
3 ;;; E-Mail:
4 ;;; Internet: completion@think.com, bug-completion@think.com
5 ;;; UUCP: {rutgers,harvard,mit-eddie}!think!completion
6 ;;;
7 ;;; If you are a new user, we'd appreciate knowing your site name and
8 ;;; any comments you have.
9 ;;;
10 ;;;
11 ;;; NO WARRANTY
12 ;;;
13 ;;; This software is distributed free of charge and is in the public domain.
14 ;;; Anyone may use, duplicate or modify this program. Thinking Machines
15 ;;; Corporation does not restrict in any way the use of this software by
16 ;;; anyone.
17 ;;;
18 ;;; Thinking Machines Corporation provides absolutely no warranty of any kind.
19 ;;; The entire risk as to the quality and performance of this program is with
20 ;;; you. In no event will Thinking Machines Corporation be liable to you for
21 ;;; damages, including any lost profits, lost monies, or other special,
22 ;;; incidental or consequential damages arising out of the use of this program.
23 ;;;
24 ;;; You must not restrict the distribution of this software.
25 ;;;
26 ;;; Please keep this notice and author information in any copies you make.
27 ;;;
28 ;;; 4/90
29 ;;;
30 ;;;
31 ;;; Advertisement
32 ;;;---------------
33 ;;; Try using this. If you are like most you will be happy you did.
34 ;;;
35 ;;; What to put in .emacs
36 ;;;-----------------------
37 ;;; (load "completion") ;; If it's not part of the standard band.
38 ;;; (initialize-completions)
39 ;;;
40 ;;; For best results, be sure to byte-compile the file first.
41 ;;;
42 \f
43 ;;; Authors
44 ;;;---------
45 ;;; Jim Salem {salem@think.com}
46 ;;; Brewster Kahle {brewster@think.com}
47 ;;; Thinking Machines Corporation
48 ;;; 245 First St., Cambridge MA 02142 (617) 876-1111
49 ;;;
50 ;;; Mailing Lists
51 ;;;---------------
52 ;;;
53 ;;; Bugs to bug-completion@think.com
54 ;;; Comments to completion@think.com
55 ;;; Requests to be added completion-request@think.com
56 ;;;
57 ;;; Availability
58 ;;;--------------
59 ;;; Anonymous FTP from think.com
60 ;;;
61 \f
62 ;;;---------------------------------------------------------------------------
63 ;;; Documentation [Slightly out of date]
64 ;;;---------------------------------------------------------------------------
65 ;;; (also check the documentation string of the functions)
66 ;;;
67 ;;; Introduction
68 ;;;---------------
69 ;;;
70 ;;; After you type a few characters, pressing the "complete" key inserts
71 ;;; the rest of the word you are likely to type.
72 ;;;
73 ;;; This watches all the words that you type and remembers them. When
74 ;;; typing a new word, pressing "complete" (meta-return) "completes" the
75 ;;; word by inserting the most recently used word that begins with the
76 ;;; same characters. If you press meta-return repeatedly, it cycles
77 ;;; through all the words it knows about.
78 ;;;
79 ;;; If you like the completion then just continue typing, it is as if you
80 ;;; entered the text by hand. If you want the inserted extra characters
81 ;;; to go away, type control-w or delete. More options are described below.
82 ;;;
83 ;;; The guesses are made in the order of the most recently "used". Typing
84 ;;; in a word and then typing a separator character (such as a space) "uses"
85 ;;; the word. So does moving a cursor over the word. If no words are found,
86 ;;; it uses an extended version of the dabbrev style completion.
87 ;;;
88 ;;; You automatically save the completions you use to a file between
89 ;;; sessions.
90 ;;;
91 ;;; Completion enables programmers to enter longer, more descriptive
92 ;;; variable names while typing fewer keystrokes than they normally would.
93 ;;;
94 ;;;
95 ;;; Full documentation
96 ;;;---------------------
97 ;;;
98 ;;; A "word" is any string containing characters with either word or symbol
99 ;;; syntax. [E.G. Any alphanumeric string with hypens, underscores, etc.]
100 ;;; Unless you change the constants, you must type at least three characters
101 ;;; for the word to be recognized. Only words longer than 6 characters are
102 ;;; saved.
103 ;;;
104 ;;; When you load this file, completion will be on. I suggest you use the
105 ;;; compiled version (because it is noticibly faster).
106 ;;;
107 ;;; M-X completion-mode toggles whether or not new words are added to the
108 ;;; database by changing the value of *completep*.
109 ;;;
110 ;;; SAVING/LOADING COMPLETIONS
111 ;;; Completions are automatically saved from one session to another
112 ;;; (unless *save-completions-p* or *completep* is nil).
113 ;;; Loading this file (or calling initialize-completions) causes EMACS
114 ;;; to load a completions database for a saved completions file
115 ;;; (default: ~/.completions). When you exit, EMACS saves a copy of the
116 ;;; completions that you
117 ;;; often use. When you next start, EMACS loads in the saved completion file.
118 ;;;
119 ;;; The number of completions saved depends loosely on
120 ;;; *saved-completions-decay-factor*. Completions that have never been
121 ;;; inserted via "complete" are not saved. You are encouraged to experiment
122 ;;; with different functions (see compute-completion-min-num-uses).
123 ;;;
124 ;;; Some completions are permanent and are always saved out. These
125 ;;; completions have their num-uses slot set to T. Use
126 ;;; add-permanent-completion to do this
127 ;;;
128 ;;; Completions are saved only if *completep* is T. The number of old
129 ;;; versions kept of the saved completions file is controlled by
130 ;;; *completion-file-versions-kept*.
131 ;;;
132 ;;; COMPLETE KEY OPTIONS
133 ;;; The complete function takes a numeric arguments.
134 ;;; control-u :: leave the point at the beginning of the completion rather
135 ;;; than the middle.
136 ;;; a number :: rotate through the possible completions by that amount
137 ;;; `-' :: same as -1 (insert previous completion)
138 ;;;
139 ;;; HOW THE DATABASE IS MAINTAINED
140 ;;; <write>
141 ;;;
142 ;;; UPDATING THE DATABASE MANUALLY
143 ;;; m-x kill-completion
144 ;;; kills the completion at point.
145 ;;; m-x add-completion
146 ;;; m-x add-permanent-completion
147 ;;;
148 ;;; UPDATING THE DATABASE FROM A SOURCE CODE FILE
149 ;;; m-x add-completions-from-buffer
150 ;;; Parses all the definition names from a C or LISP mode buffer and
151 ;;; adds them to the completion database.
152 ;;;
153 ;;; m-x add-completions-from-lisp-file
154 ;;; Parses all the definition names from a C or Lisp mode file and
155 ;;; adds them to the completion database.
156 ;;;
157 ;;; UPDATING THE DATABASE FROM A TAGS TABLE
158 ;;; m-x add-completions-from-tags-table
159 ;;; Adds completions from the current tags-table-buffer.
160 ;;;
161 ;;; HOW A COMPLETION IS FOUND
162 ;;; <write>
163 ;;;
164 ;;; STRING CASING
165 ;;; Completion is string case independent if case-fold-search has its
166 ;;; normal default of T. Also when the completion is inserted the case of the
167 ;;; entry is coerced appropriately.
168 ;;; [E.G. APP --> APPROPRIATELY app --> appropriately
169 ;;; App --> Appropriately]
170 ;;;
171 ;;; INITIALIZATION
172 ;;; The form `(initialize-completions)' initializes the completion system by
173 ;;; trying to load in the user's completions. After the first cal, further
174 ;;; calls have no effect so one should be careful not to put the form in a
175 ;;; site's standard site-init file.
176 ;;;
177 ;;;---------------------------------------------------------------------------
178 ;;;
179 ;;;
180 \f
181 ;;;-----------------------------------------------
182 ;;; Porting Notes
183 ;;;-----------------------------------------------
184 ;;;
185 ;;; Should run on 18.49, 18.52, and 19.0
186 ;;; Tested on vanilla version.
187 ;;; This requires the standard cl.el file. It could easily rewritten to not
188 ;;; require it. It defines remove which is not in cl.el.
189 ;;;
190 ;;; FUNCTIONS BASHED
191 ;;; The following functions are bashed but it is done carefully and should not
192 ;;; cause problems ::
193 ;;; kill-region, next-line, previous-line, newline, newline-and-indent,
194 ;;; kill-emacs
195 ;;;
196 ;;;
197 ;;;---------------------------------------------------------------------------
198 ;;; Functions you might like to call
199 ;;;---------------------------------------------------------------------------
200 ;;;
201 ;;; add-completion string &optional num-uses
202 ;;; Adds a new string to the database
203 ;;;
204 ;;; add-permanent-completion string
205 ;;; Adds a new string to the database with num-uses = T
206 ;;;
208 ;;; kill-completion string
209 ;;; Kills the completion from the database.
210 ;;;
211 ;;; clear-all-completions
212 ;;; Clears the database
213 ;;;
214 ;;; list-all-completions
215 ;;; Returns a list of all completions.
216 ;;;
217 ;;;
218 ;;; next-completion string &optional index
219 ;;; Returns a completion entry that starts with string.
220 ;;;
221 ;;; find-exact-completion string
222 ;;; Returns a completion entry that exactly matches string.
223 ;;;
224 ;;; complete
225 ;;; Inserts a completion at point
226 ;;;
227 ;;; initialize-completions
228 ;;; Loads the completions file and sets up so that exiting emacs will
229 ;;; save them.
230 ;;;
231 ;;; save-completions-to-file &optional filename
232 ;;; load-completions-from-file &optional filename
233 ;;;
234 ;;;-----------------------------------------------
235 ;;; Other functions
236 ;;;-----------------------------------------------
237 ;;;
238 ;;; get-completion-list string
239 ;;;
240 ;;; These things are for manipulating the structure
241 ;;; make-completion string num-uses
242 ;;; completion-num-uses completion
243 ;;; completion-string completion
244 ;;; set-completion-num-uses completion num-uses
245 ;;; set-completion-string completion string
246 ;;;
247 ;;;
248 \f
249 ;;;-----------------------------------------------
250 ;;; To Do :: (anybody ?)
251 ;;;-----------------------------------------------
252 ;;;
253 ;;; Implement Lookup and keyboard interface in C
254 ;;; Add package prefix smarts (for Common Lisp)
255 ;;; Add autoprompting of possible completions after every keystroke (fast
256 ;;; terminals only !)
257 ;;; Add doc. to texinfo
258 ;;;
259 ;;;
260 ;;;-----------------------------------------------
261 ;;; History ::
262 ;;;-----------------------------------------------
263 ;;; Sometime in '84 Brewster implemented a somewhat buggy version for
264 ;;; Symbolics LISPMs.
265 ;;; Jan. '85 Jim became enamored of the idea and implemented a faster,
266 ;;; more robust version.
267 ;;; With input from many users at TMC, (rose, craig, and gls come to mind),
268 ;;; the current style of interface was developed.
269 ;;; 9/87, Jim and Brewster took terminals home. Yuck. After
270 ;;; complaining for a while Brewester implemented a subset of the current
271 ;;; LISPM version for GNU Emacs.
272 ;;; 8/88 After complaining for a while (and with sufficient
273 ;;; promised rewards), Jim reimplemented a version of GNU completion
274 ;;; superior to that of the LISPM version.
275 ;;;
276 ;;;-----------------------------------------------
277 ;;; Acknowlegements
278 ;;;-----------------------------------------------
279 ;;; Cliff Lasser (cal@think.com), Kevin Herbert (kph@cisco.com),
280 ;;; eero@media-lab, kgk@cs.brown.edu, jla@ai.mit.edu,
281 ;;;
282 ;;;-----------------------------------------------
283 ;;; Change Log
284 ;;;-----------------------------------------------
285 ;;; From version 9 to 10
286 ;;; - Allowance for non-integral *completion-version* nos.
287 ;;; - Fix cmpl-apply-as-top-level for keyboard macros
288 ;;; - Fix broken completion merging (in save-completions-to-file)
289 ;;; - More misc. fixes for version 19.0 of emacs
290 ;;;
291 ;;; From Version 8 to 9
292 ;;; - Ported to version 19.0 of emacs (backcompatible with version 18)
293 ;;; - Added add-completions-from-tags-table (with thanks to eero@media-lab)
294 ;;;
295 ;;; From Version 7 to 8
296 ;;; - Misc. changes to comments
297 ;;; - new completion key bindings: c-x o, M->, M-<, c-a, c-e
298 ;;; - cdabbrev now checks all the visible window buffers and the "other buffer"
299 ;;; - `%' is now a symbol character rather than a separator (except in C mode)
300 ;;;
301 ;;; From Version 6 to 7
302 ;;; - Fixed bug with saving out .completion file the first time
303 ;;;
304 ;;; From Version 5 to 6
305 ;;; - removed statistics recording
306 ;;; - reworked advise to handle autoloads
307 ;;; - Fixed fortran mode support
308 ;;; - Added new cursor motion triggers
309 ;;;
310 ;;; From Version 4 to 5
311 ;;; - doesn't bother saving if nothing has changed
312 ;;; - auto-save if haven't used for a 1/2 hour
313 ;;; - save period extended to two weeks
314 ;;; - minor fix to capitalization code
315 ;;; - added *completion-auto-save-period* to variables recorded.
316 ;;; - added reenter protection to cmpl-record-statistics-filter
317 ;;; - added backup protection to save-completions-to-file (prevents
318 ;;; problems with disk full errors)
319 \f
320 ;;;-----------------------------------------------
321 ;;; Requires
322 ;;; Version
323 ;;;-----------------------------------------------
325 ;;(require 'cl) ;; DOTIMES, etc. {actually done after variable defs.}
330 ;;;---------------------------------------------------------------------------
331 ;;; User changeable parameters
332 ;;;---------------------------------------------------------------------------
335 "*Set to nil to turn off the completion hooks.
339 "*If non-nil, the most useful completions are saved to disk when
346 "*The maximum amount of time to save a completion for if it has not been used.
347 In hours. (1 day = 24, 1 week = 168). If this is 0, non-permanent completions
351 "*If non-nil, typing a separator character after a completion symbol that
355 "*Set this to the number of versions you want save-completions-to-file
359 "*The baud rate at or above which to print the next potential completion
360 after inserting the current one."
361 )
364 "*If non-nil, the next completion prompt will also do a cdabbrev search.
368 "*How far to search for cdabbrevs. In number of characters. If nil, the
372 "*A list of modes {either C or Lisp}. Definitions from visited files
379 "*The period in seconds to wait for emacs to be idle before autosaving
383 "*The minimum length of a stored completion.
387 "*The maximum length of a stored completion.
391 "The minimum length of a completion search string.
395 ;; eval everything before expanding
401 ;; These vars. are defined at both compile and load time.
405 ;; Need this file around too
410 ;;;---------------------------------------------------------------------------
411 ;;; Internal Variables
412 ;;;---------------------------------------------------------------------------
415 "Set to t when the completion system is initialized. Indicates that the
419 "Set to T as soon as the first completion has been accepted. Used to
422 \f
423 ;;;---------------------------------------------------------------------------
424 ;;; Low level tools
425 ;;;---------------------------------------------------------------------------
427 ;;;-----------------------------------------------
428 ;;; Misc.
429 ;;;-----------------------------------------------
436 "True iff the current window is the minibuffer."
441 ;; True iff symbol is represents an autoloaded function and has not yet been
442 ;; autoloaded.
445 )))
448 ;; True iff symbol is bound to a loaded function.
452 ;; Like the #. reader macro
455 ;;;-----------------------------------------------
456 ;;; Emacs Version 19 compatibility
457 ;;;-----------------------------------------------
463 baud-rate
471 ;;;-----------------------------------------------
472 ;;; Advise
473 ;;;-----------------------------------------------
476 "Adds the body code before calling function. This advise is not compiled.
477 WHERE is either :BEFORE or :AFTER."
479 )
482 "Calls function-name interactively if inside a call-interactively."
485 )
491 ))
498 ;; This condition-case is here to stave
499 ;; off bizarre load time errors 18.52 gets
500 ;; on the function c-mode
504 )
508 )))
514 )
524 quoted-new-name))
526 )))
527 )
531 )
540 (:before
544 (:after
547 body)
548 )))
549 )))
550 ))))
554 ;;;-----------------------------------------------
555 ;;; String case coercion
556 ;;;-----------------------------------------------
559 "Returns :capitalized, :up, :down, :mixed, or :neither."
573 ))
575 ;;; Tests -
576 ;;; (cmpl-string-case-type "123ABCDEF456") --> :up
577 ;;; (cmpl-string-case-type "123abcdef456") --> :down
578 ;;; (cmpl-string-case-type "123aBcDeF456") --> :mixed
579 ;;; (cmpl-string-case-type "123456") --> :neither
580 ;;; (cmpl-string-case-type "Abcde123") --> :capitalized
588 string)
590 ))
594 )
596 ;; Found string is in a standard case. Coerce to a type based on
597 ;; the given string
600 )
602 ;; If the found string is in some unusual case, just insert it
603 ;; as is
604 string-to-coerce)
605 )))
607 ;;; Tests -
608 ;;; (cmpl-merge-string-cases "AbCdEf456" "abc") --> AbCdEf456
609 ;;; (cmpl-merge-string-cases "abcdef456" "ABC") --> ABCDEF456
610 ;;; (cmpl-merge-string-cases "ABCDEF456" "Abc") --> Abcdef456
611 ;;; (cmpl-merge-string-cases "ABCDEF456" "abc") --> abcdef456
613 \f
614 ;;;-----------------------------------------------
615 ;;; Emacs Idle Time hooks
616 ;;;-----------------------------------------------
624 "Initialize the emacs idle process."
627 ;; do not allocate a pty
635 "loadst"
639 ))
646 ;; returns T if emacs has been idle
651 )
652 t ;; idle
653 ;; otherwise, update count
658 nil
659 ))
668 ;; This gets called every cmpl-emacs-idle-interval seconds
669 ;; Update idle time clock
675 ;; Don't reenter if we are hung
683 ))
685 ))
687 \f
688 ;;;-----------------------------------------------
689 ;;; Time
690 ;;;-----------------------------------------------
691 ;;; What a backwards way to get the time! Unfortunately, GNU Emacs
692 ;;; doesn't have an accessible time function.
697 cmpl-hours-per-day))
706 "Month is an integer from 1 to 12. Year is a two digit integer (19XX)"
710 ;; minus two to account for 1968 rather than 1900
711 ;; month
712 (* cmpl-hours-per-day
714 cmpl-days-since-start-of-leap-year
715 cmpl-days-since-start-of-year)))
717 hours))
720 "Month string is a three char. month string"
723 )
728 count))
731 "String is a string in the format of current-time-string (the default)."
737 )
740 ;;; Tests -
741 ;;;(cmpl-hours-since-1900 "Wed Jan 1 00:00:28 1900") --> 35040
742 ;;;(cmpl-hours-since-1900 "Wed Nov 2 23:00:28 1988") --> 778751
743 ;;;(cmpl-hours-since-1900 "Wed Jan 23 14:34:28 1988") --> 771926
744 ;;;(cmpl-hours-since-1900 "Wed Feb 23 14:34:28 1988") --> 772670
745 ;;;(cmpl-hours-since-1900 "Wed Mar 23 14:34:28 1988") --> 773366
746 ;;;(cmpl-hours-since-1900 "Wed Apr 23 14:34:28 1988") --> 774110
747 ;;;(cmpl-hours-since-1900 "Wed May 23 14:34:28 1988") --> 774830
748 ;;;(cmpl-hours-since-1900 "Wed Jun 23 14:34:28 1988") --> 775574
749 ;;;(cmpl-hours-since-1900 "Wed Jul 23 14:34:28 1988") --> 776294
750 ;;;(cmpl-hours-since-1900 "Wed Aug 23 14:34:28 1988") --> 777038
751 ;;;(cmpl-hours-since-1900 "Wed Sep 23 14:34:28 1988") --> 777782
752 ;;;(cmpl-hours-since-1900 "Wed Oct 23 14:34:28 1988") --> 778502
753 ;;;(cmpl-hours-since-1900 "Wed Nov 23 14:34:28 1988") --> 779246
754 ;;;(cmpl-hours-since-1900 "Wed Dec 23 14:34:28 1988") --> 779966
755 ;;;(cmpl-hours-since-1900 "Wed Jan 23 14:34:28 1957") --> 500198
756 ;;;(cmpl-hours-since-1900 "Wed Feb 23 14:34:28 1957") --> 500942
757 ;;;(cmpl-hours-since-1900 "Wed Mar 23 14:34:28 1957") --> 501614
758 ;;;(cmpl-hours-since-1900 "Wed Apr 23 14:34:28 1957") --> 502358
759 ;;;(cmpl-hours-since-1900 "Wed May 23 14:34:28 1957") --> 503078
760 ;;;(cmpl-hours-since-1900 "Wed Jun 23 14:34:28 1957") --> 503822
761 ;;;(cmpl-hours-since-1900 "Wed Jul 23 14:34:28 1957") --> 504542
762 ;;;(cmpl-hours-since-1900 "Wed Aug 23 14:34:28 1957") --> 505286
763 ;;;(cmpl-hours-since-1900 "Wed Sep 23 14:34:28 1957") --> 506030
764 ;;;(cmpl-hours-since-1900 "Wed Oct 23 14:34:28 1957") --> 506750
765 ;;;(cmpl-hours-since-1900 "Wed Nov 23 14:34:28 1957") --> 507494
766 ;;;(cmpl-hours-since-1900 "Wed Dec 23 14:34:28 1957") --> 508214
768 \f
769 ;;;---------------------------------------------------------------------------
770 ;;; "Symbol" parsing functions
771 ;;;---------------------------------------------------------------------------
772 ;;; The functions symbol-before-point, symbol-under-point, etc. quickly return
773 ;;; an appropriate symbol string. The strategy is to temporarily change
774 ;;; the syntax table to enable fast symbol searching. There are three classes
775 ;;; of syntax in these "symbol" syntax tables ::
776 ;;;
777 ;;; syntax (?_) - "symbol" chars (e.g. alphanumerics)
778 ;;; syntax (?w) - symbol chars to ignore at end of words (e.g. period).
779 ;;; syntax (? ) - everything else
780 ;;;
781 ;;; Thus by judicious use of scan-sexps and forward-word, we can get
782 ;;; the word we want relatively fast and without consing.
783 ;;;
784 ;;; Why do we need a separate category for "symbol chars to ignore at ends" ?
785 ;;; For example, in LISP we want starting :'s trimmed
786 ;;; so keyword argument specifiers also define the keyword completion. And,
787 ;;; for example, in C we want `.' appearing in a structure ref. to
788 ;;; be kept intact in order to store the whole structure ref.; however, if
789 ;;; it appears at the end of a symbol it should be discarded because it is
790 ;;; probably used as a period.
792 ;;; Here is the default completion syntax ::
793 ;;; Symbol chars :: A-Z a-z 0-9 @ / \ * + ~ $ < > %
794 ;;; Symbol chars to ignore at ends :: _ : . -
795 ;;; Separator chars. :: <tab> <space> ! ^ & ( ) = ` | { } [ ] ; " ' #
796 ;;; , ? <Everything else>
798 ;;; Mode specific differences and notes ::
799 ;;; LISP diffs ->
800 ;;; Symbol chars :: ! & ? = ^
801 ;;;
802 ;;; C diffs ->
803 ;;; Separator chars :: + * / : %
804 ;;; A note on the hypen (`-'). Perhaps, the hypen should also be a separator
805 ;;; char., however, we wanted to have completion symbols include pointer
806 ;;; references. For example, "foo->bar" is a symbol as far as completion is
807 ;;; concerned.
808 ;;;
809 ;;; FORTRAN diffs ->
810 ;;; Separator chars :: + - * / :
811 ;;;
812 ;;; Pathname diffs ->
813 ;;; Symbol chars :: .
814 ;;; Of course there is no pathname "mode" and in fact we have not implemented
815 ;;; this table. However, if there was such a mode, this is what it would look
816 ;;; like.
818 ;;;-----------------------------------------------
819 ;;; Table definitions
820 ;;;-----------------------------------------------
824 )
825 ;; alpha chars
829 ;; digit chars.
832 ;; Other ones
835 )
840 )
841 )
842 table))
849 )
852 table))
857 )
860 table))
865 )
868 table))
878 ;;;-----------------------------------------------
879 ;;; Installing the appropriate mode tables
880 ;;;-----------------------------------------------
884 )
888 )
893 )
895 ;;;-----------------------------------------------
896 ;;; Symbol functions
897 ;;;-----------------------------------------------
899 "Set to the first character of the symbol after one of the completion
902 "Set to the last character of the symbol after one of the completion
904 ;;; These are temp. vars. we use to avoid using let.
905 ;;; Why ? Small speed improvement.
910 "Returns the symbol that the point is currently on if it is longer
911 than *completion-min-length*."
915 ;; Cursor is on following-char and after preceding-char
920 ;; remove chars to ignore at the start
926 ))
927 ;; remove chars to ignore at the end
933 ))
934 ;; restore state
936 ;; Return completion if the length is reasonable
942 )
944 ;; restore table if no symbol
946 nil)
947 ))
949 ;;; tests for symbol-under-point
950 ;;; `^' indicates cursor pos. where value is returned
951 ;;; simple-word-test
952 ;;; ^^^^^^^^^^^^^^^^ --> simple-word-test
953 ;;; _harder_word_test_
954 ;;; ^^^^^^^^^^^^^^^^^^ --> harder_word_test
955 ;;; .___.______.
956 ;;; --> nil
957 ;;; /foo/bar/quux.hello
958 ;;; ^^^^^^^^^^^^^^^^^^^ --> /foo/bar/quux.hello
959 ;;;
962 "Returns a string of the symbol immediately before point
963 or nil if there isn't one longer than *completion-min-length*."
964 ;; This is called when a word separator is typed so it must be FAST !
967 ;; Cursor is on following-char and after preceding-char
969 ;; No chars. to ignore at end
972 )
973 ;; remove chars to ignore at the start
979 ))
980 ;; restore state
982 ;; return value if long enough
984 (+ cmpl-symbol-start
987 )
989 ;; chars to ignore at end
992 ;; take off chars. from end
995 ;; remove chars to ignore at the start
1000 ))
1001 ;; restore state
1004 ;; Return completion if the length is reasonable
1010 )
1012 ;; restore table if no symbol
1014 nil)
1015 ))
1017 ;;; tests for symbol-before-point
1018 ;;; `^' indicates cursor pos. where value is returned
1019 ;;; simple-word-test
1020 ;;; ^ --> nil
1021 ;;; ^ --> nil
1022 ;;; ^ --> simple-w
1023 ;;; ^ --> simple-word-test
1024 ;;; _harder_word_test_
1025 ;;; ^ --> harder_word_test
1026 ;;; ^ --> harder_word_test
1027 ;;; ^ --> harder
1028 ;;; .___....
1029 ;;; --> nil
1032 ;;; This could be made slightly faster but it is better to avoid
1033 ;;; copying all the code.
1034 ;;; However, it is only used by the completion string prompter.
1035 ;;; If it comes into common use, it could be rewritten.
1044 ))
1048 ;; "Returns a string of the symbol immediately before point
1049 ;; or nil if there isn't one. Like symbol-before-point but doesn't trim the
1050 ;; end chars."
1051 ;; Cursor is on following-char and after preceding-char
1058 )
1059 ;; remove chars to ignore at the start
1065 ))
1066 ;; restore state
1068 ;; Return completion if the length is reasonable
1075 )
1077 ;; restore table if no symbol
1079 nil)
1080 ))
1082 ;;; tests for symbol-before-point-for-complete
1083 ;;; `^' indicates cursor pos. where value is returned
1084 ;;; simple-word-test
1085 ;;; ^ --> nil
1086 ;;; ^ --> nil
1087 ;;; ^ --> simple-w
1088 ;;; ^ --> simple-word-test
1089 ;;; _harder_word_test_
1090 ;;; ^ --> harder_word_test
1091 ;;; ^ --> harder_word_test_
1092 ;;; ^ --> harder_
1093 ;;; .___....
1094 ;;; --> nil
1097 \f
1098 ;;;---------------------------------------------------------------------------
1099 ;;; Statistics Recording
1100 ;;;---------------------------------------------------------------------------
1102 ;;; Note that the guts of this has been turned off. The guts
1103 ;;; are in completion-stats.el.
1105 ;;;-----------------------------------------------
1106 ;;; Conditionalizing code on *record-cmpl-statistics-p*
1107 ;;;-----------------------------------------------
1108 ;;; All statistics code outside this block should use this
1110 "Only executes body if we are recording statistics."
1113 ))
1115 ;;;-----------------------------------------------
1116 ;;; Completion Sources
1117 ;;;-----------------------------------------------
1119 ;; ID numbers
1131 \f
1132 ;;;---------------------------------------------------------------------------
1133 ;;; Completion Method #2: dabbrev-expand style
1134 ;;;---------------------------------------------------------------------------
1135 ;;;
1136 ;;; This method is used if there are no useful stored completions. It is
1137 ;;; based on dabbrev-expand with these differences :
1138 ;;; 1) Faster (we don't use regexps)
1139 ;;; 2) case coercion handled correctly
1140 ;;; This is called cdabbrev to differentiate it.
1141 ;;; We simply search backwards through the file looking for words which
1142 ;;; start with the same letters we are trying to complete.
1143 ;;;
1146 ;;; "A list of all the cdabbrev completions since the last reset.")
1149 ;;; "The current point position the cdabbrev search is at.")
1152 ;;; "The current window we are looking for cdabbrevs in. T if looking in
1153 ;;; (other-buffer), NIL if no more cdabbrevs.")
1156 ;;; "T if the cdabbrev search has wrapped around the file.")
1161 ;;; Test strings for cdabbrev
1162 ;;; cdat-upcase ;;same namestring
1163 ;;; CDAT-UPCASE ;;ok
1164 ;;; cdat2 ;;too short
1165 ;;; cdat-1-2-3-4 ;;ok
1166 ;;; a-cdat-1 ;;doesn't start correctly
1167 ;;; cdat-simple ;;ok
1171 "Resets the cdabbrev search to search for abbrev-string.
1172 initial-completions-tried is a list of downcased strings to ignore
1173 during the search."
1175 cdabbrev-completions-tried
1177 )
1179 )
1182 ;; cdabbrev-current-window must not be NIL
1186 )
1190 "Resets the cdabbrev search to search for abbrev-string.
1191 initial-completions-tried is a list of downcased strings to ignore
1192 during the search."
1193 ;; Set the window
1196 )
1198 ;; Everything has failed
1203 ;; No more windows, try other buffer.
1205 )
1210 cdabbrev-start-point cdabbrev-current-point
1211 cdabbrev-stop-point
1216 cdabbrev-wrapped-p nil)
1217 )))
1220 "Return the next possible cdabbrev expansion or nil if there isn't one.
1221 reset-cdabbrev must've been called. This is sensitive to case-fold-search."
1222 ;; note that case-fold-search affects the behavior of this function
1223 ;; Bug: won't pick up an expansion that starts at the top of buffer
1226 saved-syntax
1228 downcase-expansion tried-list syntax saved-point-2)
1232 ;; Switch to current completion buffer
1234 ;; Save current buffer state
1237 ;; Restore completion state
1240 ;; Loop looking for completions
1242 ;; This code returns t if it should loop again
1246 ;; return nil if the completion is valid
1249 ;; does it start with a separator char ?
1252 ;; symbol char to ignore at end. Are we at end ?
1259 ))))
1260 ;; is the symbol long enough ?
1262 ;; have we not tried this one before
1264 ;; See if we've already used it
1270 ;; Already tried, don't choose this one
1272 )
1273 ;; at this point tried-list will be nil if this
1274 ;; expansion has not yet been tried
1277 t)
1278 ))))
1279 ;; search failed
1281 ;; If already wrapped, then we've failed completely
1282 nil)
1284 ;; need to wrap
1291 ))
1292 ;; end of while loop
1294 ;; successful
1298 )
1301 ))
1302 ;; If no expansion, go to next window
1306 )))
1308 ;;; The following must be eval'd in the minibuffer ::
1309 ;;; (reset-cdabbrev "cdat")
1310 ;;; (next-cdabbrev) --> "cdat-simple"
1311 ;;; (next-cdabbrev) --> "cdat-1-2-3-4"
1312 ;;; (next-cdabbrev) --> "CDAT-UPCASE"
1313 ;;; (next-cdabbrev) --> "cdat-wrapping"
1314 ;;; (next-cdabbrev) --> "cdat_start_sym"
1315 ;;; (next-cdabbrev) --> nil
1316 ;;; (next-cdabbrev) --> nil
1317 ;;; (next-cdabbrev) --> nil
1319 ;;; _cdat_start_sym
1320 ;;; cdat-wrapping
1322 \f
1323 ;;;---------------------------------------------------------------------------
1324 ;;; Completion Database
1325 ;;;---------------------------------------------------------------------------
1327 ;;; We use two storage modes for the two search types ::
1328 ;;; 1) Prefix {cmpl-prefix-obarray} for looking up possible completions
1329 ;;; Used by search-completion-next
1330 ;;; the value of the symbol is nil or a cons of head and tail pointers
1331 ;;; 2) Interning {cmpl-obarray} to see if it's in the database
1332 ;;; Used by find-exact-completion, completion-in-database-p
1333 ;;; The value of the symbol is the completion entry
1335 ;;; bad things may happen if this length is changed due to the way
1336 ;;; GNU implements obarrays
1340 "An obarray used to store the downcased completion prefices.
1344 "An obarray used to store the downcased completions.
1347 ;;;-----------------------------------------------
1348 ;;; Completion Entry Structure Definition
1349 ;;;-----------------------------------------------
1351 ;;; A completion entry is a LIST of string, prefix-symbol num-uses, and
1352 ;;; last-use-time (the time the completion was last used)
1353 ;;; last-use-time is T if the string should be kept permanently
1354 ;;; num-uses is incremented everytime the completion is used.
1356 ;;; We chose lists because (car foo) is faster than (aref foo 0) and the
1357 ;;; creation time is about the same.
1359 ;;; READER MACROS
1365 ;; "The number of times it has used. Used to decide whether to save
1366 ;; it."
1370 ;; "The time it was last used. In hours since 1900. Used to decide
1371 ;; whether to save it. T if one should always save it."
1377 ;;; WRITER MACROS
1387 ;;; CONSTRUCTOR
1389 "Returns a list of a completion entry."
1392 ;; Obsolete
1393 ;;(defmacro cmpl-prefix-entry-symbol (completion-entry)
1394 ;; (list 'car (list 'cdr completion-entry)))
1397 \f
1398 ;;;-----------------------------------------------
1399 ;;; Prefix symbol entry definition
1400 ;;;-----------------------------------------------
1401 ;;; A cons of (head . tail)
1403 ;;; READER Macros
1411 ;;; WRITER Macros
1419 ;;; Contructor
1422 "Makes a new prefix entry containing only completion-entry."
1425 ;;;-----------------------------------------------
1426 ;;; Completion Database - Utilities
1427 ;;;-----------------------------------------------
1430 "Initializes the completion storage. All existing completions are lost."
1436 )
1439 "Returns a list of all the known completion entries."
1442 return-completions))
1448 return-completions))))
1451 "Returns a list of lists of all the known completion entries organized by
1452 hash bucket."
1455 return-completions))
1461 return-completions))))
1463 \f
1464 ;;;-----------------------------------------------
1465 ;;; Updating the database
1466 ;;;-----------------------------------------------
1467 ;;;
1468 ;;; These are the internal functions used to update the datebase
1469 ;;;
1470 ;;;
1472 ;;"Set to a string that is pending its acceptance."
1473 ;; this checked by the top level reading functions
1476 ;; "Setup by find-exact-completion, etc. The given string, downcased."
1478 ;; "The interned symbol corresponding to cmpl-db-downcase-string.
1479 ;; Set up by cmpl-db-symbol."
1481 ;; "The interned prefix symbol corresponding to cmpl-db-downcase-string."
1486 ;;; READS
1488 "Returns the completion entry for string or nil.
1489 Sets up cmpl-db-downcase-string and cmpl-db-symbol."
1492 cmpl-obarray)))
1494 ))
1497 "Returns the prefix entry for string. Sets cmpl-db-prefix-symbol.
1498 Prefix-string must be exactly *completion-prefix-min-length* long
1499 and downcased. Sets up cmpl-db-prefix-symbol."
1505 ;; used to trap lossage in silent error correction
1508 "Locates the completion entry. Returns a pointer to the element
1509 before the completion entry or nil if the completion entry is at the head.
1510 Must be called after find-exact-completion."
1512 next-prefix-list
1513 )
1516 ;; not already at head
1520 )))
1523 prefix-list)
1524 ;; Didn't find it. Database is messed up.
1526 ;; not found, error if debug mode
1528 string))
1530 ;; recursive error: really scrod
1533 ;; Patch out
1535 ;; Retry
1537 ))))))
1550 )
1552 ;; try again
1554 ;; still losing
1556 )))
1559 ;; recursive error: really scrod
1561 )
1563 ;;; WRITES
1565 "If the string is not in the database it is added to the end of the
1566 approppriate prefix list with num-uses = 0. The database is unchanged if it
1567 is there. string must be longer than *completion-prefix-min-length*.
1568 This must be very fast.
1569 Returns the completion entry."
1571 ;; not there
1574 ;; setup the prefix
1579 )
1580 ;; The next two forms should happen as a unit (atomically) but
1581 ;; no fatal errors should result if that is not the case.
1583 ;; These two should be atomic, but nothing fatal will happen
1584 ;; if they're not.
1589 ))
1590 ;; statistics
1593 ;; set symbol
1595 )))
1598 "If the string is not in the database it is added to the head of the
1599 approppriate prefix list. Otherwise it is moved to the head of the list.
1600 string must be longer than *completion-prefix-min-length*.
1601 Updates the saved string with the supplied string.
1602 This must be very fast.
1603 Returns the completion entry."
1604 ;; Handle pending acceptance
1606 ;; test if already in database
1608 ;; found
1615 )
1616 ;; update entry
1618 ;; move to head (if necessary)
1620 ;; These should all execute atomically but it is not fatal if
1621 ;; they don't.
1622 ;; splice it out
1624 ;; fix up tail if necessary
1626 ;; splice in at head
1629 ))
1630 cmpl-db-entry)
1631 ;; not there
1634 ;; setup the prefix
1639 )
1641 ;; Splice in at head
1645 ;; Start new prefix entry
1647 ))
1648 ;; statistics
1651 ;; Add it to the symbol
1653 )))
1656 "Deletes the completion from the database. string must be longer than
1657 *completion-prefix-min-length*."
1658 ;; Handle pending acceptance
1661 ;; found
1667 )
1668 ;; delete symbol reference
1670 ;; remove from prefix list
1672 ;; not at head
1674 ;; fix up tail if necessary
1676 )
1678 ;; at head
1681 ;; List is now empty
1683 ))
1686 )
1688 ))
1690 ;;; Tests --
1691 ;;; - Add and Find -
1692 ;;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1693 ;;; (find-exact-completion "banana") --> ("banana" 0 nil 0)
1694 ;;; (find-exact-completion "bana") --> nil
1695 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1696 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1697 ;;; (add-completion-to-head "banish") --> ("banish" 0 nil 0)
1698 ;;; (find-exact-completion "banish") --> ("banish" 0 nil 0)
1699 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1700 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1701 ;;; (add-completion-to-head "banana") --> ("banana" 0 nil 0)
1702 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1703 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1704 ;;;
1705 ;;; - Deleting -
1706 ;;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1707 ;;; (delete-completion "banner")
1708 ;;; (find-exact-completion "banner") --> nil
1709 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1710 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1711 ;;; (add-completion-to-head "banner") --> ("banner" 0 nil 0)
1712 ;;; (delete-completion "banana")
1713 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banish" ...))
1714 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banish" ...))
1715 ;;; (delete-completion "banner")
1716 ;;; (delete-completion "banish")
1717 ;;; (find-cmpl-prefix-entry "ban") --> nil
1718 ;;; (delete-completion "banner") --> error
1719 ;;;
1720 ;;; - Tail -
1721 ;;; (add-completion-to-tail-if-new "banana") --> ("banana" 0 nil 0)
1722 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1723 ;;; (cdr (find-cmpl-prefix-entry "ban")) --> (("banana" ...))
1724 ;;; (add-completion-to-tail-if-new "banish") --> ("banish" 0 nil 0)
1725 ;;; (car (find-cmpl-prefix-entry "ban")) -->(("banana" ...) ("banish" ...))
1726 ;;; (cdr (find-cmpl-prefix-entry "ban")) -->(("banish" ...))
1727 ;;;
1729 \f
1730 ;;;---------------------------------------------------------------------------
1731 ;;; Database Update :: Interface level routines
1732 ;;;---------------------------------------------------------------------------
1733 ;;;
1734 ;;; These lie on top of the database ref. functions but below the standard
1735 ;;; user interface level
1744 )
1746 )
1749 ))
1754 string)
1758 "If the string is not there, it is added to the head of the completion list.
1759 Otherwise, it is moved to the head of the list.
1760 The completion is altered appropriately if num-uses and/or last-use-time is
1761 specified."
1765 cmpl-source-interactive
1766 current-completion-source))
1772 ))
1775 "Adds string if it isn't already there and and makes it a permanent string."
1779 cmpl-source-interactive
1780 current-completion-source))
1781 )
1783 ))
1789 )
1792 "Accepts the pending completion in completion-to-accept.
1793 This bumps num-uses. Called by add-completion-to-head and
1794 completion-search-reset."
1796 ;; if this is added afresh here, then it must be a cdabbrev
1798 entry
1799 )
1804 ))
1807 "Call this to add the completion symbol underneath the point into
1808 the completion buffer."
1814 "Call this to add the completion symbol before point into
1815 the completion buffer."
1821 "Call this to add the completion symbol before point into
1822 the completion buffer."
1828 "Call this to add the completion symbol before point into
1829 the completion buffer. Completions added this way will automatically be
1830 saved if *separator-character-uses-completion-p* is non-nil."
1833 entry)
1836 )
1843 )))
1844 ))
1846 ;;; Tests --
1847 ;;; - Add and Find -
1848 ;;; (add-completion "banana" 5 10)
1849 ;;; (find-exact-completion "banana") --> ("banana" 5 10 0)
1850 ;;; (add-completion "banana" 6)
1851 ;;; (find-exact-completion "banana") --> ("banana" 6 10 0)
1852 ;;; (add-completion "banish")
1853 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banish" ...) ("banana" ...))
1854 ;;;
1855 ;;; - Accepting -
1856 ;;; (setq completion-to-accept "banana")
1857 ;;; (accept-completion)
1858 ;;; (find-exact-completion "banana") --> ("banana" 7 10)
1859 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banana" ...) ("banish" ...))
1860 ;;; (setq completion-to-accept "banish")
1861 ;;; (add-completion "banner")
1862 ;;; (car (find-cmpl-prefix-entry "ban"))
1863 ;;; --> (("banner" ...) ("banish" 1 ...) ("banana" 7 ...))
1864 ;;;
1865 ;;; - Deleting -
1866 ;;; (kill-completion "banish")
1867 ;;; (car (find-cmpl-prefix-entry "ban")) --> (("banner" ...) ("banana" ...))
1869 \f
1870 ;;;---------------------------------------------------------------------------
1871 ;;; Searching the database
1872 ;;;---------------------------------------------------------------------------
1873 ;;; Functions outside this block must call completion-search-reset followed
1874 ;;; by calls to completion-search-next or completion-search-peek
1875 ;;;
1877 ;;; Status variables
1878 ;; Commented out to improve loading speed
1880 ;; "The current string used by completion-search-next."
1882 ;; "The current regexp used by completion-search-next.
1883 ;; (derived from cmpl-test-string)"
1885 ;; "The last index that completion-search-next was called with."
1887 ;; "Set to t when cdabbrevs have been reset."
1889 ;; "A pointer to the element BEFORE the next set of possible completions.
1890 ;; cadr of this is the cmpl-next-possibility"
1892 ;; "The initial list of starting possibilities."
1894 ;; "The cached next possibility."
1896 ;; "A downcased list of all the completions we have tried."
1900 "Given a string, sets up the get-completion and completion-search-next functions.
1901 String must be longer than *completion-prefix-min-length*."
1906 cmpl-test-string string
1909 )
1913 cmpl-next-possibility nil
1914 cmpl-cdabbrev-reset-p nil
1915 cmpl-last-index -1
1916 cmpl-tried-list nil
1917 ))
1920 "Returns the next completion entry. If index is out of sequence it resets
1921 and starts from the top. If there are no more entries it tries cdabbrev and
1922 returns only a string."
1929 ;; reverse the possibilities list
1931 ;; do a "normal" search
1935 )
1937 ;; If no more possibilities, leave it that way
1939 ;; next completion is at index 0. reset next-possibility list
1940 ;; to start at beginning
1943 ;; otherwise point to one before current
1947 cmpl-starting-possibilities))
1948 )))
1950 ;; non-negative index, reset and search
1951 ;;(prin1 'reset)
1957 ))
1958 )
1960 cmpl-next-possibility
1962 ))
1966 "Returns the next completion entry without actually moving the pointers.
1967 Calling this again or calling completion-search-next will result in the same
1968 string being returned. Depends on case-fold-search.
1969 If there are no more entries it tries cdabbrev and then returns only a string."
1971 ;; return the cached value if we have it
1974 ;; still a few possibilities left
1980 ))
1981 cmpl-next-possibilities
1982 ))
1983 ;; successful match
1986 cmpl-tried-list)
1988 )
1989 cmpl-next-possibility)
1991 ;; unsuccessful, use cdabbrev
1995 ))
1997 )
1998 ;; Completely unsuccessful, return nil
1999 ))
2001 ;;; Tests --
2002 ;;; - Add and Find -
2003 ;;; (add-completion "banana")
2004 ;;; (completion-search-reset "ban")
2005 ;;; (completion-search-next 0) --> "banana"
2006 ;;;
2007 ;;; - Discrimination -
2008 ;;; (add-completion "cumberland")
2009 ;;; (add-completion "cumberbund")
2010 ;;; cumbering
2011 ;;; (completion-search-reset "cumb")
2012 ;;; (completion-search-peek t) --> "cumberbund"
2013 ;;; (completion-search-next 0) --> "cumberbund"
2014 ;;; (completion-search-peek t) --> "cumberland"
2015 ;;; (completion-search-next 1) --> "cumberland"
2016 ;;; (completion-search-peek nil) --> nil
2017 ;;; (completion-search-next 2) --> "cumbering" {cdabbrev}
2018 ;;; (completion-search-next 3) --> nil or "cumming"{depends on context}
2019 ;;; (completion-search-next 1) --> "cumberland"
2020 ;;; (completion-search-peek t) --> "cumbering" {cdabbrev}
2021 ;;;
2022 ;;; - Accepting -
2023 ;;; (completion-search-next 1) --> "cumberland"
2024 ;;; (setq completion-to-accept "cumberland")
2025 ;;; (completion-search-reset "foo")
2026 ;;; (completion-search-reset "cum")
2027 ;;; (completion-search-next 0) --> "cumberland"
2028 ;;;
2029 ;;; - Deleting -
2030 ;;; (kill-completion "cumberland")
2031 ;;; cummings
2032 ;;; (completion-search-reset "cum")
2033 ;;; (completion-search-next 0) --> "cumberbund"
2034 ;;; (completion-search-next 1) --> "cummings"
2035 ;;;
2036 ;;; - Ignoring Capitalization -
2037 ;;; (completion-search-reset "CuMb")
2038 ;;; (completion-search-next 0) --> "cumberbund"
2041 \f
2042 ;;;-----------------------------------------------
2043 ;;; COMPLETE
2044 ;;;-----------------------------------------------
2047 "Toggles whether or not new words are added to the database."
2051 )
2059 "Inserts a completion at point.
2060 Point is left at end. Consective calls rotate through all possibilities.
2061 Prefix args ::
2062 control-u :: leave the point at the beginning of the completion rather
2063 than at the end.
2064 a number :: rotate through the possible completions by that amount
2065 `-' :: same as -1 (insert previous completion)
2066 {See the comments at the top of completion.el for more info.}
2067 "
2069 ;;; Set up variables
2071 ;; Undo last one
2073 ;; get next completion
2075 )
2082 )
2085 ))
2086 ;; get string
2092 ;; get index
2094 ;; statistics
2097 ;; reset database
2099 ;; erase what we've got
2101 ))
2103 ;; point is at the point to insert the new symbol
2104 ;; Get the next completion
2110 string
2111 )
2112 ;; entry is either a completion entry or a string (if cdabbrev)
2114 ;; If found, insert
2116 ;; Setup for proper case
2120 string cmpl-original-string))
2121 ;; insert
2123 ;; accept it
2125 ;; fixup and cache point
2131 )
2132 ;; statistics
2135 ;; Done ! cmpl-stat-complete-successful
2136 ;;display the next completion
2139 ;; This updates the display and only prints if there
2140 ;; is no typeahead
2148 string cmpl-original-string))
2150 ))
2151 )
2154 ;; Don't accept completions
2156 ;; print message
2160 ;; statistics
2163 ;; Pretend that we were never here
2165 ))))
2167 ;;;-----------------------------------------------
2168 ;;; "Complete" Key Keybindings
2169 ;;;-----------------------------------------------
2171 ;;; Complete key definition
2172 ;;; These define c-return and meta-return
2173 ;;; In any case you really want to bind this to a single keystroke
2176 ;; this can fail if some of the prefix chars. are already used
2177 ;; as commands (this happens on wyses)
2180 ))
2183 )
2186 ;;; Tests -
2187 ;;; (add-completion "cumberland")
2188 ;;; (add-completion "cumberbund")
2189 ;;; cum
2190 ;;; Cumber
2191 ;;; cumbering
2192 ;;; cumb
2194 \f
2195 ;;;---------------------------------------------------------------------------
2196 ;;; Parsing definitions from files into the database
2197 ;;;---------------------------------------------------------------------------
2199 ;;;-----------------------------------------------
2200 ;;; Top Level functions ::
2201 ;;;-----------------------------------------------
2203 ;;; User interface
2205 "Parses all the definition names from a Lisp mode file and adds them to the
2206 completion database."
2213 )
2217 ))
2222 )
2225 )))
2233 mode
2234 )
2238 )
2242 )
2245 major-mode)
2246 ))
2251 start-num)))
2252 ))
2254 ;;; Find file hook
2259 )
2263 )
2265 )))
2266 ))
2270 ;;;-----------------------------------------------
2271 ;;; Tags Table Completions
2272 ;;;-----------------------------------------------
2275 ;; Inspired by eero@media-lab.media.mit.edu
2276 "Add completions from the current tags-table-buffer."
2289 )
2291 ))))
2293 \f
2294 ;;;-----------------------------------------------
2295 ;;; Lisp File completion parsing
2296 ;;;-----------------------------------------------
2297 ;;; This merely looks for phrases beginning with (def.... or
2298 ;;; (package:def ... and takes the next word.
2299 ;;;
2300 ;;; We tried using forward-lines and explicit searches but the regexp technique
2301 ;;; was faster. (About 100K characters per second)
2302 ;;;
2305 "A regexp that searches for lisp definition form."
2306 )
2308 ;;; Tests -
2309 ;;; (and (string-match *lisp-def-regexp* "\n(defun foo") (match-end 0)) -> 8
2310 ;;; (and (string-match *lisp-def-regexp* "\n(si:def foo") (match-end 0)) -> 9
2311 ;;; (and (string-match *lisp-def-regexp* "\n(def-bar foo")(match-end 0)) -> 10
2312 ;;; (and (string-match *lisp-def-regexp* "\n(defun (foo") (match-end 0)) -> 9
2315 "Parses all the definition names from a Lisp mode buffer and adds them to
2316 the completion database."
2317 ;;; Benchmarks
2318 ;;; Sun-3/280 - 1500 to 3000 lines of lisp code per second
2327 )
2329 ))))
2331 \f
2332 ;;;-----------------------------------------------
2333 ;;; C file completion parsing
2334 ;;;-----------------------------------------------
2335 ;;; C :
2336 ;;; Looks for #define or [<storage class>] [<type>] <name>{,<name>}
2337 ;;; or structure, array or pointer defs.
2338 ;;; It gets most of the definition names.
2339 ;;;
2340 ;;; As you might suspect by now, we use some symbol table hackery
2341 ;;;
2342 ;;; Symbol separator chars (have whitespace syntax) --> , ; * = (
2343 ;;; Opening char --> [ {
2344 ;;; Closing char --> ] }
2345 ;;; openning and closing must be skipped over
2346 ;;; Whitespace chars (have symbol syntax)
2347 ;;; Everything else has word syntax
2352 ;; unforunately the ?( causes the parens to appear unbalanced
2354 ))
2355 )
2356 ;; default syntax is whitespace
2367 table))
2371 ;;; Regexps
2373 ;; This stops on lines with possible definitions
2375 ;; This stops after the symbol to add.
2376 ;;"\n\\(#define\\s +.\\|\\(\\(\\w\\|\\s_\\)+\\b\\s *\\)+[(;,[*{=]\\)"
2377 ;; This stops before the symbol to add. {Test cases in parens. below}
2378 ;;"\n\\(\\(\\w\\|\\s_\\)+\\s *(\\|\\(\\(#define\\|auto\\|extern\\|register\\|static\\|int\\|long\\|short\\|unsigned\\|char\\|void\\|float\\|double\\|enum\\|struct\\|union\\|typedef\\)\\s +\\)+\\)"
2379 ;; this simple version picks up too much extraneous stuff
2380 ;; "\n\\(\\w\\|\\s_\\|#\\)\\B"
2381 "A regexp that searches for a definition form."
2382 )
2383 ;
2384 ;(defconst *c-cont-regexp*
2385 ; "\\(\\w\\|\\s_\\)+\\b\\s *\\({\\|\\(\\[[0-9\t ]*\\]\\s *\\)*,\\(*\\|\\s \\)*\\b\\)"
2386 ; "This regexp should be used in a looking-at to parse for lists of variables.")
2387 ;
2388 ;(defconst *c-struct-regexp*
2389 ; "\\(*\\|\\s \\)*\\b"
2390 ; "This regexp should be used to test whether a symbol follows a structure definition.")
2392 ;(defun test-c-def-regexp (regexp string)
2393 ; (and (eq 0 (string-match regexp string)) (match-end 0))
2394 ; )
2396 ;;; Tests -
2397 ;;; (test-c-def-regexp *c-def-regexp* "\n#define foo") -> 10 (9)
2398 ;;; (test-c-def-regexp *c-def-regexp* "\nfoo (x, y) {") -> 6 (6)
2399 ;;; (test-c-def-regexp *c-def-regexp* "\nint foo (x, y)") -> 10 (5)
2400 ;;; (test-c-def-regexp *c-def-regexp* "\n int foo (x, y)") -> nil
2401 ;;; (test-c-def-regexp *c-cont-regexp* "oo, bar") -> 4
2402 ;;; (test-c-def-regexp *c-cont-regexp* "oo, *bar") -> 5
2403 ;;; (test-c-def-regexp *c-cont-regexp* "a [5][6], bar") -> 10
2404 ;;; (test-c-def-regexp *c-cont-regexp* "oo(x,y)") -> nil
2405 ;;; (test-c-def-regexp *c-cont-regexp* "a [6] ,\t bar") -> 9
2406 ;;; (test-c-def-regexp *c-cont-regexp* "oo {trout =1} my_carp;") -> 14
2407 ;;; (test-c-def-regexp *c-cont-regexp* "truct_p complex foon") -> nil
2410 "Parses all the definition names from a C mode buffer and adds them to the
2411 completion database."
2412 ;; Benchmark --
2413 ;; Sun 3/280-- 1250 lines/sec.
2417 )
2423 ;; we loop here only when scan-sexps fails
2424 ;; (i.e. unbalance exps.)
2431 ;; preprocessor macro, see if it's one we handle
2435 )
2436 ;; skip forward over definition symbol
2437 ;; and add it to database
2440 ;;(push string foo)
2442 ))))
2444 ;; C definition
2447 next-point
2448 ;; scan to next separator char.
2450 )
2451 ;; position the point on the word we want to add
2454 ;; handle pointer ref
2455 ;; move to next separator char.
2458 )
2460 ;; add to database
2462 ;; (push string foo)
2464 ;; Local TMC hack (useful for parsing paris.h)
2470 ))
2472 )
2473 )
2474 ;; go to next
2476 ;; (push (format "%c" (following-char)) foo)
2478 ;; if on an opening delimiter, go to end
2482 )
2484 ;; Current char is an end char.
2486 ))
2487 ))))
2490 )
2492 ;; Check for failure in scan-sexps
2496 ;; unbalanced paren., keep going
2497 ;;(ding)
2501 ))
2502 ))
2504 )))))
2506 \f
2507 ;;;---------------------------------------------------------------------------
2508 ;;; Init files
2509 ;;;---------------------------------------------------------------------------
2512 "The version of save-completions-to-file called at kill-emacs
2513 time."
2520 ))
2521 ))
2524 ";;; Completion Initialization file.
2525 ;;; Version = %s
2526 ;;; Format is (<string> . <last-use-time>)
2527 ;;; <string> is the completion
2528 ;;; <last-use-time> is the time the completion was last used
2529 ;;; If it is t, the completion will never be pruned from the file.
2530 ;;; Otherwise it is in hours since 1900.
2537 "Saves a completion init file. If file is not specified,
2538 then *saved-completions-filename* is used."
2549 last-use-time
2555 )
2563 ;; file has changed on disk. Bring us up-to-date
2567 )
2569 ;; prepare the buffer to be modified
2572 ;; (/ 1 0)
2577 ;; Update num uses and maybe write completion to a file
2579 ;; permanent
2582 ;; or if
2584 ;; it's been used
2586 ;; or it was saved before and
2588 ;; *saved-completion-retention-time* is nil
2590 ;; or time since last use is < ...retention-time*
2593 )))
2594 ;; write to file
2598 )))
2600 ;; write the buffer
2604 ;; If file exists . . .
2605 ;; Save a backup(so GNU doesn't screw us when we're out of disk)
2606 ;; (GNU leaves a 0 length file if it gets a disk full error!)
2608 ;; If backup doesn't exit, Rename current to backup
2609 ;; {If backup exists the primary file is probably messed up}
2612 ;; Copy the backup back to the current name
2613 ;; (so versioning works)
2615 )
2616 ;; Save it
2619 ;; If successful, remove backup
2621 ))
2625 ))
2626 ;; Reset accepted-p flag
2628 )
2631 )))
2637 cmpl-completions-accepted-p)
2639 ))
2644 "loads a completion init file. If file is not specified,
2645 then *saved-completions-filename* is used"
2650 )
2660 ;; prepare the buffer to be modified
2667 string num-uses entry last-use-time
2668 cmpl-entry cmpl-last-use-time
2674 )
2675 ;; insert the file into a buffer
2682 filename)))
2683 ;; parse it
2696 ;; handle case sensitivity
2702 ))
2703 ;; Valid entry
2704 ;; add it in
2709 ))
2714 ;; more recent
2716 ))
2717 ;; update last-use-time
2719 ))
2721 ;; Bad format
2724 ;; try to get back in sync
2726 )))
2729 )
2734 filename))
2736 ))
2737 ))
2741 total-in-file total-perm
2743 start-num)))
2745 )))))
2748 "Loads the default completions file and sets up so that exiting emacs will
2749 automatically save the file."
2753 ))
2756 )
2759 ;;;-----------------------------------------------
2760 ;;; Kill EMACS patch
2761 ;;;-----------------------------------------------
2764 ;; | All completion code should go in here
2765 ;;\ /
2767 ;;/ \
2768 ;; | All completion code should go in here
2771 )
2773 \f
2774 ;;;-----------------------------------------------
2775 ;;; Kill region patch
2776 ;;;-----------------------------------------------
2778 ;;; Patched to remove the most recent completion
2782 "Kill between point and mark.
2783 The text is deleted but saved in the kill ring.
2787 This is the primitive for programs to kill text (as opposed to deleting it).
2788 Supply two arguments, character numbers indicating the stretch of text
2789 to be killed.
2791 If the previous command was also a kill command,
2792 the text killed this time appends to the text killed last time
2793 to make one entry in the kill ring.
2794 Patched to remove the most recent completion."
2802 )
2807 )
2809 )))
2811 ;;;-----------------------------------------------
2812 ;;; Patches to self-insert-command.
2813 ;;;-----------------------------------------------
2815 ;;; Need 2 versions: generic seperator chars. and space (to get auto fill
2816 ;;; to work)
2818 ;;; All common separators (eg. space "(" ")" """) characters go through a
2819 ;;; function to add new words to the list of words to complete from:
2820 ;;; COMPLETION-SEPARATOR-SELF-INSERT-COMMAND (arg).
2821 ;;; If the character before this was an alpha-numeric then this adds the
2822 ;;; symbol befoe point to the completion list (using ADD-COMPLETION).
2828 )
2835 auto-fill-hook
2837 )
2839 ;;;-----------------------------------------------
2840 ;;; Wrapping Macro
2841 ;;;-----------------------------------------------
2843 ;;; Note that because of the way byte compiling works, none of
2844 ;;; the functions defined with this macro get byte compiled.
2847 "Add a call to update the completion database before the function is
2848 executed. TYPE is the type of the wrapper to be added. Can be :before or
2849 :under."
2851 function-name ':before
2856 (:under-or-before
2858 (:minibuffer-separator
2861 )
2862 new-name
2863 ))
2865 ;;;(defun foo (x y z) (+ x y z))
2866 ;;;foo
2867 ;;;(macroexpand '(def-completion-wrapper foo :under))
2868 ;;;(progn (defvar $$$cmpl-foo (symbol-function (quote foo))) (defun foo (&rest arglist) (progn (use-completion-under-point)) (cmpl-apply-as-top-level $$$cmpl-foo arglist)))
2869 ;;;(defun bar (x y z) "Documentation" (+ x y z))
2870 ;;;bar
2871 ;;;(macroexpand '(def-completion-wrapper bar :under))
2872 ;;;(progn (defvar $$$cmpl-bar (symbol-function (quote bar))) (defun bar (&rest arglist) "Documentation" (progn (use-completion-under-point)) (cmpl-apply-as-top-level $$$cmpl-bar arglist)))
2873 ;;;(defun quuz (x &optional y z) "Documentation" (interactive "P") (+ x y z))
2874 ;;;quuz
2875 ;;;(macroexpand '(def-completion-wrapper quuz :before))
2876 ;;;(progn (defvar $$$cmpl-quuz (symbol-function (quote quuz))) (defun quuz (&rest arglist) "Documentation" (interactive) (progn (use-completion-before-point)) (cmpl-apply-as-top-level $$$cmpl-quuz arglist)))
2879 ;;;---------------------------------------------------------------------------
2880 ;;; Patches to standard keymaps insert completions
2881 ;;;---------------------------------------------------------------------------
2883 ;;;-----------------------------------------------
2884 ;;; Separators
2885 ;;;-----------------------------------------------
2886 ;;; We've used the completion syntax table given as a guide.
2887 ;;;
2888 ;;; Global separator chars.
2889 ;;; We left out <tab> because there are too many special cases for it. Also,
2890 ;;; in normal coding it's rarely typed after a word.
2912 ;;; We include period and colon even though they are symbol chars because :
2913 ;;; - in text we want to pick up the last word in a sentence.
2914 ;;; - in C pointer refs. we want to pick up the first symbol
2915 ;;; - it won't make a difference for lisp mode (package names are short)
2919 ;;; Lisp Mode diffs
2927 ;;; C mode diffs.
2933 ;;; FORTRAN mode diffs. (these are defined when fortran is called)
2939 )
2941 ;;;-----------------------------------------------
2942 ;;; End of line chars.
2943 ;;;-----------------------------------------------
2951 ;;(def-completion-wrapper minibuffer-complete-and-exit :minibuffer)
2953 ;;;-----------------------------------------------
2954 ;;; Cursor movement
2955 ;;;-----------------------------------------------
2962 ;; we patch these explicitly so they byte compile and so we don't have to
2963 ;; patch the faster underlying function.
2968 If scan reaches end of buffer, stop there without error."
2972 )
2977 If scan reaches end of buffer, stop there without error."
2981 )
2985 On reaching end of buffer, stop and signal error."
2989 )
2992 On attempt to pass beginning or end of buffer, stop and signal error."
2996 ;; probably a failed completion if you have to back up
2999 )
3005 and nil is returned."
3009 )
3011 "Move backward until encountering the end of a word.
3012 With argument, do this that many times.
3013 In programs, it is faster to call forward-word with negative arg."
3017 ;; probably a failed completion if you have to back up
3020 )
3023 "Move forward across one balanced expression.
3024 With argument, do this that many times."
3028 )
3030 "Move backward across one balanced expression.
3031 With argument, do this that many times."
3035 ;; probably a failed completion if you have to back up
3038 )
3044 ARG was explicitly specified."
3047 ;; probably a failed completion if you have to back up
3050 )
3056 "Delete characters backward, changing tabs into spaces.
3057 Delete ARG chars, and kill (save in kill ring) if KILLP is non-nil.
3058 Interactively, ARG is the prefix arg (default 1)
3059 and KILLP is t if prefix arg is was specified."
3062 ;; probably a failed completion if you have to back up
3065 )
3078 ;;;-----------------------------------------------
3079 ;;; Misc.
3080 ;;;-----------------------------------------------
3090 ;;;-----------------------------------------------
3091 ;;; Local Thinking Machines stuff
3092 ;;;-----------------------------------------------
3106 ;;; Tests --
3107 ;;; foobarbiz
3108 ;;; foobar
3109 ;;; fooquux
3110 ;;; fooper