*** empty log message ***
[emacs.git] / lisp / hippie-exp.el
blob499e99352e2dfb737cc207b7793d5cd0ae58b167
1 ;;; hippie-exp.el --- expand text trying various ways to find its expansion
3 ;; Copyright (C) 1992 Free Software Foundation, Inc.
5 ;; Author: Anders Holst <aho@sans.kth.se>
6 ;; Last change: 3 March 1998
7 ;; Version: 1.6
8 ;; Keywords: abbrev convenience
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
15 ;; any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to the
24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25 ;; Boston, MA 02111-1307, USA.
27 ;;; Commentary:
29 ;; `hippie-expand' is a single function for a lot of different kinds
30 ;; of completions and expansions. Called repeatedly it tries all
31 ;; possible completions in succession.
32 ;; Which kinds of completions to try, and in which order, is
33 ;; determined by the contents of `hippie-expand-try-functions-list'.
34 ;; Much customization of `hippie-expand' can be made by changing the
35 ;; order of, removing, or inserting new functions in this list.
36 ;; Given a positive numeric argument, `hippie-expand' jumps directly
37 ;; ARG functions forward in this list. Given some other argument
38 ;; (a negative argument or just Ctrl-U) it undoes the tried
39 ;; completion.
41 ;; If the variable `hippie-expand-verbose' is non-nil, `hippie-expand'
42 ;; outputs in a message which try-function in the list that is used
43 ;; currently (ie. was used currently and will be tried first the next
44 ;; time).
45 ;; The variable `hippie-expand-max-buffers' determines in how many
46 ;; buffers, apart from the current, to search for expansions in. It
47 ;; is used by the try-functions named "-all-buffers".
48 ;; The variable `hippie-expand-ignore-buffers' is a list of regexps
49 ;; matching buffer names (as strings) or major modes (as atoms) of
50 ;; buffers that should not be searched by the try-functions named
51 ;; "-all-buffers".
52 ;; If set, the variable `hippie-expand-only-buffers' does the opposite
53 ;; of `hippie-expand-ignore-buffers', in that the search is restricted
54 ;; to only the kind of buffers listed.
55 ;; If the variable `hippie-expand-no-restriction' is non-nil, narrowed
56 ;; buffers are widened before they are searched.
57 ;; The variable `hippie-expand-dabbrev-skip-space' controls whether
58 ;; trailing spaces will be included in the abbreviation to search for,
59 ;; which then gives the same behavior as the original `dabbrev-expand'.
60 ;; The variable `hippie-expand-dabbrev-as-symbol' controls whether
61 ;; characters of syntax '_' is considered part of the words to expand
62 ;; dynamically.
63 ;; See also the macro `make-hippie-expand-function' below.
65 ;; A short description of the current try-functions in this file:
66 ;; `try-complete-file-name' : very convenient to have in any buffer,
67 ;; and not just in the minibuffer or (some) shell-mode. It goes
68 ;; through all possible completions instead of just completing as
69 ;; much as is unique.
70 ;; `try-complete-file-name-partially' : To insert in the list just
71 ;; before `try-complete-file-name' for those who want first to get
72 ;; a file name completed only as many characters as is unique.
73 ;; `try-expand-all-abbrevs' : can be removed if you don't use abbrevs.
74 ;; Otherwise it looks through all abbrev-tables, starting with
75 ;; the local followed by the global.
76 ;; `try-expand-line' : Searches the buffer for an entire line that
77 ;; begins exactly as the current line. Convenient sometimes, for
78 ;; example as a substitute for (or complement to) the history
79 ;; list in shell-like buffers. At other times, only confusing.
80 ;; `try-expand-line-all-buffers' : Like `try-expand-line' but searches
81 ;; in all buffers (except the current). (This may be a little
82 ;; slow, don't use it unless you are really fond of `hippie-expand'.)
83 ;; `try-expand-list' : Tries to expand the text back to the nearest
84 ;; open delimiter, to a whole list from the buffer. Convenient for
85 ;; example when writing lisp or TeX.
86 ;; `try-expand-list-all-buffers' : Like `try-expand-list' but searches
87 ;; in all buffers (except the current).
88 ;; `try-expand-dabbrev' : works exactly as dabbrev-expand (but of
89 ;; course in a way compatible with the other try-functions).
90 ;; `try-expand-dabbrev-all-buffers' : perhaps the most useful of them,
91 ;; like `dabbrev-expand' but searches all Emacs buffers (except the
92 ;; current) for matching words. (No, I don't find this one
93 ;; particularly slow.)
94 ;; `try-expand-dabbrev-visible': Searches the currently visible parts of
95 ;; all windows. Can be put before `try-expand-dabbrev-all-buffers' to
96 ;; first try the expansions you can see.
97 ;; `try-expand-dabbrev-from-kill': Searches the kill ring for a suitable
98 ;; completion of the word. Good to have, just in case the word was not
99 ;; found elsewhere.
100 ;; `try-expand-whole-kill' : Tries to complete text with a whole entry
101 ;; from the kill ring. May be good if you don't know how far up in
102 ;; the kill-ring the required entry is, and don't want to mess with
103 ;; "Choose Next Paste".
104 ;; `try-complete-lisp-symbol' : like `lisp-complete-symbol', but goes
105 ;; through all possibilities instead of completing what is unique.
106 ;; Might be tedious (usually a lot of possible completions) and
107 ;; since its function is much like `lisp-complete-symbol', which
108 ;; already has a key of its own, you might want to remove this.
109 ;; `try-complete-lisp-symbol-partially' : To insert in the list just
110 ;; before `try-complete-lisp-symbol' for those who first want to get
111 ;; completion of what is unique in the name.
113 ;; Not all of the above functions are by default in
114 ;; `hippie-expand-try-functions-list'. This variable is better set
115 ;; in ".emacs" to make `hippie-expand' behave maximally convenient
116 ;; according to personal taste. Also, instead of loading the
117 ;; variable with all kinds of try-functions above, it might be an
118 ;; idea to use `make-hippie-expand-function' to construct different
119 ;; `hippie-expand'-like functions, with different try-lists and bound
120 ;; to different keys. It is also possible to make
121 ;; `hippie-expand-try-functions-list' a buffer local variable, and
122 ;; let it depend on the mode (by setting it in the mode-hooks).
124 ;; To write new try-functions, consider the following:
125 ;; Each try-function takes one argument OLD which is nil the first
126 ;; time the function is called and true in succeeding calls for the
127 ;; same string to complete. The first time the function has to
128 ;; extract the string before point to complete, and substitute the
129 ;; first completion alternative for it. On following calls it has to
130 ;; substitute the next possible completion for the last tried string.
131 ;; The try-function is to return t as long as it finds new
132 ;; possible completions. When there are no more alternatives it has
133 ;; to restore the text before point to its original contents, and
134 ;; return nil (don't beep or message or anything).
135 ;; The try-function can (should) use the following functions:
136 ;; `he-init-string' : Initializes the text to substitute to the
137 ;; contents of the region BEGIN to END. Also sets the variable
138 ;; `he-search-string' to the text to expand.
139 ;; `he-substitute-string' : substitutes STR into the region
140 ;; initialized with `he-init-string'. (An optional second argument
141 ;; TRANS-CASE non-nil, means transfer of case from the abbreviation
142 ;; to the expansion is ok if that is enabled in the buffer.)
143 ;; `he-reset-string' : Resets the initialized region to its original
144 ;; contents.
145 ;; There is also a variable: `he-tried-table' which is meant to contain
146 ;; all tried expansions so far. The try-function can check this
147 ;; variable to see whether an expansion has already been tried
148 ;; (hint: `he-string-member').
150 ;; Known bugs
152 ;; It may happen that some completion suggestion occurs twice, in
153 ;; spite of the use of `he-tried-table' to prevent that. This is
154 ;; because different try-functions may try to complete different
155 ;; lengths of text, and thus put different amounts of the
156 ;; text in `he-tried-table'. Anyway this seems to occur seldom enough
157 ;; not to be too disturbing. Also it should NOT be possible for the
158 ;; opposite situation to occur, that `hippie-expand' misses some
159 ;; suggestion because it thinks it has already tried it.
161 ;; Acknowledgement
163 ;; I want to thank Mikael Djurfeldt in discussions with whom the idea
164 ;; of this function took form.
165 ;; I am also grateful to all those who have given me suggestions on
166 ;; how to improve it, and all those who helped to find and remove bugs.
169 ;;; Code:
171 (eval-when-compile (require 'comint))
173 (defgroup hippie-expand nil
174 "Expand text trying various ways to find its expansion."
175 :link '(custom-manual "(autotype)Hippie Expand")
176 :link '(emacs-commentary-link "hippie-exp")
177 :group 'abbrev
178 :group 'convenience)
180 (defvar he-num -1)
182 (defvar he-string-beg (make-marker))
184 (defvar he-string-end (make-marker))
186 (defvar he-search-string ())
188 (defvar he-expand-list ())
190 (defvar he-tried-table ())
192 (defvar he-search-loc (make-marker))
194 (defvar he-search-loc2 ())
196 (defvar he-search-bw ())
198 (defvar he-search-bufs ())
200 (defvar he-searched-n-bufs ())
202 (defvar he-search-window ())
204 ;;;###autoload
205 (defcustom hippie-expand-try-functions-list
206 '(try-complete-file-name-partially
207 try-complete-file-name
208 try-expand-all-abbrevs
209 try-expand-list
210 try-expand-line
211 try-expand-dabbrev
212 try-expand-dabbrev-all-buffers
213 try-expand-dabbrev-from-kill
214 try-complete-lisp-symbol-partially
215 try-complete-lisp-symbol)
216 "The list of expansion functions tried in order by `hippie-expand'.
217 To change the behavior of `hippie-expand', remove, change the order of,
218 or insert functions in this list."
219 :type '(repeat function)
220 :group 'hippie-expand)
222 ;;;###autoload
223 (defcustom hippie-expand-verbose t
224 "*Non-nil makes `hippie-expand' output which function it is trying."
225 :type 'boolean
226 :group 'hippie-expand)
228 ;;;###autoload
229 (defcustom hippie-expand-dabbrev-skip-space nil
230 "*Non-nil means tolerate trailing spaces in the abbreviation to expand."
231 :group 'hippie-expand
232 :type 'boolean)
234 ;;;###autoload
235 (defcustom hippie-expand-dabbrev-as-symbol t
236 "*Non-nil means expand as symbols, i.e. syntax `_' is considered a letter."
237 :group 'hippie-expand
238 :type 'boolean)
240 ;;;###autoload
241 (defcustom hippie-expand-no-restriction t
242 "*Non-nil means that narrowed buffers are widened during search."
243 :group 'hippie-expand
244 :type 'boolean)
246 ;;;###autoload
247 (defcustom hippie-expand-max-buffers ()
248 "*The maximum number of buffers (apart from the current) searched.
249 If nil, all buffers are searched."
250 :type '(choice (const :tag "All" nil)
251 integer)
252 :group 'hippie-expand)
254 ;;;###autoload
255 (defcustom hippie-expand-ignore-buffers '("^ \\*.*\\*$" dired-mode)
256 "*A list specifying which buffers not to search (if not current).
257 Can contain both regexps matching buffer names (as strings) and major modes
258 \(as atoms)"
259 :type '(repeat (choice regexp (symbol :tag "Major Mode")))
260 :group 'hippie-expand)
262 ;;;###autoload
263 (defcustom hippie-expand-only-buffers ()
264 "*A list specifying the only buffers to search (in addition to current).
265 Can contain both regexps matching buffer names (as strings) and major modes
266 \(as atoms). If non-nil, this variable overrides the variable
267 `hippie-expand-ignore-buffers'."
268 :type '(repeat (choice regexp (symbol :tag "Major Mode")))
269 :group 'hippie-expand)
271 ;;;###autoload
272 (defun hippie-expand (arg)
273 "Try to expand text before point, using multiple methods.
274 The expansion functions in `hippie-expand-try-functions-list' are
275 tried in order, until a possible expansion is found. Repeated
276 application of `hippie-expand' inserts successively possible
277 expansions.
278 With a positive numeric argument, jumps directly to the ARG next
279 function in this list. With a negative argument or just \\[universal-argument],
280 undoes the expansion."
281 (interactive "P")
282 (if (or (not arg)
283 (and (integerp arg) (> arg 0)))
284 (let ((first (or (= he-num -1)
285 (not (equal this-command last-command)))))
286 (if first
287 (progn
288 (setq he-num -1)
289 (setq he-tried-table nil)))
290 (if arg
291 (if (not first) (he-reset-string))
292 (setq arg 0))
293 (let ((i (max (+ he-num arg) 0)))
294 (while (not (or (>= i (length hippie-expand-try-functions-list))
295 (apply (nth i hippie-expand-try-functions-list)
296 (list (= he-num i)))))
297 (setq i (1+ i)))
298 (setq he-num i))
299 (if (>= he-num (length hippie-expand-try-functions-list))
300 (progn
301 (setq he-num -1)
302 (if first
303 (message "No expansion found")
304 (message "No further expansions found"))
305 (ding))
306 (if (and hippie-expand-verbose
307 (not (window-minibuffer-p (selected-window))))
308 (message "Using %s"
309 (nth he-num hippie-expand-try-functions-list)))))
310 (if (and (>= he-num 0)
311 (eq (marker-buffer he-string-beg) (current-buffer)))
312 (progn
313 (setq he-num -1)
314 (he-reset-string)
315 (if (and hippie-expand-verbose
316 (not (window-minibuffer-p (selected-window))))
317 (message "Undoing expansions"))))))
319 ;; Initializes the region to expand (to between BEG and END).
320 (defun he-init-string (beg end)
321 (set-marker he-string-beg beg)
322 (set-marker he-string-end end)
323 (setq he-search-string (buffer-substring-no-properties beg end)))
325 ;; Resets the expanded region to its original contents.
326 (defun he-reset-string ()
327 (let ((newpos (point-marker)))
328 (goto-char he-string-beg)
329 (insert he-search-string)
330 (delete-region (point) he-string-end)
331 (goto-char newpos)))
333 ;; Substitutes an expansion STR into the correct region (the region
334 ;; initialized with `he-init-string').
335 ;; An optional argument TRANS-CASE means that it is ok to transfer case
336 ;; from the abbreviation to the expansion if that is possible, and is
337 ;; enabled in the buffer.
338 (defun he-substitute-string (str &optional trans-case)
339 (let ((trans-case (and trans-case
340 case-replace
341 case-fold-search))
342 (newpos (point-marker))
343 (subst ()))
344 (goto-char he-string-beg)
345 (setq subst (if trans-case (he-transfer-case he-search-string str) str))
346 (setq he-tried-table (cons subst he-tried-table))
347 (insert subst)
348 (delete-region (point) he-string-end)
349 (goto-char newpos)))
351 (defun he-capitalize-first (str)
352 (save-match-data
353 (if (string-match "\\Sw*\\(\\sw\\).*" str)
354 (let ((res (downcase str))
355 (no (match-beginning 1)))
356 (aset res no (upcase (aref str no)))
357 res)
358 str)))
360 (defun he-ordinary-case-p (str)
361 (or (string= str (downcase str))
362 (string= str (upcase str))
363 (string= str (capitalize str))
364 (string= str (he-capitalize-first str))))
366 (defun he-transfer-case (from-str to-str)
367 (cond ((string= from-str (substring to-str 0 (min (length from-str)
368 (length to-str))))
369 to-str)
370 ((not (he-ordinary-case-p to-str))
371 to-str)
372 ((string= from-str (downcase from-str))
373 (downcase to-str))
374 ((string= from-str (upcase from-str))
375 (upcase to-str))
376 ((string= from-str (he-capitalize-first from-str))
377 (he-capitalize-first to-str))
378 ((string= from-str (capitalize from-str))
379 (capitalize to-str))
381 to-str)))
384 ;; Check if STR is a member of LST.
385 ;; Transform to the final case if optional TRANS-CASE is non-nil.
386 (defun he-string-member (str lst &optional trans-case)
387 (if str
388 (member (if (and trans-case
389 case-replace
390 case-fold-search)
391 (he-transfer-case he-search-string str)
392 str)
393 lst)))
395 ;; Check if current buffer matches any atom or regexp in LST.
396 ;; Atoms are interpreted as major modes, strings as regexps mathing the name.
397 (defun he-buffer-member (lst)
398 (or (memq major-mode lst)
399 (progn
400 (while (and lst
401 (or (not (stringp (car lst)))
402 (not (string-match (car lst) (buffer-name)))))
403 (setq lst (cdr lst)))
404 lst)))
406 ;; For the real hippie-expand enthusiast: A macro that makes it
407 ;; possible to use many functions like hippie-expand, but with
408 ;; different try-functions-lists.
409 ;; Usage is for example:
410 ;; (fset 'my-complete-file (make-hippie-expand-function
411 ;; '(try-complete-file-name-partially
412 ;; try-complete-file-name)))
413 ;; (fset 'my-complete-line (make-hippie-expand-function
414 ;; '(try-expand-line
415 ;; try-expand-line-all-buffers)))
417 ;;;###autoload
418 (defmacro make-hippie-expand-function (try-list &optional verbose)
419 "Construct a function similar to `hippie-expand'.
420 Make it use the expansion functions in TRY-LIST. An optional second
421 argument VERBOSE non-nil makes the function verbose."
422 `(function (lambda (arg)
423 ,(concat
424 "Try to expand text before point, using the following functions: \n"
425 (mapconcat 'prin1-to-string (eval try-list) ", "))
426 (interactive "P")
427 (let ((hippie-expand-try-functions-list ,try-list)
428 (hippie-expand-verbose ,verbose))
429 (hippie-expand arg)))))
432 ;;; Here follows the try-functions and their requisites:
435 (defun try-complete-file-name (old)
436 "Try to complete text as a file name.
437 The argument OLD has to be nil the first call of this function, and t
438 for subsequent calls (for further possible completions of the same
439 string). It returns t if a new completion is found, nil otherwise."
440 (if (not old)
441 (progn
442 (he-init-string (he-file-name-beg) (point))
443 (let ((name-part (he-file-name-nondirectory he-search-string))
444 (dir-part (expand-file-name (or (he-file-name-directory
445 he-search-string) ""))))
446 (if (not (he-string-member name-part he-tried-table))
447 (setq he-tried-table (cons name-part he-tried-table)))
448 (if (and (not (equal he-search-string ""))
449 (he-file-directory-p dir-part))
450 (setq he-expand-list (sort (file-name-all-completions
451 name-part
452 dir-part)
453 'string-lessp))
454 (setq he-expand-list ())))))
456 (while (and he-expand-list
457 (he-string-member (car he-expand-list) he-tried-table))
458 (setq he-expand-list (cdr he-expand-list)))
459 (if (null he-expand-list)
460 (progn
461 (if old (he-reset-string))
463 (let ((filename (he-concat-directory-file-name
464 (he-file-name-directory he-search-string)
465 (car he-expand-list))))
466 (he-substitute-string filename)
467 (setq he-tried-table (cons (car he-expand-list) (cdr he-tried-table)))
468 (setq he-expand-list (cdr he-expand-list))
469 t)))
471 (defun try-complete-file-name-partially (old)
472 "Try to complete text as a file name, as many characters as unique.
473 The argument OLD has to be nil the first call of this function. It
474 returns t if a unique, possibly partial, completion is found, nil
475 otherwise."
476 (let ((expansion ()))
477 (if (not old)
478 (progn
479 (he-init-string (he-file-name-beg) (point))
480 (let ((name-part (he-file-name-nondirectory he-search-string))
481 (dir-part (expand-file-name (or (he-file-name-directory
482 he-search-string) ""))))
483 (if (and (not (equal he-search-string ""))
484 (he-file-directory-p dir-part))
485 (setq expansion (file-name-completion name-part
486 dir-part)))
487 (if (or (eq expansion t)
488 (string= expansion name-part)
489 (he-string-member expansion he-tried-table))
490 (setq expansion ())))))
492 (if (not expansion)
493 (progn
494 (if old (he-reset-string))
496 (let ((filename (he-concat-directory-file-name
497 (he-file-name-directory he-search-string)
498 expansion)))
499 (he-substitute-string filename)
500 (setq he-tried-table (cons expansion (cdr he-tried-table)))
501 t))))
503 (defvar he-file-name-chars
504 (cond ((memq system-type '(vax-vms axp-vms))
505 "-a-zA-Z0-9_/.,~^#$+=:\\[\\]")
506 ((memq system-type '(ms-dos windows-nt cygwin))
507 "-a-zA-Z0-9_/.,~^#$+=:\\\\")
508 (t ;; More strange file formats ?
509 "-a-zA-Z0-9_/.,~^#$+="))
510 "Characters that are considered part of the file name to expand.")
512 (defun he-file-name-beg ()
513 (let ((op (point)))
514 (save-excursion
515 (skip-chars-backward he-file-name-chars)
516 (if (> (skip-syntax-backward "w") 0) ;; No words with non-file chars
518 (point)))))
520 ;; Thanks go to Richard Levitte <levitte@e.kth.se> who helped to make these
521 ;; work under VMS, and to David Hughes <ukchugd@ukpmr.cs.philips.nl> who
522 ;; helped to make it work on PC.
523 (defun he-file-name-nondirectory (file)
524 "Fix to make `file-name-nondirectory' work for hippie-expand under VMS."
525 (if (memq system-type '(axp-vms vax-vms))
526 (let ((n (file-name-nondirectory file)))
527 (if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
528 (concat "[." (substring n (match-beginning 2) (match-end 2)))
530 (file-name-nondirectory file)))
532 (defun he-file-name-directory (file)
533 "Fix to make `file-name-directory' work for hippie-expand under VMS."
534 (if (memq system-type '(axp-vms vax-vms))
535 (let ((n (file-name-nondirectory file))
536 (d (file-name-directory file)))
537 (if (string-match "^\\(\\[.*\\)\\.\\([^\\.]*\\)$" n)
538 (concat d (substring n (match-beginning 1) (match-end 1)) "]")
540 (file-name-directory file)))
542 (defun he-file-directory-p (file)
543 "Fix to make `file-directory-p' work for hippie-expand under VMS."
544 (if (memq system-type '(vax-vms axp-vms))
545 (or (file-directory-p file)
546 (file-directory-p (concat file "[000000]")))
547 (file-directory-p file)))
549 (defun he-concat-directory-file-name (dir-part name-part)
550 "Try to slam together two parts of a file specification, system dependently."
551 (cond ((null dir-part) name-part)
552 ((memq system-type '(axp-vms vax-vms))
553 (if (and (string= (substring dir-part -1) "]")
554 (string= (substring name-part 0 2) "[."))
555 (concat (substring dir-part 0 -1) (substring name-part 1))
556 (concat dir-part name-part)))
557 ((memq system-type '(ms-dos w32))
558 (if (and (string-match "\\\\" dir-part)
559 (not (string-match "/" dir-part))
560 (= (aref name-part (1- (length name-part))) ?/))
561 (aset name-part (1- (length name-part)) ?\\))
562 (concat dir-part name-part))
564 (concat dir-part name-part))))
566 (defun try-complete-lisp-symbol (old)
567 "Try to complete word as an Emacs Lisp symbol.
568 The argument OLD has to be nil the first call of this function, and t
569 for subsequent calls (for further possible completions of the same
570 string). It returns t if a new completion is found, nil otherwise."
571 (if (not old)
572 (progn
573 (he-init-string (he-lisp-symbol-beg) (point))
574 (if (not (he-string-member he-search-string he-tried-table))
575 (setq he-tried-table (cons he-search-string he-tried-table)))
576 (setq he-expand-list
577 (and (not (equal he-search-string ""))
578 (sort (all-completions he-search-string obarray
579 (function (lambda (sym)
580 (or (boundp sym)
581 (fboundp sym)
582 (symbol-plist sym)))))
583 'string-lessp)))))
584 (while (and he-expand-list
585 (he-string-member (car he-expand-list) he-tried-table))
586 (setq he-expand-list (cdr he-expand-list)))
587 (if (null he-expand-list)
588 (progn
589 (if old (he-reset-string))
591 (progn
592 (he-substitute-string (car he-expand-list))
593 (setq he-expand-list (cdr he-expand-list))
594 t)))
596 (defun try-complete-lisp-symbol-partially (old)
597 "Try to complete as an Emacs Lisp symbol, as many characters as unique.
598 The argument OLD has to be nil the first call of this function. It
599 returns t if a unique, possibly partial, completion is found, nil
600 otherwise."
601 (let ((expansion ()))
602 (if (not old)
603 (progn
604 (he-init-string (he-lisp-symbol-beg) (point))
605 (if (not (string= he-search-string ""))
606 (setq expansion
607 (try-completion he-search-string obarray
608 (function (lambda (sym)
609 (or (boundp sym)
610 (fboundp sym)
611 (symbol-plist sym)))))))
612 (if (or (eq expansion t)
613 (string= expansion he-search-string)
614 (he-string-member expansion he-tried-table))
615 (setq expansion ()))))
617 (if (not expansion)
618 (progn
619 (if old (he-reset-string))
621 (progn
622 (he-substitute-string expansion)
623 t))))
625 (defun he-lisp-symbol-beg ()
626 (save-excursion
627 (skip-syntax-backward "w_")
628 (point)))
630 (defun try-expand-line (old)
631 "Try to complete the current line to an entire line in the buffer.
632 The argument OLD has to be nil the first call of this function, and t
633 for subsequent calls (for further possible completions of the same
634 string). It returns t if a new completion is found, nil otherwise."
635 (let ((expansion ())
636 (strip-prompt (and (get-buffer-process (current-buffer))
637 comint-use-prompt-regexp-instead-of-fields
638 comint-prompt-regexp)))
639 (if (not old)
640 (progn
641 (he-init-string (he-line-beg strip-prompt) (point))
642 (set-marker he-search-loc he-string-beg)
643 (setq he-search-bw t)))
645 (if (not (equal he-search-string ""))
646 (save-excursion
647 (save-restriction
648 (if hippie-expand-no-restriction
649 (widen))
650 ;; Try looking backward unless inhibited.
651 (if he-search-bw
652 (progn
653 (goto-char he-search-loc)
654 (setq expansion (he-line-search he-search-string
655 strip-prompt t))
656 (set-marker he-search-loc (point))
657 (if (not expansion)
658 (progn
659 (set-marker he-search-loc he-string-end)
660 (setq he-search-bw ())))))
662 (if (not expansion) ; Then look forward.
663 (progn
664 (goto-char he-search-loc)
665 (setq expansion (he-line-search he-search-string
666 strip-prompt nil))
667 (set-marker he-search-loc (point)))))))
669 (if (not expansion)
670 (progn
671 (if old (he-reset-string))
673 (progn
674 (he-substitute-string expansion t)
675 t))))
677 (defun try-expand-line-all-buffers (old)
678 "Try to complete the current line, searching all other buffers.
679 The argument OLD has to be nil the first call of this function, and t
680 for subsequent calls (for further possible completions of the same
681 string). It returns t if a new completion is found, nil otherwise."
682 (let ((expansion ())
683 (strip-prompt (and (get-buffer-process (current-buffer))
684 comint-use-prompt-regexp-instead-of-fields
685 comint-prompt-regexp))
686 (buf (current-buffer))
687 (orig-case-fold-search case-fold-search))
688 (if (not old)
689 (progn
690 (he-init-string (he-line-beg strip-prompt) (point))
691 (setq he-search-bufs (buffer-list))
692 (setq he-searched-n-bufs 0)
693 (set-marker he-search-loc 1 (car he-search-bufs))))
695 (if (not (equal he-search-string ""))
696 (while (and he-search-bufs
697 (not expansion)
698 (or (not hippie-expand-max-buffers)
699 (< he-searched-n-bufs hippie-expand-max-buffers)))
700 (set-buffer (car he-search-bufs))
701 (if (and (not (eq (current-buffer) buf))
702 (if hippie-expand-only-buffers
703 (he-buffer-member hippie-expand-only-buffers)
704 (not (he-buffer-member hippie-expand-ignore-buffers))))
705 (save-excursion
706 (save-restriction
707 (if hippie-expand-no-restriction
708 (widen))
709 (goto-char he-search-loc)
710 (setq strip-prompt (and (get-buffer-process (current-buffer))
711 comint-use-prompt-regexp-instead-of-fields
712 comint-prompt-regexp))
713 (setq expansion
714 (let ((case-fold-search orig-case-fold-search))
715 (he-line-search he-search-string
716 strip-prompt nil)))
717 (set-marker he-search-loc (point))
718 (if (not expansion)
719 (progn
720 (setq he-search-bufs (cdr he-search-bufs))
721 (setq he-searched-n-bufs (1+ he-searched-n-bufs))
722 (set-marker he-search-loc 1 (car he-search-bufs))))))
723 (setq he-search-bufs (cdr he-search-bufs))
724 (set-marker he-search-loc 1 (car he-search-bufs)))))
726 (set-buffer buf)
727 (if (not expansion)
728 (progn
729 (if old (he-reset-string))
731 (progn
732 (he-substitute-string expansion t)
733 t))))
735 (defun he-line-search (str strip-prompt reverse)
736 (let ((result ()))
737 (while (and (not result)
738 (if reverse
739 (re-search-backward
740 (he-line-search-regexp str strip-prompt)
741 nil t)
742 (re-search-forward
743 (he-line-search-regexp str strip-prompt)
744 nil t)))
745 (setq result (buffer-substring-no-properties (match-end 1)
746 (match-end 0)))
747 (if (he-string-member result he-tried-table t)
748 (setq result nil))) ; if already in table, ignore
749 result))
751 (defun he-line-beg (strip-prompt)
752 (save-excursion
753 (if (re-search-backward (he-line-search-regexp "" strip-prompt)
754 (save-excursion (beginning-of-line)
755 (point)) t)
756 (match-beginning 2)
757 (point))))
759 (defun he-line-search-regexp (pat strip-prompt)
760 (if strip-prompt
761 (concat "\\(" comint-prompt-regexp "\\|^\\s-*\\)\\("
762 (regexp-quote pat)
763 "[^\n]*[^ \t\n]\\)")
764 (concat "^\\(\\s-*\\)\\("
765 (regexp-quote pat)
766 "[^\n]*[^ \t\n]\\)")))
768 (defun try-expand-list (old)
769 "Try to complete the current beginning of a list.
770 The argument OLD has to be nil the first call of this function, and t
771 for subsequent calls (for further possible completions of the same
772 string). It returns t if a new completion is found, nil otherwise."
773 (let ((expansion ()))
774 (if (not old)
775 (progn
776 (he-init-string (he-list-beg) (point))
777 (set-marker he-search-loc he-string-beg)
778 (setq he-search-bw t)))
780 (if (not (equal he-search-string ""))
781 (save-excursion
782 (save-restriction
783 (if hippie-expand-no-restriction
784 (widen))
785 ;; Try looking backward unless inhibited.
786 (if he-search-bw
787 (progn
788 (goto-char he-search-loc)
789 (setq expansion (he-list-search he-search-string t))
790 (set-marker he-search-loc (point))
791 (if (not expansion)
792 (progn
793 (set-marker he-search-loc he-string-end)
794 (setq he-search-bw ())))))
796 (if (not expansion) ; Then look forward.
797 (progn
798 (goto-char he-search-loc)
799 (setq expansion (he-list-search he-search-string nil))
800 (set-marker he-search-loc (point)))))))
802 (if (not expansion)
803 (progn
804 (if old (he-reset-string))
806 (progn
807 (he-substitute-string expansion t)
808 t))))
810 (defun try-expand-list-all-buffers (old)
811 "Try to complete the current list, searching all other buffers.
812 The argument OLD has to be nil the first call of this function, and t
813 for subsequent calls (for further possible completions of the same
814 string). It returns t if a new completion is found, nil otherwise."
815 (let ((expansion ())
816 (buf (current-buffer))
817 (orig-case-fold-search case-fold-search))
818 (if (not old)
819 (progn
820 (he-init-string (he-list-beg) (point))
821 (setq he-search-bufs (buffer-list))
822 (setq he-searched-n-bufs 0)
823 (set-marker he-search-loc 1 (car he-search-bufs))))
825 (if (not (equal he-search-string ""))
826 (while (and he-search-bufs
827 (not expansion)
828 (or (not hippie-expand-max-buffers)
829 (< he-searched-n-bufs hippie-expand-max-buffers)))
830 (set-buffer (car he-search-bufs))
831 (if (and (not (eq (current-buffer) buf))
832 (if hippie-expand-only-buffers
833 (he-buffer-member hippie-expand-only-buffers)
834 (not (he-buffer-member hippie-expand-ignore-buffers))))
835 (save-excursion
836 (save-restriction
837 (if hippie-expand-no-restriction
838 (widen))
839 (goto-char he-search-loc)
840 (setq expansion
841 (let ((case-fold-search orig-case-fold-search))
842 (he-list-search he-search-string nil)))
843 (set-marker he-search-loc (point))
844 (if (not expansion)
845 (progn
846 (setq he-search-bufs (cdr he-search-bufs))
847 (setq he-searched-n-bufs (1+ he-searched-n-bufs))
848 (set-marker he-search-loc 1 (car he-search-bufs))))))
849 (setq he-search-bufs (cdr he-search-bufs))
850 (set-marker he-search-loc 1 (car he-search-bufs)))))
852 (set-buffer buf)
853 (if (not expansion)
854 (progn
855 (if old (he-reset-string))
857 (progn
858 (he-substitute-string expansion t)
859 t))))
861 (defun he-list-search (str reverse)
862 (let ((result ())
863 beg pos err)
864 (while (and (not result)
865 (if reverse
866 (search-backward str nil t)
867 (search-forward str nil t)))
868 (setq pos (point))
869 (setq beg (match-beginning 0))
870 (goto-char beg)
871 (setq err ())
872 (condition-case ()
873 (forward-list 1)
874 (error (setq err t)))
875 (if (and reverse
876 (> (point) he-string-beg))
877 (setq err t))
878 (if (not err)
879 (progn
880 (setq result (buffer-substring-no-properties beg (point)))
881 (if (he-string-member result he-tried-table t)
882 (setq result nil)))) ; if already in table, ignore
883 (goto-char pos))
884 result))
886 (defun he-list-beg ()
887 (save-excursion
888 (condition-case ()
889 (backward-up-list 1)
890 (error ()))
891 (point)))
893 (defun try-expand-all-abbrevs (old)
894 "Try to expand word before point according to all abbrev tables.
895 The argument OLD has to be nil the first call of this function, and t
896 for subsequent calls (for further possible expansions of the same
897 string). It returns t if a new expansion is found, nil otherwise."
898 (if (not old)
899 (progn
900 (he-init-string (he-dabbrev-beg) (point))
901 (setq he-expand-list
902 (and (not (equal he-search-string ""))
903 (mapcar (function (lambda (sym)
904 (if (and (boundp sym) (vectorp (eval sym)))
905 (abbrev-expansion (downcase he-search-string)
906 (eval sym)))))
907 (append '(local-abbrev-table
908 global-abbrev-table)
909 abbrev-table-name-list))))))
910 (while (and he-expand-list
911 (or (not (car he-expand-list))
912 (he-string-member (car he-expand-list) he-tried-table t)))
913 (setq he-expand-list (cdr he-expand-list)))
914 (if (null he-expand-list)
915 (progn
916 (if old (he-reset-string))
918 (progn
919 (he-substitute-string (car he-expand-list) t)
920 (setq he-expand-list (cdr he-expand-list))
921 t)))
923 (defun try-expand-dabbrev (old)
924 "Try to expand word \"dynamically\", searching the current buffer.
925 The argument OLD has to be nil the first call of this function, and t
926 for subsequent calls (for further possible expansions of the same
927 string). It returns t if a new expansion is found, nil otherwise."
928 (let ((expansion ()))
929 (if (not old)
930 (progn
931 (he-init-string (he-dabbrev-beg) (point))
932 (set-marker he-search-loc he-string-beg)
933 (setq he-search-bw t)))
935 (if (not (equal he-search-string ""))
936 (save-excursion
937 (save-restriction
938 (if hippie-expand-no-restriction
939 (widen))
940 ;; Try looking backward unless inhibited.
941 (if he-search-bw
942 (progn
943 (goto-char he-search-loc)
944 (setq expansion (he-dabbrev-search he-search-string t))
945 (set-marker he-search-loc (point))
946 (if (not expansion)
947 (progn
948 (set-marker he-search-loc he-string-end)
949 (setq he-search-bw ())))))
951 (if (not expansion) ; Then look forward.
952 (progn
953 (goto-char he-search-loc)
954 (setq expansion (he-dabbrev-search he-search-string nil))
955 (set-marker he-search-loc (point)))))))
957 (if (not expansion)
958 (progn
959 (if old (he-reset-string))
961 (progn
962 (he-substitute-string expansion t)
963 t))))
965 (defun try-expand-dabbrev-all-buffers (old)
966 "Tries to expand word \"dynamically\", searching all other buffers.
967 The argument OLD has to be nil the first call of this function, and t
968 for subsequent calls (for further possible expansions of the same
969 string). It returns t if a new expansion is found, nil otherwise."
970 (let ((expansion ())
971 (buf (current-buffer))
972 (orig-case-fold-search case-fold-search))
973 (if (not old)
974 (progn
975 (he-init-string (he-dabbrev-beg) (point))
976 (setq he-search-bufs (buffer-list))
977 (setq he-searched-n-bufs 0)
978 (set-marker he-search-loc 1 (car he-search-bufs))))
980 (if (not (equal he-search-string ""))
981 (while (and he-search-bufs
982 (not expansion)
983 (or (not hippie-expand-max-buffers)
984 (< he-searched-n-bufs hippie-expand-max-buffers)))
985 (set-buffer (car he-search-bufs))
986 (if (and (not (eq (current-buffer) buf))
987 (if hippie-expand-only-buffers
988 (he-buffer-member hippie-expand-only-buffers)
989 (not (he-buffer-member hippie-expand-ignore-buffers))))
990 (save-excursion
991 (save-restriction
992 (if hippie-expand-no-restriction
993 (widen))
994 (goto-char he-search-loc)
995 (setq expansion
996 (let ((case-fold-search orig-case-fold-search))
997 (he-dabbrev-search he-search-string nil)))
998 (set-marker he-search-loc (point))
999 (if (not expansion)
1000 (progn
1001 (setq he-search-bufs (cdr he-search-bufs))
1002 (setq he-searched-n-bufs (1+ he-searched-n-bufs))
1003 (set-marker he-search-loc 1 (car he-search-bufs))))))
1004 (setq he-search-bufs (cdr he-search-bufs))
1005 (set-marker he-search-loc 1 (car he-search-bufs)))))
1007 (set-buffer buf)
1008 (if (not expansion)
1009 (progn
1010 (if old (he-reset-string))
1012 (progn
1013 (he-substitute-string expansion t)
1014 t))))
1016 ;; Thanks go to Jeff Dairiki <dairiki@faraday.apl.washington.edu> who
1017 ;; suggested this one.
1018 (defun try-expand-dabbrev-visible (old)
1019 "Try to expand word \"dynamically\", searching visible window parts.
1020 The argument OLD has to be nil the first call of this function, and t
1021 for subsequent calls (for further possible expansions of the same
1022 string). It returns t if a new expansion is found, nil otherwise."
1023 (let ((expansion ())
1024 (buf (current-buffer))
1025 (flag (if (frame-visible-p (window-frame (selected-window)))
1026 'visible t)))
1027 (if (not old)
1028 (progn
1029 (he-init-string (he-dabbrev-beg) (point))
1030 (setq he-search-window (selected-window))
1031 (set-marker he-search-loc
1032 (window-start he-search-window)
1033 (window-buffer he-search-window))))
1035 (while (and (not (equal he-search-string ""))
1036 (marker-position he-search-loc)
1037 (not expansion))
1038 (save-excursion
1039 (set-buffer (marker-buffer he-search-loc))
1040 (goto-char he-search-loc)
1041 (setq expansion (he-dabbrev-search he-search-string ()
1042 (window-end he-search-window)))
1043 (if (and expansion
1044 (eq (marker-buffer he-string-beg) (current-buffer))
1045 (eq (marker-position he-string-beg) (match-beginning 0)))
1046 (setq expansion (he-dabbrev-search he-search-string ()
1047 (window-end he-search-window))))
1048 (set-marker he-search-loc (point) (current-buffer)))
1049 (if (not expansion)
1050 (progn
1051 (setq he-search-window (next-window he-search-window nil flag))
1052 (if (eq he-search-window (selected-window))
1053 (set-marker he-search-loc nil)
1054 (set-marker he-search-loc (window-start he-search-window)
1055 (window-buffer he-search-window))))))
1057 (set-buffer buf)
1058 (if (not expansion)
1059 (progn
1060 (if old (he-reset-string))
1062 (progn
1063 (he-substitute-string expansion t)
1064 t))))
1066 (defun he-dabbrev-search (pattern &optional reverse limit)
1067 (let ((result ())
1068 (regpat (cond ((not hippie-expand-dabbrev-as-symbol)
1069 (concat "\\<" (regexp-quote pattern) "\\sw+"))
1070 ((eq (char-syntax (aref pattern 0)) ?_)
1071 (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
1073 (concat "\\<" (regexp-quote pattern)
1074 "\\(\\sw\\|\\s_\\)+")))))
1075 (while (and (not result)
1076 (if reverse
1077 (re-search-backward regpat limit t)
1078 (re-search-forward regpat limit t)))
1079 (setq result (buffer-substring-no-properties (match-beginning 0)
1080 (match-end 0)))
1081 (if (or (and hippie-expand-dabbrev-as-symbol
1082 (> (match-beginning 0) (point-min))
1083 (memq (char-syntax (char-after (1- (match-beginning 0))))
1084 '(?_ ?w)))
1085 (he-string-member result he-tried-table t))
1086 (setq result nil))) ; ignore if bad prefix or already in table
1087 result))
1089 (defun he-dabbrev-beg ()
1090 (let ((op (point)))
1091 (save-excursion
1092 (if hippie-expand-dabbrev-skip-space
1093 (skip-syntax-backward ". "))
1094 (if (= (skip-syntax-backward (if hippie-expand-dabbrev-as-symbol
1095 "w_" "w"))
1098 (point)))))
1100 (defun try-expand-dabbrev-from-kill (old)
1101 "Try to expand word \"dynamically\", searching the kill ring.
1102 The argument OLD has to be nil the first call of this function, and t
1103 for subsequent calls (for further possible completions of the same
1104 string). It returns t if a new completion is found, nil otherwise."
1105 (let ((expansion ()))
1106 (if (not old)
1107 (progn
1108 (he-init-string (he-dabbrev-beg) (point))
1109 (setq he-expand-list
1110 (if (not (equal he-search-string ""))
1111 kill-ring))
1112 (setq he-search-loc2 0)))
1113 (if (not (equal he-search-string ""))
1114 (setq expansion (he-dabbrev-kill-search he-search-string)))
1115 (if (not expansion)
1116 (progn
1117 (if old (he-reset-string))
1119 (progn
1120 (he-substitute-string expansion t)
1121 t))))
1123 (defun he-dabbrev-kill-search (pattern)
1124 (let ((result ())
1125 (regpat (cond ((not hippie-expand-dabbrev-as-symbol)
1126 (concat "\\<" (regexp-quote pattern) "\\sw+"))
1127 ((eq (char-syntax (aref pattern 0)) ?_)
1128 (concat (regexp-quote pattern) "\\(\\sw\\|\\s_\\)+"))
1130 (concat "\\<" (regexp-quote pattern)
1131 "\\(\\sw\\|\\s_\\)+"))))
1132 (killstr (car he-expand-list)))
1133 (while (and (not result)
1134 he-expand-list)
1135 (while (and (not result)
1136 (string-match regpat killstr he-search-loc2))
1137 (setq result (substring killstr (match-beginning 0) (match-end 0)))
1138 (set-text-properties 0 (length result) () result)
1139 (setq he-search-loc2 (1+ (match-beginning 0)))
1140 (if (or (and hippie-expand-dabbrev-as-symbol
1141 (> (match-beginning 0) 0)
1142 (memq (char-syntax (aref killstr (1- (match-beginning 0))))
1143 '(?_ ?w)))
1144 (he-string-member result he-tried-table t))
1145 (setq result nil))) ; ignore if bad prefix or already in table
1146 (if (and (not result)
1147 he-expand-list)
1148 (progn
1149 (setq he-expand-list (cdr he-expand-list))
1150 (setq killstr (car he-expand-list))
1151 (setq he-search-loc2 0))))
1152 result))
1154 (defun try-expand-whole-kill (old)
1155 "Try to complete text with something from the kill ring.
1156 The argument OLD has to be nil the first call of this function, and t
1157 for subsequent calls (for further possible completions of the same
1158 string). It returns t if a new completion is found, nil otherwise."
1159 (let ((expansion ()))
1160 (if (not old)
1161 (progn
1162 (he-init-string (he-kill-beg) (point))
1163 (if (not (he-string-member he-search-string he-tried-table))
1164 (setq he-tried-table (cons he-search-string he-tried-table)))
1165 (setq he-expand-list
1166 (if (not (equal he-search-string ""))
1167 kill-ring))
1168 (setq he-search-loc2 ())))
1169 (if (not (equal he-search-string ""))
1170 (setq expansion (he-whole-kill-search he-search-string)))
1171 (if (not expansion)
1172 (progn
1173 (if old (he-reset-string))
1175 (progn
1176 (he-substitute-string expansion)
1177 t))))
1179 (defun he-whole-kill-search (str)
1180 (let ((case-fold-search ())
1181 (result ())
1182 (str (regexp-quote str))
1183 (killstr (car he-expand-list))
1184 (pos -1))
1185 (while (and (not result)
1186 he-expand-list)
1187 (if (not he-search-loc2)
1188 (while (setq pos (string-match str killstr (1+ pos)))
1189 (setq he-search-loc2 (cons pos he-search-loc2))))
1190 (while (and (not result)
1191 he-search-loc2)
1192 (setq pos (car he-search-loc2))
1193 (setq he-search-loc2 (cdr he-search-loc2))
1194 (save-excursion
1195 (goto-char he-string-beg)
1196 (if (and (>= (- (point) pos) (point-min)) ; avoid some string GC
1197 (eq (char-after (- (point) pos)) (aref killstr 0))
1198 (search-backward (substring killstr 0 pos)
1199 (- (point) pos) t))
1200 (progn
1201 (setq result (substring killstr pos))
1202 (set-text-properties 0 (length result) () result))))
1203 (if (and result
1204 (he-string-member result he-tried-table))
1205 (setq result nil))) ; ignore if already in table
1206 (if (and (not result)
1207 he-expand-list)
1208 (progn
1209 (setq he-expand-list (cdr he-expand-list))
1210 (setq killstr (car he-expand-list))
1211 (setq pos -1))))
1212 result))
1214 (defun he-kill-beg ()
1215 (let ((op (point)))
1216 (save-excursion
1217 (skip-syntax-backward "^w_")
1218 (if (= (skip-syntax-backward "w_") 0)
1220 (point)))))
1223 (provide 'hippie-exp)
1225 ;;; hippie-exp.el ends here