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