1 ;;; ido.el --- interactively do things with buffers and files
3 ;; Copyright (C) 1996-2017 Free Software Foundation, Inc.
5 ;; Author: Kim F. Storm <storm@cua.dk>
6 ;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
7 ;; Keywords: extensions convenience
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;; Ido - interactive do - switches between buffers and opens files and
28 ;; directories with a minimum of keystrokes. It is a superset of
29 ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
31 ;; Interactive substring matching
32 ;; ------------------------------
34 ;; As you type in a substring, the list of buffers or files currently
35 ;; matching the substring are displayed as you type. The list is
36 ;; ordered so that the most recent buffers or files visited come at
37 ;; the start of the list.
39 ;; The buffer or file at the start of the list will be the one visited
40 ;; when you press RETURN. By typing more of the substring, the list is
41 ;; narrowed down so that gradually the buffer or file you want will be
42 ;; at the top of the list. Alternatively, you can use C-s and C-r (or
43 ;; the right and left arrow keys) to rotate buffer or file names in the
44 ;; list until the one you want is at the top of the list.
46 ;; Completion is also available so that you can see what is common to
47 ;; all of the matching buffers or files as you type.
51 ;; If I have two buffers called "123456" and "123", with "123456" the
52 ;; most recent, when I use ido-switch-buffer, I first of all get
53 ;; presented with the list of all the buffers
55 ;; Buffer: {123456 | 123}
58 ;; Buffer: 2[3]{123456 | 123}
60 ;; The list in {...} are the matching buffers, most recent first
61 ;; (buffers visible in the current frame are put at the end of the
62 ;; list by default). At any time I can select the item at the head of
63 ;; the list by pressing RET. I can also put the first element at the
64 ;; end of the list by pressing C-s or [right], or bring the last
65 ;; element to the head of the list by pressing C-r or [left].
67 ;; The item in [...] indicates what can be added to my input by
68 ;; pressing TAB. In this case, I will get "3" added to my input.
71 ;; Buffer: 23{123456 | 123}
73 ;; At this point, I still have two matching buffers.
74 ;; If I want the first buffer in the list, I simply press RET. If I
75 ;; wanted the second in the list, I could press C-s to move it to the
76 ;; top of the list and then RET to select it.
78 ;; However, if I type 4, I only have one match left:
79 ;; Buffer: 234[123456]
81 ;; Since there is only one matching buffer left, it is given in [] and
82 ;; it is shown in the `ido-only-match' face (ForestGreen). I can now
83 ;; press TAB or RET to go to that buffer.
85 ;; If I want to create a new buffer named "234", I press C-j instead of
88 ;; If instead, I type "a":
89 ;; Buffer: 234a [No match]
90 ;; There are no matching buffers. If I press RET or TAB, I can be
91 ;; prompted to create a new buffer called "234a".
93 ;; Of course, where this function comes in really useful is when you
94 ;; can specify the buffer using only a few keystrokes. In the above
95 ;; example, the quickest way to get to the "123456" file would be
96 ;; just to type 4 and then RET (assuming there isn't any newer buffer
97 ;; with 4 in its name).
99 ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
100 ;; directories in the current directory is provided in the same
101 ;; fashion as the buffers above. The files and directories are
102 ;; normally sorted in alphabetical order, but the most recently
103 ;; visited directory is placed first to speed up navigating to
104 ;; directories that you have visited recently.
106 ;; In addition to scrolling through the list using [right] and [left],
107 ;; you can use [up] and [down] to quickly scroll the list to the next
108 ;; or previous subdirectory.
110 ;; To go down into a subdirectory, and continue the file selection on
111 ;; the files in that directory, simply move the directory to the head
112 ;; of the list and hit RET.
114 ;; To go up to the parent directory, delete any partial file name
115 ;; already specified (e.g. using [backspace]) and hit [backspace].
117 ;; To go to the root directory (on the current drive), enter two
118 ;; slashes. On MS-DOS or Windows, to select the root of another
119 ;; drive, enter X:/ where X is the drive letter. You can also visit
120 ;; files on other hosts using the ange-ftp notations `/host:' and
121 ;; `/user@host:'. See the variable `ido-slow-ftp-hosts' if you want
122 ;; to inhibit the ido substring matching for ftp access.
124 ;; If for some reason you cannot specify the proper file using
125 ;; ido-find-file, you can press C-f to enter the normal find-file.
126 ;; You can also press C-b to drop into ido-switch-buffer.
128 ;; See the doc string of ido-switch-buffer and ido-find-file for full
129 ;; keybindings and features.
130 ;; (describe-function 'ido-find-file)
132 ;; Hidden buffers and files
133 ;; ------------------------
135 ;; Normally, ido does not include hidden buffers (whose name starts
136 ;; with a space) and hidden files and directories (whose name starts
137 ;; with `.') in the list of possible completions. However, if the
138 ;; substring you enter does not match any of the visible buffers or
139 ;; files, ido will automatically look for completions among the hidden
142 ;; You can toggle display of the hidden buffers and files with C-a.
144 ;; Additional functionality
145 ;; ------------------------
147 ;; After C-x b, the buffer at the head of the list can be killed by
148 ;; pressing C-k. If the buffer needs saving, you will be queried
149 ;; before the buffer is killed.
151 ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
152 ;; the file at the head of the list with C-k. You will always be
153 ;; asked for confirmation before the file is deleted.
155 ;; If you enter C-x b to switch to a buffer visiting a given file, and
156 ;; you find that the file you are after is not in any buffer, you can
157 ;; press C-f to immediately drop into ido-find-file. And you can
158 ;; switch back to buffer selection with C-b.
163 ;; The standard way of completion with Unix-shells and Emacs is to insert a
164 ;; PREFIX and then hitting TAB (or another completion key). Cause of this
165 ;; behavior has become second nature to a lot of Emacs users, Ido offers in
166 ;; addition to the default substring-matching-method (look above) also the
167 ;; prefix-matching-method. The kind of matching is the only difference to
168 ;; the description of the substring-matching above.
170 ;; You can toggle prefix matching with C-p.
174 ;; If you have again two Buffers "123456" and "123" then hitting "2" does
175 ;; not match because "2" is not a PREFIX in any of the buffer-names.
180 ;; If you set ido-enable-flex-matching, ido will do a more flexible
181 ;; matching (unless regexp matching is active) to find possible matches
182 ;; among the available buffer or file names if no matches are found using
183 ;; the normal prefix or substring matching.
185 ;; The flexible matching implies that any item which simply contains all
186 ;; of the entered characters in the specified sequence will match.
190 ;; If you have four files "alpha", "beta", "gamma", and "delta",
191 ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
192 ;; "beta" and "delta". If prefix matching is also active, "aa" only
193 ;; matches "alpha", while "ea" does not match any files.
198 ;; There is limited provision for regexp matching within ido,
199 ;; enabled through `ido-enable-regexp' (toggle with C-t).
200 ;; This allows you to type `[ch]$' for example and see all file names
201 ;; ending in `c' or `h'.
203 ;; Note: ido-style completion is inhibited when you enable regexp matching.
209 ;; Customize the Ido group to change the Ido functionality.
211 ;; To modify the keybindings, use `define-key' on
212 ;; `ido-common-completion-map' or one of the specialized keymaps:
213 ;; `ido-file-dir-completion-map', `ido-file-completion-map' or
214 ;; `ido-buffer-completion-map'.
216 ;; (with-eval-after-load 'ido
217 ;; (define-key ido-common-completion-map " " 'ido-next-match))
219 ;; Seeing all the matching buffers or files
220 ;; ----------------------------------------
222 ;; If you have many matching files, they may not all fit onto one
223 ;; line of the minibuffer. Normally, the minibuffer window will grow
224 ;; to show you more of the matching files (depending on the setting
225 ;; of the variables `resize-mini-windows' and `max-mini-window-height').
226 ;; If you want ido to behave differently from the default minibuffer
227 ;; resizing behavior, set the variable `ido-max-window-height'.
229 ;; Also, to improve the responsiveness of ido, the maximum number of
230 ;; matching items is limited to 12, but you can increase or removed
231 ;; this limit via the `ido-max-prospects' variable.
233 ;; To see a full list of all matching buffers in a separate buffer,
234 ;; hit ? or press TAB when there are no further completions to the
235 ;; substring. Repeated TAB presses will scroll you through this
238 ;; Changing the list of files
239 ;; --------------------------
241 ;; By default, the list of current files is most recent first,
242 ;; oldest last, with the exception that the files visible in the
243 ;; current frame are put at the end of the list. A hook exists to
244 ;; allow other functions to order the list. For example, if you add:
246 ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
248 ;; then all files matching "Summary" are moved to the end of the
249 ;; list. (I find this handy for keeping the INBOX Summary and so on
250 ;; out of the way.) It also moves files matching "output\*$" to the
251 ;; end of the list (these are created by AUCTeX when compiling.)
252 ;; Other functions could be made available which alter the list of
253 ;; matching files (either deleting or rearranging elements.)
258 ;; The highlighting of matching items is controlled via ido-use-faces.
259 ;; The faces used are ido-first-match, ido-only-match and
261 ;; Coloring of the matching item was suggested by
262 ;; Carsten Dominik (dominik@strw.leidenuniv.nl).
264 ;; Replacement for read-buffer and read-file-name
265 ;; ----------------------------------------------
267 ;; ido-read-buffer and ido-read-file-name have been written to be drop
268 ;; in replacements for the normal buffer and file name reading
269 ;; functions `read-buffer' and `read-file-name'.
271 ;; To use ido for all buffer and file selections in Emacs, customize the
272 ;; variable `ido-everywhere'.
274 ;; Using ido-like behavior in other Lisp packages
275 ;; -----------------------------------------------
277 ;; If you don't want to rely on the `ido-everywhere' functionality,
278 ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
279 ;; can be used by other packages to read a buffer name, a file name,
280 ;; or a directory name in the Ido way.
284 ;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
285 ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
286 ;; for ido-switch-buffer and found the inspiration for ido-find-file.
287 ;; The ido package would never have existed without his work.
289 ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
290 ;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
291 ;; fixes and improvements.
295 ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
296 ;; couldn't live without it, but once being addicted to switching buffers
297 ;; with a minimum of keystrokes, I soon found that opening files in the
298 ;; old-fashioned way was just too slow - so I decided to write a package
299 ;; which could open files with the same speed and ease as iswitchb could
302 ;; I originally wrote a separate ifindf.el package based on a copy of
303 ;; iswitchb.el, which did for opening files what iswitchb did for
304 ;; switching buffers. Along the way, I corrected a few errors in
305 ;; ifindf which could have found its way back into iswitchb, but since
306 ;; most of the functionality of the two package was practically
307 ;; identical, I decided that the proper thing to do was to merge my
308 ;; ifindf package back into iswitchb.
310 ;; This is basically what ido (interactively do) is all about; but I
311 ;; found it awkward to merge my changes into the "iswitchb-" namespace,
312 ;; so I invented a common "ido-" namespace for the merged packages.
314 ;; This version is based on ido.el version 1.57 released on
315 ;; gnu.emacs.sources adapted for Emacs 22.1 to use command remapping
316 ;; and optionally hooking the read-buffer and read-file-name functions.
318 ;; Prefix matching was added by Klaus Berndl <klaus.berndl@sdm.de> based on
319 ;; an idea of Yuji Minejima <ggb01164@nifty.ne.jp> and his mcomplete-package.
324 (defvar recentf-list
)
329 ;; These are some things you might want to change.
331 (defun ido-fractionp (n)
332 "Return t if N is a fraction."
333 (and (numberp n
) (> n
0.0) (<= n
1.0)))
336 "Switch between files using substrings."
340 :link
'(emacs-commentary-link :tag
"Commentary" "ido.el")
341 :link
'(emacs-library-link :tag
"Lisp File" "ido.el")
342 :link
'(custom-manual "(ido) Top")
343 :link
'(info-link "(ido) Customization"))
346 (defcustom ido-mode nil
347 "Determines for which buffer/file Ido should be enabled.
348 The following values are possible:
349 - `buffer': Turn only on Ido buffer behavior (switching, killing,
351 - `file': Turn only on Ido file behavior (finding, writing, inserting...)
352 - `both': Turn on Ido buffer and file behavior.
353 - nil: Turn off any Ido switching.
355 Setting this variable directly does not take effect;
356 use either \\[customize] or the function `ido-mode'."
357 :set
#'(lambda (_symbol value
)
359 :initialize
'custom-initialize-default
361 :link
'(emacs-commentary-link "ido.el")
362 :set-after
'(ido-save-directory-list-file
363 ;; This will clear ido-unc-hosts-cache, so set it
364 ;; before loading history file.
366 :type
'(choice (const :tag
"Turn on only buffer" buffer
)
367 (const :tag
"Turn on only file" file
)
368 (const :tag
"Turn on both buffer and file" both
)
369 (const :tag
"Switch off all" nil
))
372 (defcustom ido-case-fold case-fold-search
373 "Non-nil if searching of buffer and file names should ignore case."
377 (defcustom ido-ignore-buffers
379 "List of regexps or functions matching buffer names to ignore.
380 For example, traditional behavior is not to list buffers whose names begin
381 with a space, for which the regexp is `\\\\=` '. See the source file for
382 example functions that filter buffer names."
383 :type
'(repeat (choice regexp function
))
386 (defcustom ido-ignore-files
387 '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
388 "List of regexps or functions matching file names to ignore.
389 For example, traditional behavior is not to list files whose names begin
390 with a #, for which the regexp is `\\\\=`#'. See the source file for
391 example functions that filter filenames."
392 :type
'(repeat (choice regexp function
))
395 (defcustom ido-ignore-extensions t
396 "Non-nil means ignore files in `completion-ignored-extensions' list."
400 (defcustom ido-show-dot-for-dired nil
401 "Non-nil means to always put . as the first item in file name lists.
402 This allows the current directory to be opened immediately with `dired'."
406 (defcustom ido-file-extensions-order nil
407 "List of file extensions specifying preferred order of file selections.
408 Each element is either a string with `.' as the first char, an empty
409 string matching files without extension, or t which is the default order
410 for files with an unlisted file extension."
411 :type
'(repeat (choice string
412 (const :tag
"Default order" t
)))
415 (defcustom ido-ignore-directories
416 '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
417 "List of regexps or functions matching sub-directory names to ignore."
418 :type
'(repeat (choice regexp function
))
421 (defcustom ido-ignore-directories-merge nil
422 "List of regexps or functions matching directory names to ignore during merge.
423 Directory names matched by one of the regexps in this list are not inserted
424 in merged file and directory lists."
425 :type
'(repeat (choice regexp function
))
428 ;; Examples for setting the value of ido-ignore-buffers
429 ;;(defun ido-ignore-c-mode (name)
430 ;; "Ignore all c mode buffers -- example function for ido."
431 ;; (with-current-buffer name
432 ;; (derived-mode-p 'c-mode)))
434 ;;(setq ido-ignore-buffers '("\\` " ido-ignore-c-mode))
436 ;; Examples for setting the value of ido-ignore-files
437 ;;(setq ido-ignore-files '("\\` " "\\.c\\'" "\\.h\\'"))
439 (defcustom ido-default-file-method
'raise-frame
440 "How to visit a new file when using `ido-find-file'.
442 `selected-window' Show new file in selected window
443 `other-window' Show new file in another window (same frame)
444 `display' Display file in another window without selecting to it
445 `other-frame' Show new file in another frame
446 `maybe-frame' If a file is visible in another frame, prompt to ask if you
447 you want to see the file in the same window of the current
448 frame or in the other frame
449 `raise-frame' If a file is visible in another frame, raise that
450 frame; otherwise, visit the file in the same window"
451 :type
'(choice (const :tag
"Visit in selected window" selected-window
)
452 (const :tag
"Visit in other window" other-window
)
453 (const :tag
"Display (no select) in other window" display
)
454 (const :tag
"Visit in other frame" other-frame
)
455 (const :tag
"Ask to visit in other frame" maybe-frame
)
456 (const :tag
"Raise frame if already visited" raise-frame
))
459 (defcustom ido-default-buffer-method
'raise-frame
460 "How to switch to new buffer when using `ido-switch-buffer'.
461 See `ido-default-file-method' for details."
462 :type
'(choice (const :tag
"Show in selected window" selected-window
)
463 (const :tag
"Show in other window" other-window
)
464 (const :tag
"Display (no select) in other window" display
)
465 (const :tag
"Show in other frame" other-frame
)
466 (const :tag
"Ask to show in other frame" maybe-frame
)
467 (const :tag
"Raise frame if already shown" raise-frame
))
470 (defcustom ido-enable-flex-matching nil
471 "Non-nil means that Ido will do flexible string matching.
472 Flexible matching means that if the entered string does not
473 match any item, any item containing the entered characters
474 in the given sequence will match."
479 (defcustom ido-enable-regexp nil
480 "Non-nil means that Ido will do regexp matching.
481 Value can be toggled within Ido using `ido-toggle-regexp'."
485 (defcustom ido-enable-prefix nil
486 "Non-nil means only match if the entered text is a prefix of file name.
487 This behavior is like the standard Emacs completion.
488 If nil, match if the entered text is an arbitrary substring.
489 Value can be toggled within Ido using `ido-toggle-prefix'."
493 (defcustom ido-enable-dot-prefix nil
494 "Non-nil means to match leading dot as prefix.
495 I.e. hidden files and buffers will match only if you type a dot
496 as first char even if `ido-enable-prefix' is nil."
500 ;; See http://debbugs.gnu.org/2042 for more info.
501 (defcustom ido-buffer-disable-smart-matches t
502 "Non-nil means not to re-order matches for buffer switching.
503 By default, Ido arranges matches in the following order:
505 full-matches > suffix matches > prefix matches > remaining matches
507 which can get in the way for buffer switching."
512 (defcustom ido-confirm-unique-completion nil
513 "Non-nil means that even a unique completion must be confirmed.
514 This means that \\[ido-complete] must always be followed by \\[ido-exit-minibuffer]
515 even when there is only one unique completion."
519 (defcustom ido-cannot-complete-command
'ido-completion-help
520 "Command run when `ido-complete' can't complete any more.
521 The most useful values are `ido-completion-help', which pops up a
522 window with completion alternatives, or `ido-next-match' or
523 `ido-prev-match', which cycle the buffer list."
528 (defcustom ido-record-commands t
529 "Non-nil means that Ido will record commands in command history.
530 Note that the non-Ido equivalent command is recorded."
534 (defcustom ido-max-prospects
12
535 "Upper limit of the prospect list if non-zero.
536 Zero means no limit for the prospect list.
537 For a long list of prospects, building the full list for the
538 minibuffer can take a non-negligible amount of time; setting this
539 variable reduces that time."
543 (defcustom ido-max-file-prompt-width
0.35
544 "Upper limit of the prompt string.
545 If value is an integer, it specifies the number of characters of
547 If value is a floating point number, it specifies a fraction of
550 (integer :tag
"Characters" :value
20)
551 (restricted-sexp :tag
"Fraction of frame width"
553 :match-alternatives
(ido-fractionp)))
556 (defcustom ido-max-window-height nil
557 "Non-nil specifies a value to override `max-mini-window-height'."
559 (const :tag
"Don't override" nil
)
560 (integer :tag
"Number of lines" :value
1)
562 :tag
"Fraction of window height"
564 :match-alternatives
(ido-fractionp)))
567 (defcustom ido-enable-last-directory-history t
568 "Non-nil means that Ido will remember latest selected directory names.
569 See `ido-last-directory-list' and `ido-save-directory-list-file'."
573 (defcustom ido-max-work-directory-list
50
574 "Maximum number of working directories to record.
575 This is the list of directories where files have most recently been opened.
576 See `ido-work-directory-list' and `ido-save-directory-list-file'."
580 (defcustom ido-work-directory-list-ignore-regexps nil
581 "List of regexps matching directories which should not be recorded.
582 Directory names matched by one of the regexps in this list are not inserted in
583 the `ido-work-directory-list' list."
584 :type
'(repeat regexp
)
588 (defcustom ido-use-filename-at-point nil
589 "Non-nil means that Ido shall look for a filename at point.
590 May use `ffap-guesser' to guess whether text at point is a filename.
591 If found, use that as the starting point for filename selection."
593 (const :tag
"Disabled" nil
)
594 (const :tag
"Guess filename" guess
)
595 (other :tag
"Use literal filename" t
))
599 (defcustom ido-use-url-at-point nil
600 "Non-nil means that ido shall look for a URL at point.
601 If found, call `find-file-at-point' to visit it."
606 (defcustom ido-enable-tramp-completion t
607 "Non-nil means that Ido shall perform tramp method and server name completion.
608 A tramp file name uses the following syntax: /method:user@host:filename."
612 (defcustom ido-record-ftp-work-directories t
613 "Non-nil means record FTP file names in the work directory list."
617 (defcustom ido-merge-ftp-work-directories nil
618 "If nil, merging ignores FTP file names in the work directory list."
622 (defcustom ido-cache-ftp-work-directory-time
1.0
623 "Maximum time to cache contents of an FTP directory (in hours).
624 \\<ido-file-completion-map>
625 Use \\[ido-reread-directory] in prompt to refresh list.
626 If zero, FTP directories are not cached."
630 (defcustom ido-slow-ftp-hosts nil
631 "List of slow FTP hosts where Ido prompting should not be used.
632 If an FTP host is on this list, Ido automatically switches to the non-Ido
633 equivalent function, e.g. `find-file' rather than `ido-find-file'."
634 :type
'(repeat string
)
637 (defcustom ido-slow-ftp-host-regexps nil
638 "List of regexps matching slow FTP hosts (see `ido-slow-ftp-hosts')."
639 :type
'(repeat regexp
)
642 (defvar ido-unc-hosts-cache t
643 "Cached value from the function `ido-unc-hosts'.")
645 (defcustom ido-unc-hosts nil
646 "List of known UNC host names to complete after initial //.
647 If value is a function, that function is called to search network for
648 hosts on first use of UNC path."
649 :type
'(choice (repeat :tag
"List of UNC host names" string
)
650 (function-item :tag
"Use `NET VIEW'"
651 :value ido-unc-hosts-net-view
)
652 (function :tag
"Your own function"))
653 :set
#'(lambda (symbol value
)
655 (setq ido-unc-hosts-cache t
))
658 (defcustom ido-downcase-unc-hosts t
659 "Non-nil if UNC host names should be downcased."
663 (defcustom ido-ignore-unc-host-regexps nil
664 "List of regexps matching UNC hosts to ignore.
665 Case is ignored if `ido-downcase-unc-hosts' is set."
666 :type
'(repeat regexp
)
669 (defcustom ido-cache-unc-host-shares-time
8.0
670 "Maximum time to cache shares of an UNC host (in hours).
671 \\<ido-file-completion-map>
672 Use \\[ido-reread-directory] in prompt to refresh list.
673 If zero, UNC host shares are not cached."
677 (defcustom ido-max-work-file-list
10
678 "Maximum number of names of recently opened files to record.
679 This is the list of the file names (sans directory) which have most recently
680 been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
684 (defcustom ido-work-directory-match-only t
685 "Non-nil means to skip non-matching directories in the directory history.
686 When some text is already entered at the `ido-find-file' prompt, using
687 \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip directories
688 without any matching entries."
692 (defcustom ido-auto-merge-work-directories-length
0
693 "Automatically switch to merged work directories during file name input.
694 The value is number of characters to type before switching to merged mode.
695 If zero, the switch happens when no matches are found in the current directory.
696 Automatic merging is disabled if the value is negative."
700 (defcustom ido-auto-merge-delay-time
0.70
701 "Delay in seconds to wait for more input before doing auto merge."
705 (defcustom ido-auto-merge-inhibit-characters-regexp
"[][*?~]"
706 "Regexp matching characters which should inhibit automatic merging.
707 When a (partial) file name matches this regexp, merging is inhibited."
711 (defcustom ido-merged-indicator
"^"
712 "The string appended to first choice if it has multiple directory choices."
716 (defcustom ido-max-dir-file-cache
100
717 "Maximum number of working directories to be cached.
718 \\<ido-file-completion-map>
719 This is the size of the cache of `file-name-all-completions' results.
720 Each cache entry is time stamped with the modification time of the
721 directory. Some systems, like Windows, have unreliable directory
722 modification times, so you may choose to disable caching on such
723 systems, or explicitly refresh the cache contents using the command
724 `ido-reread-directory' command (\\[ido-reread-directory]) in the minibuffer.
725 See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
729 (defcustom ido-max-directory-size nil
730 "Maximum size (in bytes) for directories to use Ido completion.
731 \\<ido-completion-map>
732 If you enter a directory with a size larger than this size, Ido will
733 not provide the normal completion. To show the completions, use \\[ido-toggle-ignore]."
734 :type
'(choice (const :tag
"No limit" nil
)
735 (integer :tag
"Size in bytes" 30000))
738 (defcustom ido-rotate-file-list-default nil
739 "Non-nil means that Ido will always rotate file list to get default in front."
743 (defcustom ido-enter-matching-directory
'only
744 "Additional methods to enter sub-directory of first/only matching item.
745 If value is `first', enter first matching sub-directory when typing a slash.
746 If value is `only', typing a slash only enters the sub-directory if it is
747 the only matching item.
748 If value is t, automatically enter a sub-directory when it is the only
749 matching item, even without typing a slash."
750 :type
'(choice (const :tag
"Never" nil
)
751 (const :tag
"Slash enters first directory" first
)
752 (const :tag
"Slash enters first and only directory" only
)
753 (other :tag
"Always enter unique directory" t
))
756 (defcustom ido-create-new-buffer
'prompt
757 "Specify whether a new buffer is created if no buffer matches substring.
758 Choices are `always' to create new buffers unconditionally, `prompt' to
759 ask user whether to create buffer, or `never' to never create new buffer."
760 :type
'(choice (const always
)
765 (defcustom ido-setup-hook nil
766 "Hook run after the Ido variables and keymap have been setup.
767 The dynamic variable `ido-cur-item' contains the current type of item that
768 is read by Ido; possible values are file, dir, buffer, and list.
769 Additional keys can be defined in `ido-completion-map'."
773 (defcustom ido-separator nil
774 "String used by Ido to separate the alternatives in the minibuffer."
775 :type
'(choice string
(const nil
))
777 (make-obsolete-variable 'ido-separator
778 "set 3rd element of `ido-decorations' instead." nil
)
780 (defcustom ido-decorations
'("{" "}" " | " " | ..." "[" "]" " [No match]"
781 " [Matched]" " [Not readable]" " [Too big]" " [Confirm]")
782 "List of strings used by Ido to display the alternatives in the minibuffer.
783 There are between 11 and 13 elements in this list:
784 1st and 2nd elements are used as brackets around the prospect list,
785 3rd element is the separator between prospects (ignored if
786 `ido-separator' is set),
787 4th element is the string inserted at the end of a truncated list of prospects,
788 5th and 6th elements are used as brackets around the common match string which
789 can be completed using TAB,
790 7th element is the string displayed when there are no matches, and
791 8th element is displayed if there is a single match (and faces are not used),
792 9th element is displayed when the current directory is non-readable,
793 10th element is displayed when directory exceeds `ido-max-directory-size',
794 11th element is displayed to confirm creating new file or buffer.
795 12th and 13th elements (if present) are used as brackets around the sole
796 remaining completion. If absent, elements 5 and 6 are used instead."
797 :type
'(repeat string
)
800 (defcustom ido-use-virtual-buffers nil
801 "If non-nil, refer to past (\"virtual\") buffers as well as existing ones.
803 nil: Do not use virtual buffers.
804 t: Always use virtual buffers.
805 auto: Use virtual buffers if the current input matches no existing buffer.
807 Essentially it works as follows: Say you are visiting a file and
808 the buffer gets cleaned up by midnight.el. Later, you want to
809 switch to that buffer, but find it's no longer open. With virtual
810 buffers enabled, the buffer name stays in the buffer list (using
811 the `ido-virtual' face, and always at the end), and if you select
812 it, it opens the file back up again. This allows you to think
813 less about whether recently opened files are still open or not.
814 Most of the time you can quit Emacs, restart, and then switch to
815 a file buffer that was previously open as if it still were.
817 This feature relies upon the `recentf' package, which will be
818 enabled if this variable is configured to a non-nil value."
820 :type
'(choice (const :tag
"Always" t
)
821 (const :tag
"Automatic" auto
)
822 (const :tag
"Never" nil
))
825 (defcustom ido-use-faces t
826 "Non-nil means use Ido faces to highlighting first match, only match and
827 subdirs in the alternatives."
831 (defface ido-first-match
'((t :weight bold
))
832 "Face used by Ido for highlighting first match."
835 (defface ido-only-match
'((((class color
))
836 :foreground
"ForestGreen")
838 "Face used by Ido for highlighting only match."
841 (defface ido-subdir
'((((min-colors 88) (class color
))
846 "Face used by Ido for highlighting subdirs in the alternatives."
849 (defface ido-virtual
'((t :inherit font-lock-builtin-face
))
850 "Face used by Ido for matching virtual buffer names."
854 (defface ido-indicator
'((((min-colors 88) (class color
))
855 :foreground
"yellow1" :background
"red1" :width condensed
)
857 :foreground
"yellow" :background
"red" :width condensed
)
858 (t :inverse-video t
))
859 "Face used by Ido for highlighting its indicators."
862 (defface ido-incomplete-regexp
863 '((t :inherit font-lock-warning-face
))
864 "Ido face for indicating incomplete regexps."
867 (defcustom ido-make-file-list-hook nil
868 "List of functions to run when the list of matching files is created.
869 Each function on the list may modify the dynamically bound variable
870 `ido-temp-list' which contains the current list of matching files."
874 (defcustom ido-make-dir-list-hook nil
875 "List of functions to run when the list of matching directories is created.
876 Each function on the list may modify the dynamically bound variable
877 `ido-temp-list' which contains the current list of matching directories."
881 (defcustom ido-make-buffer-list-hook nil
882 "List of functions to run when the list of matching buffers is created.
883 Each function on the list may modify the dynamically bound variable
884 `ido-temp-list' which contains the current list of matching buffer names."
888 (defcustom ido-rewrite-file-prompt-functions nil
889 "List of functions to run when the find-file prompt is created.
890 Each function on the list may modify the following dynamically bound
892 dirname - the (abbreviated) directory name
893 to be modified by the hook functions
894 max-width - the max width of the resulting dirname; nil means no limit
895 prompt - the basic prompt (e.g. \"Find File: \")
896 literal - the string shown if doing \"literal\" find; set to nil to omit
897 vc-off - the string shown if version control is inhibited; set to nil to omit
898 prefix - either nil or a fixed prefix for the dirname
900 The following variables are available, but should not be changed:
901 `ido-current-directory' - the unabbreviated directory name
902 item - equals `file' or `dir' depending on the current mode."
906 (defvar ido-rewrite-file-prompt-rules nil
907 "Alist of rewriting rules for directory names in Ido prompts.
908 A list of elements of the form (FROM . TO) or (FROM . FUNC), each
909 meaning to rewrite the directory name if matched by FROM by either
910 substituting the matched string by TO or calling the function FUNC
911 with the current directory name as its only argument and using the
912 return value as the new directory name. In addition, each FUNC may
913 also modify the dynamic variables described for the variable
914 `ido-rewrite-file-prompt-functions'.")
916 (defcustom ido-completion-buffer
"*Ido Completions*"
917 "Name of completion buffer used by Ido.
918 Set to nil to disable completion buffers popping up."
922 (defcustom ido-completion-buffer-all-completions nil
923 "Non-nil means to show all completions in completion buffer.
924 Otherwise, only the current list of matches is shown."
928 (defcustom ido-all-frames
'visible
929 "Argument to pass to `walk-windows' when Ido is finding buffers.
930 See documentation of `walk-windows' for useful values."
931 :type
'(choice (const :tag
"Selected frame only" nil
)
932 (const :tag
"All existing frames" t
)
933 (const :tag
"All visible frames" visible
)
934 (const :tag
"All frames on this terminal" 0))
937 (defcustom ido-minibuffer-setup-hook nil
938 "Ido-specific customization of minibuffer setup.
940 This hook is run during minibuffer setup if Ido is active.
941 It is intended for use in customizing Ido for interoperation
942 with other packages. For instance:
944 (add-hook \\='ido-minibuffer-setup-hook
945 (lambda () (setq-local max-mini-window-height 3)))
947 will constrain Emacs to a maximum minibuffer height of 3 lines when
948 Ido is running. Copied from `icomplete-minibuffer-setup-hook'."
952 (defcustom ido-save-directory-list-file
953 (locate-user-emacs-file "ido.last" ".ido.last")
954 "File in which the Ido state is saved between invocations.
955 Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
956 `ido-work-file-list', and `ido-dir-file-cache'.
957 Must be set before enabling Ido mode."
958 :version
"24.4" ; added locate-user-emacs-file
962 (defcustom ido-read-file-name-as-directory-commands
'()
963 "List of commands which use `read-file-name' to read a directory name.
964 When `ido-everywhere' is non-nil, the commands in this list will read
965 the directory using `ido-read-directory-name'."
966 :type
'(repeat symbol
)
969 (defcustom ido-read-file-name-non-ido
'()
970 "List of commands which shall not read file names the Ido way.
971 When `ido-everywhere' is non-nil, the commands in this list will read
972 the file name using normal `read-file-name' style."
973 :type
'(repeat symbol
)
976 (defcustom ido-before-fallback-functions
'()
977 "List of functions to call before calling a fallback command.
978 The fallback command is passed as an argument to the functions."
984 (defvar ido-common-completion-map
985 (let ((map (make-sparse-keymap)))
986 (set-keymap-parent map minibuffer-local-map
)
987 (define-key map
"\C-a" 'ido-toggle-ignore
)
988 (define-key map
"\C-c" 'ido-toggle-case
)
989 (define-key map
"\C-e" 'ido-edit-input
)
990 (define-key map
"\t" 'ido-complete
)
991 (define-key map
" " 'ido-complete-space
)
992 (define-key map
"\C-j" 'ido-select-text
)
993 (define-key map
"\C-m" 'ido-exit-minibuffer
)
994 (define-key map
"\C-p" 'ido-toggle-prefix
)
995 (define-key map
"\C-r" 'ido-prev-match
)
996 (define-key map
"\C-s" 'ido-next-match
)
997 (define-key map
[?\C-.
] 'ido-next-match
)
998 (define-key map
[?\C-
,] 'ido-prev-match
)
999 (define-key map
"\C-t" 'ido-toggle-regexp
)
1000 (define-key map
"\C-z" 'ido-undo-merge-work-directory
)
1001 (define-key map
[(control ?\s
)] 'ido-restrict-to-matches
)
1002 (define-key map
[(meta ?\s
)] 'ido-take-first-match
)
1003 (define-key map
[(control ?
@)] 'ido-restrict-to-matches
)
1004 (define-key map
[right] 'ido-next-match)
1005 (define-key map [left] 'ido-prev-match)
1006 (define-key map "?" 'ido-completion-help)
1007 (define-key map "\C-b" 'ido-magic-backward-char)
1008 (define-key map "\C-f" 'ido-magic-forward-char)
1009 (define-key map "\C-d" 'ido-magic-delete-char)
1011 "Keymap for all Ido commands.")
1013 (defvar ido-file-dir-completion-map
1014 (let ((map (make-sparse-keymap)))
1015 (set-keymap-parent map ido-common-completion-map)
1016 (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
1017 (define-key map "\C-x\C-f" 'ido-fallback-command)
1018 (define-key map "\C-x\C-d" 'ido-enter-dired)
1019 (define-key map [down] 'ido-next-match-dir)
1020 (define-key map [up] 'ido-prev-match-dir)
1021 (define-key map [(meta up)] 'ido-prev-work-directory)
1022 (define-key map [(meta down)] 'ido-next-work-directory)
1023 (define-key map [backspace] 'ido-delete-backward-updir)
1024 (define-key map "\d" 'ido-delete-backward-updir)
1025 (define-key map [remap delete-backward-char] 'ido-delete-backward-updir) ; BS
1026 (define-key map [remap backward-kill-word] 'ido-delete-backward-word-updir) ; M-DEL
1027 (define-key map [(control backspace)] 'ido-up-directory)
1028 (define-key map "\C-l" 'ido-reread-directory)
1029 (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
1030 (define-key map [(meta ?b)] 'ido-push-dir)
1031 (define-key map [(meta ?v)] 'ido-push-dir-first)
1032 (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
1033 (define-key map [(meta ?k)] 'ido-forget-work-directory)
1034 (define-key map [(meta ?m)] 'ido-make-directory)
1035 (define-key map [(meta ?n)] 'ido-next-work-directory)
1036 (define-key map [(meta ?o)] 'ido-prev-work-file)
1037 (define-key map [(meta control ?o)] 'ido-next-work-file)
1038 (define-key map [(meta ?p)] 'ido-prev-work-directory)
1039 (define-key map [(meta ?s)] 'ido-merge-work-directories)
1041 "Keymap for Ido file and directory commands.")
1043 (defvar ido-file-completion-map
1044 (let ((map (make-sparse-keymap)))
1045 (set-keymap-parent map ido-file-dir-completion-map)
1046 (define-key map "\C-k" 'ido-delete-file-at-head)
1047 (define-key map "\C-o" 'ido-copy-current-word)
1048 (define-key map "\C-w" 'ido-copy-current-file-name)
1049 (define-key map [(meta ?l)] 'ido-toggle-literal)
1051 "Keymap for Ido file commands.")
1053 (defvar ido-buffer-completion-map
1054 (let ((map (make-sparse-keymap)))
1055 (set-keymap-parent map ido-common-completion-map)
1056 (define-key map "\C-x\C-f" 'ido-enter-find-file)
1057 (define-key map "\C-x\C-b" 'ido-fallback-command)
1058 (define-key map "\C-k" 'ido-kill-buffer-at-head)
1059 (define-key map [?\C-\S-b] 'ido-bury-buffer-at-head)
1060 (define-key map "\C-o" 'ido-toggle-virtual-buffers)
1062 "Keymap for Ido buffer commands.")
1064 ;;;; Persistent variables
1066 (defvar ido-file-history nil
1067 "History of files selected using `ido-find-file'.")
1069 (defvar ido-buffer-history nil
1070 "History of buffers selected using `ido-switch-buffer'.")
1072 (defvar ido-last-directory-list nil
1073 "List of last selected directory names.
1074 See `ido-enable-last-directory-history' for details.")
1076 (defvar ido-work-directory-list nil
1077 "List of actual working directory names.
1078 The current directory is inserted at the front of this list whenever a
1079 file is opened with `ido-find-file' and family.")
1081 (defvar ido-work-file-list nil
1082 "List of actual work file names.
1083 Opening a file with `ido-find-file' and similar functions
1084 inserts the current file name (relative to its containing directory)
1085 at the front of this list.")
1087 (defvar ido-dir-file-cache nil
1088 "List of `file-name-all-completions' results.
1089 Each element in the list is of the form (DIR (MTIME) FILE...).")
1091 (defvar ido-ignore-item-temp-list nil
1092 "List of items to ignore in current Ido invocation.
1093 Intended to be let-bound by functions which call Ido repeatedly.
1094 Should never be set permanently.")
1096 ;;;; Temporary storage
1098 (defvar ido-completion-map nil
1099 "Currently active keymap for Ido commands.")
1101 (defvar ido-eoinput 1
1102 "Point where minibuffer input ends and completion info begins.
1103 Copied from `icomplete-eoinput'.")
1104 (make-variable-buffer-local 'ido-eoinput)
1106 (defvar ido-common-match-string nil
1107 "Stores the string that is common to all matching files.")
1109 (defvar ido-rescan nil
1110 "Non-nil means we need to regenerate the list of matching items.")
1112 (defvar ido-rotate nil
1113 "Non-nil means we are rotating list of matches.")
1115 (defvar ido-text nil
1116 "Stores the user's string as it is typed in.")
1118 (defvar ido-text-init nil
1119 "The initial string for the user's string it is typed in.")
1121 (defvar ido-input-stack nil
1122 "Stores the user's strings when user hits M-b/M-f.")
1124 (defvar ido-matches nil
1125 "List of files currently matching `ido-text'.")
1127 (defvar ido-report-no-match t
1128 "Report \"[No Match]\" when no completions matches `ido-text'.")
1130 (defvar ido-exit nil
1131 "Flag to monitor how `ido-find-file' exits.
1132 If equal to `takeprompt', we use the prompt as the file name to be
1135 (defvar ido-current-directory nil
1136 "Current directory for `ido-find-file'.")
1138 (defvar ido-auto-merge-timer nil
1139 "Delay timer for auto merge.")
1141 (defvar ido-use-mycompletion-depth 0
1142 "Non-nil means use Ido completion feedback.
1143 Is set by Ido functions to the current `minibuffer-depth',
1144 so that it doesn't interfere with other minibuffer usage.")
1146 (defvar ido-incomplete-regexp nil
1147 "Non-nil if an incomplete regexp is entered.")
1149 (defvar ido-initial-position nil
1150 "Non-nil means to explicitly cursor on entry to minibuffer.
1151 Value is an integer which is number of chars to right of prompt.")
1153 (defvar ido-virtual-buffers nil
1154 "List of virtual buffers, that is, past visited files.
1155 This is a copy of `recentf-list', pared down and with faces applied.
1156 Only used if `ido-use-virtual-buffers' is non-nil.")
1158 ;;;; Variables with dynamic bindings.
1160 ;; These are declared here to keep the byte compiler quiet.
1162 ;; Stores the current ido item type ('file, 'dir, 'buffer, or 'list).
1163 (defvar ido-cur-item)
1165 ;; Stores the current default item.
1166 (defvar ido-default-item)
1168 ;; Stores the current list of items that will be searched through.
1169 ;; The list is ordered, so that the most interesting item comes first,
1170 ;; although by default, the files visible in the current frame are put
1171 ;; at the end of the list. Created by `ido-make-item-list'.
1172 (defvar ido-cur-list)
1174 ;; Stores the choice list for ido-completing-read
1175 (defvar ido-choice-list)
1177 ;; Stores the list of items which are ignored when building
1178 ;; `ido-cur-list'. It is in no specific order.
1179 (defvar ido-ignored-list)
1181 ;; Remember if current directory is non-readable (so we cannot do completion).
1182 (defvar ido-directory-nonreadable)
1184 ;; Remember if current directory is 'huge' (so we don't want to do completion).
1185 (defvar ido-directory-too-big)
1187 ;; Keep current item list if non-nil.
1188 (defvar ido-keep-item-list)
1190 ;; Process ido-ignore-* lists.
1191 (defvar ido-process-ignore-lists)
1193 ;; Don't process ido-ignore- lists once.
1194 (defvar ido-process-ignore-lists-inhibit)
1196 ;; Is ido using virtual buffers?
1197 (defvar ido-enable-virtual-buffers)
1199 ;; Buffer from which ido was entered.
1200 (defvar ido-entry-buffer)
1202 ;; Non-nil if matching file must be selected.
1203 (defvar ido-require-match)
1205 ;; Non-nil if we should add [confirm] to prompt
1206 (defvar ido-show-confirm-message)
1208 ;; Stores a temporary version of the file list being created.
1209 (defvar ido-temp-list)
1211 ;; Non-nil if default list element should be rotated into place.
1212 (defvar ido-rotate-temp)
1214 ;; Stores current index in ido-work-directory-list.
1215 (defvar ido-work-directory-index)
1217 ;; Stores current index in ido-work-file-list.
1218 (defvar ido-work-file-index)
1220 ;; Set when merged work directory list is in use.
1221 (defvar ido-use-merged-list)
1223 ;; Set when merged work directory list not yet built.
1224 (defvar ido-try-merged-list)
1226 ;; Saved state prior to last work directory merge.
1227 ;; Value is a list (ido-text dir cur-list ignored-list matches).
1228 (defvar ido-pre-merge-state)
1230 ;; Original value of vc-handled-backends for use in ido-toggle-vc.
1231 (defvar ido-saved-vc-hb)
1233 ;; Stores temporary state of literal find file.
1234 (defvar ido-find-literal)
1236 ;; Set to 'ignore to inhibit switching between find-file/switch-buffer.
1237 (defvar ido-context-switch-command)
1239 ;; Dynamically bound in ido-read-internal.
1240 (defvar ido-completing-read)
1244 (defun ido-active (&optional merge)
1247 (and (boundp 'ido-completing-read)
1248 (or (featurep 'xemacs)
1249 (= ido-use-mycompletion-depth (minibuffer-depth))))))
1251 (defvar ido-trace-enable nil)
1253 (defun ido-trace (p &optional s retval)
1254 (if ido-trace-enable
1255 (let ((b (get-buffer-create " *IDO Trace*"))
1256 (deactivate-mark deactivate-mark))
1260 (insert p ": " (if (stringp s) s (format "%S" s)) "\n")))))
1263 (defun ido-toggle-trace (arg)
1265 (setq ido-trace-enable (or arg (not ido-trace-enable)))
1266 (if ido-trace-enable
1267 (message "IDO trace on"))
1268 (let ((b (get-buffer " *IDO Trace*")))
1270 (if ido-trace-enable
1272 (pop-to-buffer b t t)
1273 (setq truncate-lines t)))))
1275 (defun ido-local-file-exists-p (file)
1276 "Tell if FILE exists locally."
1277 (let (file-name-handler-alist)
1278 (file-exists-p file)))
1280 (defun ido-unc-hosts (&optional query)
1281 "Return list of UNC host names."
1284 ((listp ido-unc-hosts)
1285 ido-unc-hosts) ;; static list or nil
1286 ((listp ido-unc-hosts-cache)
1287 ido-unc-hosts-cache) ;; result of net search
1288 ((and query (fboundp ido-unc-hosts))
1289 (message (propertize "Searching for UNC hosts..." 'face 'highlight))
1290 (setq ido-unc-hosts-cache (funcall ido-unc-hosts))
1292 ido-unc-hosts-cache)
1294 (setq ido-unc-hosts-cache nil))
1295 (t (fboundp ido-unc-hosts)))))
1297 (let ((case-fold-search ido-downcase-unc-hosts)
1298 res host re-list re)
1300 (setq host (car hosts)
1302 re-list (and ido-process-ignore-lists
1303 ido-ignore-unc-host-regexps))
1305 (setq re (car re-list)
1306 re-list (cdr re-list))
1307 (if (string-match re host)
1311 (when ido-downcase-unc-hosts
1312 (setq host (downcase host)))
1313 (setq res (cons host res))))
1314 (setq hosts (sort res #'string<))))
1317 (defun ido-unc-hosts-net-view ()
1318 "Query network for list of UNC host names using `NET VIEW'."
1321 (shell-command "net view" t)
1322 (goto-char (point-min))
1323 (while (re-search-forward "^\\\\\\\\\\([[:graph:]]+\\)" nil t)
1324 (setq hosts (cons (match-string 1) hosts))))
1327 (defun ido-is-tramp-root (&optional dir)
1328 (and ido-enable-tramp-completion
1329 (string-match "\\`/[^/]+[@:]\\'"
1330 (or dir ido-current-directory))))
1332 (defun ido-is-unc-root (&optional dir)
1333 (and (ido-unc-hosts)
1335 (or dir ido-current-directory))))
1337 (defun ido-is-unc-host (&optional dir)
1338 (and (ido-unc-hosts)
1339 (string-match "\\`//[^/]+/\\'"
1340 (or dir ido-current-directory))))
1342 (defun ido-is-root-directory (&optional dir)
1343 (setq dir (or dir ido-current-directory))
1345 (string-equal "/" dir)
1346 (and (memq system-type '(windows-nt ms-dos))
1347 (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
1348 (if ido-enable-tramp-completion
1349 (ido-is-tramp-root dir)
1350 (string-match "\\`/[^:/][^:/]+:\\'" dir))))
1352 (defun ido-is-ftp-directory (&optional dir)
1354 (if ido-enable-tramp-completion
1355 ;; like tramp-file-name-regexp-unified, but doesn't match single drive letters
1357 "\\`/[^/:][^/:]+:/")
1358 (or dir ido-current-directory)))
1360 (defun ido-is-slow-ftp-host (&optional dir)
1361 (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
1362 (setq dir (or dir ido-current-directory))
1363 ;; (featurep 'ange-ftp)
1364 ;; (ange-ftp-ftp-name dir)
1366 (if ido-enable-tramp-completion
1367 "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
1368 "\\`/\\([^/:]*@\\)?\\([^@/:][^@/:]+\\):/")
1370 (let ((host (substring dir (match-beginning 2) (match-end 2))))
1371 (or (member host ido-slow-ftp-hosts)
1372 (let ((re ido-slow-ftp-host-regexps))
1373 (while (and re (not (string-match (car re) host)))
1377 (defun ido-time-stamp (&optional time)
1378 ;; Time is a floating point number (fractions of 1 hour)
1379 (/ (float-time time) 3600))
1381 (defun ido-cache-ftp-valid (&optional time)
1382 (and (numberp ido-cache-ftp-work-directory-time)
1383 (> ido-cache-ftp-work-directory-time 0)
1385 (< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
1387 (defun ido-cache-unc-valid (&optional time)
1388 (and (numberp ido-cache-unc-host-shares-time)
1389 (> ido-cache-unc-host-shares-time 0)
1391 (< (- (ido-time-stamp) time) ido-cache-unc-host-shares-time))))
1393 (defun ido-may-cache-directory (&optional dir)
1394 (setq dir (or dir ido-current-directory))
1396 ((and (ido-is-root-directory dir)
1397 (or ido-enable-tramp-completion
1398 (memq system-type '(windows-nt ms-dos))))
1400 ((ido-is-unc-host dir)
1401 (ido-cache-unc-valid))
1402 ((ido-is-ftp-directory dir)
1403 (ido-cache-ftp-valid))
1404 ((ido-directory-too-big-p dir)
1408 (defun ido-pp (list &optional sep)
1409 (let ((print-level nil) (eval-expression-print-level nil)
1410 (print-length nil) (eval-expression-print-length nil))
1411 (insert "\n;; ----- " (symbol-name list) " -----\n(\n ")
1412 (setq list (symbol-value list))
1414 (let* ((elt (car list))
1415 (s (if (consp elt) (car elt) elt)))
1416 (if (and (stringp s) (= (length s) 0))
1419 (prin1 elt (current-buffer)))
1420 (if (and (setq list (cdr list)) s)
1421 (insert (or sep "\n ")))))
1424 (defun ido-save-history ()
1425 "Save Ido history and cache information between sessions."
1427 (when (and ido-last-directory-list ido-save-directory-list-file)
1428 (let ((buf (get-buffer-create " *ido session*"))
1429 (version-control 'never))
1431 (with-current-buffer buf
1433 (insert ";;; -*- coding: utf-8 -*-\n")
1434 (setq buffer-file-coding-system 'utf-8)
1435 (ido-pp 'ido-last-directory-list)
1436 (ido-pp 'ido-work-directory-list)
1437 (ido-pp 'ido-work-file-list)
1438 (ido-pp 'ido-dir-file-cache "\n\n ")
1439 (if (listp ido-unc-hosts-cache)
1440 (ido-pp 'ido-unc-hosts-cache)
1441 (insert "\n;; ----- ido-unc-hosts-cache -----\nt\n"))
1442 (write-file ido-save-directory-list-file nil))
1443 (kill-buffer buf)))))
1445 (defun ido-load-history (&optional arg)
1446 "Load Ido history and cache information from previous session.
1447 With prefix argument, reload history unconditionally."
1449 (if (or arg (and ido-save-directory-list-file (not ido-last-directory-list)))
1450 (let ((file (expand-file-name ido-save-directory-list-file))
1452 (when (file-readable-p file)
1453 (setq buf (get-buffer-create " *ido session*"))
1455 (with-current-buffer buf
1457 (insert-file-contents file)
1459 (setq ido-last-directory-list (read (current-buffer))
1460 ido-work-directory-list (read (current-buffer))
1461 ido-work-file-list (read (current-buffer))
1462 ido-dir-file-cache (read (current-buffer))
1463 ido-unc-hosts-cache (read (current-buffer)))
1465 (kill-buffer buf)))))
1468 (defun ido-wash-history ()
1469 "Clean-up Ido history and cache information.
1470 Removes badly formatted data and ignored directories."
1472 ;; Check format of each of our lists, discard bogus elements
1473 (setq ido-last-directory-list
1474 (and (listp ido-last-directory-list)
1475 (let ((l ido-last-directory-list) r)
1477 (if (and (consp (car l))
1478 (stringp (car (car l)))
1479 (stringp (cdr (car l))))
1480 (setq r (cons (car l) r)))
1483 (setq ido-work-directory-list
1484 (and (listp ido-work-directory-list)
1485 (let ((l ido-work-directory-list) r)
1487 (if (and (stringp (car l))
1488 (or ido-record-ftp-work-directories
1489 (not (ido-is-ftp-directory (car l)))))
1490 (setq r (cons (car l) r)))
1493 (setq ido-work-file-list
1494 (and (listp ido-work-file-list)
1495 (let ((l ido-work-file-list) r)
1497 (if (stringp (car l))
1498 (setq r (cons (car l) r)))
1501 (setq ido-dir-file-cache
1502 (and (listp ido-dir-file-cache)
1503 (let ((l ido-dir-file-cache) r)
1505 (if (and (listp (car l))
1506 (> (length (car l)) 2)
1507 (let ((dir (car (car l)))
1508 (time (car (cdr (car l))))
1509 (files (cdr (cdr (car l)))))
1514 ((integerp (car time))
1515 (and (/= (car time) 0)
1516 (integerp (car (cdr time)))
1517 (/= (car (cdr time)) 0)
1518 (ido-may-cache-directory dir)))
1519 ((eq (car time) 'ftp)
1520 (and (numberp (cdr time))
1521 (ido-is-ftp-directory dir)
1522 (ido-cache-ftp-valid (cdr time))))
1523 ((eq (car time) 'unc)
1524 (and (numberp (cdr time))
1525 (ido-is-unc-host dir)
1526 (ido-cache-unc-valid (cdr time))))
1528 (let ((s files) (ok t))
1530 (if (stringp (car s))
1532 (setq s nil ok nil)))
1534 (setq r (cons (car l) r)))
1538 ;; Remove ignored directories from work directory list
1539 ;; according to ido-work-directory-list-ignore-regexps
1540 (if ido-work-directory-list
1541 (let ((dirs (reverse ido-work-directory-list)))
1542 (setq ido-work-directory-list nil)
1544 (ido-record-work-directory (car dirs))
1545 (setq dirs (cdr dirs)))))
1546 ;; Get rid of text properties
1547 (let ((l ido-last-directory-list) e)
1549 (setq e (car l) l (cdr l))
1550 (set-text-properties 0 (length (car e)) nil (car e))
1551 (set-text-properties 0 (length (cdr e)) nil (cdr e))))
1552 (let ((l ido-work-directory-list) e)
1554 (setq e (car l) l (cdr l))
1555 (set-text-properties 0 (length e) nil e)))
1556 (let ((l ido-work-file-list) e)
1558 (setq e (car l) l (cdr l))
1559 (set-text-properties 0 (length e) nil e)))
1560 (let ((l ido-dir-file-cache) e d)
1562 (setq e (car l) l (cdr l))
1565 (setq d (car e) e (cdr e))
1567 (set-text-properties 0 (length d) nil d)))))))
1570 (defun ido-kill-emacs-hook ()
1571 ;; ido kill emacs hook
1574 (defun ido-common-initialization ()
1575 (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
1576 (add-hook 'choose-completion-string-functions 'ido-choose-completion-string))
1578 (define-minor-mode ido-everywhere
1579 "Toggle use of Ido for all buffer/file reading.
1580 With a prefix argument ARG, enable this feature if ARG is
1581 positive, and disable it otherwise. If called from Lisp,
1582 enable the mode if ARG is omitted or nil."
1585 (when (get 'ido-everywhere 'file)
1586 (setq read-file-name-function (car (get 'ido-everywhere 'file)))
1587 (put 'ido-everywhere 'file nil))
1588 (when (get 'ido-everywhere 'buffer)
1589 (setq read-buffer-function (car (get 'ido-everywhere 'buffer)))
1590 (put 'ido-everywhere 'buffer nil))
1591 (when ido-everywhere
1592 (when (memq ido-mode '(both file))
1593 (put 'ido-everywhere 'file (cons read-file-name-function nil))
1594 (setq read-file-name-function #'ido-read-file-name))
1595 (when (memq ido-mode '(both buffer))
1596 (put 'ido-everywhere 'buffer (cons read-buffer-function nil))
1597 (setq read-buffer-function #'ido-read-buffer))))
1599 (defvar ido-minor-mode-map-entry nil)
1602 (defun ido-mode (&optional arg)
1603 "Toggle Ido mode on or off.
1604 With ARG, turn Ido mode on if arg is positive, off otherwise.
1605 Turning on Ido mode will remap (via a minor-mode keymap) the default
1606 keybindings for the `find-file' and `switch-to-buffer' families of
1607 commands to the Ido versions of these functions.
1608 However, if ARG arg equals `files', remap only commands for files, or
1609 if it equals `buffers', remap only commands for buffer switching.
1610 This function also adds a hook to the minibuffer."
1614 ((null arg) (if ido-mode nil 'both))
1616 ((eq arg 'files) 'file)
1617 ((eq arg 'buffers) 'buffer)
1618 ((memq arg '(file buffer both)) arg)
1619 ((> (prefix-numeric-value arg) 0) 'both)
1622 (ido-everywhere (if ido-everywhere 1 -1))
1625 (ido-common-initialization)
1628 (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
1630 (let ((map (make-sparse-keymap)))
1631 (when (memq ido-mode '(file both))
1632 (define-key map [remap find-file] 'ido-find-file)
1633 (define-key map [remap find-file-read-only] 'ido-find-file-read-only)
1634 (define-key map [remap find-alternate-file] 'ido-find-alternate-file)
1635 (define-key map [remap write-file] 'ido-write-file)
1636 (define-key map [remap insert-file] 'ido-insert-file)
1637 (define-key map [remap list-directory] 'ido-list-directory)
1638 (define-key map [remap dired] 'ido-dired)
1639 (define-key map [remap find-file-other-window]
1640 'ido-find-file-other-window)
1641 (define-key map [remap find-file-read-only-other-window]
1642 'ido-find-file-read-only-other-window)
1643 (define-key map [remap find-file-other-frame]
1644 'ido-find-file-other-frame)
1645 (define-key map [remap find-file-read-only-other-frame]
1646 'ido-find-file-read-only-other-frame))
1648 (when (memq ido-mode '(buffer both))
1649 (define-key map [remap switch-to-buffer] 'ido-switch-buffer)
1650 (define-key map [remap switch-to-buffer-other-window]
1651 'ido-switch-buffer-other-window)
1652 (define-key map [remap switch-to-buffer-other-frame]
1653 'ido-switch-buffer-other-frame)
1654 (define-key map [remap insert-buffer] 'ido-insert-buffer)
1655 (define-key map [remap kill-buffer] 'ido-kill-buffer)
1656 (define-key map [remap display-buffer] 'ido-display-buffer))
1658 (if ido-minor-mode-map-entry
1659 (setcdr ido-minor-mode-map-entry map)
1660 (setq ido-minor-mode-map-entry (cons 'ido-mode map))
1661 (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))))
1663 (when (called-interactively-p 'any)
1664 (message "Ido mode %s" (if ido-mode "enabled" "disabled"))))
1669 (defalias 'ido-init-completion-maps 'ignore "")
1670 (make-obsolete 'ido-init-completion-maps "it does nothing." "25.1")
1672 (defun ido-setup-completion-map ()
1673 "Set up the completion keymap used by Ido.
1675 Create a keymap, bind `ido-completion-map' to it, and depending
1676 on what is being completed (`ido-cur-item') set its parent keymap
1679 `ido-common-completion-map'
1680 `ido-file-dir-completion-map'
1681 `ido-file-completion-map'
1682 `ido-buffer-completion-map'
1684 If option `ido-context-switch-command' is non-nil or `viper-mode'
1685 is enabled then some keybindings are changed in the keymap."
1686 ;; generated every time so that it can inherit new functions.
1687 (let ((map (make-sparse-keymap))
1688 (viper-p (if (boundp 'viper-mode) viper-mode)))
1690 (define-key map [remap viper-intercept-ESC-key] 'ignore))
1693 (when ido-context-switch-command
1694 (define-key map "\C-x\C-b" ido-context-switch-command)
1695 (define-key map "\C-x\C-d" 'ignore))
1697 (define-key map [remap viper-backward-char]
1698 'ido-delete-backward-updir)
1699 (define-key map [remap viper-del-backward-char-in-insert]
1700 'ido-delete-backward-updir)
1701 (define-key map [remap viper-delete-backward-word]
1702 'ido-delete-backward-word-updir))
1703 (set-keymap-parent map
1704 (if (eq ido-cur-item 'file)
1705 ido-file-completion-map
1706 ido-file-dir-completion-map)))
1708 (when ido-context-switch-command
1709 (define-key map "\C-x\C-f" ido-context-switch-command))
1710 (set-keymap-parent map ido-buffer-completion-map))
1712 (set-keymap-parent map ido-common-completion-map)))
1713 (setq ido-completion-map map)))
1715 (defun ido-final-slash (dir &optional fix-it)
1716 ;; return DIR if DIR has final slash.
1717 ;; else if FIX-IT is non-nil, return DIR/
1719 (setq dir (ido-name dir))
1721 ((string-match "/\\'" dir) dir)
1722 ((ido-is-tramp-root dir) dir)
1723 (fix-it (concat dir "/"))
1726 (defun ido-no-final-slash (s)
1727 ;; Remove optional final slash from string S
1728 (let ((l (1- (length s))))
1729 (if (and (> l 0) (eq (aref s l) ?/))
1733 (defun ido-nonreadable-directory-p (dir)
1734 ;; Return t if dir is a directory, but not readable
1735 ;; Do not check for non-readable directories via tramp, as this causes a premature
1736 ;; connect on incomplete tramp paths (after entering just method:).
1737 (let ((ido-enable-tramp-completion nil))
1738 (and (ido-final-slash dir)
1739 (not (ido-is-unc-host dir))
1740 (file-directory-p dir)
1741 (not (file-readable-p dir)))))
1743 (defun ido-directory-too-big-p (dir)
1744 ;; Return t if dir is a directory, but too big to show
1745 ;; Do not check for non-readable directories via tramp, as this causes a premature
1746 ;; connect on incomplete tramp paths (after entering just method:).
1747 (let ((ido-enable-tramp-completion nil))
1748 (and (numberp ido-max-directory-size)
1749 (ido-final-slash dir)
1750 (not (ido-is-unc-host dir))
1751 (file-directory-p dir)
1752 (> (nth 7 (file-attributes (file-truename dir))) ido-max-directory-size))))
1754 (defun ido-set-current-directory (dir &optional subdir no-merge)
1755 ;; Set ido's current directory to DIR or DIR/SUBDIR
1756 (unless (and ido-enable-tramp-completion
1757 (string-match "\\`/[^/]*@\\'" dir))
1758 (setq dir (ido-final-slash dir t)))
1759 (setq ido-use-merged-list nil
1760 ido-try-merged-list (not no-merge))
1762 (setq dir (concat dir subdir))
1763 (unless (and ido-enable-tramp-completion
1764 (string-match "\\`/[^/]*@\\'" dir))
1765 (setq dir (ido-final-slash dir t))))
1766 (and ido-completion-buffer
1767 (get-buffer ido-completion-buffer)
1768 (kill-buffer ido-completion-buffer))
1770 ((equal dir ido-current-directory)
1772 ((ido-is-unc-root dir)
1773 (ido-trace "unc" dir)
1774 (setq ido-current-directory dir)
1775 (setq ido-directory-nonreadable nil)
1776 (setq ido-directory-too-big nil)
1779 (ido-trace "cd" dir)
1780 (setq ido-current-directory dir)
1781 (and ido-completion-buffer
1782 (get-buffer ido-completion-buffer)
1783 (kill-buffer ido-completion-buffer))
1784 (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
1785 (setq ido-directory-too-big (and (not ido-directory-nonreadable)
1786 (ido-directory-too-big-p dir)))
1789 (defun ido-set-current-home (&optional dir)
1790 ;; Set ido's current directory to user's home directory
1791 (ido-set-current-directory (expand-file-name (or dir "~/"))))
1793 (defun ido-record-command (command arg)
1794 "Add (COMMAND ARG) to `command-history' if `ido-record-commands' is non-nil."
1795 (if ido-record-commands ; FIXME: use `when' instead of `if'?
1796 (let ((cmd (list command arg)))
1797 (if (or (not command-history) ; FIXME: ditto
1798 (not (equal cmd (car command-history))))
1799 (setq command-history (cons cmd command-history))))))
1801 (defun ido-make-prompt (item prompt)
1802 ;; Make the prompt for ido-read-internal
1804 ((and (memq item '(file dir)) ido-current-directory)
1805 (let ((dirname (abbreviate-file-name ido-current-directory))
1806 (max-width (if (and ido-max-file-prompt-width (floatp ido-max-file-prompt-width))
1807 (floor (* (frame-width) ido-max-file-prompt-width))
1808 ido-max-file-prompt-width))
1809 (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) "))
1810 (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
1812 (rule ido-rewrite-file-prompt-rules))
1813 (let ((case-fold-search nil))
1815 (if (and (consp (car rule))
1816 (string-match (car (car rule)) dirname))
1818 (if (stringp (cdr (car rule)))
1819 (replace-match (cdr (car rule)) t nil dirname)
1820 (funcall (cdr (car rule)) dirname))))
1821 (setq rule (cdr rule))))
1822 (run-hooks 'ido-rewrite-file-prompt-functions)
1824 ; (if ido-process-ignore-lists "" "&")
1828 (let ((l (length dirname)))
1829 (if (and max-width (> max-width 0) (> l max-width))
1830 (let* ((s (substring dirname (- max-width)))
1831 (i (string-match "/" s)))
1832 (concat "..." (if i (substring s i) s)))
1836 ;; Here is very briefly how ido-find-file works:
1839 ;; (ido-file-internal method)
1840 ;; set ido-current-directory
1841 ;; (ido-read-internal 'file ...)
1843 ;; (ido-make-item-list ...)
1844 ;; (ido-set-matches)
1845 ;; (completing-read ... ido-text-init ...)
1847 ;; ... here user is allowed to type characters and commands
1848 ;; a command may set ido-exit and call (exit-minibuffer)
1849 ;; to make ido-read-internal do advanced tasks (or return)
1851 ;; ... ido-tidy and ido-exhibit are pre- and post-hooks
1852 ;; which are run before and after each user command.
1854 ;; return value from completing-read is stored in ido-final-text
1855 ;; - ido-exit may cause further actions to be taken:
1856 ;; 'refresh - repeat loop (make-item-list, set-matches)
1857 ;; 'edit - edit the prompt string, then repeat loop
1858 ;; 'keep - repeat loop but don't (re)make-item-list
1859 ;; 'updir - go up one directory, repeat loop
1860 ;; else set ido-selected based on ido-final-text,
1861 ;; optionally update ido-current-directory and repeat loop, or
1862 ;; exit with the return value of ido-selected (file name)
1863 ;; selected file name is returned from ido-read-internal,
1864 ;; ido-exit and method determines what action is taken
1865 ;; e.g. the file name may be ignored or joined with ido-current-directory, and
1866 ;; the relevant function is called (find-file, write-file, etc).
1868 (defun ido-read-internal (item prompt hist &optional default require-match initial)
1869 "Perform the `ido-read-buffer' and `ido-read-file-name' functions.
1870 Return the name of a buffer or file selected.
1871 PROMPT is the prompt to give to the user.
1872 DEFAULT if given is the default item to start with.
1873 If REQUIRE-MATCH is non-nil, an existing file must be selected.
1874 If INITIAL is non-nil, it specifies the initial input string."
1876 ((ido-cur-item item)
1877 (ido-entry-buffer (current-buffer))
1878 (ido-process-ignore-lists t)
1879 (ido-process-ignore-lists-inhibit nil)
1880 (ido-set-default-item t)
1885 (icomplete-mode nil) ;; prevent icomplete starting up
1886 ;; Exported dynamic variables:
1889 (ido-rotate-temp nil)
1890 (ido-keep-item-list nil)
1891 (ido-use-merged-list nil)
1892 (ido-try-merged-list t)
1893 (ido-pre-merge-state nil)
1894 (ido-case-fold ido-case-fold)
1895 (ido-enable-prefix ido-enable-prefix)
1896 (ido-enable-regexp ido-enable-regexp)
1897 (ido-show-confirm-message nil)
1900 (ido-setup-completion-map)
1901 (setq ido-text-init initial)
1902 (setq ido-input-stack nil)
1904 (run-hooks 'ido-setup-hook)
1907 (ido-trace "\n_LOOP_" ido-text-init)
1910 (setq ido-rotate nil)
1912 (when ido-set-default-item
1913 (setq ido-default-item
1916 (if (bufferp default) (buffer-name default) default))
1918 (if (memq item '(file dir))
1919 (file-name-nondirectory default)
1922 (and ido-enable-last-directory-history
1923 (let ((d (assoc ido-current-directory ido-last-directory-list)))
1924 (and d (cdr d)))))))
1925 (if (member ido-default-item ido-ignore-item-temp-list)
1926 (setq ido-default-item nil))
1927 (ido-trace "new default" ido-default-item)
1928 (if ido-default-item
1929 (setq ido-initial-position 0))
1930 (setq ido-set-default-item nil))
1932 (if ido-process-ignore-lists-inhibit
1933 (setq ido-process-ignore-lists nil))
1935 (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not ido-keep-item-list))
1936 (let ((olist ido-cur-list)
1937 (oign ido-ignored-list)
1939 (l (ido-make-merged-file-list ido-text-init
1940 (eq ido-use-merged-list 'auto)
1941 (eq ido-try-merged-list 'wide))))
1942 (ido-trace "merged" l)
1945 (if (eq ido-try-merged-list 'wide)
1946 (setq ido-pre-merge-state
1947 (list "" ido-current-directory olist oign omat)
1949 ido-ignored-list nil
1951 ido-keep-item-list t
1952 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1953 ido-use-merged-list nil)
1954 (setq ido-cur-list olist
1955 ido-ignored-list oign
1957 ido-keep-item-list t
1958 ido-try-merged-list (if (eq ido-use-merged-list 'auto) 'auto nil)
1959 ido-use-merged-list nil)))
1961 (setq ido-use-merged-list nil))
1962 ((eq l 'input-pending-p)
1963 (setq ido-try-merged-list t
1964 ido-use-merged-list nil))
1966 (setq ido-pre-merge-state
1967 (list ido-text-init ido-current-directory olist oign omat))
1968 (ido-set-current-directory (car (cdr (car l))))
1969 (if (ido-final-slash ido-text-init)
1970 (setq ido-text-init ""))
1971 (setq ido-cur-list l
1972 ido-ignored-list nil
1975 ido-keep-item-list t
1976 ido-use-merged-list t)
1977 (ido-trace "Merged" t)
1982 (setq ido-keep-item-list nil
1984 ((eq ido-cur-item 'file)
1985 (setq ido-ignored-list nil
1986 ido-cur-list (and (not ido-directory-nonreadable)
1987 (not ido-directory-too-big)
1988 (ido-make-file-list ido-default-item))))
1989 ((eq ido-cur-item 'dir)
1990 (setq ido-ignored-list nil
1991 ido-cur-list (and (not ido-directory-nonreadable)
1992 (not ido-directory-too-big)
1993 (ido-make-dir-list ido-default-item))))
1994 ((eq ido-cur-item 'buffer)
1995 (setq ido-ignored-list nil
1996 ido-cur-list (ido-make-buffer-list ido-default-item)))
1997 ((eq ido-cur-item 'list)
1998 (setq ido-ignored-list nil
1999 ido-cur-list (ido-make-choice-list ido-default-item)))
2001 (setq ido-rotate-temp nil)
2003 (if ido-process-ignore-lists-inhibit
2004 (setq ido-process-ignore-lists t
2005 ido-process-ignore-lists-inhibit nil))
2008 (if (and ido-matches (eq ido-try-merged-list 'auto))
2009 (setq ido-try-merged-list t))
2010 (let ((max-mini-window-height (or ido-max-window-height
2011 (and (boundp 'max-mini-window-height)
2012 max-mini-window-height)))
2013 (ido-completing-read t)
2014 (ido-require-match require-match)
2015 (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
2016 (show-paren-mode nil)
2017 ;; Postpone history adding till later
2018 (history-add-new-input nil))
2019 ;; prompt the user for the file name
2021 (setq ido-final-text
2023 (read-from-minibuffer (ido-make-prompt item prompt)
2024 (prog1 ido-text-init
2025 (setq ido-text-init nil))
2026 ido-completion-map nil hist))))
2027 (ido-trace "read-from-minibuffer" ido-final-text)
2028 (and ido-completion-buffer
2029 (get-buffer ido-completion-buffer)
2030 (kill-buffer ido-completion-buffer))
2032 (ido-trace "\n_EXIT_" ido-exit)
2035 ((eq ido-exit 'refresh)
2036 (if (and (eq ido-use-merged-list 'auto)
2037 (or (input-pending-p)))
2038 (setq ido-use-merged-list nil
2039 ido-keep-item-list t))
2042 ((eq ido-exit 'done)
2044 ido-selected ido-text
2047 ((memq ido-exit '(edit chdir))
2049 ((memq ido-cur-item '(file dir))
2050 (let* ((read-file-name-function nil)
2051 (edit (eq ido-exit 'edit))
2052 (d ido-current-directory)
2055 (setq ido-text-init "")
2059 (read-file-name (concat prompt "[EDIT] ")
2060 (expand-file-name d)
2062 (quit (concat d f)))
2064 d (or (file-name-directory new) "/")
2065 f (file-name-nondirectory new)
2068 (file-directory-p d)
2069 (and (yes-or-no-p (format "Create directory %s? " d))
2071 (progn (make-directory d t) t)
2073 (message "Could not create directory")
2077 (ido-set-current-directory d nil (eq ido-exit 'chdir))
2078 (setq ido-text-init f
2083 (read-string (concat prompt "[EDIT] ") ido-final-text)
2084 (quit ido-final-text)))))
2088 ((eq ido-exit 'keep)
2089 (setq ido-keep-item-list t))
2091 ((memq ido-exit '(dired fallback find-file switch-to-buffer insert-buffer insert-file))
2094 ((memq ido-exit '(updir push))
2095 ;; cannot go up if already at the root-dir (Unix) or at the
2096 ;; root-dir of a certain drive (Windows or MS-DOS).
2097 (if (ido-is-tramp-root)
2098 (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" ido-current-directory)
2099 (setq ido-text-init (match-string 3 ido-current-directory))
2100 (ido-set-current-directory (match-string 1 ido-current-directory))
2101 (setq ido-set-default-item t))
2102 (unless (ido-is-root-directory)
2103 (when (eq ido-exit 'push)
2104 (setq ido-input-stack (cons (cons ido-cur-item ido-text) ido-input-stack))
2105 (setq ido-cur-item 'dir)
2106 (setq ido-text-init (file-name-nondirectory (substring ido-current-directory 0 -1)))
2107 (ido-trace "push" ido-input-stack))
2108 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1)))
2109 (setq ido-set-default-item t))))
2112 (ido-trace "pop" ido-input-stack)
2113 (let ((elt (car ido-input-stack)))
2114 (setq ido-input-stack (cdr ido-input-stack))
2115 (ido-set-current-directory (concat ido-current-directory ido-text))
2116 (setq ido-cur-item (car elt))
2117 (setq ido-text-init (cdr elt))))
2119 ((eq ido-exit 'pop-all)
2120 (ido-trace "pop-all" ido-input-stack)
2121 (while ido-input-stack
2122 (let ((elt (car ido-input-stack)))
2123 (setq ido-input-stack (cdr ido-input-stack))
2124 (ido-set-current-directory (concat ido-current-directory ido-text))
2125 (setq ido-cur-item (car elt))
2126 (setq ido-text-init (cdr elt)))))
2128 ;; Handling the require-match must be done in a better way.
2130 (not (memq require-match '(confirm confirm-after-completion)))
2131 (not (if ido-directory-too-big
2132 (file-exists-p (concat ido-current-directory ido-final-text))
2133 (ido-existing-item-p))))
2134 (error "Must specify valid item"))
2138 (if (or (eq ido-exit 'takeprompt)
2141 ;; else take head of list
2142 (ido-name (car ido-matches))))
2145 ((memq item '(buffer list))
2148 ((string-equal "./" ido-selected)
2151 ((string-equal "../" ido-selected)
2152 ;; cannot go up if already at the root-dir (Unix) or at the
2153 ;; root-dir of a certain drive (Windows or MS-DOS).
2154 (or (ido-is-root-directory)
2155 (ido-set-current-directory (file-name-directory (substring ido-current-directory 0 -1))))
2156 (setq ido-set-default-item t))
2158 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") ido-selected)
2159 (ido-is-root-directory) ;; Ange-ftp or Tramp
2160 (not (ido-local-file-exists-p ido-selected)))
2161 (ido-set-current-directory ido-current-directory ido-selected)
2162 (ido-trace "tramp prefix" ido-selected)
2163 (if (ido-is-slow-ftp-host)
2164 (setq ido-exit 'fallback
2166 (setq ido-set-default-item t)))
2168 ((string-match (if (memq system-type '(windows-nt ms-dos))
2169 "\\`[a-zA-Z]:\\|[/\\][^/\\]"
2172 (ido-set-current-directory (file-name-directory ido-selected))
2173 (setq ido-set-default-item t))
2175 ((string-match "\\`~" ido-selected)
2176 (ido-set-current-home ido-selected))
2178 ((ido-final-slash ido-selected)
2179 (if ido-enable-last-directory-history
2180 (let ((x (assoc ido-current-directory ido-last-directory-list)))
2182 (setcdr x ido-selected)
2183 (setq ido-last-directory-list
2184 (cons (cons ido-current-directory ido-selected) ido-last-directory-list)))))
2185 (ido-set-current-directory ido-current-directory ido-selected)
2187 ; automatically pop stack elements which match existing files or directories
2189 (while (and (setq elt (car ido-input-stack))
2190 (file-exists-p (concat ido-current-directory (cdr elt))))
2191 (if (setq ido-input-stack (cdr ido-input-stack))
2192 (ido-set-current-directory ido-current-directory (cdr elt))
2193 (setq ido-text-init (cdr elt)))
2194 (setq ido-cur-item (car elt))))
2195 (setq ido-set-default-item t)))
2199 (add-to-history (cond
2201 (or (car hist) 'minibuffer-history))
2203 (t 'minibuffer-history))
2207 (defun ido-edit-input ()
2208 "Edit absolute file name entered so far with Ido; terminate by RET.
2209 If cursor is not at the end of the user input, move to end of input."
2213 (setq ido-text-init (if ido-matches (ido-name (car ido-matches)) ido-text))
2214 (setq ido-exit 'edit)
2218 (defun ido-buffer-internal (method &optional fallback prompt default initial switch-cmd)
2219 ;; Internal function for ido-switch-buffer and friends
2222 (run-hook-with-args 'ido-before-fallback-functions
2223 (or fallback 'switch-to-buffer))
2224 (call-interactively (or fallback 'switch-to-buffer)))
2225 (let* ((ido-context-switch-command switch-cmd)
2226 (ido-current-directory nil)
2227 (ido-directory-nonreadable nil)
2228 (ido-directory-too-big nil)
2229 (ido-enable-virtual-buffers (and ido-use-virtual-buffers
2230 (not (eq ido-use-virtual-buffers 'auto))))
2231 (require-match (confirm-nonexistent-file-or-buffer))
2232 (buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default
2233 require-match initial))
2236 ;; Choose the buffer name: either the text typed in, or the head
2237 ;; of the list of matches
2240 ((eq ido-exit 'find-file)
2242 (if (memq method '(other-window other-frame)) method ido-default-file-method)
2243 nil nil nil nil ido-text))
2245 ((eq ido-exit 'insert-file)
2246 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil ido-text 'ido-enter-insert-buffer))
2248 ((eq ido-exit 'fallback)
2249 (let ((read-buffer-function nil))
2250 (setq this-command (or fallback 'switch-to-buffer))
2251 (run-hook-with-args 'ido-before-fallback-functions this-command)
2252 (call-interactively this-command)))
2254 ;; Check buf is non-nil.
2256 ((= (length buf) 0) nil)
2258 ;; View buffer if it exists
2260 (add-to-history 'buffer-name-history buf)
2261 (if (eq method 'insert)
2263 (ido-record-command 'insert-buffer buf)
2266 (insert-buffer-substring (get-buffer buf))
2268 (ido-visit-buffer buf method t)))
2270 ;; check for a virtual buffer reference
2271 ((and ido-enable-virtual-buffers
2273 (setq filename (assoc buf ido-virtual-buffers)))
2274 (ido-visit-buffer (find-file-noselect (cdr filename)) method t))
2276 ((and (eq ido-create-new-buffer 'prompt)
2277 (null require-match)
2278 (not (y-or-n-p (format-message
2279 "No buffer matching `%s', create one? " buf))))
2282 ;; buffer doesn't exist
2283 ((and (eq ido-create-new-buffer 'never)
2284 (null require-match))
2285 (message "No buffer matching `%s'" buf))
2287 ((and (eq ido-create-new-buffer 'prompt)
2288 (null require-match)
2289 (not (y-or-n-p (format-message
2290 "No buffer matching `%s', create one? " buf))))
2293 ;; create a new buffer
2295 (add-to-history 'buffer-name-history buf)
2296 (setq buf (get-buffer-create buf))
2297 (if (fboundp 'set-buffer-major-mode)
2298 (set-buffer-major-mode buf))
2299 (ido-visit-buffer buf method t))))))
2301 (defun ido-record-work-directory (&optional dir)
2302 (when (and (numberp ido-max-work-directory-list) (> ido-max-work-directory-list 0))
2303 (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
2304 (let ((items ido-work-directory-list-ignore-regexps)
2305 (case-fold-search nil))
2306 (while (and items dir)
2307 (if (string-match (car items) dir)
2309 (setq items (cdr items)))
2311 (setq ido-work-directory-list (cons dir (delete dir ido-work-directory-list))))))
2312 (if (> (length ido-work-directory-list) ido-max-work-directory-list)
2313 (setcdr (nthcdr (1- ido-max-work-directory-list) ido-work-directory-list) nil))))
2315 (defun ido-forget-work-directory ()
2317 (when (and ido-current-directory ido-work-directory-list)
2318 (setq ido-work-directory-list (delete ido-current-directory ido-work-directory-list))
2319 (when ido-use-merged-list
2320 (ido-undo-merge-work-directory)
2321 (setq ido-exit 'refresh
2322 ido-try-merged-list t
2323 ido-use-merged-list t
2324 ido-text-init ido-text
2326 (exit-minibuffer))))
2328 (defun ido-record-work-file (name)
2329 ;; Save NAME in ido-work-file-list
2330 (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
2332 (and ido-work-file-list (equal (car ido-work-file-list) name))
2333 (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
2334 (if (> (length ido-work-file-list) ido-max-work-file-list)
2335 (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
2337 (defun ido-expand-directory (dir)
2338 ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
2339 ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
2340 (ido-final-slash (expand-file-name (or dir default-directory)) t))
2342 (defun ido-file-internal (method &optional fallback default prompt item initial switch-cmd)
2343 ;; Internal function for ido-find-file and friends
2346 (let ((ido-current-directory (ido-expand-directory default))
2347 (ido-context-switch-command switch-cmd)
2348 ido-directory-nonreadable ido-directory-too-big
2351 (if (or (not ido-mode) (ido-is-slow-ftp-host))
2354 (setq ido-directory-nonreadable
2355 (ido-nonreadable-directory-p ido-current-directory)
2356 ido-directory-too-big
2357 (and (not ido-directory-nonreadable)
2358 (ido-directory-too-big-p ido-current-directory))))
2360 (when (and (eq item 'file)
2361 (or ido-use-url-at-point ido-use-filename-at-point))
2364 ;; Duplicate code from ffap-guesser as we want different
2365 ;; behavior for files and URLs.
2368 (and ido-use-url-at-point
2370 (ffap-fixup-url (or (ffap-url-at-point)
2371 (ffap-gopher-at-point)))))
2372 (setq ido-exit 'ffap
2375 ((and ido-use-filename-at-point
2376 (setq fn (with-no-warnings
2377 (if (eq ido-use-filename-at-point 'guess)
2379 (ffap-string-at-point))))
2380 (not (string-match "\\`http:/" fn)))
2381 (let ((absolute-fn (expand-file-name fn)))
2383 ((file-directory-p absolute-fn)
2384 (setq ido-current-directory
2385 (file-name-as-directory absolute-fn)))
2386 ((file-directory-p (file-name-directory absolute-fn))
2387 (setq ido-current-directory (file-name-directory absolute-fn))
2388 (setq initial (file-name-nondirectory absolute-fn)))))))))
2390 (let (ido-saved-vc-hb
2391 (vc-handled-backends (and (boundp 'vc-handled-backends)
2392 vc-handled-backends))
2393 (ido-work-directory-index -1)
2394 (ido-work-file-index -1)
2395 (ido-find-literal nil))
2398 (setq ido-saved-vc-hb vc-handled-backends)
2399 (let ((minibuffer-completing-file-name t))
2401 (ido-read-internal item
2402 (or prompt "Find file: ")
2404 (and (eq method 'alt-file) buffer-file-name)
2405 (confirm-nonexistent-file-or-buffer)
2408 ;; Choose the file name: either the text typed in, or the head
2409 ;; of the list of matches
2412 ((eq ido-exit 'fallback)
2413 ;; Need to guard setting of default-directory here, since
2414 ;; we don't want to change directory of current buffer.
2415 (let ((default-directory ido-current-directory)
2416 (read-file-name-function nil))
2417 (setq this-command (or fallback 'find-file))
2418 (run-hook-with-args 'ido-before-fallback-functions this-command)
2419 (call-interactively this-command)))
2421 ((eq ido-exit 'switch-to-buffer)
2422 (ido-buffer-internal
2423 (if (memq method '(other-window other-frame))
2424 method ido-default-buffer-method)
2425 nil nil nil ido-text))
2427 ((eq ido-exit 'insert-buffer)
2428 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "
2429 nil ido-text 'ido-enter-insert-file))
2431 ((eq ido-exit 'dired)
2432 (funcall (cond ((eq method 'other-window) 'dired-other-window)
2433 ((eq method 'other-frame) 'dired-other-frame)
2435 (concat ido-current-directory (or ido-text ""))))
2437 ((eq ido-exit 'ffap)
2438 (find-file-at-point))
2440 ((eq method 'alt-file)
2441 (ido-record-work-file filename)
2442 (setq default-directory ido-current-directory)
2443 (ido-record-work-directory)
2444 (find-alternate-file filename))
2446 ((memq method '(dired list-directory))
2447 (if (equal filename ".")
2449 (let* ((dirname (ido-final-slash
2450 (concat ido-current-directory filename) t))
2451 (file (substring dirname 0 -1)))
2453 ((file-directory-p dirname)
2454 (ido-record-command method dirname)
2455 (ido-record-work-directory dirname)
2456 (funcall method dirname))
2457 ((file-directory-p ido-current-directory)
2459 ((file-exists-p file)
2460 (ido-record-command method ido-current-directory)
2461 (ido-record-work-directory)
2462 (funcall method ido-current-directory)
2463 (if (eq method 'dired)
2465 (dired-goto-file (expand-file-name file)))))
2466 ((string-match "[[*?]" filename)
2467 (setq dirname (concat ido-current-directory filename))
2468 (ido-record-command method dirname)
2469 (ido-record-work-directory)
2470 (funcall method dirname))
2471 ((y-or-n-p (format "Directory %s does not exist. Create it? "
2473 (ido-record-command method dirname)
2474 (ido-record-work-directory dirname)
2475 (make-directory-internal dirname)
2476 (funcall method dirname))
2478 ;; put make-directory command on history
2479 (ido-record-command 'make-directory dirname))))
2480 (t (error "No such directory")))))
2483 (ido-record-work-file filename)
2484 (setq default-directory ido-current-directory)
2485 (setq filename (concat ido-current-directory filename))
2486 (ido-record-command 'write-file filename)
2487 (add-to-history 'file-name-history filename)
2488 (ido-record-work-directory)
2489 (write-file filename t))
2491 ((eq method 'read-only)
2492 (ido-record-work-file filename)
2493 (setq filename (concat ido-current-directory filename))
2494 (ido-record-command fallback filename)
2495 (ido-record-work-directory)
2496 (run-hook-with-args 'ido-before-fallback-functions fallback)
2497 (funcall fallback filename))
2499 ((eq method 'insert)
2500 (ido-record-work-file filename)
2501 (setq filename (concat ido-current-directory filename))
2503 (if ido-find-literal 'insert-file-literally 'insert-file)
2505 (add-to-history 'file-name-history filename)
2506 (ido-record-work-directory)
2507 (insert-file-1 filename
2508 (if ido-find-literal
2509 #'insert-file-contents-literally
2510 #'insert-file-contents)))
2513 (ido-record-work-file filename)
2514 (setq filename (concat ido-current-directory filename))
2515 (ido-record-command 'find-file filename)
2516 (add-to-history 'file-name-history filename)
2517 (ido-record-work-directory)
2518 (ido-visit-buffer (find-file-noselect filename nil ido-find-literal)
2521 (defun ido-existing-item-p ()
2522 ;; Return non-nil if there is a matching item
2523 (not (null ido-matches)))
2527 (defun ido-set-common-completion ()
2528 ;; Find common completion of `ido-text' in `ido-matches'
2529 ;; The result is stored in `ido-common-match-string'
2531 (setq ido-common-match-string nil)
2532 (if (and ido-matches
2533 (not ido-enable-regexp) ;; testing
2535 (> (length ido-text) 0))
2536 (if (setq val (ido-find-common-substring ido-matches ido-text))
2537 (setq ido-common-match-string val)))
2540 (defun ido-complete ()
2541 "Try and complete the current pattern amongst the file names."
2545 (ido-incomplete-regexp
2548 ((and (memq ido-cur-item '(file dir))
2549 (string-match "[$]" ido-text))
2550 (let ((evar (substitute-in-file-name (concat ido-current-directory ido-text))))
2551 (if (not (file-exists-p (file-name-directory evar)))
2552 (message "Expansion generates non-existing directory name")
2553 (if (file-directory-p evar)
2554 (ido-set-current-directory evar)
2555 (let ((d (or (file-name-directory evar) "/"))
2556 (f (file-name-nondirectory evar)))
2557 (when (file-directory-p d)
2558 (ido-set-current-directory d)
2559 (setq ido-text-init f))))
2560 (setq ido-exit 'refresh)
2561 (exit-minibuffer))))
2563 (ido-directory-too-big
2564 (setq ido-directory-too-big nil)
2565 (setq ido-text-init ido-text)
2566 (setq ido-exit 'refresh)
2570 (when ido-completion-buffer
2571 (call-interactively (setq this-command ido-cannot-complete-command))))
2573 ((and (= 1 (length ido-matches))
2574 (not (and ido-enable-tramp-completion
2575 (string-equal ido-current-directory "/")
2576 (string-match ".[@:]\\'" (ido-name (car ido-matches)))))
2577 (not (ido-local-file-exists-p (ido-name (car ido-matches)))))
2578 ;; only one choice, so select it.
2579 (if (not ido-confirm-unique-completion)
2581 (setq ido-rescan (not ido-enable-prefix))
2582 (delete-region (minibuffer-prompt-end) (point))
2583 (insert (ido-name (car ido-matches)))))
2585 (t ;; else there could be some completions
2586 (setq res ido-common-match-string)
2587 (if (and (not (memq res '(t nil)))
2588 (not (equal res ido-text)))
2589 ;; found something to complete, so put it in the minibuffer.
2591 ;; move exact match to front if not in prefix mode
2592 (setq ido-rescan (not ido-enable-prefix))
2593 (delete-region (minibuffer-prompt-end) (point))
2595 ;; else nothing to complete
2596 (call-interactively (setq this-command ido-cannot-complete-command))
2599 (defun ido-complete-space ()
2600 "Try completion unless inserting the space makes sense."
2602 (if (and (stringp ido-common-match-string)
2605 ((> (length ido-common-match-string) (length ido-text))
2606 (= (aref ido-common-match-string (length ido-text)) ? ))
2609 (re (concat (regexp-quote ido-text) " "))
2612 (if (string-match re (ido-name (car comp)))
2613 (setq comp nil insert-space t)
2614 (setq comp (cdr comp))))
2620 (defun ido-undo-merge-work-directory (&optional text try refresh)
2621 "Undo or redo last Ido directory merge operation.
2622 If no merge has yet taken place, toggle automatic merging option."
2625 (ido-pre-merge-state
2626 (ido-set-current-directory (nth 1 ido-pre-merge-state))
2627 (setq ido-text-init (or text (car ido-pre-merge-state))
2628 ido-cur-list (nth 2 ido-pre-merge-state)
2629 ido-ignored-list (nth 3 ido-pre-merge-state)
2630 ido-matches (nth 4 ido-pre-merge-state)
2631 ido-use-merged-list nil
2632 ido-try-merged-list try
2633 ido-keep-item-list (not refresh)
2636 ido-pre-merge-state nil)
2640 (ido-try-merged-list
2641 (setq ido-try-merged-list nil))
2643 (setq ido-try-merged-list t))
2644 ((not ido-use-merged-list)
2645 (ido-merge-work-directories))))
2649 (defun ido-magic-forward-char (arg)
2650 "Move forward in user input or perform magic action.
2651 If no user input is present, or at end of input, perform magic actions:
2652 C-x C-b ... C-f switch to `ido-find-file'.
2653 C-x C-f ... C-f fallback to non-Ido `find-file'.
2654 C-x C-d ... C-f fallback to non-Ido brief `dired'.
2655 C-x d ... C-f fallback to non-Ido `dired'."
2658 ((or arg (not (eobp)))
2659 (forward-char (min (prefix-numeric-value arg)
2660 (- (point-max) (point)))))
2661 ((memq ido-cur-item '(file dir))
2662 (ido-fallback-command))
2663 (ido-context-switch-command
2664 (call-interactively ido-context-switch-command))
2665 ((eq ido-cur-item 'buffer)
2666 (ido-enter-find-file))))
2670 (defun ido-magic-backward-char (arg)
2671 "Move backward in user input or perform magic action.
2672 If no user input is present, or at start of input, perform magic actions:
2673 C-x C-f C-b switch to `ido-switch-buffer'.
2674 C-x C-d C-b switch to `ido-switch-buffer'.
2675 C-x d C-b switch to `ido-switch-buffer'.
2676 C-x C-b C-b fallback to non-Ido `switch-to-buffer'."
2679 ((or arg (> (point) (minibuffer-prompt-end)))
2681 (- (min (prefix-numeric-value arg)
2682 (- (point) (minibuffer-prompt-end))))))
2683 ((eq last-command this-command)
2684 (when (and (memq ido-cur-item '(file dir))
2686 (ido-push-dir))) ; else do nothing
2687 ((eq ido-cur-item 'buffer)
2688 (ido-fallback-command))
2689 (ido-context-switch-command
2690 (call-interactively ido-context-switch-command))
2692 (ido-enter-switch-buffer))))
2696 (defun ido-magic-delete-char (arg)
2697 "Delete following char in user input or perform magic action.
2698 If at end of user input, perform magic actions:
2699 C-x C-f ... C-d enter `dired' on current directory."
2702 ((or arg (not (eobp)))
2703 (delete-char (min (prefix-numeric-value arg)
2704 (- (point-max) (point)))))
2705 (ido-context-switch-command
2707 ((memq ido-cur-item '(file dir))
2708 (ido-enter-dired))))
2711 ;;; TOGGLE FUNCTIONS
2713 (defun ido-toggle-case ()
2714 "Toggle the value of `ido-case-fold'."
2716 (setq ido-case-fold (not ido-case-fold))
2717 ;; ask for list to be regenerated.
2718 (setq ido-rescan t))
2720 (defun ido-toggle-regexp ()
2721 "Toggle the value of `ido-enable-regexp'."
2723 (setq ido-enable-regexp (not ido-enable-regexp))
2724 ;; ask for list to be regenerated.
2725 (setq ido-rescan t))
2727 (defun ido-toggle-prefix ()
2728 "Toggle the value of `ido-enable-prefix'."
2730 (setq ido-enable-prefix (not ido-enable-prefix))
2731 ;; ask for list to be regenerated.
2732 (setq ido-rescan t))
2734 (defun ido-toggle-ignore ()
2735 "Toggle ignoring files specified with `ido-ignore-files'."
2737 (if (and (not (eobp)) (> (point) (minibuffer-prompt-end)))
2738 (goto-char (minibuffer-prompt-end))
2739 (if ido-directory-too-big
2741 (message "Reading directory...")
2742 (setq ido-directory-too-big nil))
2743 (setq ido-process-ignore-lists (not ido-process-ignore-lists)))
2744 (setq ido-text-init ido-text)
2745 (setq ido-exit 'refresh)
2748 (defun ido-toggle-vc ()
2749 "Toggle version control for this file."
2751 (if (and ido-mode (eq ido-cur-item 'file))
2753 (setq vc-handled-backends
2754 (if vc-handled-backends nil ido-saved-vc-hb))
2755 (setq ido-text-init ido-text)
2756 (setq ido-exit 'keep)
2757 (exit-minibuffer))))
2759 (defun ido-toggle-literal ()
2760 "Toggle literal reading of this file."
2762 (if (and ido-mode (eq ido-cur-item 'file))
2764 (setq ido-find-literal (not ido-find-literal))
2765 (setq ido-text-init ido-text)
2766 (setq ido-exit 'keep)
2767 (exit-minibuffer))))
2769 (defun ido-toggle-virtual-buffers ()
2770 "Toggle the use of virtual buffers.
2771 See `ido-use-virtual-buffers' for explanation of virtual buffer."
2773 (when (and ido-mode (eq ido-cur-item 'buffer))
2774 (setq ido-enable-virtual-buffers
2775 (if ido-enable-virtual-buffers
2777 ;; Use `always' instead of t for `ido-exhibit'.
2779 (setq ido-text-init ido-text)
2780 (setq ido-exit 'refresh)
2783 (defun ido-reread-directory ()
2784 "Read current directory again.
2785 May be useful if cached version is no longer valid, but directory
2786 timestamp has not changed (e.g. with FTP or on Windows)."
2788 (if (and ido-mode (memq ido-cur-item '(file dir)))
2790 (if (ido-is-unc-root)
2791 (setq ido-unc-hosts-cache t)
2792 (ido-remove-cached-dir ido-current-directory))
2793 (setq ido-text-init ido-text)
2794 (setq ido-rotate-temp t)
2795 (setq ido-exit 'refresh)
2796 (exit-minibuffer))))
2798 (defun ido-exit-minibuffer ()
2799 "Exit minibuffer, but make sure we have a match if one is needed."
2801 (if (and (or (not ido-require-match)
2802 (if (memq ido-require-match '(confirm confirm-after-completion))
2803 (if (or (eq ido-cur-item 'dir)
2804 (eq last-command this-command))
2806 (setq ido-show-confirm-message t)
2808 (ido-existing-item-p))
2809 (not ido-incomplete-regexp))
2812 (defun ido-select-text ()
2813 "Select the buffer or file named by the prompt.
2814 If no buffer or file exactly matching the prompt exists, maybe create a new one."
2816 (setq ido-exit 'takeprompt)
2819 (defun ido-fallback-command ()
2820 "Fallback to non-Ido version of current command."
2822 (let ((i (length ido-text)))
2824 (push (aref ido-text (setq i (1- i))) unread-command-events)))
2825 (setq ido-exit 'fallback)
2828 (defun ido-enter-find-file ()
2829 "Drop into `find-file' from buffer switching."
2831 (setq ido-exit 'find-file)
2834 (defun ido-enter-switch-buffer ()
2835 "Drop into `ido-switch-buffer' from file switching."
2837 (setq ido-exit 'switch-to-buffer)
2840 (defun ido-enter-dired ()
2841 "Drop into `dired' from file switching."
2843 (setq ido-exit 'dired)
2846 (defun ido-enter-insert-buffer ()
2847 "Drop into `insert-buffer' from insert file."
2849 (setq ido-exit 'insert-buffer)
2852 (defun ido-enter-insert-file ()
2853 "Drop into `insert-file' from insert buffer."
2855 (setq ido-exit 'insert-file)
2859 (defun ido-up-directory (&optional clear)
2860 "Go up one directory level."
2862 (setq ido-text-init (if clear nil ido-text))
2863 (setq ido-exit 'updir)
2864 (setq ido-rotate-temp t)
2867 (defun ido-delete-backward-updir (count)
2868 "Delete char backwards, or at beginning of buffer, go up one level."
2871 ((= (minibuffer-prompt-end) (point))
2873 (ido-up-directory t)))
2874 ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) ido-text))
2875 (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
2876 ((eq this-original-command 'viper-backward-char)
2877 (funcall this-original-command (prefix-numeric-value count)))
2878 ((eq this-original-command 'viper-del-backward-char-in-insert)
2879 (funcall this-original-command))
2881 (delete-char (- (prefix-numeric-value count))))))
2883 (defun ido-delete-backward-word-updir (count)
2884 "Delete all chars backwards, or at beginning of buffer, go up one level."
2886 (if (= (minibuffer-prompt-end) (point))
2888 (ido-up-directory t))
2889 (if (eq this-original-command 'viper-delete-backward-word)
2890 (funcall this-original-command (prefix-numeric-value count))
2891 (backward-kill-word (prefix-numeric-value count)))))
2893 (defun ido-get-work-directory (&optional incr must-match)
2894 (let ((n (length ido-work-directory-list))
2895 (i ido-work-directory-index)
2898 (if (or (not ido-text) (= (length ido-text) 0))
2899 (setq must-match nil))
2904 (if (>= i n) (setq i 0))
2905 (if (< i 0) (setq i (1- n))))
2906 (setq dir (nth i ido-work-directory-list))
2908 (not (equal dir ido-current-directory))
2909 (file-directory-p dir)
2910 (or (not must-match)
2911 ;; TODO. check for nonreadable and too-big.
2913 (if (eq ido-cur-item 'file)
2914 (ido-make-file-list-1 dir)
2915 (ido-make-dir-list-1 dir)))))
2919 (setq ido-work-directory-index i))
2922 (defun ido-prev-work-directory ()
2923 "Change to next working directory in list."
2925 (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
2927 (ido-set-current-directory dir)
2928 (setq ido-exit 'refresh)
2929 (setq ido-text-init ido-text)
2930 (setq ido-rotate-temp t)
2931 (exit-minibuffer))))
2933 (defun ido-next-work-directory ()
2934 "Change to previous working directory in list."
2936 (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
2938 (ido-set-current-directory dir)
2939 (setq ido-exit 'refresh)
2940 (setq ido-text-init ido-text)
2941 (setq ido-rotate-temp t)
2942 (exit-minibuffer))))
2944 (defun ido-merge-work-directories ()
2945 "Search (and merge) work directories for files matching the current input string."
2947 (setq ido-use-merged-list t ido-try-merged-list t)
2948 (setq ido-exit 'refresh)
2949 (setq ido-text-init ido-text)
2950 (setq ido-rotate-temp t)
2953 (defun ido-wide-find-file (&optional file)
2954 "Prompt for FILE to search for using `find', starting from current directory."
2957 (let ((enable-recursive-minibuffers t))
2960 (read-string (concat "Wide find file: " ido-current-directory) ido-text)
2962 (when (> (length file) 0)
2963 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2964 (setq ido-exit 'refresh)
2965 (setq ido-text-init file)
2966 (setq ido-rotate-temp t)
2969 (defun ido-wide-find-dir (&optional dir)
2970 "Prompt for DIR to search for using `find', starting from current directory."
2973 (let ((enable-recursive-minibuffers t))
2976 (read-string (concat "Wide find directory: " ido-current-directory) ido-text)
2978 (when (> (length dir) 0)
2979 (setq ido-use-merged-list t ido-try-merged-list 'wide)
2980 (setq ido-exit 'refresh)
2981 (setq ido-text-init (ido-final-slash dir t))
2982 (setq ido-rotate-temp t)
2985 (defun ido-wide-find-dir-or-delete-dir (&optional _dir)
2986 "Prompt for DIR to search for using `find', starting from current directory.
2987 If input stack is non-empty, delete current directory component."
2990 (ido-delete-backward-word-updir 1)
2991 (ido-wide-find-dir)))
2993 (defun ido-take-first-match ()
2994 "Use first matching item as input text."
2997 (setq ido-text-init (ido-name (car ido-matches)))
2998 (setq ido-exit 'refresh)
3001 (defun ido-push-dir ()
3002 "Move to previous directory in file name, push current input on stack."
3004 (setq ido-exit 'push)
3007 (defun ido-push-dir-first ()
3008 "Move to previous directory in file name, push first match on stack."
3011 (setq ido-text (ido-name (car ido-matches))))
3012 (setq ido-exit 'push)
3015 (defun ido-pop-dir (arg)
3016 "Pop directory from input stack back to input.
3017 With \\[universal-argument], pop all elements."
3019 (when ido-input-stack
3020 (setq ido-exit (if arg 'pop-all 'pop))
3023 (defun ido-wide-find-file-or-pop-dir (arg)
3027 (ido-wide-find-file)))
3029 (defun ido-make-directory (&optional dir)
3030 "Prompt for DIR to create in current directory."
3033 (let ((enable-recursive-minibuffers t))
3035 (read-string (concat "Make directory: " ido-current-directory) ido-text))))
3036 (when (> (length dir) 0)
3037 (setq dir (concat ido-current-directory dir))
3038 (unless (file-exists-p dir)
3039 (make-directory dir t)
3040 (ido-set-current-directory dir)
3041 (setq ido-exit 'refresh)
3042 (setq ido-text-init nil)
3043 (setq ido-rotate-temp t)
3044 (exit-minibuffer))))
3046 (defun ido-get-work-file (incr)
3047 (let ((n (length ido-work-file-list))
3048 (i (+ ido-work-file-index incr))
3051 (if (>= i n) (setq i 0))
3052 (if (< i 0) (setq i (1- n))))
3053 (setq name (nth i ido-work-file-list))
3054 (setq ido-work-file-index i)
3057 (defun ido-prev-work-file ()
3058 "Change to next working file name in list."
3060 (let ((name (ido-get-work-file 1)))
3062 (setq ido-text-init name)
3063 (setq ido-exit 'refresh)
3064 (exit-minibuffer))))
3066 (defun ido-next-work-file ()
3067 "Change to previous working file name in list."
3069 (let ((name (ido-get-work-file -1)))
3071 (setq ido-text-init name)
3072 (setq ido-exit 'refresh)
3073 (exit-minibuffer))))
3075 (defun ido-copy-current-file-name (all)
3076 "Insert file name of current buffer.
3077 If repeated, insert text from buffer instead."
3079 (let* ((bfname (or (buffer-file-name ido-entry-buffer)
3080 (buffer-name ido-entry-buffer)))
3081 (name (and bfname (file-name-nondirectory bfname))))
3085 (eq last-command this-command)
3086 (not (equal (file-name-directory bfname) ido-current-directory))
3087 (not (string-match "\\.[^.]*\\'" name)))
3089 (substring name 0 (1+ (match-beginning 0)))))
3090 (setq ido-exit 'refresh
3091 ido-try-merged-list nil)
3092 (exit-minibuffer))))
3094 (defun ido-copy-current-word (_all)
3095 "Insert current word (file or directory name) from current buffer."
3097 (let ((word (with-current-buffer ido-entry-buffer
3098 (let ((p (point)) start-line end-line start-name)
3099 (if (and mark-active (/= p (mark)))
3100 (setq start-name (mark))
3102 (setq start-line (point))
3104 (setq end-line (point))
3106 (if (re-search-backward "[^-_a-zA-Z0-9:./\\~@]" start-line 1)
3108 (setq start-name (point))
3109 (re-search-forward "[-_a-zA-Z0-9:./\\~@]*" end-line 1)
3110 (if (= start-name (point))
3111 (setq start-name nil)))
3113 (buffer-substring-no-properties start-name (point)))))))
3116 ((string-match "\\`[~/]" word)
3117 (setq ido-text-init word
3118 ido-try-merged-list nil
3120 ((string-match "/" word)
3121 (setq ido-text-init (concat ido-current-directory word)
3122 ido-try-merged-list nil
3125 (setq ido-text-init word
3126 ido-try-merged-list nil
3127 ido-exit 'refresh)))
3128 (exit-minibuffer))))
3130 (defun ido-next-match ()
3131 "Put first element of `ido-matches' at the end of the list."
3134 (let ((next (cadr ido-matches)))
3135 (setq ido-cur-list (ido-chop ido-cur-list next))
3136 (setq ido-matches (ido-chop ido-matches next))
3137 (setq ido-rescan nil))))
3139 (defun ido-prev-match ()
3140 "Put last element of `ido-matches' at the front of the list."
3143 (let ((prev (car (last ido-matches))))
3144 (setq ido-cur-list (ido-chop ido-cur-list prev))
3145 (setq ido-matches (ido-chop ido-matches prev))
3146 (setq ido-rescan nil))))
3148 (defun ido-next-match-dir ()
3149 "Find next directory in match list.
3150 If work directories have been merged, cycle through directories for
3151 first matching file."
3153 (if ido-use-merged-list
3155 (let* ((elt (car ido-matches))
3157 (when (> (length dirs) 1)
3158 (setcdr elt (ido-chop dirs (cadr dirs))))
3159 (setq ido-rescan nil)))
3160 (let ((cnt (length ido-matches))
3162 (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
3165 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3167 (defun ido-prev-match-dir ()
3168 "Find previous directory in match list.
3169 If work directories have been merged, cycle through directories
3170 for first matching file."
3172 (if ido-use-merged-list
3174 (let* ((elt (car ido-matches))
3176 (when (> (length dirs) 1)
3177 (setcdr elt (ido-chop dirs (car (last dirs)))))
3178 (setq ido-rescan nil)))
3179 (let* ((cnt (length ido-matches))
3181 (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
3184 (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
3186 (defun ido-restrict-to-matches (&optional removep)
3187 "Set current item list to the currently matched items.
3189 When argument REMOVEP is non-nil, the currently matched items are
3190 instead removed from the current item list."
3193 (setq ido-cur-list (if removep
3194 ;; An important feature is to preserve the
3195 ;; order of the elements.
3196 (seq-difference ido-cur-list ido-matches)
3198 ido-matches ido-cur-list
3204 (defun ido-chop (items elem)
3205 "Remove all elements before ELEM and put them at the end of ITEMS."
3210 (setq next (car items))
3211 (if (equal next elem)
3212 (setq ret (append items (nreverse sofar)))
3215 (setq items (cdr items))
3216 (setq sofar (cons next sofar)))))
3219 (defun ido-name (item)
3220 ;; Return file name for current item, whether in a normal list
3221 ;; or a merged work directory list.
3222 (if (consp item) (car item) item))
3225 ;;; CREATE LIST OF ALL CURRENT FILES
3227 (defun ido-all-completions ()
3228 ;; Return unsorted list of all completions.
3229 (let ((ido-process-ignore-lists nil)
3230 (ido-directory-too-big nil))
3232 ((eq ido-cur-item 'file)
3233 (ido-make-file-list-1 ido-current-directory))
3234 ((eq ido-cur-item 'dir)
3235 (ido-make-dir-list-1 ido-current-directory))
3236 ((eq ido-cur-item 'buffer)
3237 (ido-make-buffer-list-1))
3238 ((eq ido-cur-item 'list)
3243 ;; File list sorting
3245 (defun ido-file-lessp (a b)
3246 ;; Simple compare two file names.
3247 (string-lessp (ido-no-final-slash a) (ido-no-final-slash b)))
3250 (defun ido-file-extension-lessp (a b)
3251 ;; Compare file names according to ido-file-extensions-order list.
3252 (let ((n (compare-strings a 0 nil b 0 nil nil))
3265 (ido-file-extension-aux a b n lessp))
3267 (while (and (> n 2) (/= (aref a n) ?.))
3270 (ido-file-extension-aux a b n lessp)
3273 (defun ido-file-extension-aux (a b n lessp)
3274 (let ((oa (ido-file-extension-order a n))
3275 (ob (ido-file-extension-order b n)))
3292 (defun ido-file-extension-order (s n)
3293 (let ((l ido-file-extensions-order)
3300 ((eq (compare-strings s n nil (car l) 0 nil nil) t)
3309 (defun ido-sort-merged-list (items promote)
3310 ;; Input is list of ("file" . "dir") cons cells.
3311 ;; Output is sorted list of ("file "dir" ...) lists
3312 (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
3317 (if (and res (string-equal (car (car res)) (car a)))
3319 (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
3320 (if (and promote (string-equal ido-current-directory (cdr a)))
3322 (setq res (cons (list (car a) (cdr a)) res)
3326 (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
3327 ;; As ido-run-find-command, but returns a list of cons pairs ("file" . "dir")
3330 (mapcar (lambda (name)
3331 (unless (ido-ignore-item-p name ido-ignore-files t)
3334 (shell-command-to-string
3336 (shell-quote-argument dir)
3337 (if ido-case-fold " -iname " " -name ")
3338 (shell-quote-argument
3339 (concat (if prefix "" "*") file "*"))
3340 " -type " (if finddir "d" "f") " -print"))))))
3344 (setq filename (car filenames)
3345 filenames (cdr filenames))
3346 (if (and (file-name-absolute-p filename)
3347 (file-exists-p filename))
3348 (setq d (file-name-directory filename)
3349 f (file-name-nondirectory filename)
3350 res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
3353 (defun ido-flatten-merged-list (items)
3354 "Create a list of directory names based on a merged directory list."
3357 (let* ((item (car items))
3361 (setq res (cons (concat (car dirs) file) res)
3363 (setq items (cdr items)))
3367 (defun ido-make-merged-file-list-1 (text auto wide)
3369 (if (and (ido-final-slash text) ido-dir-file-cache)
3371 (setq res (ido-wide-find-dirs-or-files
3372 ido-current-directory (substring text 0 -1) ido-enable-prefix t))
3373 ;; Use list of cached directories
3374 (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
3375 (dirs ido-dir-file-cache)
3379 (setq dir (car (car dirs))
3381 (when (and (string-match re dir)
3382 (not (ido-ignore-item-p dir ido-ignore-directories-merge))
3383 (file-directory-p dir))
3384 (setq b (substring dir 0 -1)
3385 f (concat (file-name-nondirectory b) "/")
3386 d (file-name-directory b)
3387 res (cons (cons f d) res))))
3389 (setq dir (car dirs)
3392 (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
3393 (setq dir (cdr (cdr dir)))
3397 (if (and (string-match re f)
3398 (not (ido-ignore-item-p f ido-ignore-directories)))
3399 (setq res (cons (cons f d) res)))))
3400 (if (and auto (input-pending-p))
3404 (setq res (ido-wide-find-dirs-or-files
3405 ido-current-directory text ido-enable-prefix nil))
3406 (let ((ido-text text)
3407 (dirs ido-work-directory-list)
3408 (must-match (and text (> (length text) 0)))
3410 (if (and auto (not (member ido-current-directory dirs)))
3411 (setq dirs (cons ido-current-directory dirs)))
3413 (setq dir (car dirs)
3415 (when (and dir (stringp dir)
3416 (or ido-merge-ftp-work-directories
3417 (not (ido-is-ftp-directory dir)))
3418 (file-directory-p dir)
3419 ;; TODO. check for nonreadable and too-big.
3420 (setq fl (if (eq ido-cur-item 'file)
3421 (ido-make-file-list-1 dir t)
3422 (ido-make-dir-list-1 dir t))))
3424 (setq fl (ido-set-matches-1 fl)))
3426 (setq res (nconc fl res))))
3427 (if (and auto (input-pending-p))
3432 (defun ido-make-merged-file-list (text auto wide)
3434 (message "Searching for `%s'...." text)
3438 (ido-make-merged-file-list-1 text auto wide))))
3439 (setq res 'input-pending-p))
3442 ido-try-merged-list nil
3443 ido-use-merged-list nil)))
3444 (when (and res (listp res))
3445 (setq res (ido-sort-merged-list res auto)))
3446 (when (and (or ido-rotate-temp ido-rotate-file-list-default)
3448 (> (length text) 0))
3449 (let ((elt (assoc text res)))
3450 (when (and elt (not (eq elt (car res))))
3451 (setq res (delq elt res))
3452 (setq res (cons elt res)))))
3456 (defun ido-make-buffer-list-1 (&optional frame visible)
3457 "Return list of non-ignored buffer names."
3461 (let ((name (buffer-name x)))
3462 (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member name visible)))
3464 (buffer-list frame))))
3466 (defun ido-make-buffer-list (default)
3467 "Return the current list of buffers.
3468 Currently visible buffers are put at the end of the list.
3469 The hook `ido-make-buffer-list-hook' is run after the list has been
3470 created to allow the user to further modify the order of the buffer names
3471 in this list. If DEFAULT is non-nil, and corresponds to an existing buffer,
3472 it is put to the start of the list."
3473 (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
3474 (ido-temp-list (ido-make-buffer-list-1 (selected-frame) ido-current-buffers)))
3476 (nconc ido-temp-list ido-current-buffers)
3477 (setq ido-temp-list ido-current-buffers))
3480 (cons default (delete default ido-temp-list))))
3481 (if (bound-and-true-p ido-enable-virtual-buffers)
3482 (ido-add-virtual-buffers-to-list))
3483 (run-hooks 'ido-make-buffer-list-hook)
3486 (defun ido-add-virtual-buffers-to-list ()
3487 "Add recently visited files, and bookmark files, to the buffer list.
3488 This is to make them appear as if they were \"virtual buffers\"."
3489 ;; If no buffers matched, and virtual buffers are being used, then
3490 ;; consult the list of past visited files, to see if we can find
3491 ;; the file which the user might thought was still open.
3492 (unless recentf-mode (recentf-mode 1))
3493 (setq ido-virtual-buffers nil)
3495 (dolist (head (append
3497 (and (fboundp 'bookmark-get-filename)
3498 (delq nil (mapcar #'bookmark-get-filename
3499 (bound-and-true-p bookmark-alist))))))
3500 (setq name (file-name-nondirectory head))
3501 ;; In case HEAD is a directory with trailing /. See bug#14552.
3502 (when (equal name "")
3503 (setq name (file-name-nondirectory (directory-file-name head))))
3504 (when (equal name "")
3506 (and (not (equal name ""))
3507 (null (get-file-buffer head))
3508 (not (assoc name ido-virtual-buffers))
3509 (not (member name ido-temp-list))
3510 (not (ido-ignore-item-p name ido-ignore-buffers))
3511 ;;(file-exists-p head)
3512 (push (cons name head) ido-virtual-buffers))))
3513 (when ido-virtual-buffers
3515 (dolist (comp ido-virtual-buffers)
3516 (put-text-property 0 (length (car comp))
3520 (nconc ido-temp-list
3521 (nreverse (mapcar #'car ido-virtual-buffers))))))
3523 (defun ido-make-choice-list (default)
3524 "Return the current list of choices.
3525 If DEFAULT is non-nil, and corresponds to an element of choices,
3526 it is put to the start of the list."
3527 (let ((ido-temp-list ido-choice-list))
3531 (delete default ido-temp-list))
3533 (cons default ido-temp-list))))
3534 ; (run-hooks 'ido-make-choice-list-hook)
3537 (defun ido-to-end (items)
3538 "Move the elements from ITEMS to the end of `ido-temp-list'."
3541 (setq ido-temp-list (delq elem ido-temp-list)))
3544 (nconc ido-temp-list items)
3545 (setq ido-temp-list items)))
3547 (defun ido-file-name-all-completions-1 (dir)
3549 ((ido-nonreadable-directory-p dir) '())
3550 ;; do not check (ido-directory-too-big-p dir) here.
3551 ;; Caller must have done that if necessary.
3553 ((and ido-enable-tramp-completion
3554 (string-match "\\`/[^/]+[:@]\\'" dir))
3555 ;; Strip method:user@host: part of tramp completions.
3556 ;; Tramp completions do not include leading slash.
3557 (let* ((len (1- (length dir)))
3560 (or ;; We do not want to be disturbed by "File does not
3562 (ignore-errors (file-name-all-completions "" dir))
3563 ;; work around bug in ange-ftp.
3564 ;; /ftp:user@host: => nil
3565 ;; /ftp:user@host:./ => ok
3567 (not (string= "/ftp:" dir))
3569 ;; tramp-ftp-file-name-p is available only when tramp
3571 (fboundp 'tramp-ftp-file-name-p)
3572 (funcall 'tramp-ftp-file-name-p dir)
3573 (string-match ":\\'" dir)
3574 (file-name-all-completions "" (concat dir "./"))))))
3576 (> (length (car compl)) len)
3577 (string= (substring (car compl) 0 len) (substring dir 1)))
3578 (mapcar (lambda (c) (substring c len)) compl)
3581 (file-name-all-completions "" dir))))
3583 (defun ido-file-name-all-completions (dir)
3584 "Return name of all files in DIR.
3585 Uses and updates `ido-dir-file-cache'."
3587 ((ido-is-unc-root dir)
3590 (if (string-match "/\\'" host) host (concat host "/")))
3592 ((and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
3593 (stringp dir) (> (length dir) 0)
3594 (ido-may-cache-directory dir))
3595 (let* ((cached (assoc dir ido-dir-file-cache))
3596 (ctime (nth 1 cached))
3597 (ftp (ido-is-ftp-directory dir))
3598 (unc (ido-is-unc-host dir))
3599 (attr (if (or ftp unc) nil (file-attributes dir)))
3600 (mtime (nth 5 attr))
3602 (when cached ; should we use the cached entry ?
3605 (setq valid (and (eq (car ctime) 'ftp)
3606 (ido-cache-ftp-valid (cdr ctime)))))
3608 (setq valid (and (eq (car ctime) 'unc)
3609 (ido-cache-unc-valid (cdr ctime)))))
3612 (setq valid (and (= (car ctime) (car mtime))
3613 (= (car (cdr ctime)) (car (cdr mtime))))))))
3615 (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
3620 (setq mtime (cons 'unc (ido-time-stamp))))
3621 ((and ftp (file-readable-p dir))
3622 (setq mtime (cons 'ftp (ido-time-stamp)))))
3624 (setq cached (cons dir (cons mtime (ido-file-name-all-completions-1 dir)))
3625 ido-dir-file-cache (cons cached ido-dir-file-cache)))
3626 (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
3627 (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) nil)))
3629 (cdr (cdr cached)))))
3631 (ido-file-name-all-completions-1 dir))))
3633 (defun ido-remove-cached-dir (dir)
3634 "Remove DIR from `ido-dir-file-cache'."
3635 (if (and ido-dir-file-cache
3636 (stringp dir) (> (length dir) 0))
3637 (let ((cached (assoc dir ido-dir-file-cache)))
3639 (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
3642 (defun ido-make-file-list-1 (dir &optional merged)
3643 "Return list of non-ignored files in DIR
3644 If MERGED is non-nil, each file is cons'ed with DIR."
3645 (and (or (ido-is-tramp-root dir) (ido-is-unc-root dir)
3646 (file-directory-p dir))
3650 (if (not (ido-ignore-item-p name ido-ignore-files t))
3651 (if merged (cons name dir) name)))
3652 (ido-file-name-all-completions dir)))))
3654 (defun ido-make-file-list (default)
3655 "Return the current list of files.
3656 Currently visible files are put at the end of the list.
3657 The hook `ido-make-file-list-hook' is run after the list has been
3658 created to allow the user to further modify the order of the file names
3660 (let ((ido-temp-list (ido-make-file-list-1 ido-current-directory)))
3661 (setq ido-temp-list (sort ido-temp-list
3662 (if ido-file-extensions-order
3663 #'ido-file-extension-lessp
3665 (unless (ido-is-tramp-root ido-current-directory)
3666 (let ((default-directory ido-current-directory))
3667 (ido-to-end ;; move ftp hosts and visited files to end
3669 (lambda (x) (if (or (and (string-match ".:\\'" x)
3670 (not (ido-local-file-exists-p x)))
3671 (and (not (ido-final-slash x))
3672 (let (file-name-handler-alist)
3673 (get-file-buffer x)))) x))
3675 (ido-to-end ;; move . files to end
3677 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3679 (if (and default (member default ido-temp-list))
3680 (if (or ido-rotate-temp ido-rotate-file-list-default)
3681 (unless (equal default (car ido-temp-list))
3682 (let ((l ido-temp-list) k)
3683 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3687 (nconc k ido-temp-list)
3688 (setq ido-temp-list k)))
3690 (delete default ido-temp-list))
3692 (cons default ido-temp-list))))
3693 (when ido-show-dot-for-dired
3694 (setq ido-temp-list (delete "." ido-temp-list))
3695 (setq ido-temp-list (cons "." ido-temp-list)))
3696 (run-hooks 'ido-make-file-list-hook)
3699 (defun ido-make-dir-list-1 (dir &optional merged)
3700 "Return list of non-ignored subdirs in DIR.
3701 If MERGED is non-nil, each subdir is cons'ed with DIR."
3702 (and (or (ido-is-tramp-root dir) (file-directory-p dir))
3706 (and (ido-final-slash name) (not (ido-ignore-item-p name ido-ignore-directories))
3707 (if merged (cons name dir) name)))
3708 (ido-file-name-all-completions dir)))))
3710 (defun ido-make-dir-list (default)
3711 "Return the current list of directories.
3712 The hook `ido-make-dir-list-hook' is run after the list has been
3713 created to allow the user to further modify the order of the
3714 directory names in this list."
3715 (let ((ido-temp-list (ido-make-dir-list-1 ido-current-directory)))
3716 (setq ido-temp-list (sort ido-temp-list #'ido-file-lessp))
3717 (ido-to-end ;; move . files to end
3719 (lambda (x) (if (string-equal (substring x 0 1) ".") x))
3721 (if (and default (member default ido-temp-list))
3722 (if (or ido-rotate-temp ido-rotate-file-list-default)
3723 (unless (equal default (car ido-temp-list))
3724 (let ((l ido-temp-list) k)
3725 (while (and l (cdr l) (not (equal default (car (cdr l)))))
3729 (nconc k ido-temp-list)
3730 (setq ido-temp-list k)))
3732 (delete default ido-temp-list))
3734 (cons default ido-temp-list))))
3735 (setq ido-temp-list (delete "." ido-temp-list))
3736 (unless ido-input-stack
3737 (setq ido-temp-list (cons "." ido-temp-list)))
3738 (run-hooks 'ido-make-dir-list-hook)
3741 ;; List of the files visible in the current frame.
3742 (defvar ido-bufs-in-frame)
3744 (defun ido-get-buffers-in-frames (&optional current)
3745 "Return the list of buffers that are visible in the current frame.
3746 If optional argument CURRENT is given, restrict searching to the current
3747 frame, rather than all frames, regardless of value of `ido-all-frames'."
3748 (let ((ido-bufs-in-frame nil))
3749 (walk-windows 'ido-get-bufname nil
3755 (defun ido-get-bufname (win)
3756 "Used by `ido-get-buffers-in-frames' to walk through all windows."
3757 (let ((buf (buffer-name (window-buffer win))))
3758 (unless (or (member buf ido-bufs-in-frame)
3759 (member buf ido-ignore-item-temp-list))
3760 ;; Only add buf if it is not already in list.
3761 ;; This prevents same buf in two different windows being
3762 ;; put into the list twice.
3763 (setq ido-bufs-in-frame
3764 (cons buf ido-bufs-in-frame)))))
3766 ;;; FIND MATCHING ITEMS
3768 (defun ido-set-matches-1 (items &optional do-full)
3769 "Return list of matches in ITEMS."
3770 (let* ((case-fold-search ido-case-fold)
3771 (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
3772 (text (if slash (substring ido-text 0 -1) ido-text))
3773 (rex0 (if ido-enable-regexp text (regexp-quote text)))
3774 (rexq (concat rex0 (if slash ".*/" "")))
3775 (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
3776 (full-re (and do-full
3777 (not (and (eq ido-cur-item 'buffer)
3778 ido-buffer-disable-smart-matches))
3779 (not ido-enable-regexp)
3780 (not (string-match "$\\'" rex0))
3781 (concat "\\`" rex0 (if slash "/" "") "\\'")))
3782 (suffix-re (and do-full slash
3783 (not (and (eq ido-cur-item 'buffer)
3784 ido-buffer-disable-smart-matches))
3785 (not ido-enable-regexp)
3786 (not (string-match "$\\'" rex0))
3787 (concat rex0 "/\\'")))
3788 (prefix-re (and full-re (not ido-enable-prefix)
3789 (concat "\\`" rexq)))
3790 (non-prefix-dot (or (not ido-enable-dot-prefix)
3791 (not ido-process-ignore-lists)
3793 (= (length ido-text) 0)))
3794 full-matches suffix-matches prefix-matches matches)
3795 (setq ido-incomplete-regexp nil)
3796 (condition-case error
3799 (let ((name (ido-name item)))
3800 (if (and (or non-prefix-dot
3801 (if (= (aref ido-text 0) ?.)
3802 (= (aref name 0) ?.)
3803 (/= (aref name 0) ?.)))
3804 (string-match re name))
3806 ((and (eq ido-cur-item 'buffer)
3807 (or (not (stringp ido-default-item))
3808 (not (string= name ido-default-item)))
3809 (string= name (buffer-name ido-entry-buffer)))
3810 (setq matches (cons item matches)))
3811 ((and full-re (string-match full-re name))
3812 (setq full-matches (cons item full-matches)))
3813 ((and suffix-re (string-match suffix-re name))
3814 (setq suffix-matches (cons item suffix-matches)))
3815 ((and prefix-re (string-match prefix-re name))
3816 (setq prefix-matches (cons item prefix-matches)))
3817 (t (setq matches (cons item matches))))))
3821 (setq ido-incomplete-regexp t
3822 ;; Consider the invalid regexp message internally as a
3823 ;; special-case single match, and handle appropriately
3825 matches (cdr error))))
3826 (when prefix-matches
3827 (ido-trace "prefix match" prefix-matches)
3829 (setq matches (nconc prefix-matches matches)))
3830 (when suffix-matches
3831 (ido-trace "suffix match" (list text suffix-re suffix-matches))
3832 (setq matches (nconc suffix-matches matches)))
3834 (ido-trace "full match" (list text full-re full-matches))
3835 (setq matches (nconc full-matches matches)))
3836 (when (and (null matches)
3837 ido-enable-flex-matching
3838 (> (length ido-text) 1)
3839 (not ido-enable-regexp))
3840 (setq re (concat (regexp-quote (string (aref ido-text 0)))
3841 (mapconcat (lambda (c)
3842 (concat "[^" (string c) "]*"
3843 (regexp-quote (string c))))
3844 (substring ido-text 1) "")))
3845 (if ido-enable-prefix
3846 (setq re (concat "\\`" re)))
3849 (let ((name (ido-name item)))
3850 (if (string-match re name)
3851 (setq matches (cons item matches)))))
3853 (delete-consecutive-dups matches t)))
3856 (defun ido-set-matches ()
3857 "Set `ido-matches' to the list of items matching prompt."
3859 (setq ido-matches (ido-set-matches-1 (reverse ido-cur-list) (not ido-rotate))
3862 (defun ido-ignore-item-p (name re-list &optional ignore-ext)
3863 "Return t if the buffer or file NAME should be ignored."
3864 (or (member name ido-ignore-item-temp-list)
3866 ido-process-ignore-lists re-list
3868 (let ((ext-list (and ignore-ext ido-ignore-extensions
3869 completion-ignored-extensions))
3870 (case-fold-search ido-case-fold)
3872 (flen (length name)) slen)
3874 (setq nextstr (car ext-list))
3877 (and (>= flen (setq slen (length nextstr)))
3878 (string-equal (substring name (- flen slen)) nextstr)))
3879 ((functionp nextstr) (funcall nextstr name))
3884 (setq ext-list (cdr ext-list))))
3886 (setq nextstr (car re-list))
3888 ((stringp nextstr) (string-match nextstr name))
3889 ((functionp nextstr) (funcall nextstr name))
3893 (setq re-list (cdr re-list))))
3894 ;; return the result
3896 (setq ido-ignored-list (cons name ido-ignored-list)))
3899 ;; Private variable used by `ido-word-matching-substring'.
3900 (defvar ido-change-word-sub)
3902 (defun ido-find-common-substring (items subs)
3903 "Return common string following SUBS in each element of ITEMS."
3906 ido-change-word-sub)
3907 (setq ido-change-word-sub
3908 (if ido-enable-regexp
3910 (regexp-quote subs)))
3911 (setq res (mapcar #'ido-word-matching-substring items))
3912 (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
3913 (setq alist (mapcar #'ido-makealist res)) ;; could use an OBARRAY
3915 ;; try-completion returns t if there is an exact match.
3916 (let* ((completion-ignore-case ido-case-fold)
3917 (comp (try-completion subs alist)))
3922 (defun ido-word-matching-substring (word)
3923 "Return part of WORD before first match to `ido-change-word-sub'.
3924 If `ido-change-word-sub' cannot be found in WORD, return nil."
3925 (let ((case-fold-search ido-case-fold))
3926 (let ((m (string-match ido-change-word-sub (ido-name word))))
3928 (substring (ido-name word) m)
3932 (defun ido-makealist (res)
3933 "Return dotted pair (RES . 1)."
3936 (defun ido-choose-completion-string (choice &rest ignored)
3938 ;; Insert the completion into the buffer where completion was requested.
3939 (and ido-completion-buffer
3940 (get-buffer ido-completion-buffer)
3941 (kill-buffer ido-completion-buffer))
3943 ((ido-active t) ;; ido-use-merged-list
3944 (setq ido-current-directory ""
3947 ((not (ido-final-slash choice))
3948 (setq ido-text choice
3951 (ido-set-current-directory ido-current-directory choice)
3952 (setq ido-exit 'refresh)))
3956 (defun ido-completion-help ()
3957 "Show possible completions in a \"*File Completions*\" buffer."
3959 (setq ido-rescan nil)
3960 (let ((temp-buf (and ido-completion-buffer
3961 (get-buffer ido-completion-buffer)))
3962 display-it full-list)
3963 (if (and (eq last-command this-command) temp-buf)
3965 (let (win (buf (current-buffer)))
3966 (display-buffer temp-buf nil nil)
3967 (set-buffer temp-buf)
3968 (setq win (get-buffer-window temp-buf))
3969 (if (pos-visible-in-window-p (point-max) win)
3970 (if (or ido-completion-buffer-all-completions
3971 (boundp 'ido-completion-buffer-full))
3972 (set-window-start win (point-min))
3974 (set (make-local-variable 'ido-completion-buffer-full) t))
3977 (scroll-other-window))
3979 (setq display-it t))
3980 (if (and ido-completion-buffer display-it)
3981 (with-output-to-temp-buffer ido-completion-buffer
3982 (let ((completion-list (sort
3984 (ido-directory-too-big
3985 (message "Reading directory...")
3986 (setq ido-directory-too-big nil
3987 ido-ignored-list nil
3988 ido-cur-list (ido-all-completions)
3991 (or ido-matches ido-cur-list))
3992 (ido-use-merged-list
3993 (ido-flatten-merged-list (or ido-matches ido-cur-list)))
3994 ((or full-list ido-completion-buffer-all-completions)
3995 (ido-all-completions))
3997 (copy-sequence (or ido-matches ido-cur-list))))
3999 (if (featurep 'xemacs)
4000 ;; XEmacs extents are put on by default, doesn't seem to be
4001 ;; any way of switching them off.
4002 (display-completion-list
4006 (lambda (&rest _) (message "Doesn't work yet, sorry!")))
4007 ;; else running Emacs
4008 ;;(add-hook 'completion-setup-hook 'completion-setup-function)
4009 (display-completion-list completion-list)))))))
4011 ;;; KILL CURRENT BUFFER
4012 (defun ido-kill-buffer-at-head ()
4013 "Kill the buffer at the head of `ido-matches'.
4014 If cursor is not at the end of the user input, delete to end of input."
4017 (delete-region (point) (line-end-position))
4018 (let ((enable-recursive-minibuffers t)
4019 (buf (ido-name (car ido-matches)))
4020 (nextbuf (cadr ido-matches)))
4023 ;; If next match names a buffer use the buffer object; buffer
4024 ;; name may be changed by packages such as uniquify.
4025 (when (and nextbuf (get-buffer nextbuf))
4026 (setq nextbuf (get-buffer nextbuf)))
4027 (if (null (kill-buffer buf))
4028 ;; Buffer couldn't be killed.
4030 ;; Else `kill-buffer' succeeds so re-make the buffer list
4031 ;; taking into account packages like uniquify may rename
4033 (if (bufferp nextbuf)
4034 (setq nextbuf (buffer-name nextbuf)))
4035 (setq ido-default-item nextbuf
4036 ido-text-init ido-text
4039 ;; Handle virtual buffers
4040 ((assoc buf ido-virtual-buffers)
4042 (delete (cdr (assoc buf ido-virtual-buffers)) recentf-list))
4043 (setq ido-cur-list (delete buf ido-cur-list))
4044 (setq ido-rescan t))))))
4046 ;;; BURY CURRENT BUFFER
4047 (defun ido-bury-buffer-at-head ()
4048 "Bury the buffer at the head of `ido-matches'."
4050 (let ((enable-recursive-minibuffers t)
4051 (buf (ido-name (car ido-matches)))
4052 (nextbuf (cadr ido-matches)))
4053 (when (get-buffer buf)
4055 (setq ido-default-item nextbuf
4056 ido-text-init ido-text
4058 (exit-minibuffer))))
4060 ;;; DELETE CURRENT FILE
4061 (defun ido-delete-file-at-head ()
4062 "Delete the file at the head of `ido-matches'.
4063 Trash the file if `delete-by-moving-to-trash' is non-nil.
4064 If cursor is not at the end of the user input, delete to end of input."
4067 (delete-region (point) (line-end-position))
4068 (let ((enable-recursive-minibuffers t)
4069 (file (ido-name (car ido-matches))))
4071 (setq file (concat ido-current-directory file)))
4073 (file-exists-p file)
4074 (not (file-directory-p file))
4075 (file-writable-p ido-current-directory)
4076 (or delete-by-moving-to-trash
4077 (yes-or-no-p (concat "Delete " file "? "))))
4078 (delete-file file 'trash)
4079 ;; Check if file still exists.
4080 (if (file-exists-p file)
4081 ;; file could not be deleted
4083 ;; else file was killed so remove name from list.
4084 (setq ido-cur-list (delq (car ido-matches) ido-cur-list)))))))
4087 ;;; VISIT CHOSEN BUFFER
4088 (defun ido-visit-buffer (buffer method &optional record)
4089 "Switch to BUFFER according to METHOD.
4090 Record command in `command-history' if optional RECORD is non-nil."
4091 (if (bufferp buffer)
4092 (setq buffer (buffer-name buffer)))
4097 (ido-record-command 'kill-buffer buffer))
4098 (kill-buffer buffer))
4100 ((eq method 'other-window)
4102 (ido-record-command 'switch-to-buffer buffer))
4103 (switch-to-buffer-other-window buffer))
4105 ((eq method 'display)
4106 (display-buffer buffer))
4108 ((eq method 'other-frame)
4109 (switch-to-buffer-other-frame buffer)
4110 (select-frame-set-input-focus (selected-frame)))
4112 ((and (memq method '(raise-frame maybe-frame))
4114 (setq win (ido-buffer-window-other-frame buffer))
4115 (or (eq method 'raise-frame)
4116 (y-or-n-p "Jump to frame? ")))
4117 (setq newframe (window-frame win))
4118 (select-frame-set-input-focus newframe)
4119 (select-window win))
4121 ;; (eq method 'selected-window)
4123 ;; No buffer in other frames...
4125 (ido-record-command 'switch-to-buffer buffer))
4126 (switch-to-buffer buffer)
4130 (defun ido-buffer-window-other-frame (buffer)
4131 "Return window pointer if BUFFER is visible in another frame.
4132 If BUFFER is visible in the current frame, return nil."
4133 (let ((blist (ido-get-buffers-in-frames 'current)))
4134 ;;If the buffer is visible in current frame, return nil
4135 (if (member buffer blist)
4137 ;; maybe in other frame or icon
4138 (get-buffer-window buffer 0) ; better than 'visible
4142 ;;; ----------- IDONIZED FUNCTIONS ------------
4145 (defun ido-switch-buffer ()
4146 "Switch to another buffer.
4147 The buffer is displayed according to `ido-default-buffer-method' -- the
4148 default is to show it in the same window, unless it is already visible
4151 As you type in a string, all of the buffers matching the string are
4152 displayed if substring-matching is used (default). Look at
4153 `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
4154 buffer you want, it can then be selected. As you type, most keys have
4155 their normal keybindings, except for the following: \\<ido-buffer-completion-map>
4157 RET\tSelect the buffer at the front of the list of matches.
4158 \tIf the list is empty, possibly prompt to create new buffer.
4160 \\[ido-select-text]\tUse the current input string verbatim.
4162 \\[ido-next-match]\tPut the first element at the end of the list.
4163 \\[ido-prev-match]\tPut the last element at the start of the list.
4164 \\[ido-complete]\tComplete a common suffix to the current string that matches
4165 \tall buffers. If there is only one match, select that buffer.
4166 \tIf there is no common suffix, show a list of all matching buffers
4167 \tin a separate window.
4168 \\[ido-edit-input]\tEdit input string.
4169 \\[ido-fallback-command]\tFallback to non-ido version of current command.
4170 \\[ido-toggle-regexp]\tToggle regexp searching.
4171 \\[ido-toggle-prefix]\tToggle between substring and prefix matching.
4172 \\[ido-toggle-case]\tToggle case-sensitive searching of buffer names.
4173 \\[ido-completion-help]\tShow list of matching buffers in separate window.
4174 \\[ido-enter-find-file]\tDrop into `ido-find-file'.
4175 \\[ido-kill-buffer-at-head]\tKill buffer at head of buffer list.
4176 \\[ido-toggle-ignore]\tToggle ignoring buffers listed in `ido-ignore-buffers'."
4178 (ido-buffer-internal ido-default-buffer-method))
4181 (defun ido-switch-buffer-other-window ()
4182 "Switch to another buffer and show it in another window.
4183 The buffer name is selected interactively by typing a substring.
4184 For details of keybindings, see `ido-switch-buffer'."
4186 (ido-buffer-internal 'other-window 'switch-to-buffer-other-window))
4189 (defun ido-display-buffer ()
4190 "Display a buffer in another window but don't select it.
4191 The buffer name is selected interactively by typing a substring.
4192 For details of keybindings, see `ido-switch-buffer'."
4194 (ido-buffer-internal 'display 'display-buffer nil nil nil 'ignore))
4197 (defun ido-kill-buffer ()
4199 The buffer name is selected interactively by typing a substring.
4200 For details of keybindings, see `ido-switch-buffer'."
4202 (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: "
4203 (buffer-name (current-buffer)) nil 'ignore))
4206 (defun ido-insert-buffer ()
4207 "Insert contents of a buffer in current buffer after point.
4208 The buffer name is selected interactively by typing a substring.
4209 For details of keybindings, see `ido-switch-buffer'."
4211 (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "
4212 nil nil 'ido-enter-insert-file))
4215 (defun ido-switch-buffer-other-frame ()
4216 "Switch to another buffer and show it in another frame.
4217 The buffer name is selected interactively by typing a substring.
4218 For details of keybindings, see `ido-switch-buffer'."
4221 (ido-buffer-internal 'other-frame)
4222 (call-interactively 'switch-to-buffer-other-frame)))
4225 (defun ido-find-file-in-dir (dir)
4226 "Switch to another file starting from DIR."
4227 (interactive "DDir: ")
4228 (setq dir (file-name-as-directory dir))
4229 (ido-file-internal ido-default-file-method nil dir nil nil nil 'ignore))
4232 (defun ido-find-file ()
4233 "Edit file with name obtained via minibuffer.
4234 The file is displayed according to `ido-default-file-method' -- the
4235 default is to show it in the same window, unless it is already visible
4238 The file name is selected interactively by typing a substring. As you
4239 type in a string, all of the filenames matching the string are displayed
4240 if substring-matching is used (default). Look at `ido-enable-prefix' and
4241 `ido-toggle-prefix'. When you have found the filename you want, it can
4242 then be selected. As you type, most keys have their normal keybindings,
4243 except for the following: \\<ido-file-completion-map>
4245 RET\tSelect the file at the front of the list of matches.
4246 \tIf the list is empty, possibly prompt to create new file.
4248 \\[ido-select-text]\tUse the current input string verbatim.
4250 \\[ido-next-match]\tPut the first element at the end of the list.
4251 \\[ido-prev-match]\tPut the last element at the start of the list.
4252 \\[ido-complete]\tComplete a common suffix to the current string that matches
4253 \tall files. If there is only one match, select that file.
4254 \tIf there is no common suffix, show a list of all matching files
4255 \tin a separate window.
4256 \\[ido-magic-delete-char]\tOpen the specified directory in Dired mode.
4257 \\[ido-edit-input]\tEdit input string (including directory).
4258 \\[ido-prev-work-directory]\tGo to previous directory in work directory history.
4259 \\[ido-next-work-directory]\tGo to next directory in work directory history.
4260 \\[ido-merge-work-directories]\tSearch for file in the work directory history.
4261 \\[ido-forget-work-directory]\tRemove current directory from the work directory history.
4262 \\[ido-prev-work-file]\tCycle to previous file in work file history.
4263 \\[ido-next-work-file]\tCycle to next file in work file history.
4264 \\[ido-wide-find-file-or-pop-dir]\tPrompt for a file and use find to locate it.
4265 \\[ido-wide-find-dir-or-delete-dir]\tPrompt for a directory and use find to locate it.
4266 \\[ido-make-directory]\tPrompt for a directory to create in current directory.
4267 \\[ido-fallback-command]\tFallback to non-Ido version of current command.
4268 \\[ido-toggle-regexp]\tToggle regexp searching.
4269 \\[ido-toggle-prefix]\tToggle between substring and prefix matching.
4270 \\[ido-toggle-case]\tToggle case-sensitive searching of file names.
4271 \\[ido-toggle-literal]\tToggle literal reading of this file.
4272 \\[ido-completion-help]\tShow list of matching files in separate window.
4273 \\[ido-toggle-ignore]\tToggle ignoring files listed in `ido-ignore-files'."
4276 (ido-file-internal ido-default-file-method))
4279 (defun ido-find-file-other-window ()
4280 "Switch to another file and show it in another window.
4281 The file name is selected interactively by typing a substring.
4282 For details of keybindings, see `ido-find-file'."
4284 (ido-file-internal 'other-window 'find-file-other-window))
4287 (defun ido-find-alternate-file ()
4288 "Switch to another file and show it in another window.
4289 The file name is selected interactively by typing a substring.
4290 For details of keybindings, see `ido-find-file'."
4292 (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: "))
4295 (defun ido-find-file-read-only ()
4296 "Edit file read-only with name obtained via minibuffer.
4297 The file name is selected interactively by typing a substring.
4298 For details of keybindings, see `ido-find-file'."
4300 (ido-file-internal 'read-only 'find-file-read-only nil "Find file read-only: "))
4303 (defun ido-find-file-read-only-other-window ()
4304 "Edit file read-only in other window with name obtained via minibuffer.
4305 The file name is selected interactively by typing a substring.
4306 For details of keybindings, see `ido-find-file'."
4308 (ido-file-internal 'read-only 'find-file-read-only-other-window nil
4309 "Find file read-only other window: "))
4312 (defun ido-find-file-read-only-other-frame ()
4313 "Edit file read-only in other frame with name obtained via minibuffer.
4314 The file name is selected interactively by typing a substring.
4315 For details of keybindings, see `ido-find-file'."
4317 (ido-file-internal 'read-only 'find-file-read-only-other-frame nil
4318 "Find file read-only other frame: "))
4321 (defun ido-display-file ()
4322 "Display a file in another window but don't select it.
4323 The file name is selected interactively by typing a substring.
4324 For details of keybindings, see `ido-find-file'."
4326 (ido-file-internal 'display nil nil nil nil nil 'ignore))
4329 (defun ido-find-file-other-frame ()
4330 "Switch to another file and show it in another frame.
4331 The file name is selected interactively by typing a substring.
4332 For details of keybindings, see `ido-find-file'."
4334 (ido-file-internal 'other-frame 'find-file-other-frame))
4337 (defun ido-write-file ()
4338 "Write current buffer to a file.
4339 The file name is selected interactively by typing a substring.
4340 For details of keybindings, see `ido-find-file'."
4342 (let ((ido-process-ignore-lists t)
4343 (ido-work-directory-match-only nil)
4344 (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
4345 (ido-report-no-match nil)
4346 (ido-confirm-unique-completion t)
4347 (ido-auto-merge-work-directories-length -1))
4348 (ido-file-internal 'write 'write-file nil "Write file: " nil nil 'ignore)))
4351 (defun ido-insert-file ()
4352 "Insert contents of file in current buffer.
4353 The file name is selected interactively by typing a substring.
4354 For details of keybindings, see `ido-find-file'."
4356 (ido-file-internal 'insert 'insert-file nil "Insert file: " nil nil 'ido-enter-insert-buffer))
4360 "Call `dired' the Ido way.
4361 The directory is selected interactively by typing a substring.
4362 For details of keybindings, see `ido-find-file'."
4364 (let ((ido-report-no-match nil)
4365 (ido-auto-merge-work-directories-length -1))
4366 (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
4368 (defun ido-list-directory ()
4369 "Call `list-directory' the Ido way.
4370 The directory is selected interactively by typing a substring.
4371 For details of keybindings, see `ido-find-file'."
4373 (let ((ido-report-no-match nil)
4374 (ido-auto-merge-work-directories-length -1))
4375 (ido-file-internal 'list-directory 'list-directory nil "List directory: " 'dir)))
4377 ;;; XEmacs hack for showing default buffer
4379 ;; The first time we enter the minibuffer, Emacs puts up the default
4380 ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
4381 ;; subtle difference in the two versions of post-command-hook. The
4382 ;; default is shown for both whenever we delete all of our text
4383 ;; though, indicating its just a problem the first time we enter the
4384 ;; function. To solve this, we use another entry hook for emacs to
4385 ;; show the default the first time we enter the minibuffer.
4388 ;;; ICOMPLETE TYPE CODE
4390 (defun ido-initiate-auto-merge (buffer)
4391 (ido-trace "\n*merge timeout*" buffer)
4392 (setq ido-auto-merge-timer nil)
4393 (when (and (buffer-live-p buffer)
4395 (boundp 'ido-eoinput) ido-eoinput)
4396 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) ido-eoinput)))
4397 (ido-trace "request merge")
4398 (setq ido-use-merged-list 'auto
4399 ido-text-init contents
4402 (with-current-buffer buffer
4404 (throw 'ido contents))))
4406 (defun ido-exhibit ()
4407 "Post command hook for Ido."
4408 ;; Find matching files and display a list in the minibuffer.
4409 ;; Copied from `icomplete-exhibit' with two changes:
4410 ;; 1. It prints a default file name when there is no text yet entered.
4411 ;; 2. It calls my completion routine rather than the standard completion.
4414 (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) (point-max)))
4415 (buffer-undo-list t)
4416 try-single-dir-match
4419 (when ido-trace-enable
4420 (ido-trace "\nexhibit" this-command)
4421 (ido-trace "dir" ido-current-directory)
4422 (ido-trace "contents" contents)
4423 (ido-trace "list" ido-cur-list)
4424 (ido-trace "matches" ido-matches)
4425 (ido-trace "rescan" ido-rescan))
4428 (goto-char (point-max))
4429 ;; Register the end of input, so we know where the extra stuff (match-status info) begins:
4430 (unless (boundp 'ido-eoinput)
4431 ;; In case it got wiped out by major mode business:
4432 (make-local-variable 'ido-eoinput))
4433 (setq ido-eoinput (point))
4435 ;; Handle explicit directory changes
4437 ((memq ido-cur-item '(buffer list))
4440 ((= (length contents) 0)
4443 ((= (length contents) 1)
4445 ((and (ido-is-tramp-root) (string-equal contents "/"))
4446 (ido-set-current-directory ido-current-directory contents)
4448 ((and (ido-unc-hosts) (string-equal contents "/")
4449 (let ((ido-enable-tramp-completion nil))
4450 (ido-is-root-directory)))
4451 (ido-set-current-directory "//")
4455 ((and (string-match (if ido-enable-tramp-completion ".[:@]\\'" ".:\\'") contents)
4456 (ido-is-root-directory) ;; Ange-ftp or tramp
4457 (not (ido-local-file-exists-p contents)))
4458 (ido-set-current-directory ido-current-directory contents)
4459 (when (ido-is-slow-ftp-host)
4460 (setq ido-exit 'fallback)
4464 ((ido-final-slash contents) ;; xxx/
4465 (ido-trace "final slash" contents)
4467 ((string-equal contents "~/")
4468 (ido-set-current-home)
4470 ((string-equal contents "../")
4471 (ido-up-directory t)
4473 ((string-equal contents "./")
4475 ((string-match "\\`~[-_a-zA-Z0-9]+[$]?/\\'" contents)
4476 (ido-trace "new home" contents)
4477 (ido-set-current-home contents)
4479 ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
4480 (let ((exp (condition-case ()
4482 (substitute-in-file-name (substring contents 0 -1))
4483 ido-current-directory)
4485 (ido-trace contents exp)
4486 (when (and exp (file-directory-p exp))
4487 (ido-set-current-directory (file-name-directory exp))
4488 (setq ido-text-init (file-name-nondirectory exp))
4490 ((and (memq system-type '(windows-nt ms-dos))
4491 (string-equal (substring contents 1) ":/"))
4492 (ido-set-current-directory (file-name-directory contents))
4494 ((string-equal (substring contents -2 -1) "/")
4495 (ido-set-current-directory
4496 (if (memq system-type '(windows-nt ms-dos))
4497 (expand-file-name "/" ido-current-directory)
4500 ((and (or ido-directory-nonreadable ido-directory-too-big)
4501 (file-directory-p (concat ido-current-directory (file-name-directory contents))))
4502 (ido-set-current-directory
4503 (concat ido-current-directory (file-name-directory contents)))
4506 (ido-trace "try single dir")
4507 (setq try-single-dir-match t))))
4509 ((and (string-equal (substring contents -2 -1) "/")
4510 (not (string-match "[$]" contents)))
4511 (ido-set-current-directory
4513 ((= (length contents) 2)
4516 (concat ido-current-directory (ido-name (car ido-matches))))
4518 (concat ido-current-directory (substring contents 0 -1)))))
4519 (setq ido-text-init (substring contents -1))
4522 ((and (not ido-use-merged-list)
4523 (not (ido-final-slash contents))
4524 (eq ido-try-merged-list t)
4525 (numberp ido-auto-merge-work-directories-length)
4526 (> ido-auto-merge-work-directories-length 0)
4527 (= (length contents) ido-auto-merge-work-directories-length)
4528 (not (and ido-auto-merge-inhibit-characters-regexp
4529 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4530 (not (input-pending-p)))
4531 (setq ido-use-merged-list 'auto
4532 ido-text-init contents
4539 (ido-trace "refresh on /" ido-text-init)
4540 (setq ido-exit 'refresh)
4543 (when (and ido-enter-matching-directory
4545 (or (eq ido-enter-matching-directory 'first)
4546 (null (cdr ido-matches)))
4547 (ido-final-slash (ido-name (car ido-matches)))
4548 (or try-single-dir-match
4549 (eq ido-enter-matching-directory t)))
4550 (ido-trace "single match" (car ido-matches))
4551 (ido-set-current-directory
4552 (concat ido-current-directory (ido-name (car ido-matches))))
4553 (setq ido-exit 'refresh)
4556 ;; Update the list of matches
4557 (setq ido-text contents)
4559 (ido-trace "new " ido-matches)
4561 (when (and (boundp 'ido-enable-virtual-buffers)
4562 (not (eq ido-enable-virtual-buffers 'always))
4563 (eq ido-cur-item 'buffer)
4564 (eq ido-use-virtual-buffers 'auto))
4566 (when (and (not ido-enable-virtual-buffers)
4568 (setq ido-text-init ido-text)
4569 (setq ido-enable-virtual-buffers t)
4570 (setq ido-exit 'refresh)
4573 ;; If input matches real buffers turn off virtual buffers.
4574 (when (and ido-enable-virtual-buffers
4576 (ido-set-matches-1 (ido-make-buffer-list-1)))
4577 (setq ido-enable-virtual-buffers nil)
4578 (setq ido-text-init ido-text)
4579 (setq ido-exit 'refresh)
4582 (when (and (not ido-matches)
4583 (not ido-directory-nonreadable)
4584 (not ido-directory-too-big)
4586 ido-process-ignore-lists
4588 (let ((ido-process-ignore-lists nil)
4589 (ido-rotate ido-rotate)
4590 (ido-cur-list ido-ignored-list))
4591 (ido-trace "try all" ido-ignored-list)
4594 (ido-trace "found " ido-matches)
4596 (setq ido-process-ignore-lists-inhibit t)
4597 (setq ido-text-init ido-text)
4598 (setq ido-exit 'refresh)
4604 (memq ido-cur-item '(file dir))
4605 (not (ido-is-root-directory))
4606 (> (length contents) 1)
4607 (not (string-match "[$]" contents))
4608 (not ido-directory-nonreadable)
4609 (not ido-directory-too-big))
4610 (ido-trace "merge?")
4611 (if ido-use-merged-list
4612 (ido-undo-merge-work-directory contents nil)
4613 (when (and (eq ido-try-merged-list t)
4614 (numberp ido-auto-merge-work-directories-length)
4615 (= ido-auto-merge-work-directories-length 0)
4616 (not (and ido-auto-merge-inhibit-characters-regexp
4617 (string-match ido-auto-merge-inhibit-characters-regexp contents)))
4618 (not (input-pending-p)))
4619 (ido-trace "\n*start timer*")
4620 (setq ido-auto-merge-timer
4621 (run-with-timer ido-auto-merge-delay-time nil 'ido-initiate-auto-merge (current-buffer))))))
4625 (if (and ido-use-merged-list
4627 (not (string-equal (car (cdr (car ido-matches))) ido-current-directory)))
4629 (ido-set-current-directory (car (cdr (car ido-matches))))
4630 (setq ido-use-merged-list t
4632 ido-text-init ido-text)
4635 ;; Insert the match-status information:
4636 (ido-set-common-completion)
4637 (let ((inf (ido-completions contents)))
4638 (setq ido-show-confirm-message nil)
4639 (ido-trace "inf" inf)
4643 (defun ido-completions (name)
4644 "Return the string that is displayed after the user's text.
4645 Modified from `icomplete-completions'."
4646 (let* ((comps ido-matches)
4647 (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
4648 ido-merged-indicator))
4651 (if (and ind ido-use-faces)
4652 (put-text-property 0 1 'face 'ido-indicator ind))
4654 (if (and ido-use-faces comps)
4655 (let* ((fn (ido-name (car comps)))
4657 (setq first (format "%s" fn))
4658 (put-text-property 0 ln 'face
4659 (if (= (length comps) 1)
4660 (if ido-incomplete-regexp
4661 'ido-incomplete-regexp
4665 (if ind (setq first (concat first ind)))
4666 (setq comps (cons first (cdr comps)))))
4670 (ido-show-confirm-message
4671 (or (nth 10 ido-decorations) " [Confirm]"))
4672 (ido-directory-nonreadable
4673 (or (nth 8 ido-decorations) " [Not readable]"))
4674 (ido-directory-too-big
4675 (or (nth 9 ido-decorations) " [Too big]"))
4676 (ido-report-no-match
4677 (nth 6 ido-decorations)) ;; [No match]
4679 (ido-incomplete-regexp
4680 (concat " " (car comps)))
4681 ((null (cdr comps)) ;one match
4682 (concat (if (if (not ido-enable-regexp)
4683 (= (length (ido-name (car comps))) (length name))
4684 ;; We can't rely on the length of the input
4685 ;; for regexps, so explicitly check for a
4687 (string-match name (ido-name (car comps)))
4688 (string-equal (match-string 0 (ido-name (car comps)))
4689 (ido-name (car comps))))
4691 ;; When there is only one match, show the matching file
4692 ;; name in full, wrapped in [ ... ].
4694 (or (nth 11 ido-decorations) (nth 4 ido-decorations))
4695 (ido-name (car comps))
4696 (or (nth 12 ido-decorations) (nth 5 ido-decorations))))
4697 (if (not ido-use-faces) (nth 7 ido-decorations)))) ;; [Matched]
4698 (t ;multiple matches
4699 (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 999))
4707 (setq com (ido-name com))
4708 (setq items (1- items))
4711 ((= items 0) (list (nth 3 ido-decorations))) ; " | ..."
4713 (list (or ido-separator (nth 2 ido-decorations)) ; " | "
4714 (let ((str (substring com 0)))
4715 (if (and ido-use-faces
4716 (not (string= str first))
4717 (ido-final-slash str))
4718 (put-text-property 0 (length str) 'face 'ido-subdir str))
4723 ;; put in common completion item -- what you get by pressing tab
4724 (if (and (stringp ido-common-match-string)
4725 (> (length ido-common-match-string) (length name)))
4726 (concat (nth 4 ido-decorations) ;; [ ... ]
4727 (substring ido-common-match-string (length name))
4728 (nth 5 ido-decorations)))
4729 ;; list all alternatives
4730 (nth 0 ido-decorations) ;; { ... }
4732 (nth 1 ido-decorations)))))))
4734 (defun ido-minibuffer-setup ()
4735 "Minibuffer setup hook for Ido."
4736 ;; Copied from `icomplete-minibuffer-setup-hook'.
4738 (add-hook 'pre-command-hook 'ido-tidy nil t)
4739 (add-hook 'post-command-hook 'ido-exhibit nil t)
4740 (when (featurep 'xemacs)
4742 (goto-char (point-min)))
4743 (run-hooks 'ido-minibuffer-setup-hook)
4744 (when ido-initial-position
4745 (goto-char (+ (minibuffer-prompt-end) ido-initial-position))
4746 (setq ido-initial-position nil))))
4749 "Pre command hook for Ido."
4750 ;; Remove completions display, if any, prior to new user input.
4751 ;; Copied from `icomplete-tidy'."
4753 (when ido-auto-merge-timer
4754 (ido-trace "\n*cancel timer*" this-command)
4755 (cancel-timer ido-auto-merge-timer)
4756 (setq ido-auto-merge-timer nil))
4759 (if (bound-and-true-p ido-eoinput)
4760 (if (> ido-eoinput (point-max))
4761 ;; Oops, got rug pulled out from under us - reinit:
4762 (setq ido-eoinput (point-max))
4763 (let ((inhibit-read-only t)
4764 (buffer-undo-list t))
4765 (delete-region ido-eoinput (point-max))))
4767 ;; Reestablish the local variable 'cause minibuffer-setup is weird:
4768 (make-local-variable 'ido-eoinput)
4769 (setq ido-eoinput 1))))
4771 (defun ido-summary-buffers-to-end ()
4772 ;; Move the summaries to the end of the buffer list.
4773 ;; This is an example function which can be hooked on to
4774 ;; `ido-make-buffer-list-hook'. Any buffer matching the regexps
4775 ;; `Summary' or `output\*$'are put to the end of the list.
4776 (let ((summaries (delq nil (mapcar
4779 (string-match "Summary" x)
4780 (string-match "output\\*\\'" x))
4783 (ido-to-end summaries)))
4785 ;;; Helper functions for other programs
4787 (put 'ibuffer-find-file 'ido 'find-file)
4788 (put 'dired 'ido 'dir)
4789 (put 'dired-other-window 'ido 'dir)
4790 (put 'dired-other-frame 'ido 'dir)
4791 ;; See http://debbugs.gnu.org/11954 for reasons.
4792 (put 'dired-do-copy 'ido 'ignore)
4793 (put 'dired-do-rename 'ido 'ignore)
4796 (defun ido-read-buffer (prompt &optional default require-match predicate)
4797 "Ido replacement for the built-in `read-buffer'.
4798 Return the name of a buffer selected.
4799 PROMPT is the prompt to give to the user. DEFAULT if given is the default
4800 buffer to be selected, which will go to the front of the list.
4801 If REQUIRE-MATCH is non-nil, an existing buffer must be selected."
4802 (let* ((ido-current-directory nil)
4803 (ido-directory-nonreadable nil)
4804 (ido-directory-too-big nil)
4805 (ido-context-switch-command 'ignore)
4806 (buf (ido-read-internal 'buffer prompt 'ido-buffer-history default require-match)))
4807 (if (eq ido-exit 'fallback)
4808 (let ((read-buffer-function nil))
4809 (run-hook-with-args 'ido-before-fallback-functions 'read-buffer)
4810 (read-buffer prompt default require-match predicate))
4814 (defun ido-read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
4815 "Ido replacement for the built-in `read-file-name'.
4816 Read file name, prompting with PROMPT and completing in directory DIR.
4817 See `read-file-name' for additional parameters."
4820 ((or (eq predicate 'file-directory-p)
4821 (eq (and (symbolp this-command)
4822 (get this-command 'ido)) 'dir)
4823 (memq this-command ido-read-file-name-as-directory-commands))
4825 (ido-read-directory-name prompt dir default-filename mustmatch initial)))
4826 ((and (not (eq (and (symbolp this-command)
4827 (get this-command 'ido)) 'ignore))
4828 (not (memq this-command ido-read-file-name-non-ido))
4829 (or (null predicate) (eq predicate 'file-exists-p)))
4830 (let* (ido-saved-vc-hb
4831 (ido-context-switch-command
4832 (if (eq (and (symbolp this-command)
4833 (get this-command 'ido)) 'find-file)
4835 (vc-handled-backends (and (boundp 'vc-handled-backends) vc-handled-backends))
4836 (minibuffer-completing-file-name t)
4837 (ido-current-directory (ido-expand-directory dir))
4838 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4839 (ido-directory-too-big (and (not ido-directory-nonreadable)
4840 (ido-directory-too-big-p ido-current-directory)))
4841 (ido-work-directory-index -1)
4842 (ido-show-dot-for-dired (and ido-show-dot-for-dired
4843 (not default-filename)))
4844 (ido-work-file-index -1)
4845 (ido-find-literal nil))
4848 (ido-read-internal 'file prompt 'ido-file-history
4850 ((stringp default-filename) default-filename)
4851 ((consp default-filename) (car default-filename))
4852 ((and (not default-filename) initial)
4853 (expand-file-name initial dir))
4854 (buffer-file-name buffer-file-name))
4856 (setq dir ido-current-directory) ; See bug#1516.
4858 ((eq ido-exit 'fallback)
4859 (setq filename 'fallback))
4860 ((eq ido-exit 'dired)
4861 (setq filename ido-current-directory))
4864 (concat ido-current-directory filename))))))
4866 (setq filename 'fallback)))
4867 (if (eq filename 'fallback)
4868 (let ((read-file-name-function nil))
4869 (run-hook-with-args 'ido-before-fallback-functions 'read-file-name)
4870 (read-file-name prompt dir default-filename mustmatch initial predicate))
4874 (defun ido-read-directory-name (prompt &optional dir default-dirname mustmatch initial)
4875 "Ido replacement for the built-in `read-directory-name'.
4876 Read directory name, prompting with PROMPT and completing in directory DIR.
4877 See `read-directory-name' for additional parameters."
4879 (minibuffer-completing-file-name t)
4880 (ido-context-switch-command 'ignore)
4882 (ido-current-directory (ido-expand-directory dir))
4883 (ido-directory-nonreadable (not (file-readable-p ido-current-directory)))
4884 (ido-directory-too-big (and (not ido-directory-nonreadable)
4885 (ido-directory-too-big-p ido-current-directory)))
4886 (ido-work-directory-index -1)
4887 (ido-work-file-index -1))
4888 (setq filename (ido-read-internal
4889 'dir prompt 'ido-file-history
4890 (or default-dirname ; Bug#11861.
4892 (expand-file-name initial ido-current-directory)
4893 ido-current-directory))
4896 ((eq ido-exit 'fallback)
4897 (let ((read-file-name-function nil))
4898 (run-hook-with-args 'ido-before-fallback-functions 'read-directory-name)
4899 (read-directory-name prompt ido-current-directory
4900 default-dirname mustmatch initial)))
4901 ((equal filename ".") ido-current-directory)
4902 (t (concat ido-current-directory filename)))))
4905 (defun ido-completing-read (prompt choices &optional _predicate require-match
4906 initial-input hist def _inherit-input-method)
4907 "Ido replacement for the built-in `completing-read'.
4908 Read a string in the minibuffer with Ido-style completion.
4909 PROMPT is a string to prompt with; normally it ends in a colon and a space.
4910 CHOICES is a list of strings which are the possible completions.
4911 PREDICATE and INHERIT-INPUT-METHOD are currently ignored; they are included
4912 to be compatible with `completing-read'.
4913 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
4914 the input is (or completes to) an element of CHOICES or is null.
4915 If the input is null, `ido-completing-read' returns DEF, or an empty
4916 string if DEF is nil, regardless of the value of REQUIRE-MATCH.
4917 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
4918 with point positioned at the end.
4919 HIST, if non-nil, specifies a history list.
4920 DEF, if non-nil, is the default value."
4921 (let ((ido-current-directory nil)
4922 (ido-directory-nonreadable nil)
4923 (ido-directory-too-big nil)
4924 (ido-context-switch-command 'ignore)
4925 (ido-choice-list choices))
4926 ;; Initialize ido before invoking ido-read-internal
4927 (ido-common-initialization)
4928 (ido-read-internal 'list prompt hist def require-match initial-input)))
4930 (defun ido-unload-function ()
4931 "Unload the Ido library."
4933 (setq minor-mode-map-alist (assq-delete-all 'ido-mode minor-mode-map-alist))
4934 ;; continue standard unloading
4939 ;;; ido.el ends here