emacs-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Emacs-diffs] Changes to emacs/lisp/ido.el [gnus-5_10-branch]


From: Miles Bader
Subject: [Emacs-diffs] Changes to emacs/lisp/ido.el [gnus-5_10-branch]
Date: Sat, 04 Sep 2004 08:38:20 -0400

Index: emacs/lisp/ido.el
diff -c /dev/null emacs/lisp/ido.el:1.39.2.1
*** /dev/null   Sat Sep  4 12:01:36 2004
--- emacs/lisp/ido.el   Sat Sep  4 12:01:07 2004
***************
*** 0 ****
--- 1,3860 ----
+ ;;; ido.el --- interactively do things with buffers and files.
+ 
+ ;; Copyright (C) 1996-2004  Free Software Foundation, Inc.
+ 
+ ;; Author: Kim F. Storm <address@hidden>
+ ;; Based on: iswitchb by Stephen Eglen <address@hidden>
+ ;; Keywords: extensions convenience
+ 
+ ;; This file is part of GNU Emacs.
+ 
+ ;; GNU Emacs is free software; you can redistribute it and/or modify
+ ;; it under the terms of the GNU General Public License as published by
+ ;; the Free Software Foundation; either version 2, or (at your option)
+ ;; any later version.
+ 
+ ;; GNU Emacs is distributed in the hope that it will be useful,
+ ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ ;; GNU General Public License for more details.
+ 
+ ;; You should have received a copy of the GNU General Public License
+ ;; along with GNU Emacs; see the file COPYING.  If not, write to the
+ ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ ;; Boston, MA 02111-1307, USA.
+ 
+ ;;; Acknowledgements
+ 
+ ;; Infinite amounts of gratitude goes to Stephen Eglen <address@hidden>
+ ;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
+ ;; for ido-switch-buffer and found the inspiration for ido-find-file.
+ ;; The ido package would never have existed without his work.
+ 
+ ;; Also thanks to Klaus Berndl, Rohit Namjoshi, Robert Fenk, Alex
+ ;; Schroeder, Bill Benedetto, Stephen Eglen, and many others for bug
+ ;; fixes and improvements.
+ 
+ ;;; History
+ 
+ ;; Since I discovered Stephen Eglen's excellent iswitchb package, I just
+ ;; couldn't live without it, but once being addicted to switching buffers
+ ;; with a minimum of keystrokes, I soon found that opening files in the
+ ;; old-fashioned way was just too slow - so I decided to write a package
+ ;; which could open files with the same speed and ease as iswitchb could
+ ;; switch buffers.
+ 
+ ;; I originally wrote a separate ifindf.el package based on a copy of
+ ;; iswitchb.el, which did for opening files what iswitchb did for
+ ;; switching buffers.  Along the way, I corrected a few errors in
+ ;; ifindf which could have found its way back into iswitchb, but since
+ ;; most of the functionality of the two package was practically
+ ;; identical, I decided that the proper thing to do was to merge my
+ ;; ifindf package back into iswitchb.
+ ;;
+ ;; This is basically what ido (interactively do) is all about; but I
+ ;; found it ackward to merge my changes into the "iswitchb-" namespace,
+ ;; so I invented a common "ido-" namespace for the merged packages.
+ ;;
+ ;; This version is based on ido.el version 1.57 released on
+ ;; gnu.emacs.sources adapted for emacs 21.5 to use command remapping
+ ;; and optionally hooking the read-buffer and read-file-name functions.
+ ;;
+ ;; Prefix matching was added by Klaus Berndl <address@hidden> based on
+ ;; an idea of Yuji Minejima <address@hidden> and his mcomplete-package.
+ 
+ 
+ ;;; Commentary:
+ 
+ ;; Ido - interactive do - switches between buffers and opens files and
+ ;; directories with a minimum of keystrokes.  It is a superset of
+ ;; iswitchb, the interactive buffer switching package by Stephen Eglen.
+ 
+ ;; Interactive substring matching
+ ;; ------------------------------
+ ;;
+ ;; As you type in a substring, the list of buffers or files currently
+ ;; matching the substring are displayed as you type.  The list is
+ ;; ordered so that the most recent buffers or files visited come at
+ ;; the start of the list.
+ ;;
+ ;; The buffer or file at the start of the list will be the one visited
+ ;; when you press RETURN.  By typing more of the substring, the list is
+ ;; narrowed down so that gradually the buffer or file you want will be
+ ;; at the top of the list.  Alternatively, you can use C-s and C-r (or
+ ;; the right and left arrow keys) to rotate buffer or file names in the
+ ;; list until the one you want is at the top of the list.
+ ;;
+ ;; Completion is also available so that you can see what is common to
+ ;; all of the matching buffers or files as you type.
+ ;;
+ ;; Example:
+ ;;
+ ;; If I have two buffers called "123456" and "123", with "123456" the
+ ;; most recent, when I use ido-switch-buffer, I first of all get
+ ;; presented with the list of all the buffers
+ ;;
+ ;;       Buffer:  {123456,123}
+ ;;
+ ;; If I then press 2:
+ ;;       Buffer: 2[3]{123456,123}
+ ;;
+ ;; The list in {...} are the matching buffers, most recent first
+ ;; (buffers visible in the current frame are put at the end of the
+ ;; list by default).  At any time I can select the item at the head of
+ ;; the list by pressing RET.  I can also bring the put the first
+ ;; element at the end of the list by pressing C-s or [right], or put
+ ;; the last element at the head of the list by pressing C-r or [left].
+ ;;
+ ;; The item in [...] indicates what can be added to my input by
+ ;; pressing TAB.  In this case, I will get "3" added to my input.
+ 
+ ;; So, I press TAB:
+ ;;     Buffer: 23{123456,123}
+ ;;
+ ;; At this point, I still have two matching buffers.
+ ;; If I want the first buffer in the list, I simply press RET.  If I
+ ;; wanted the second in the list, I could press C-s to move it to the
+ ;; top of the list and then RET to select it.
+ ;;
+ ;; However, if I type 4, I only have one match left:
+ ;;       Buffer: 234[123456] [Matched]
+ ;;
+ ;; Since there is only one matching buffer left, it is given in [] and we
+ ;; see the text [Matched] afterwards.  I can now press TAB or RET to go
+ ;; to that buffer.
+ ;;
+ ;; If however, I now type "a":
+ ;;       Buffer: 234a [No match]
+ ;; There are no matching buffers.  If I press RET or TAB, I can be
+ ;; prompted to create a new buffer called "234a".
+ ;;
+ ;; Of course, where this function comes in really useful is when you
+ ;; can specify the buffer using only a few keystrokes.  In the above
+ ;; example, the quickest way to get to the "123456" file would be
+ ;; just to type 4 and then RET (assuming there isn't any newer buffer
+ ;; with 4 in its name).
+ 
+ ;; Likewise, if you use C-x C-f (ido-find-file), the list of files and
+ ;; directories in the current directory is provided in the same
+ ;; fashion as the buffers above.  The files and directories are
+ ;; normally sorted in alphabetical order, but the most recently
+ ;; visited directory is placed first to speed up navigating to
+ ;; directories that you have visited recently.
+ ;;
+ ;; In addition to scrolling through the list using [right] and [left],
+ ;; you can use [up] and [down] to quickly scroll the list to the next
+ ;; or previous subdirectory.
+ ;;
+ ;; To go down into a subdirectory, and continue the file selection on
+ ;; the files in that directory, simply move the directory to the head
+ ;; of the list and hit RET.
+ ;;
+ ;; To go up to the parent directory, delete any partial file name
+ ;; already specified (e.g. using [backspace]) and hit [backspace].
+ ;;
+ ;; To go to the root directory (on the current drive), enter two
+ ;; slashes.  On MS-DOS or Windows, to select the root of another
+ ;; drive, enter X:/ where X is the drive letter.  You can also visit
+ ;; files on other hosts using the ange-ftp notations `/host:' and
+ ;; `/address@hidden:'.  See the variable `ido-slow-ftp-hosts' if you want
+ ;; to inhibit the ido substring matching for ftp access.
+ ;;
+ ;; If for some reason you cannot specify the proper file using
+ ;; ido-find-file, you can press C-f to enter the normal find-file.
+ ;; You can also press C-b to drop into ido-switch-buffer.
+ 
+ ;; See the doc string of ido-switch-buffer and ido-find-file for full
+ ;; keybindings and features.
+ ;;  (describe-function 'ido-find-file)
+ 
+ ;; Hidden buffers and files
+ ;; ------------------------
+ ;;
+ ;; Normally, ido does not include hidden buffers (whose name starts
+ ;; with a space) and hidden files and directories (whose name starts
+ ;; with `.') in the list of possible completions.  However, if the
+ ;; substring you enter does not match any of the visible buffers or
+ ;; files, ido will automatically look for completions among the hidden
+ ;; buffers or files.
+ ;;
+ ;; You can toggle display of the hidden buffers and files with C-a.
+ 
+ ;; Additional functionality
+ ;; ------------------------
+ ;;
+ ;; After C-x b, the buffer at the head of the list can be killed by
+ ;; pressing C-k.  If the buffer needs saving, you will be queried
+ ;; before the buffer is killed.
+ ;;
+ ;; Likewise, after C-x C-f, you can delete (i.e. physically remove)
+ ;; the file at the head of the list with C-k.  You will always be
+ ;; asked for confirmation before the file is deleted.
+ ;;
+ ;; If you enter C-x b to switch to a buffer visiting a given file, and
+ ;; you find that the file you are after is not in any buffer, you can
+ ;; press C-f to immediately drop into ido-find-file.  And you can
+ ;; switch back to buffer selection with C-b.
+ 
+ ;; Prefix matching
+ ;; ---------------
+ ;;
+ ;; The standard way of completion with Unix-shells and Emacs is to insert a
+ ;; PREFIX and then hitting TAB (or another completion key). Cause of this
+ ;; behavior has become second nature to a lot of emacs users `ido' offers in
+ ;; addition to the default substring-matching-method (look above) also the
+ ;; prefix-matching-method. The kind of matching is the only difference to
+ ;; the description of the substring-matching above.
+ ;;
+ ;; You can toggle prefix matching with C-p.
+ ;;
+ ;; Example:
+ ;;
+ ;; If you have again two Buffers "123456" and "123" then hitting "2" does
+ ;; not match because "2" is not a PREFIX in any of the buffer-names. This
+ ;; is the only difference between the substring and prefix matching.
+ 
+ ;; Flexible matching
+ ;; -----------------
+ ;;
+ ;; If you set ido-enable-flex-matching, ido will do a more flexible
+ ;; matching (unless regexp matching is active) to find possible matches
+ ;; among the available buffer or file names if no matches are found using
+ ;; the normal prefix or substring matching.
+ ;;
+ ;; The flexible matching implies that any item which simply contains all
+ ;; of the entered characters in the specified sequence will match.
+ ;;
+ ;; Example:
+ ;;
+ ;; If you have four files "alpha", "beta", "gamma", and "delta",
+ ;; entering "aa" will match "alpha" and "gamma", while "ea" matches
+ ;; "beta" and "delta".  If prefix matching is also active, "aa" only
+ ;; matches "alpha", while "ea" does not match any files.
+ 
+ ;; Regexp matching
+ ;; ---------------
+ ;;
+ ;; There is limited provision for regexp matching within ido,
+ ;; enabled through `ido-enable-regexp' (toggle with C-t).
+ ;; This allows you to type `c$' for example and see all file names
+ ;; ending in `c'.  This facility is quite limited though in two
+ ;; respects.  First, you can't currently type in expressions like
+ ;; `[0-9]' directly -- you have to type them in when ido-enable-regexp
+ ;; is nil and then toggle on the regexp functionality.  Likewise,
+ ;; don't enter an expression containing `\' in regexp mode.  If you
+ ;; try, ido gets confused, so just hit C-g and try again.  Secondly,
+ ;; no completion mechanism is currently offered with regexp searching.
+ 
+ 
+ ;; Customization
+ ;; -------------
+ ;;
+ ;; Customize the `ido' group to change the `ido' functionality.
+ ;;
+ ;; To modify the keybindings, use the hook provided.  For example:
+ ;;(add-hook 'ido-define-mode-map-hook 'ido-my-keys)
+ ;;
+ ;;(defun ido-my-keys ()
+ ;;  "Add my keybindings for ido."
+ ;;  (define-key ido-mode-map " " 'ido-next-match)
+ ;;  )
+ 
+ ;; Seeing all the matching buffers or files
+ ;; ----------------------------------------
+ ;;
+ ;; If you have many matching files, they may not all fit onto one
+ ;; line of the minibuffer.  Normally, the minibuffer window will grow
+ ;; to show you more of the matching files (depending on the setting
+ ;; of the variables `resize-mini-windows' and `max-mini-window-height').
+ ;; If you want ido to behave differently from the default minibuffer
+ ;; resizing behaviour, set the variable `ido-max-window-height'.
+ ;;
+ ;; Also, to improve the responsiveness of ido, the maximum number of
+ ;; matching items is limited to 12, but you can increase or removed
+ ;; this limit via the `ido-max-prospects' variable.
+ 
+ ;; To see a full list of all matching buffers in a separate buffer,
+ ;; hit ? or press TAB when there are no further completions to the
+ ;; substring.  Repeated TAB presses will scroll you through this
+ ;; separate buffer.
+ 
+ ;; Changing the list of files
+ ;; --------------------------
+ 
+ ;; By default, the list of current files is most recent first,
+ ;; oldest last, with the exception that the files visible in the
+ ;; current frame are put at the end of the list.  A hook exists to
+ ;; allow other functions to order the list.  For example, if you add:
+ ;;
+ ;; (add-hook 'ido-make-buffer-list-hook 'ido-summary-buffers-to-end)
+ ;;
+ ;; then all files matching "Summary" are moved to the end of the
+ ;; list.  (I find this handy for keeping the INBOX Summary and so on
+ ;; out of the way.)  It also moves files matching "output\*$" to the
+ ;; end of the list (these are created by AUCTeX when compiling.)
+ ;; Other functions could be made available which alter the list of
+ ;; matching files (either deleting or rearranging elements.)
+ 
+ ;; Highlighting
+ ;; ------------
+ 
+ ;; The highlighting of matching items is controlled via ido-use-faces.
+ ;; The faces used are ido-first-match-face, ido-only-match-face and
+ ;; ido-subdir-face.
+ ;; Colouring of the matching item was suggested by
+ ;; Carsten Dominik (address@hidden).
+ 
+ ;; Replacement for read-buffer and read-file-name
+ ;; ----------------------------------------------
+ 
+ ;; ido-read-buffer and ido-read-file-name have been written to be drop
+ ;; in replacements for the normal buffer and file name reading
+ ;; functions `read-buffer' and `read-file-name'.
+ 
+ ;; To use ido for all buffer and file selections in Emacs, customize the
+ ;; variable `ido-everywhere'.
+ 
+ ;; Using ido-like behaviour in other lisp packages
+ ;; -----------------------------------------------
+ 
+ ;; If you don't want to rely on the `ido-everywhere' functionality,
+ ;; ido-read-buffer, ido-read-file-name, and ido-read-directory-name
+ ;; can be used by other packages to read a buffer name, a file name,
+ ;; or a directory name in the `ido' way.
+ 
+ 
+ ;;; Code:
+ 
+ (provide 'ido)
+ 
+ ;;; User Variables
+ ;;
+ ;; These are some things you might want to change.
+ 
+ (defun ido-fractionp (n)
+   (and (numberp n) (> n 0.0) (<= n 1.0)))
+ 
+ (defgroup ido nil
+   "Switch between files using substrings."
+   :group 'extensions
+   :group 'convenience
+   :link '(emacs-commentary-link :tag "Commentary" "ido.el")
+   :link '(emacs-library-link :tag "Lisp File" "ido.el"))
+ 
+ ;;;###autoload
+ (defcustom ido-mode nil
+   "Determines for which functional group \(buffer and files) ido behavior
+ should be enabled. The following values are possible:
+ - `buffer': Turn only on ido buffer behavior \(switching, killing,
+   displaying...)
+ - `file': Turn only on ido file behavior \(finding, writing, inserting...)
+ - `both': Turn on ido buffer and file behavior.
+ - `nil': Turn off any ido switching.
+ 
+ Setting this variable directly does not take effect;
+ use either \\[customize] or the function `ido-mode'."
+   :set #'(lambda (symbol value)
+          (ido-mode value))
+   :initialize 'custom-initialize-default
+   :require 'ido
+   :link '(emacs-commentary-link "ido.el")
+   :set-after '(ido-save-directory-list-file)
+   :version "21.4"
+   :type '(choice (const :tag "Turn on only buffer" buffer)
+                  (const :tag "Turn on only file" file)
+                  (const :tag "Turn on both buffer and file" both)
+                  (const :tag "Switch off all" nil))
+   :group 'ido)
+ 
+ (defcustom ido-everywhere nil
+   "Use ido everywhere for reading file names and directories.
+ Setting this variable directly does not work.  Use `customize' or
+ call the function `ido-everywhere'."
+   :set #'(lambda (symbol value)
+          (ido-everywhere value))
+   :initialize 'custom-initialize-default
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-case-fold case-fold-search
+   "*Non-nil if searching of buffer and file names should ignore case."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-ignore-buffers
+   '("\\` ")
+   "*List of regexps or functions matching buffer names to ignore.
+ For example, traditional behavior is not to list buffers whose names begin
+ with a space, for which the regexp is `\\` '.  See the source file for
+ example functions that filter buffernames."
+   :type '(repeat (choice regexp function))
+   :group 'ido)
+ 
+ (defcustom ido-ignore-files
+   '("\\`CVS/" "\\`#" "\\`.#" "\\`\\.\\./" "\\`\\./")
+   "*List of regexps or functions matching file names to ignore.
+ For example, traditional behavior is not to list files whose names begin
+ with a #, for which the regexp is `\\`#'.  See the source file for
+ example functions that filter filenames."
+   :type '(repeat (choice regexp function))
+   :group 'ido)
+ 
+ (defcustom ido-ignore-extensions t
+   "*Non-nil means ignore files in completion-ignored-extensions list."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-show-dot-for-dired nil
+   "*Non-nil means to always put . as the first item in file name lists.
+ This allows the current directory to be opened immediate with `dired'."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-ignore-directories
+   '("\\`CVS/" "\\`\\.\\./" "\\`\\./")
+   "*List of regexps or functions matching sub-directory names to ignore."
+   :type '(repeat (choice regexp function))
+   :group 'ido)
+ 
+ (defcustom ido-ignore-directories-merge nil
+   "*List of regexps or functions matching directory names to ignore during 
merge.
+ Directory names matched by one of the regexps in this list are not inserted
+ in merged file and directory lists."
+   :type '(repeat (choice regexp function))
+   :group 'ido)
+ 
+ ;;; Examples for setting the value of ido-ignore-buffers
+ ;(defun ido-ignore-c-mode (name)
+ ;  "Ignore all c mode buffers -- example function for ido."
+ ;  (save-excursion
+ ;    (set-buffer name)
+ ;    (string-match "^C$" mode-name)))
+ ;
+ ;(setq ido-ignore-buffers '("^ " ido-ignore-c-mode))
+ 
+ ;;; Examples for setting the value of ido-ignore-files
+ ;(setq ido-ignore-files '("^ " "\\.c$" "\\.h$"))
+ 
+ (defcustom ido-default-file-method  'always-frame
+     "*How to switch to new file when using `ido-find-file'.
+ Possible values:
+ `samewindow'  Show new file in same window
+ `otherwindow' Show new file in another window (same frame)
+ `display'     Display file in another window without switching to it
+ `otherframe'  Show new file in another frame
+ `maybe-frame' If a file is visible in another frame, prompt to ask if you
+               you want to see the file in the same window of the current
+               frame or in the other frame.
+ `always-frame'  If a file is visible in another frame, raise that
+               frame.  Otherwise, visit the file in the same window."
+     :type '(choice (const samewindow)
+                  (const otherwindow)
+                  (const display)
+                  (const otherframe)
+                  (const maybe-frame)
+                  (const always-frame))
+     :group 'ido)
+ 
+ (defcustom ido-default-buffer-method  'always-frame
+     "*How to switch to new buffer when using `ido-switch-buffer'.
+ See ido-default-file-method for details."
+     :type '(choice (const samewindow)
+                  (const otherwindow)
+                  (const display)
+                  (const otherframe)
+                  (const maybe-frame)
+                  (const always-frame))
+     :group 'ido)
+ 
+ (defcustom ido-enable-flex-matching nil
+   "*Non-nil means that `ido' will do flexible string matching.
+ Flexible matching means that if the entered string does not
+ match any item, any item containing the entered characters
+ in the given sequence will match."
+   :type 'boolean
+   :group 'ido)
+ 
+ 
+ (defcustom ido-enable-regexp nil
+   "*Non-nil means that `ido' will do regexp matching.
+ Value can be toggled within `ido' using `ido-toggle-regexp'."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-enable-prefix nil
+   "*Nil means that `ido' will match if the inserted text is an
+ arbitrary substring (default). If non-nil `ido' will only match if the 
inserted
+ text is a prefix \(this behavior is like the standard unix- or
+ emacs-completion works).
+ Value can be toggled within `ido' using `ido-toggle-prefix'."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-confirm-unique-completion nil
+   "*Non-nil means that even a unique completion must be confirmed.
+ This means that \\[ido-complete] must always be followed by 
\\[ido-exit-minibuffer]
+ even when there is only one unique completion."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-cannot-complete-command 'ido-completion-help
+   "*Command run when `ido-complete' can't complete any more.
+ The most useful values are `ido-completion-help', which pops up a
+ window with completion alternatives, or `ido-next-match' or
+ `ido-prev-match', which cycle the buffer list."
+   :type 'function
+   :group 'ido)
+ 
+ 
+ (defcustom ido-record-commands t
+   "*Non-nil means that `ido' will record commands in command history.
+ Note that the non-ido equivalent command is recorded."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-max-prospects 12
+   "*Non-zero means that the prospect list will be limited to than number of 
items.
+ For a long list of prospects, building the full list for the minibuffer can 
take a
+ non-negletable amount of time; setting this variable reduces that time."
+   :type 'integer
+   :group 'ido)
+ 
+ (defcustom ido-max-file-prompt-width 0.35
+   "*Non-zero means that the prompt string be limited to than number of 
characters.
+ If value is a floating point number, it specifies a fraction of the frame 
width."
+   :type '(choice
+         (integer :tag "Characters" :value 20)
+         (restricted-sexp :tag "Fraction of frame width"
+                          :value 0.35
+                          :match-alternatives (ido-fractionp)))
+   :group 'ido)
+ 
+ (defcustom ido-max-window-height nil
+   "*Non-nil specifies a value to override `max-mini-window-height'."
+   :type '(choice
+         (const :tag "Don't override" nil)
+         (integer :tag "Number of lines" :value 1)
+         (restricted-sexp
+          :tag "Fraction of window height"
+          :value 0.25
+          :match-alternatives (ido-fractionp)))
+   :group 'ido)
+ 
+ (defcustom ido-enable-last-directory-history t
+   "*Non-nil means that `ido' will remember latest selected directory names.
+ See `ido-last-directory-list' and `ido-save-directory-list-file'."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-max-work-directory-list 50
+   "*Maximum number of working directories to record.
+ This is the list of directories where files have most recently been opened.
+ See `ido-work-directory-list' and `ido-save-directory-list-file'."
+   :type 'integer
+   :group 'ido)
+ 
+ (defcustom ido-work-directory-list-ignore-regexps nil
+   "*List of regexps matching directories which should not be recorded.
+ Directory names matched by one of the regexps in this list are not inserted in
+ the `ido-work-directory-list' list."
+   :type '(repeat regexp)
+   :group 'ido)
+ 
+ 
+ (defcustom ido-use-filename-at-point nil
+   "*Non-nil means that ido shall look for a filename at point.
+ If found, use that as the starting point for filename selection."
+   :type 'boolean
+   :group 'ido)
+ 
+ 
+ (defcustom ido-use-url-at-point nil
+   "*Non-nil means that ido shall look for a URL at point.
+ If found, call `find-file-at-point' to visit it."
+   :type 'boolean
+   :group 'ido)
+ 
+ 
+ (defcustom ido-enable-tramp-completion t
+   "*Non-nil means that ido shall perform tramp method and server name 
completion.
+ A tramp file name uses the following syntax: /method:address@hidden:filename."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-record-ftp-work-directories t
+   "*Non-nil means record ftp file names in the work directory list."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-merge-ftp-work-directories nil
+   "*If nil means merging ignores ftp file names in the work directory list."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-cache-ftp-work-directory-time 1.0
+   "*Maximum time to cache contents of an ftp directory (in hours).
+ If zero, ftp directories are not cached."
+   :type 'number
+   :group 'ido)
+ 
+ (defcustom ido-slow-ftp-hosts nil
+   "*List of slow ftp hosts where ido prompting should not be used.
+ If an ftp host is on this list, ido automatically switches to the non-ido
+ equivalent function, e.g. find-file rather than ido-find-file."
+   :type '(repeat string)
+   :group 'ido)
+ 
+ (defcustom ido-slow-ftp-host-regexps nil
+   "*List of regexps matching slow ftp hosts (see `ido-slow-ftp-hosts')."
+   :type '(repeat regexp)
+   :group 'ido)
+ 
+ (defcustom ido-max-work-file-list 10
+   "*Maximum number of names of recently opened files to record.
+ This is the list the file names (sans directory) which have most recently
+ been opened. See `ido-work-file-list' and `ido-save-directory-list-file'."
+   :type 'integer
+   :group 'ido)
+ 
+ (defcustom ido-work-directory-match-only t
+   "*Non-nil means to skip non-matching directories in the directory history.
+ When some text is already entered at the `ido-find-file' prompt, using
+ \\[ido-prev-work-directory] or \\[ido-next-work-directory] will skip 
directories
+ without any matching entries."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-auto-merge-work-directories-length 0
+   "*Automatically switch to merged work directories during file name input.
+ The value is number of characters to type before switching to merged mode.
+ If zero, the switch happens when no matches are found in the current 
directory.
+ Automatic merging is disabled if the value is negative."
+   :type 'integer
+   :group 'ido)
+ 
+ (defcustom ido-auto-merge-delay-time 0.70
+   "*Delay in seconds to wait for more input before doing auto merge."
+   :type 'number
+   :group 'ido)
+ 
+ (defcustom ido-auto-merge-inhibit-characters-regexp "[][*?~]"
+   "*Regexp matching characters which should inhibit automatic merging.
+ When a (partial) file name matches this regexp, merging is inhibited."
+   :type 'regexp
+   :group 'ido)
+ 
+ (defcustom ido-merged-indicator "^"
+   "The string appended to first choice if it has multiple directory choices."
+   :type 'string
+   :group 'ido)
+ 
+ (defcustom ido-max-dir-file-cache 100
+   "*Maximum number of working directories to be cached.
+ This is the size of the cache of file-name-all-completions results.
+ Each cache entry is time stamped with the modification time of the
+ directory.  Some systems, like Windows, have unreliable directory
+ modification times, so you may choose to disable caching on such
+ systems, or explicitly refresh the cache contents using the command
+ `ido-reread-directory' command (C-l) in the minibuffer.
+ See also `ido-dir-file-cache' and `ido-save-directory-list-file'."
+   :type 'integer
+   :group 'ido)
+ 
+ (defcustom ido-rotate-file-list-default nil
+   "*Non-nil means that `ido' will always rotate file list to get default in 
front."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defcustom ido-enter-single-matching-directory 'slash
+   "*Automatically enter sub-directory if it is the only matching item, if 
non-nil.
+ If value is 'slash, only enter if typing final slash, else do it always."
+   :type '(choice (const :tag "Never" nil)
+                (const :tag "When typing /" slash)
+                (other :tag "Always" t))
+   :group 'ido)
+ 
+ (defcustom ido-create-new-buffer 'prompt
+   "*Specify whether a new buffer is created if no buffer matches substring.
+ Choices are 'always to create new buffers unconditionally, 'prompt to
+ ask user whether to create buffer, or 'never to never create new buffer."
+   :type '(choice (const always)
+                (const prompt)
+                (const never))
+   :group 'ido)
+ 
+ (defcustom ido-define-mode-map-hook  nil
+   "*Hook to define keys in `ido-mode-map' for extra keybindings."
+   :type 'hook
+   :group 'ido)
+ 
+ (defcustom ido-separator nil
+   "*String used by ido to separate the alternatives in the minibuffer.
+ Obsolete.  Set 3rd element of `ido-decorations' instead."
+   :type '(choice string (const nil))
+   :group 'ido)
+ 
+ (defcustom ido-decorations '( "{" "}" " | " " | ..." "[" "]" " [No match]" " 
[Matched]" " [Not readable]")
+   "*List of strings used by ido to display the alternatives in the minibuffer.
+ There are 9 elements in this list:
+ 1st and 2nd elements are used as brackets around the prospect list,
+ 3rd element is the separator between prospects (ignored if ido-separator is 
set),
+ 4th element is the string inserted at the end of a truncated list of 
prospects,
+ 5th and 6th elements are used as brackets around the common match string which
+ can be completed using TAB,
+ 7th element is the string displayed when there are a no matches, and
+ 8th element is displayed if there is a single match (and faces are not used).
+ 9th element is displayed when the current directory is non-readable."
+   :type '(repeat string)
+   :group 'ido)
+ 
+ (defcustom ido-use-faces t
+   "*Non-nil means use ido faces to highlighting first match, only match and
+ subdirs in the alternatives."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defface ido-first-match-face  '((t (:bold t)))
+   "*Font used by ido for highlighting first match."
+   :group 'ido)
+ 
+ (defface ido-only-match-face  '((((class color))
+                                  (:foreground "ForestGreen"))
+                                 (t (:italic t)))
+   "*Font used by ido for highlighting only match."
+   :group 'ido)
+ 
+ (defface ido-subdir-face  '((((class color))
+                              (:foreground "red"))
+                             (t (:underline t)))
+   "*Font used by ido for highlighting subdirs in the alternatives."
+   :group 'ido)
+ 
+ (defface ido-indicator-face  '((((class color))
+                               (:foreground "yellow"
+                                :background "red"
+                                :width condensed))
+                              (t (:inverse-video t)))
+   "*Font used by ido for highlighting its indicators."
+   :group 'ido)
+ 
+ (defcustom ido-make-file-list-hook  nil
+   "*List of functions to run when the list of matching files is created.
+ Each function on the list may modify the dynamically bound variable
+ `ido-temp-list' which contains the current list of matching files."
+   :type 'hook
+   :group 'ido)
+ 
+ (defcustom ido-make-dir-list-hook  nil
+   "*List of functions to run when the list of matching directories is created.
+ Each function on the list may modify the dynamically bound variable
+ `ido-temp-list' which contains the current list of matching directories."
+   :type 'hook
+   :group 'ido)
+ 
+ (defcustom ido-make-buffer-list-hook  nil
+   "*List of functions to run when the list of matching buffers is created.
+ Each function on the list may modify the dynamically bound variable
+ `ido-temp-list' which contains the current list of matching buffer names."
+   :type 'hook
+   :group 'ido)
+ 
+ (defcustom ido-rewrite-file-prompt-functions nil
+   "*List of functions to run when the find-file prompt is created.
+ Each function on the list may modify the following dynamically bound
+ variables:
+   dirname   - the (abbreviated) directory name
+                to be modified by the hook functions
+   max-width - the max width of the resulting dirname; nil means no limit
+   prompt    - the basic prompt (e.g. \"Find File: \")
+   literal   - the string shown if doing \"literal\" find; set to nil to omit
+   vc-off    - the string shown if version control is inhibited; set to nit to 
omit
+   prefix    - either nil or a fixed prefix for the dirname
+ 
+ The following variables are available, but should not be changed:
+   ido-current-directory - the unabbreviated directory name
+   item - equals `file' or `dir' depending on the current mode."
+   :type 'hook
+   :group 'ido)
+ 
+ (defvar ido-rewrite-file-prompt-rules nil
+   "*Alist of rewriting rules for directory names in ido prompts.
+ A list of elements of the form (FROM . TO) or (FROM . FUNC), each
+ meaning to rewrite the directory name if matched by FROM by either
+ substituting the matched string by TO or calling the function FUNC
+ with the current directory name as its only argument and using the
+ return value as the new directory name.  In addition, each FUNC may
+ also modify the dynamic variables described for the variable
+ `ido-rewrite-file-prompt-functions'.")
+ 
+ (defcustom ido-completion-buffer "*Ido Completions*"
+   "*Name of completion buffer used by ido.
+ Set to nil to disable completion buffers popping up."
+   :type 'string
+   :group 'ido)
+ 
+ (defcustom ido-completion-buffer-all-completions nil
+   "*Non-nil means to show all completions in completion buffer.
+ Otherwise, only the current list of matches is shown."
+   :type 'boolean
+   :group 'ido)
+ 
+ (defvar ido-all-frames 'visible
+   "*Argument to pass to `walk-windows' when finding visible files.
+ See documentation of `walk-windows' for useful values.")
+ 
+ (defcustom ido-minibuffer-setup-hook nil
+   "*Ido-specific customization of minibuffer setup.
+ 
+ This hook is run during minibuffer setup iff `ido' will be active.
+ It is intended for use in customizing ido for interoperation
+ with other packages.  For instance:
+ 
+   \(add-hook 'ido-minibuffer-setup-hook
+           \(function
+            \(lambda ()
+              \(make-local-variable 'max-mini-window-height)
+              \(setq max-mini-window-height 3))))
+ 
+ will constrain Emacs to a maximum minibuffer height of 3 lines when
+ ido is running.  Copied from `icomplete-minibuffer-setup-hook'."
+   :type 'hook
+   :group 'ido)
+ 
+ (defcustom ido-save-directory-list-file "~/.ido.last"
+   "File in which the ido state is saved between invocations.
+ Variables stored are: `ido-last-directory-list', `ido-work-directory-list',
+ `ido-work-file-list', and `ido-dir-file-cache'.
+ Must be set before enabling ido mode."
+   :type 'string
+   :group 'ido)
+ 
+ (defcustom ido-read-file-name-as-directory-commands '()
+   "List of commands which uses read-file-name to read a directory name.
+ When `ido-everywhere' is non-nil, the commands in this list will read
+ the directory using ido-read-directory-name."
+   :type '(repeat symbol)
+   :group 'ido)
+ 
+ (defcustom ido-read-file-name-non-ido '()
+   "List of commands which shall not read file names the ido way.
+ When `ido-everywhere' is non-nil, the commands in this list will read
+ the file name using normal read-file-name style."
+   :type '(repeat symbol)
+   :group 'ido)
+ 
+ ;;; Internal Variables
+ 
+ ;; Persistent variables
+ 
+ (defvar ido-mode-map nil
+   "Keymap for `ido-find-file' and `ido-switch-buffer'.")
+ 
+ (defvar  ido-file-history nil
+   "History of files selected using `ido-find-file'.")
+ 
+ (defvar  ido-buffer-history nil
+   "History of buffers selected using `ido-switch-buffer'.")
+ 
+ (defvar ido-last-directory-list nil
+   "List of last selected directory names.
+ See `ido-enable-last-directory-history' for details.")
+ 
+ (defvar ido-work-directory-list nil
+   "List of actual working directory names.
+ The current directory is inserted at the front of this list whenever a
+ file is opened with ido-find-file and family.")
+ 
+ (defvar ido-work-file-list nil
+   "List of actual work file names.
+ Opening a file with `ido-find-file' and similar functions
+ inserts the current file name (relative to its containing directory)
+ at the front of this list.")
+ 
+ (defvar ido-dir-file-cache nil
+   "List of `file-name-all-completions' results.
+ Each element in the list is of the form (DIR (MTIME) FILE...).")
+ 
+ (defvar ido-ignore-item-temp-list nil
+   "List of items to ignore in current ido invocation.
+ Intended to be let-bound by functions which calls ido repeatedly.
+ Should never be set permanently.")
+ 
+ ;; Temporary storage
+ 
+ (defvar ido-eoinput 1
+   "Point where minibuffer input ends and completion info begins.
+ Copied from `icomplete-eoinput'.")
+ (make-variable-buffer-local 'ido-eoinput)
+ 
+ (defvar ido-common-match-string  nil
+   "Stores the string that is common to all matching files.")
+ 
+ (defvar ido-rescan nil
+   "Non-nil means we need to regenerate the list of matching items.")
+ 
+ (defvar ido-rotate nil
+   "Non-nil means we are rotating list of matches.")
+ 
+ (defvar ido-text nil
+   "Stores the users string as it is typed in.")
+ 
+ (defvar ido-text-init nil
+   "The initial string for the users string it is typed in.")
+ 
+ (defvar ido-matches nil
+   "List of files currently matching `ido-text'.")
+ 
+ (defvar ido-report-no-match t
+   "Report [No Match] when no completions matches ido-text.")
+ 
+ (defvar ido-exit nil
+   "Flag to monitor how `ido-find-file' exits.
+ If equal to `takeprompt', we use the prompt as the file name to be
+ selected.")
+ 
+ (defvar ido-current-directory nil
+   "Current directory for ido-find-file.")
+ 
+ (defvar ido-auto-merge-timer nil
+   "Delay timer for auto merge.")
+ 
+ (defvar ido-use-mycompletion-depth 0
+   "Non-nil means use `ido' completion feedback.
+ Is set by ido functions to the current minibuffer-depth, so that
+ it doesn't interfere with other minibuffer usage.")
+ 
+ 
+ ;;; Variables with dynamic bindings.
+ ;;; Declared here to keep the byte compiler quiet.
+ 
+ ;; Stores the current ido item type ('file, 'dir or 'buffer).
+ (defvar ido-cur-item)
+ 
+ ;; Stores the current list of items that will be searched through.
+ ;; The list is ordered, so that the most interesting item comes first,
+ ;; although by default, the files visible in the current frame are put
+ ;; at the end of the list.  Created by `ido-make-item-list'.
+ (defvar ido-cur-list)
+ 
+ ;; Stores the list of items which are ignored when building
+ ;; `ido-cur-list'.  It is in no specific order.
+ (defvar ido-ignored-list)
+ 
+ ;; Remember if current directory is non-readable (so we cannot do completion).
+ (defvar ido-directory-nonreadable)
+ 
+ ;; Keep current item list if non-nil.
+ (defvar ido-keep-item-list)
+ 
+ ;; Process ido-ignore-* lists.
+ (defvar ido-process-ignore-lists)
+ 
+ ;; Don't process ido-ignore- lists once.
+ (defvar ido-process-ignore-lists-inhibit)
+ 
+ ;; Buffer from which ido was entered.
+ (defvar ido-entry-buffer)
+ 
+ ;; Non-nil if matching file must be selected.
+ (defvar ido-require-match)
+ 
+ ;; Stores a temporary version of the file list being created.
+ (defvar ido-temp-list)
+ 
+ ;; Non-nil if default list element should be rotated into place.
+ (defvar ido-rotate-temp)
+ 
+ ;; Stores current index in ido-work-directory-list.
+ (defvar ido-work-directory-index)
+ 
+ ;; Stores current index in ido-work-file-list.
+ (defvar ido-work-file-index)
+ 
+ ;; Set when merged work directory list is in use.
+ (defvar ido-use-merged-list)
+ 
+ ;; Set when merged work directory list not yet built.
+ (defvar ido-try-merged-list)
+ 
+ ;; Saved state prior to last work directory merge.
+ ;; Value is a list (ido-text dir cur-list ignored-list matches).
+ (defvar ido-pre-merge-state)
+ 
+ ;; Original value of vc-handled-backends for use in ido-toggle-vc.
+ (defvar ido-saved-vc-hb)
+ 
+ ;; Stores temporary state of literal find file.
+ (defvar ido-find-literal)
+ 
+ 
+ ;;; FUNCTIONS
+ 
+ (defun ido-active (&optional merge)
+   (if merge
+       ido-use-merged-list
+     (and (boundp 'ido-completing-read) (= ido-use-mycompletion-depth 
(minibuffer-depth)))))
+ 
+ (defvar ido-trace-enable nil)
+ 
+ (defun ido-trace (p &optional s retval)
+   (if ido-trace-enable
+       (let ((b (get-buffer-create " *IDO Trace*"))
+           (deactivate-mark deactivate-mark))
+       (save-excursion
+         (save-restriction
+           (set-buffer b)
+           (insert p ": " (if (stringp s) s (format "%S" s)) "\n")))))
+   retval)
+ 
+ (defun ido-toggle-trace (arg)
+   (interactive "P")
+   (setq ido-trace-enable (or arg (not ido-trace-enable)))
+   (if ido-trace-enable
+       (message "IDO trace on"))
+   (let ((b (get-buffer " *IDO Trace*")))
+     (if b
+       (if ido-trace-enable
+           (kill-buffer b)
+         (pop-to-buffer b t t)
+         (setq truncate-lines t)))))
+ 
+ (defun ido-is-tramp-root (&optional dir)
+   (setq dir (or dir ido-current-directory))
+   (and ido-enable-tramp-completion
+        (string-match "\\`/[^/][^/]+:\\([^/:@address@hidden)?\\'" dir)))
+ 
+ (defun ido-is-root-directory (&optional dir)
+   (setq dir (or dir ido-current-directory))
+   (or
+    (string-equal "/" dir)
+    (and (memq system-type '(windows-nt ms-dos))
+       (string-match "\\`[a-zA-Z]:[/\\]\\'" dir))
+    (if ido-enable-tramp-completion
+        (ido-is-tramp-root dir)
+      (string-match "\\`/[^:/][^:/]+:\\'" dir))))
+ 
+ (defun ido-is-ftp-directory (&optional dir)
+   (string-match
+    (if ido-enable-tramp-completion
+        "\\`/[^/:][^/:]+:"  ;; like tramp-file-name-regexp-unified, but 
doesn't match single drive letters
+      "\\`/[^/:][^/:]+:/")
+    (or dir ido-current-directory)))
+ 
+ (defun ido-is-slow-ftp-host (&optional dir)
+   (and (or ido-slow-ftp-hosts ido-slow-ftp-host-regexps)
+        (setq dir (or dir ido-current-directory))
+        ;; (featurep 'ange-ftp)
+        ;; (ange-ftp-ftp-name dir)
+        (string-match
+       (if ido-enable-tramp-completion
+           "\\`/\\([^/]+[@:]\\)*\\([^@/:][^@/:]+\\):"
+         "\\`/\\([^/:address@hidden)?\\([^@/:][^@/:]+\\):/")
+       dir)
+        (let ((host (substring dir (match-beginning 2) (match-end 2))))
+        (or (member host ido-slow-ftp-hosts)
+            (let ((re ido-slow-ftp-host-regexps))
+              (while (and re (not (string-match (car re) host)))
+                (setq re (cdr re)))
+              re)))))
+ 
+ (defun ido-time-stamp (&optional time)
+   ;; Time is a floating point number (fractions of 1 hour)
+   (setq time (or time (current-time)))
+   (/ (+ (* (car time) 65536.0) (car (cdr time))) 3600.0))
+ 
+ (defun ido-cache-ftp-valid (&optional time)
+   (and (numberp ido-cache-ftp-work-directory-time)
+        (> ido-cache-ftp-work-directory-time 0)
+        (or (not time)
+          (< (- (ido-time-stamp) time) ido-cache-ftp-work-directory-time))))
+ 
+ (defun ido-may-cache-directory (&optional dir)
+   (setq dir (or dir ido-current-directory))
+   (cond
+    ((and (ido-is-root-directory dir)
+        (or ido-enable-tramp-completion
+            (memq system-type '(windows-nt ms-dos))))
+     nil)
+    ((not (ido-is-ftp-directory dir))
+     t)
+    ((ido-cache-ftp-valid)
+     t)))
+ 
+ (defun ido-pp (list &optional sep)
+   (let ((print-level nil) (eval-expression-print-level nil)
+       (print-length nil) (eval-expression-print-length nil))
+     (insert "\n;; ----- " (symbol-name list) " -----\n(\n ")
+     (setq list (symbol-value list))
+     (while list
+       (let* ((elt (car list))
+            (s (if (consp elt) (car elt) elt)))
+       (if (and (stringp s) (= (length s) 0))
+           (setq s nil))
+       (if s
+           (prin1 elt (current-buffer)))
+       (if (and (setq list (cdr list)) s)
+           (insert (or sep "\n ")))))
+     (insert "\n)\n")))
+ 
+ (defun ido-save-history ()
+   "Save ido history and cache information between sessions."
+   (interactive)
+   (if (and ido-last-directory-list ido-save-directory-list-file)
+       (save-excursion
+       (save-window-excursion
+         (if (find-buffer-visiting ido-save-directory-list-file)
+             (kill-buffer (find-buffer-visiting ido-save-directory-list-file)))
+         (if (file-exists-p ido-save-directory-list-file)
+             (delete-file ido-save-directory-list-file))
+         (set-buffer (let ((enable-local-variables nil))
+                       (find-file-noselect ido-save-directory-list-file t)))
+         (goto-char (point-min))
+         (delete-region (point-min) (point-max))
+         (ido-pp 'ido-last-directory-list)
+         (ido-pp 'ido-work-directory-list)
+         (ido-pp 'ido-work-file-list)
+         (ido-pp 'ido-dir-file-cache "\n\n ")
+         (insert "\n")
+         (let ((version-control 'never))
+           (write-file ido-save-directory-list-file nil))
+         (kill-buffer (current-buffer))))))
+ 
+ (defun ido-load-history (&optional arg)
+   "Load ido history and cache information from previous session.
+ With prefix argument, reload history unconditionally."
+   (interactive "P")
+   (if (or arg (and ido-save-directory-list-file (not 
ido-last-directory-list)))
+       (let ((file (expand-file-name ido-save-directory-list-file))
+           buf)
+       (when (file-readable-p file)
+         (save-excursion
+           (save-window-excursion
+             (setq buf (set-buffer (let ((enable-local-variables nil))
+                                     (find-file-noselect file))))
+             (goto-char (point-min))
+             (condition-case nil
+                 (setq ido-last-directory-list (read (current-buffer))
+                       ido-work-directory-list (read (current-buffer))
+                       ido-work-file-list (read (current-buffer))
+                       ido-dir-file-cache (read (current-buffer)))
+               (error nil))))
+         (kill-buffer buf))))
+   (ido-wash-history))
+ 
+ (defun ido-wash-history ()
+   "Clean-up ido history and cache information.
+ Removes badly formatted data and ignored directories."
+   (interactive)
+   ;; Check format of each of our lists, discard bogus elements
+   (setq ido-last-directory-list
+       (and (listp ido-last-directory-list)
+            (let ((l ido-last-directory-list) r)
+              (while l
+                (if (and (consp (car l))
+                         (stringp (car (car l)))
+                         (stringp (cdr (car l))))
+                    (setq r (cons (car l) r)))
+                (setq l (cdr l)))
+              (nreverse r))))
+   (setq ido-work-directory-list
+       (and (listp ido-work-directory-list)
+            (let ((l ido-work-directory-list) r)
+              (while l
+                (if (and (stringp (car l))
+                         (or ido-record-ftp-work-directories
+                             (not (ido-is-ftp-directory (car l)))))
+                    (setq r (cons (car l) r)))
+                (setq l (cdr l)))
+              (nreverse r))))
+   (setq ido-work-file-list
+       (and (listp ido-work-file-list)
+            (let ((l ido-work-file-list) r)
+              (while l
+                (if (stringp (car l))
+                    (setq r (cons (car l) r)))
+                (setq l (cdr l)))
+              (nreverse r))))
+   (setq ido-dir-file-cache
+       (and (listp ido-dir-file-cache)
+            (let ((l ido-dir-file-cache) r)
+              (while l
+                (if (and (listp (car l))
+                         (> (length (car l)) 2)
+                         (let ((dir (car (car l)))
+                               (time (car (cdr (car l))))
+                               (files (cdr (cdr (car l)))))
+                           (and
+                            (stringp dir)
+                            (consp time)
+                            (if (integerp (car time))
+                                (and (/= (car time) 0)
+                                     (integerp (car (cdr time)))
+                                     (/= (car (cdr time)) 0)
+                                     (ido-may-cache-directory dir))
+                              (and (eq (car time) 'ftp)
+                                   (numberp (cdr time))
+                                   (ido-is-ftp-directory dir)
+                                   (ido-cache-ftp-valid (cdr time))))
+                            (let ((s files) (ok t))
+                              (while s
+                                (if (stringp (car s))
+                                    (setq s (cdr s))
+                                  (setq s nil ok nil)))
+                              ok))))
+                    (setq r (cons (car l) r)))
+                (setq l (cdr l)))
+              (nreverse r))))
+ 
+   ;; Remove ignored directories from work directory list
+   ;; according to ido-work-directory-list-ignore-regexps
+   (if ido-work-directory-list
+       (let ((dirs (reverse ido-work-directory-list)))
+       (setq ido-work-directory-list nil)
+       (while dirs
+         (ido-record-work-directory (car dirs))
+         (setq dirs (cdr dirs)))))
+   ;; Get rid of text properties
+   (let ((l ido-last-directory-list) e)
+     (while l
+       (setq e (car l) l (cdr l))
+       (set-text-properties 0 (length (car e)) nil (car e))
+       (set-text-properties 0 (length (cdr e)) nil (cdr e))))
+   (let ((l ido-work-directory-list) e)
+     (while l
+       (setq e (car l) l (cdr l))
+       (set-text-properties 0 (length e) nil e)))
+   (let ((l ido-work-file-list) e)
+     (while l
+       (setq e (car l) l (cdr l))
+       (set-text-properties 0 (length e) nil e)))
+   (let ((l ido-dir-file-cache) e d)
+     (while l
+       (setq e (car l) l (cdr l))
+       (if (listp e)
+         (while e
+           (setq d (car e) e (cdr e))
+           (if (not (consp d))
+               (set-text-properties 0 (length d) nil d))))))
+ )
+ 
+ 
+ (defun ido-kill-emacs-hook ()
+   ;; ido kill emacs hook
+   (ido-save-history))
+ 
+ (defvar ido-minor-mode-map-entry nil)
+ 
+ ;;;###autoload
+ (defun ido-mode (&optional arg)
+   "Toggle ido speed-ups on or off.
+ With ARG, turn ido speed-up on if arg is positive, off otherwise.
+ Turning on ido-mode will remap (via a minor-mode keymap) the default
+ keybindings for the `find-file' and `switch-to-buffer' families of
+ commands to the ido versions of these functions.
+ However, if ARG arg equals 'files, remap only commands for files, or
+ if it equals 'buffers, remap only commands for buffer switching.
+ This function also adds a hook to the minibuffer."
+   (interactive "P")
+   (setq ido-mode
+       (cond
+        ((null arg) (if ido-mode nil 'both))
+        ((eq arg t) 'both)
+        ((eq arg 'files) 'file)
+        ((eq arg 'buffers) 'buffer)
+        ((memq arg '(file buffer both)) arg)
+        ((> (prefix-numeric-value arg) 0) 'both)
+        (t nil)))
+ 
+   (ido-everywhere (if ido-everywhere 1 -1))
+ 
+   (when ido-mode
+     (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
+     (add-hook 'choose-completion-string-functions 
'ido-choose-completion-string)
+     (ido-load-history)
+ 
+     (add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
+ 
+     (unless ido-minor-mode-map-entry
+       (setq ido-minor-mode-map-entry (cons 'ido-mode (make-sparse-keymap)))
+       (add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))
+ 
+     (let ((map (cdr ido-minor-mode-map-entry)))
+       (when (memq ido-mode '(file both))
+       (define-key map [remap find-file] 'ido-find-file)
+       (define-key map [remap find-file-read-only] 'ido-find-file-read-only)
+       (define-key map [remap find-alternate-file] 'ido-find-alternate-file)
+       (define-key map [remap write-file] 'ido-write-file)
+       (define-key map [remap insert-file] 'ido-insert-file)
+       (define-key map [remap list-directory] 'ido-list-directory)
+       (define-key map [remap dired] 'ido-dired)
+       (define-key map [remap find-file-other-window] 
'ido-find-file-other-window)
+       (define-key map [remap find-file-read-only-other-window] 
'ido-find-file-read-only-other-window)
+       (define-key map [remap find-file-other-frame] 
'ido-find-file-other-frame)
+       (define-key map [remap find-file-read-only-other-frame] 
'ido-find-file-read-only-other-frame))
+ 
+       (when (memq ido-mode '(buffer both))
+       (define-key map [remap switch-to-buffer] 'ido-switch-buffer)
+       (define-key map [remap switch-to-buffer-other-window] 
'ido-switch-buffer-other-window)
+       (define-key map [remap switch-to-buffer-other-frame] 
'ido-switch-buffer-other-frame)
+       (define-key map [remap insert-buffer] 'ido-insert-buffer)
+       (define-key map [remap kill-buffer] 'ido-kill-buffer)
+       (define-key map [remap display-buffer] 'ido-display-buffer)))))
+ 
+ (defun ido-everywhere (arg)
+   "Enable ido everywhere file and directory names are read."
+   (interactive "P")
+   (setq ido-everywhere (if arg
+                          (> (prefix-numeric-value arg) 0)
+                        (not ido-everywhere)))
+   (setq read-file-name-function
+       (and ido-everywhere (memq ido-mode '(both file))
+            'ido-read-file-name))
+   (setq read-buffer-function
+       (and ido-everywhere (memq ido-mode '(both buffer))
+            'ido-read-buffer)))
+ 
+ 
+ ;;; IDO KEYMAP
+ (defun ido-define-mode-map ()
+   "Set up the keymap for `ido'."
+   (let (map)
+     ;; generated every time so that it can inherit new functions.
+ 
+     (setq map (copy-keymap minibuffer-local-map))
+     (define-key map "\C-a" 'ido-toggle-ignore)
+     (define-key map "\C-c" 'ido-toggle-case)
+     (define-key map "\C-e" 'ido-edit-input)
+     (define-key map "\t" 'ido-complete)
+     (define-key map " " 'ido-complete-space)
+     (define-key map "\C-j" 'ido-select-text)
+     (define-key map "\C-m" 'ido-exit-minibuffer)
+     (define-key map "\C-p" 'ido-toggle-prefix)
+     (define-key map "\C-r" 'ido-prev-match)
+     (define-key map "\C-s" 'ido-next-match)
+     (define-key map "\C-t" 'ido-toggle-regexp)
+     (define-key map "\C-z" 'ido-undo-merge-work-directory)
+     (define-key map [(control ? )] 'ido-restrict-to-matches)
+     (define-key map [(control ?@)] 'ido-restrict-to-matches)
+     (define-key map [right] 'ido-next-match)
+     (define-key map [left] 'ido-prev-match)
+     (define-key map "?" 'ido-completion-help)
+ 
+     (when (memq ido-cur-item '(file dir))
+       (define-key map "\C-b" 'ido-enter-switch-buffer)
+       (define-key map "\C-d" 'ido-enter-dired)
+       (define-key map "\C-f" 'ido-fallback-command)
+       (define-key map [down] 'ido-next-match-dir)
+       (define-key map [up]   'ido-prev-match-dir)
+       (define-key map [(meta up)] 'ido-prev-work-directory)
+       (define-key map [(meta down)] 'ido-next-work-directory)
+       (define-key map [backspace] 'ido-delete-backward-updir)
+       (define-key map "\d"        'ido-delete-backward-updir)
+       (define-key map [(meta backspace)] 'ido-delete-backward-word-updir)
+       (define-key map [(control backspace)] 'ido-up-directory)
+       (define-key map "\C-l" 'ido-reread-directory)
+       (define-key map [(meta ?b)] 'ido-next-work-file)
+       (define-key map [(meta ?d)] 'ido-wide-find-dir)
+       (define-key map [(meta ?f)] 'ido-wide-find-file)
+       (define-key map [(meta ?k)] 'ido-forget-work-directory)
+       (define-key map [(meta ?m)] 'ido-make-directory)
+       (define-key map [(meta ?n)] 'ido-next-work-directory)
+       (define-key map [(meta ?o)] 'ido-prev-work-file)
+       (define-key map [(meta ?p)] 'ido-prev-work-directory)
+       (define-key map [(meta ?s)] 'ido-merge-work-directories)
+       )
+ 
+     (when (eq ido-cur-item 'file)
+       (define-key map "\C-k" 'ido-delete-file-at-head)
+       (define-key map "\C-o" 'ido-copy-current-word)
+       (define-key map "\C-w" 'ido-copy-current-file-name)
+       (define-key map [(meta ?l)] 'ido-toggle-literal)
+       (define-key map "\C-v" 'ido-toggle-vc)
+       )
+ 
+     (when (eq ido-cur-item 'buffer)
+       (define-key map "\C-b" 'ido-fallback-command)
+       (define-key map "\C-f" 'ido-enter-find-file)
+       (define-key map "\C-k" 'ido-kill-buffer-at-head)
+       )
+ 
+     (when (if (boundp 'viper-mode) viper-mode)
+       (define-key map [remap viper-intercept-ESC-key] 'ignore)
+       (when (memq ido-cur-item '(file dir))
+       (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
+       (define-key map [remap viper-del-backward-char-in-insert] 
'ido-delete-backward-updir)
+       (define-key map [remap viper-delete-backward-word] 
'ido-delete-backward-word-updir)))
+ 
+     (setq ido-mode-map map)
+     (run-hooks 'ido-define-mode-map-hook)))
+ 
+ (defun ido-final-slash (dir &optional fix-it)
+   ;; return DIR if DIR has final slash.
+   ;; else if FIX-IT is non-nil, return DIR/
+   ;; else return nil.
+   (setq dir (ido-name dir))
+   (cond
+    ((string-match "/\\'" dir) dir)
+    ((ido-is-tramp-root dir) dir)
+    (fix-it (concat dir "/"))
+    (t nil)))
+ 
+ (defun ido-no-final-slash (s)
+   ;; Remove optional final slash from string S
+   (let ((l (1- (length s))))
+     (if (and (> l 0) (eq (aref s l) ?/))
+       (substring s 0 l)
+       s)))
+ 
+ (defun ido-nonreadable-directory-p (dir)
+   ;; Return t if dir is a directory, but not readable
+   ;; Do not check for non-readable directories via tramp, as this causes a 
premature
+   ;; connect on incomplete tramp paths (after entring just method:).
+   (let ((ido-enable-tramp-completion nil))
+     (and (ido-final-slash dir)
+        (file-directory-p dir)
+        (not (file-readable-p dir)))))
+ 
+ (defun ido-set-current-directory (dir &optional subdir no-merge)
+   ;; Set ido's current directory to DIR or DIR/SUBDIR
+   (setq dir (ido-final-slash dir t))
+   (setq ido-use-merged-list nil
+       ido-try-merged-list (not no-merge))
+   (if subdir
+       (setq dir (ido-final-slash (concat dir subdir) t)))
+   (if (equal dir ido-current-directory)
+       nil
+     (ido-trace "cd" dir)
+     (setq ido-current-directory dir)
+     (if (get-buffer ido-completion-buffer)
+       (kill-buffer ido-completion-buffer))
+     (setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
+     t))
+ 
+ (defun ido-set-current-home (&optional dir)
+   ;; Set ido's current directory to user's home directory
+   (ido-set-current-directory (expand-file-name (or dir "~/"))))
+ 
+ (defun ido-record-command (command arg)
+   ;; Add (command arg) to command-history if ido-record-commands is t
+   (if ido-record-commands
+       (let ((cmd (list command arg)))
+       (if (or (not command-history)
+               (not (equal cmd (car command-history))))
+           (setq command-history (cons cmd command-history))))))
+ 
+ (defun ido-make-prompt (item prompt)
+   ;; Make the prompt for ido-read-internal
+   (cond
+    ((and (memq item '(file dir)) ido-current-directory)
+     (let ((dirname (abbreviate-file-name ido-current-directory))
+         (max-width (if (and ido-max-file-prompt-width (floatp 
ido-max-file-prompt-width))
+                        (floor (* (frame-width) ido-max-file-prompt-width))
+                      ido-max-file-prompt-width))
+         (literal (and (boundp 'ido-find-literal) ido-find-literal "(literal) 
"))
+         (vc-off (and ido-saved-vc-hb (not vc-handled-backends) "[-VC] "))
+         (prefix nil)
+         (rule ido-rewrite-file-prompt-rules))
+       (let ((case-fold-search nil))
+       (while rule
+         (if (and (consp (car rule))
+                  (string-match (car (car rule)) dirname))
+             (setq dirname
+                   (if (stringp (cdr (car rule)))
+                       (replace-match (cdr (car rule)) t nil dirname)
+                     (funcall (cdr (car rule)) dirname))))
+         (setq rule (cdr rule))))
+       (run-hooks 'ido-rewrite-file-prompt-functions)
+       (concat prompt
+             ; (if ido-process-ignore-lists "" "&")
+             (or literal "")
+             (or vc-off  "")
+             (or prefix "")
+             (let ((l (length dirname)))
+               (if (and max-width (> max-width 0) (> l max-width))
+                   (let* ((s (substring dirname (- max-width)))
+                          (i (string-match "/" s)))
+                     (concat "..." (if i (substring s i) s)))
+                 dirname)))))
+    (t prompt)))
+ 
+ ;; Here is very briefly how ido-find-file works:
+ ;;
+ ;;  (ido-find-file)
+ ;;    (ido-file-internal method)
+ ;;       set ido-current-directory
+ ;;       (ido-read-internal 'file ...)
+ ;;          (while ...
+ ;;             (ido-make-item-list ...)
+ ;;             (ido-set-matches)
+ ;;             (completing-read ... ido-text-init ...)
+ ;;
+ ;;               ... here user is allowed to type characters and commands
+ ;;                   a command may set ido-exit and call (exit-minibuffer)
+ ;;                   to make ido-read-internal do advanced tasks (or return)
+ ;;
+ ;;               ... ido-tidy and ido-exhibit are pre- and post-hooks
+ ;;                   which are run before and after each user command.
+ ;;
+ ;;             return value from completing-read is stored in ido-final-text
+ ;;             - ido-exit may cause further actions to be taken:
+ ;;               'refresh - repeat loop (make-item-list, set-matches)
+ ;;               'edit    - edit the prompt string, then repeat loop
+ ;;               'keep    - repeat loop but don't (re)make-item-list
+ ;;               'updir   - go up one directory, repeat loop
+ ;;               else set ido-selected based on ido-final-text,
+ ;;               optionally update ido-current-directory and repeat loop, or
+ ;;               exit with the return value of ido-selected (file name)
+ ;;       selected file name is returned from ido-read-internal,
+ ;;       ido-exit and method determines what action is taken
+ ;;       e.g. the file name may be ignored or joined with 
ido-current-directory, and
+ ;;       the relevant function is called (find-file, write-file, etc).
+ 
+ (defun ido-read-internal (item prompt history &optional default require-match 
initial)
+   "Perform the ido-read-buffer and ido-read-file-name functions.
+ Return the name of a buffer or file selected.
+ PROMPT is the prompt to give to the user.
+ DEFAULT if given is the default directory to start with.
+ If REQUIRE-MATCH is non-nil, an existing file must be selected.
+ If INITIAL is non-nil, it specifies the initial input string."
+   (let
+       ((ido-cur-item item)
+        (ido-entry-buffer (current-buffer))
+        (ido-process-ignore-lists t)
+        (ido-process-ignore-lists-inhibit nil)
+        (ido-set-default-item t)
+        ido-default-item
+        ido-selected
+        ido-final-text
+        (done nil)
+        (icomplete-mode nil) ;; prevent icomplete starting up
+        ;; Exported dynamic variables:
+        ido-cur-list
+        ido-ignored-list
+        (ido-rotate-temp nil)
+        (ido-keep-item-list nil)
+        (ido-use-merged-list nil)
+        (ido-try-merged-list t)
+        (ido-pre-merge-state nil)
+        (ido-case-fold ido-case-fold)
+        (ido-enable-prefix ido-enable-prefix)
+        (ido-enable-regexp ido-enable-regexp)
+        )
+ 
+     (ido-define-mode-map)
+     (setq ido-text-init initial)
+     (while (not done)
+       (ido-trace "\n_LOOP_" ido-text-init)
+       (setq ido-exit nil)
+       (setq ido-rescan t)
+       (setq ido-rotate nil)
+       (setq ido-text "")
+       (when ido-set-default-item
+       (setq ido-default-item
+             (cond
+              ((eq item 'buffer)
+               (if (bufferp default) (buffer-name default) default))
+              ((stringp default) default)
+              ((eq item 'file)
+               (and ido-enable-last-directory-history
+                    (let ((d (assoc ido-current-directory 
ido-last-directory-list)))
+                      (and d (cdr d)))))))
+       (if (member ido-default-item ido-ignore-item-temp-list)
+           (setq ido-default-item nil))
+       (setq ido-set-default-item nil))
+ 
+       (if ido-process-ignore-lists-inhibit
+         (setq ido-process-ignore-lists nil))
+ 
+       (if (and ido-use-merged-list (memq ido-try-merged-list '(t wide)) (not 
ido-keep-item-list))
+         (let ((olist ido-cur-list)
+               (oign ido-ignored-list)
+               (omat ido-matches)
+               (l (ido-make-merged-file-list ido-text-init
+                                             (eq ido-use-merged-list 'auto)
+                                             (eq ido-try-merged-list 'wide))))
+           (cond
+            ((not l)
+             (if (eq ido-try-merged-list 'wide)
+                 (setq ido-pre-merge-state
+                       (list "" ido-current-directory olist oign omat)
+                       ido-cur-list nil
+                       ido-ignored-list nil
+                       ido-matches nil
+                       ido-keep-item-list t
+                       ido-try-merged-list (if (eq ido-use-merged-list 'auto) 
'auto nil)
+                       ido-use-merged-list nil)
+               (setq ido-cur-list olist
+                     ido-ignored-list oign
+                     ido-matches omat
+                     ido-keep-item-list t
+                     ido-try-merged-list (if (eq ido-use-merged-list 'auto) 
'auto nil)
+                     ido-use-merged-list nil)))
+            ((eq l t)
+             (setq ido-use-merged-list nil))
+            (t
+             (setq ido-pre-merge-state
+                   (list ido-text-init ido-current-directory olist oign omat))
+             (ido-set-current-directory (car (cdr (car l))))
+             (if (ido-final-slash ido-text-init)
+                 (setq ido-text-init ""))
+             (setq ido-cur-list l
+                   ido-ignored-list nil
+                   ido-matches l
+                   ido-rescan nil
+                   ido-keep-item-list t
+                   ido-use-merged-list t)
+             (ido-trace "Merged" t)
+             ))))
+ 
+       (cond
+        (ido-keep-item-list
+       (setq ido-keep-item-list nil
+             ido-rescan nil))
+        ((eq ido-cur-item 'file)
+       (setq ido-ignored-list nil
+             ido-cur-list (ido-make-file-list ido-default-item)))
+        ((eq ido-cur-item 'dir)
+       (setq ido-ignored-list nil
+             ido-cur-list (ido-make-dir-list ido-default-item)))
+        ((eq ido-cur-item 'buffer)
+       (setq ido-ignored-list nil
+             ido-cur-list (ido-make-buffer-list ido-default-item)))
+        (t nil))
+       (setq ido-rotate-temp nil)
+ 
+       (if ido-process-ignore-lists-inhibit
+         (setq ido-process-ignore-lists t
+               ido-process-ignore-lists-inhibit nil))
+ 
+       (ido-set-matches)
+       (if (and ido-matches (eq ido-try-merged-list 'auto))
+         (setq ido-try-merged-list t))
+       (let
+         ((minibuffer-local-completion-map ido-mode-map)
+          (max-mini-window-height (or ido-max-window-height
+                                      (and (boundp 'max-mini-window-height) 
max-mini-window-height)))
+          (ido-completing-read t)
+          (ido-require-match require-match)
+          (ido-use-mycompletion-depth (1+ (minibuffer-depth)))
+          (show-paren-mode nil))
+       ;; prompt the user for the file name
+       (setq ido-exit nil)
+       (setq ido-final-text
+             (catch 'ido
+               (completing-read
+                (ido-make-prompt item prompt)
+                '(("dummy" . 1)) nil nil ; table predicate require-match
+                (prog1 ido-text-init (setq ido-text-init nil)) 
;initial-contents
+                history))))
+       (ido-trace "completing-read" ido-final-text)
+       (if (get-buffer ido-completion-buffer)
+         (kill-buffer ido-completion-buffer))
+ 
+       (ido-trace "\n_EXIT_" ido-exit)
+ 
+       (cond
+        ((eq ido-exit 'refresh)
+       (if (and (eq ido-use-merged-list 'auto)
+                (or (input-pending-p)))
+           (setq ido-use-merged-list nil
+                 ido-keep-item-list t))
+       nil)
+ 
+        ((eq ido-exit 'done)
+       (setq done t
+             ido-selected ido-text
+             ido-exit nil))
+ 
+        ((memq ido-exit '(edit chdir))
+       (cond
+        ((memq ido-cur-item '(file dir))
+         (let* ((read-file-name-function nil)
+                (edit (eq ido-exit 'edit))
+                (d ido-current-directory)
+                (f ido-text-init)
+                (new t))
+           (setq ido-text-init "")
+           (while new
+             (setq new (if edit
+                            (read-file-name (concat prompt "[EDIT] ")
+                                            (expand-file-name d)
+                                            (concat d f) nil f)
+                          f)
+                   d (or (file-name-directory new) "/")
+                   f (file-name-nondirectory new)
+                   edit t)
+             (if (or
+                  (file-directory-p d)
+                  (and (yes-or-no-p (format "Create directory %s? " d))
+                       (condition-case nil
+                           (progn (make-directory d t) t)
+                         (error
+                          (message "Could not create directory")
+                          (sit-for 1)
+                          nil))))
+                 (progn
+                   (ido-set-current-directory d nil (eq ido-exit 'chdir))
+                   (setq ido-text-init f
+                         new nil))))))
+        (t
+         (setq ido-text-init (read-string (concat prompt "[EDIT] ") 
ido-final-text))))
+       nil)
+ 
+        ((eq ido-exit 'keep)
+       (setq ido-keep-item-list t))
+ 
+        ((memq ido-exit '(dired fallback findfile findbuffer))
+       (setq done t))
+ 
+        ((eq ido-exit 'updir)
+       ;; cannot go up if already at the root-dir (Unix) or at the
+       ;; root-dir of a certain drive (Windows or MS-DOS).
+         (if (ido-is-tramp-root)
+           (when (string-match "\\`\\(/\\([^/]+[:@]\\)*\\)\\([^/]+\\)[:@]\\'" 
ido-current-directory)
+             (setq ido-text-init (match-string 3 ido-current-directory))
+             (ido-set-current-directory (match-string 1 ido-current-directory))
+             (setq ido-set-default-item t))
+         (unless (ido-is-root-directory)
+           (ido-set-current-directory (file-name-directory (substring 
ido-current-directory 0 -1)))
+           (setq ido-set-default-item t))))
+ 
+        ;; Handling the require-match must be done in a better way.
+        ((and require-match (not (ido-existing-item-p)))
+       (error "must specify valid item"))
+ 
+        (t
+       (setq ido-selected
+             (if (or (eq ido-exit 'takeprompt)
+                     (null ido-matches))
+                 ido-final-text
+               ;; else take head of list
+               (ido-name (car ido-matches))))
+ 
+       (cond
+        ((eq item 'buffer)
+         (setq done t))
+ 
+        ((string-equal "./" ido-selected)
+         nil)
+ 
+        ((string-equal "../" ido-selected)
+         ;; cannot go up if already at the root-dir (Unix) or at the
+         ;; root-dir of a certain drive (Windows or MS-DOS).
+         (or (ido-is-root-directory)
+             (ido-set-current-directory (file-name-directory (substring 
ido-current-directory 0 -1))))
+         (setq ido-set-default-item t))
+ 
+        ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" 
"..:\\'") ido-selected)
+              (ido-is-root-directory)) ;; Ange-ftp or Tramp
+         (ido-set-current-directory ido-current-directory ido-selected)
+         (ido-trace "tramp prefix" ido-selected)
+         (if (ido-is-slow-ftp-host)
+             (setq ido-exit 'fallback
+                   done t)
+           (setq ido-set-default-item t)))
+        ((or (string-match "[/\\][^/\\]" ido-selected)
+             (and (memq system-type '(windows-nt ms-dos))
+                  (string-match "\\`.:" ido-selected)))
+         (ido-set-current-directory (file-name-directory ido-selected))
+         (setq ido-set-default-item t))
+ 
+        ((string-match "\\`~" ido-selected)
+         (ido-set-current-home ido-selected))
+ 
+        ((ido-final-slash ido-selected)
+         (if ido-enable-last-directory-history
+             (let ((x (assoc ido-current-directory ido-last-directory-list)))
+               (if x
+                   (setcdr x ido-selected)
+                 (setq ido-last-directory-list
+                       (cons (cons ido-current-directory ido-selected) 
ido-last-directory-list)))))
+         (ido-set-current-directory ido-current-directory ido-selected)
+         (setq ido-set-default-item t))
+ 
+        (t
+         (setq done t))))))
+     ido-selected))
+ 
+ (defun ido-edit-input ()
+   "Edit absolute file name entered so far with ido; terminate by RET."
+   (interactive)
+   (setq ido-text-init ido-text)
+   (setq ido-exit 'edit)
+   (exit-minibuffer))
+ 
+ ;;; MAIN FUNCTIONS
+ (defun ido-buffer-internal (method &optional fallback prompt default initial)
+   ;; Internal function for ido-switch-buffer and friends
+   (if (not ido-mode)
+       (call-interactively (or fallback 'switch-to-buffer))
+     (let ((buf (ido-read-buffer (or prompt "Buffer: ") default nil initial)))
+ 
+       ;; Choose the buffer name: either the text typed in, or the head
+       ;; of the list of matches
+ 
+       (cond
+        ((eq ido-exit 'findfile)
+       (ido-file-internal ido-default-file-method nil nil nil nil ido-text))
+ 
+        ((eq ido-exit 'fallback)
+       (let ((read-buffer-function nil))
+         (call-interactively (or fallback 'switch-to-buffer))))
+ 
+        ;; Check buf is non-nil.
+        ((not buf) nil)
+        ((= (length buf) 0) nil)
+ 
+        ;; View buffer if it exists
+        ((get-buffer buf)
+       (if (eq method 'insert)
+           (progn
+             (ido-record-command 'insert-buffer buf)
+             (insert-buffer buf))
+         (ido-visit-buffer buf method t)))
+ 
+        ;; buffer doesn't exist
+        ((eq ido-create-new-buffer 'never)
+       (message "no buffer matching `%s'" buf))
+ 
+        ((and (eq ido-create-new-buffer 'prompt)
+            (not (y-or-n-p (format "No buffer matching `%s', create one? " 
buf))))
+       nil)
+ 
+        ;; create a new buffer
+        (t
+       (setq buf (get-buffer-create buf))
+       (if (fboundp 'set-buffer-major-mode)
+           (set-buffer-major-mode buf))
+       (ido-visit-buffer buf method t))))))
+ 
+ ;;;###autoload
+ (defun ido-read-buffer (prompt &optional default require-match initial)
+   "Replacement for the built-in `read-buffer'.
+ Return the name of a buffer selected.
+ PROMPT is the prompt to give to the user.  DEFAULT if given is the default
+ buffer to be selected, which will go to the front of the list.
+ If REQUIRE-MATCH is non-nil, an existing-buffer must be selected.
+ If INITIAL is non-nil, it specifies the initial input string."
+   (let ((ido-current-directory nil)
+       (ido-directory-nonreadable nil))
+     (ido-read-internal 'buffer prompt 'ido-buffer-history default 
require-match initial)))
+ 
+ (defun ido-record-work-directory (&optional dir)
+   (when (and (numberp ido-max-work-directory-list) (> 
ido-max-work-directory-list 0))
+     (if (and (setq dir (or dir ido-current-directory)) (> (length dir) 0))
+       (let ((items ido-work-directory-list-ignore-regexps)
+             (case-fold-search nil))
+         (while (and items dir)
+           (if (string-match (car items) dir)
+               (setq dir nil))
+           (setq items (cdr items)))
+         (if dir
+             (setq ido-work-directory-list (cons dir (delete dir 
ido-work-directory-list))))))
+     (if (> (length ido-work-directory-list) ido-max-work-directory-list)
+       (setcdr (nthcdr (1- ido-max-work-directory-list) 
ido-work-directory-list) nil))))
+ 
+ (defun ido-forget-work-directory ()
+   (interactive)
+   (when (and ido-current-directory ido-work-directory-list)
+     (setq ido-work-directory-list (delete ido-current-directory 
ido-work-directory-list))
+     (when ido-use-merged-list
+       (ido-undo-merge-work-directory)
+       (setq ido-exit 'refresh
+           ido-try-merged-list t
+           ido-use-merged-list t
+           ido-text-init ido-text
+           ido-rotate-temp t)
+       (exit-minibuffer))))
+ 
+ (defun ido-record-work-file (name)
+   ;; Save NAME in ido-work-file-list
+   (when (and (numberp ido-max-work-file-list) (> ido-max-work-file-list 0))
+     (or
+      (and ido-work-file-list (equal (car ido-work-file-list) name))
+      (setq ido-work-file-list (cons name (delete name ido-work-file-list))))
+     (if (> (length ido-work-file-list) ido-max-work-file-list)
+       (setcdr (nthcdr (1- ido-max-work-file-list) ido-work-file-list) nil))))
+ 
+ (defun ido-expand-directory (dir)
+   ;; Expand DIR or use DEFAULT-DIRECTORY if nil.
+   ;; Add final slash to result in case it was missing from DEFAULT-DIRECTORY.
+   (ido-final-slash (expand-file-name (or dir default-directory)) t))
+ 
+ (defun ido-file-internal (method &optional fallback default prompt item 
initial)
+   ;; Internal function for ido-find-file and friends
+   (unless item
+     (setq item 'file))
+   (let* ((ido-current-directory (ido-expand-directory default))
+        (ido-directory-nonreadable (ido-nonreadable-directory-p 
ido-current-directory))
+        filename)
+ 
+     (cond
+      ((or (not ido-mode) (ido-is-slow-ftp-host))
+       (setq filename t
+           ido-exit 'fallback))
+ 
+      ((and (eq item 'file)
+          (or ido-use-url-at-point ido-use-filename-at-point))
+       (let (fn d)
+       (require 'ffap)
+       ;; Duplicate code from ffap-guesser as we want different behaviour for 
files and URLs.
+       (cond
+        ((and ido-use-url-at-point
+              ffap-url-regexp
+              (ffap-fixup-url (or (ffap-url-at-point)
+                                  (ffap-gopher-at-point))))
+         (setq ido-exit 'ffap
+               filename t))
+ 
+        ((and ido-use-filename-at-point
+              (setq fn (ffap-string-at-point))
+              (not (string-match "^http:/" fn))
+              (setq d (file-name-directory fn))
+              (file-directory-p d))
+         (setq ido-current-directory d)
+         (setq initial (file-name-nondirectory fn)))))))
+ 
+     (let (ido-saved-vc-hb
+         (vc-handled-backends (and (boundp 'vc-handled-backends) 
vc-handled-backends))
+         (ido-work-directory-index -1)
+         (ido-work-file-index -1)
+                 (ido-find-literal nil))
+ 
+       (unless filename
+       (setq ido-saved-vc-hb vc-handled-backends)
+       (setq filename (ido-read-internal item
+                                         (or prompt "Find file: ")
+                                         'ido-file-history nil nil initial)))
+ 
+       ;; Choose the file name: either the text typed in, or the head
+       ;; of the list of matches
+ 
+       (cond
+        ((eq ido-exit 'fallback)
+       ;; Need to guard setting of default-directory here, since
+       ;; we don't want to change directory of current buffer.
+       (let ((default-directory ido-current-directory)
+             (read-file-name-function nil))
+         (call-interactively (or fallback 'find-file))))
+ 
+        ((eq ido-exit 'findbuffer)
+       (ido-buffer-internal ido-default-buffer-method nil nil nil ido-text))
+ 
+        ((eq ido-exit 'dired)
+       (dired (concat ido-current-directory (or ido-text ""))))
+ 
+        ((eq ido-exit 'ffap)
+       (find-file-at-point))
+ 
+        ((eq method 'alt-file)
+       (ido-record-work-file filename)
+       (setq default-directory ido-current-directory)
+       (ido-record-work-directory)
+       (find-alternate-file filename))
+ 
+        ((memq method '(dired list-directory))
+       (if (equal filename ".")
+           (setq filename ""))
+       (let* ((dirname (ido-final-slash (concat ido-current-directory 
filename) t))
+              (file (substring dirname 0 -1)))
+         (cond
+          ((file-directory-p dirname)
+           (ido-record-command method dirname)
+           (ido-record-work-directory dirname)
+           (funcall method dirname))
+          ((file-directory-p ido-current-directory)
+           (cond
+            ((file-exists-p file)
+             (ido-record-command method ido-current-directory)
+             (ido-record-work-directory)
+             (funcall method ido-current-directory)
+             (if (eq method 'dired)
+                 (dired-goto-file (expand-file-name file))))
+            ((string-match "[[*?]" filename)
+             (setq dirname (concat ido-current-directory filename))
+             (ido-record-command method dirname)
+             (ido-record-work-directory)
+             (funcall method dirname))
+            ((y-or-n-p (format "Directory %s does not exist. Create it " 
filename))
+             (ido-record-command method dirname)
+             (ido-record-work-directory dirname)
+             (make-directory-internal dirname)
+             (funcall method dirname))
+            (t
+             ;; put make-directory command on history
+             (ido-record-command 'make-directory dirname))))
+          (t (error "No such directory")))))
+ 
+        ((eq method 'write)
+       (ido-record-work-file filename)
+       (setq default-directory ido-current-directory)
+       (ido-record-command 'write-file (concat ido-current-directory filename))
+       (ido-record-work-directory)
+       (write-file filename))
+ 
+        ((eq method 'read-only)
+       (ido-record-work-file filename)
+       (setq filename (concat ido-current-directory filename))
+       (ido-record-command fallback filename)
+       (ido-record-work-directory)
+       (funcall fallback filename))
+ 
+        ((eq method 'insert)
+       (ido-record-work-file filename)
+       (setq filename (concat ido-current-directory filename))
+       (ido-record-command
+        (if ido-find-literal 'insert-file-literally 'insert-file)
+        filename)
+       (ido-record-work-directory)
+       (if ido-find-literal
+           (insert-file-contents-literally filename)
+         (insert-file-contents filename)))
+ 
+        (filename
+       (ido-record-work-file filename)
+       (setq filename (concat ido-current-directory filename))
+       (ido-record-command 'find-file filename)
+       (ido-record-work-directory)
+       (ido-visit-buffer (find-file-noselect filename nil ido-find-literal) 
method))))))
+ 
+ (defun ido-existing-item-p ()
+   ;; Return non-nil if there is a matching item
+   (not (null ido-matches)))
+ 
+ ;;; COMPLETION CODE
+ 
+ (defun ido-set-common-completion  ()
+   ;; Find common completion of `ido-text' in `ido-matches'
+   ;; The result is stored in `ido-common-match-string'
+   (let* (val)
+     (setq  ido-common-match-string nil)
+     (if (and ido-matches
+            (not ido-enable-regexp) ;; testing
+              (stringp ido-text)
+              (> (length ido-text) 0))
+         (if (setq val (ido-find-common-substring ido-matches ido-text))
+             (setq ido-common-match-string val)))
+     val))
+ 
+ (defun ido-complete ()
+   "Try and complete the current pattern amongst the file names."
+   (interactive)
+   (let (res)
+     (cond
+      ((and (memq ido-cur-item '(file dir))
+          (string-match "[$]" ido-text))
+       (let ((evar (substitute-in-file-name (concat ido-current-directory 
ido-text))))
+       (if (not (file-exists-p (file-name-directory evar)))
+           (message "Expansion generates non-existing directory name")
+         (if (file-directory-p evar)
+             (ido-set-current-directory evar)
+           (let ((d (or (file-name-directory evar) "/"))
+                 (f (file-name-nondirectory evar)))
+             (when (file-directory-p d)
+                 (ido-set-current-directory d)
+                 (setq ido-text-init f))))
+         (setq ido-exit 'refresh)
+         (exit-minibuffer))))
+ 
+      ((not ido-matches)
+       (when ido-completion-buffer
+       (call-interactively (setq this-command ido-cannot-complete-command))))
+ 
+      ((and (= 1 (length ido-matches))
+          (not (and ido-enable-tramp-completion
+                    (string-equal ido-current-directory "/")
+                    (string-match "..[@:]\\'" (car ido-matches)))))
+       ;; only one choice, so select it.
+       (if (not ido-confirm-unique-completion)
+         (exit-minibuffer)
+       (setq ido-rescan (not ido-enable-prefix))
+       (delete-region (minibuffer-prompt-end) (point))
+       (insert (car ido-matches))))
+ 
+      (t ;; else there could be some completions
+       (setq res ido-common-match-string)
+       (if (and (not (memq res '(t nil)))
+              (not (equal res ido-text)))
+         ;; found something to complete, so put it in the minibuffer.
+         (progn
+           ;; move exact match to front if not in prefix mode
+           (setq ido-rescan (not ido-enable-prefix))
+           (delete-region (minibuffer-prompt-end) (point))
+           (insert res))
+       ;; else nothing to complete
+       (call-interactively (setq this-command ido-cannot-complete-command))
+       )))))
+ 
+ (defun ido-complete-space ()
+   "Try completion unless inserting the space makes sense."
+   (interactive)
+   (if (and (stringp ido-common-match-string)
+          (stringp ido-text)
+          (cond
+           ((> (length ido-common-match-string) (length ido-text))
+            (= (aref ido-common-match-string (length ido-text)) ? ))
+           (ido-matches
+            (let (insert-space
+                  (re (concat (regexp-quote ido-text) " "))
+                  (comp ido-matches))
+              (while comp
+                (if (string-match re (ido-name (car comp)))
+                    (setq comp nil insert-space t)
+                  (setq comp (cdr comp))))
+              insert-space))
+           (t nil)))
+       (insert " ")
+     (ido-complete)))
+ 
+ (defun ido-undo-merge-work-directory (&optional text try refresh)
+   "Undo or redo last ido directory merge operation.
+ If no merge has yet taken place, toggle automatic merging option."
+   (interactive)
+   (cond
+    (ido-pre-merge-state
+     (ido-set-current-directory (nth 1 ido-pre-merge-state))
+     (setq ido-text-init (or text (car ido-pre-merge-state))
+         ido-cur-list (nth 2 ido-pre-merge-state)
+         ido-ignored-list (nth 3 ido-pre-merge-state)
+         ido-matches (nth 4 ido-pre-merge-state)
+         ido-use-merged-list nil
+         ido-try-merged-list try
+         ido-keep-item-list (not refresh)
+         ido-rescan nil
+         ido-exit 'refresh
+         ido-pre-merge-state nil)
+     (exit-minibuffer))
+    (text
+     nil)
+    (ido-try-merged-list
+     (setq ido-try-merged-list nil))
+    (ido-matches
+     (setq ido-try-merged-list t))
+    ((not ido-use-merged-list)
+     (ido-merge-work-directories))))
+ 
+ ;;; TOGGLE FUNCTIONS
+ 
+ (defun ido-toggle-case ()
+   "Toggle the value of `ido-case-fold'."
+   (interactive)
+   (setq ido-case-fold (not ido-case-fold))
+   ;; ask for list to be regenerated.
+   (setq ido-rescan t))
+ 
+ (defun ido-toggle-regexp ()
+   "Toggle the value of `ido-enable-regexp'."
+   (interactive)
+   (setq ido-enable-regexp (not ido-enable-regexp))
+   ;; ask for list to be regenerated.
+   (setq ido-rescan t))
+ 
+ (defun ido-toggle-prefix ()
+   "Toggle the value of `ido-enable-prefix'."
+   (interactive)
+   (setq ido-enable-prefix (not ido-enable-prefix))
+   ;; ask for list to be regenerated.
+   (setq ido-rescan t))
+ 
+ (defun ido-toggle-ignore ()
+   "Toggle ignoring files specified with `ido-ignore-files'."
+   (interactive)
+   (setq ido-process-ignore-lists (not ido-process-ignore-lists))
+   (setq ido-text-init ido-text)
+   (setq ido-exit 'refresh)
+   (exit-minibuffer))
+ 
+ (defun ido-toggle-vc ()
+   "Disable version control for this file."
+   (interactive)
+   (if (and ido-mode (eq ido-cur-item 'file))
+       (progn
+       (setq vc-handled-backends
+             (if vc-handled-backends nil ido-saved-vc-hb))
+       (setq ido-text-init ido-text)
+       (setq ido-exit 'keep)
+       (exit-minibuffer))))
+ 
+ (defun ido-toggle-literal ()
+   "Toggle literal reading of this file."
+   (interactive)
+   (if (and ido-mode (eq ido-cur-item 'file))
+       (progn
+       (setq ido-find-literal (not ido-find-literal))
+       (setq ido-text-init ido-text)
+       (setq ido-exit 'keep)
+       (exit-minibuffer))))
+ 
+ (defun ido-reread-directory ()
+   "Read current directory again.
+ May be useful if cached version is no longer valid, but directory
+ timestamp has not changed (e.g. with ftp or on Windows)."
+   (interactive)
+   (if (and ido-mode (eq ido-cur-item 'file))
+       (progn
+       (ido-remove-cached-dir ido-current-directory)
+       (setq ido-text-init ido-text)
+       (setq ido-rotate-temp t)
+       (setq ido-exit 'refresh)
+       (exit-minibuffer))))
+ 
+ (defun ido-exit-minibuffer ()
+   "Exit minibuffer, but make sure we have a match if one is needed."
+   (interactive)
+   (if (or (not ido-require-match)
+          (ido-existing-item-p))
+       (throw 'exit nil)))
+ 
+ (defun ido-select-text ()
+   "Select the buffer or file named by the prompt.
+ If no buffer or file exactly matching the prompt exists, maybe create a new 
one."
+   (interactive)
+   (setq ido-exit 'takeprompt)
+   (exit-minibuffer))
+ 
+ (defun ido-fallback-command ()
+   "Fallback to non-ido version of current command."
+   (interactive)
+   (setq ido-exit 'fallback)
+   (exit-minibuffer))
+ 
+ (defun ido-enter-find-file ()
+   "Drop into find-file from buffer switching."
+   (interactive)
+   (setq ido-exit 'findfile)
+   (exit-minibuffer))
+ 
+ (defun ido-enter-switch-buffer ()
+   "Drop into ido-switch-buffer from file switching."
+   (interactive)
+   (setq ido-exit 'findbuffer)
+   (exit-minibuffer))
+ 
+ (defun ido-enter-dired ()
+   "Drop into dired from file switching."
+   (interactive)
+   (setq ido-exit 'dired)
+   (exit-minibuffer))
+ 
+ 
+ (defun ido-up-directory (&optional clear)
+   "Go up one directory level."
+   (interactive "P")
+   (setq ido-text-init (if clear nil ido-text))
+   (setq ido-exit 'updir)
+   (setq ido-rotate-temp t)
+   (exit-minibuffer))
+ 
+ (defun ido-delete-backward-updir (count)
+   "Delete char backwards, or at beginning of buffer, go up one level."
+   (interactive "P")
+   (cond
+    ((= (minibuffer-prompt-end) (point))
+     (if (not count)
+       (ido-up-directory t)))
+    ((and ido-pre-merge-state (string-equal (car ido-pre-merge-state) 
ido-text))
+     (ido-undo-merge-work-directory (substring ido-text 0 -1) t t))
+    ((eq this-original-command 'viper-backward-char)
+     (funcall this-original-command (prefix-numeric-value count)))
+    ((eq this-original-command 'viper-del-backward-char-in-insert)
+     (funcall this-original-command))
+    (t
+     (delete-backward-char (prefix-numeric-value count)))))
+ 
+ (defun ido-delete-backward-word-updir (count)
+   "Delete all chars backwards, or at beginning of buffer, go up one level."
+   (interactive "P")
+   (if (= (minibuffer-prompt-end) (point))
+       (if (not count)
+         (ido-up-directory t))
+     (if (eq this-original-command 'viper-delete-backward-word)
+       (funcall this-original-command (prefix-numeric-value count))
+       (backward-kill-word (prefix-numeric-value count)))))
+ 
+ (defun ido-get-work-directory (&optional incr must-match)
+   (let ((n (length ido-work-directory-list))
+       (i ido-work-directory-index)
+       (j 0)
+       dir)
+     (if (or (not ido-text) (= (length ido-text) 0))
+       (setq must-match nil))
+     (while (< j n)
+       (setq i (+ i incr)
+           j (1+ j))
+       (if (> incr 0)
+         (if (>= i n) (setq i 0))
+       (if (< i 0) (setq i (1- n))))
+       (setq dir (nth i ido-work-directory-list))
+       (if (and dir
+              (not (equal dir ido-current-directory))
+              (file-directory-p dir)
+              (or (not must-match)
+                  (ido-set-matches1
+                   (if (eq ido-cur-item 'file)
+                       (ido-make-file-list1 dir)
+                     (ido-make-dir-list1 dir)))))
+         (setq j n)
+       (setq dir nil)))
+     (if dir
+       (setq ido-work-directory-index i))
+     dir))
+ 
+ (defun ido-prev-work-directory ()
+   "Change to next working directory in list."
+   (interactive)
+   (let ((dir (ido-get-work-directory 1 ido-work-directory-match-only)))
+     (when dir
+       (ido-set-current-directory dir)
+       (setq ido-exit 'refresh)
+       (setq ido-text-init ido-text)
+       (setq ido-rotate-temp t)
+       (exit-minibuffer))))
+ 
+ (defun ido-next-work-directory ()
+   "Change to previous working directory in list."
+   (interactive)
+   (let ((dir (ido-get-work-directory -1 ido-work-directory-match-only)))
+     (when dir
+       (ido-set-current-directory dir)
+       (setq ido-exit 'refresh)
+       (setq ido-text-init ido-text)
+       (setq ido-rotate-temp t)
+       (exit-minibuffer))))
+ 
+ (defun ido-merge-work-directories ()
+   "Search (and merge) work directories for files matching the current input 
string."
+   (interactive)
+   (setq ido-use-merged-list t ido-try-merged-list t)
+   (setq ido-exit 'refresh)
+   (setq ido-text-init ido-text)
+   (setq ido-rotate-temp t)
+   (exit-minibuffer))
+ 
+ (defun ido-wide-find-file (&optional file)
+   "Prompt for FILE to search for using find, starting from current directory."
+   (interactive)
+   (unless file
+     (let ((enable-recursive-minibuffers t))
+       (setq file
+           (read-string (concat "Wide find file: " ido-current-directory) 
ido-text))))
+   (when (> (length file) 0)
+     (setq ido-use-merged-list t ido-try-merged-list 'wide)
+     (setq ido-exit 'refresh)
+     (setq ido-text-init file)
+     (setq ido-rotate-temp t)
+     (exit-minibuffer)))
+ 
+ (defun ido-wide-find-dir (&optional dir)
+   "Prompt for DIR to search for using find, starting from current directory."
+   (interactive)
+   (unless dir
+     (let ((enable-recursive-minibuffers t))
+       (setq dir
+           (read-string (concat "Wide find directory: " ido-current-directory) 
ido-text))))
+   (when (> (length dir) 0)
+     (setq ido-use-merged-list t ido-try-merged-list 'wide)
+     (setq ido-exit 'refresh)
+     (setq ido-text-init (ido-final-slash dir t))
+     (setq ido-rotate-temp t)
+     (exit-minibuffer)))
+ 
+ (defun ido-make-directory (&optional dir)
+   "Prompt for DIR to create in current directory."
+   (interactive)
+   (unless dir
+     (let ((enable-recursive-minibuffers t))
+       (setq dir
+           (read-string (concat "Make directory: " ido-current-directory) 
ido-text))))
+   (when (> (length dir) 0)
+     (setq dir (concat ido-current-directory dir))
+     (unless (file-exists-p dir)
+       (make-directory dir t)
+       (ido-set-current-directory dir)
+       (setq ido-exit 'refresh)
+       (setq ido-text-init nil)
+       (setq ido-rotate-temp t)
+       (exit-minibuffer))))
+ 
+ (defun ido-get-work-file (incr)
+   (let ((n (length ido-work-file-list))
+       (i (+ ido-work-file-index incr))
+       name)
+     (if (> incr 0)
+       (if (>= i n) (setq i 0))
+       (if (< i 0) (setq i (1- n))))
+     (setq name (nth i ido-work-file-list))
+     (setq ido-work-file-index i)
+     name))
+ 
+ (defun ido-prev-work-file ()
+   "Change to next working file name in list."
+   (interactive)
+   (let ((name (ido-get-work-file 1)))
+     (when name
+       (setq ido-text-init name)
+       (setq ido-exit 'refresh)
+       (exit-minibuffer))))
+ 
+ (defun ido-next-work-file ()
+   "Change to previous working file name in list."
+   (interactive)
+   (let ((name (ido-get-work-file -1)))
+     (when name
+       (setq ido-text-init name)
+       (setq ido-exit 'refresh)
+       (exit-minibuffer))))
+ 
+ (defun ido-copy-current-file-name (all)
+   "Insert file name of current buffer.
+ If repeated, insert text from buffer instead."
+   (interactive "P")
+   (let* ((bfname (buffer-file-name ido-entry-buffer))
+        (name (and bfname (file-name-nondirectory bfname))))
+     (when name
+       (setq ido-text-init
+           (if (or all
+                   (not (equal (file-name-directory bfname) 
ido-current-directory))
+                   (not (string-match "\\.[^.]*\\'" name)))
+               name
+           (substring name 0 (1+ (match-beginning 0)))))
+       (setq ido-exit 'refresh
+           ido-try-merged-list nil)
+       (exit-minibuffer))))
+ 
+ (defun ido-copy-current-word (all)
+   "Insert current word (file or directory name) from current buffer."
+   (interactive "P")
+   (let ((word (save-excursion
+               (set-buffer ido-entry-buffer)
+               (let ((p (point)) start-line end-line start-name name)
+                 (beginning-of-line)
+                 (setq start-line (point))
+                 (end-of-line)
+                 (setq end-line (point))
+                 (goto-char p)
+                 (if (re-search-backward "[^-_a-zA-Z0-9:./address@hidden" 
start-line 1)
+                     (forward-char 1))
+                 (setq start-name (point))
+                 (re-search-forward "[-_a-zA-Z0-9:./address@hidden" end-line 1)
+                 (if (= start-name (point))
+                     nil
+                   (buffer-substring-no-properties start-name (point)))))))
+     (if (cond
+        ((not word) nil)
+        ((string-match "\\`[~/]" word)
+         (setq ido-text-init word
+               ido-try-merged-list nil
+               ido-exit 'chdir))
+        ((string-match "/" word)
+         (setq ido-text-init (concat ido-current-directory word)
+               ido-try-merged-list nil
+               ido-exit 'chdir))
+        (t
+         (setq ido-text-init word
+               ido-try-merged-list nil
+               ido-exit 'refresh)))
+       (exit-minibuffer))))
+ 
+ (defun ido-next-match ()
+   "Put first element of `ido-matches' at the end of the list."
+   (interactive)
+   (if ido-matches
+       (let ((next (cadr ido-matches)))
+       (setq ido-cur-list (ido-chop ido-cur-list next))
+       (setq ido-rescan t)
+       (setq ido-rotate t))))
+ 
+ (defun ido-prev-match ()
+   "Put last element of `ido-matches' at the front of the list."
+   (interactive)
+   (if ido-matches
+       (let ((prev (car (last ido-matches))))
+       (setq ido-cur-list (ido-chop ido-cur-list prev))
+       (setq ido-rescan t)
+       (setq ido-rotate t))))
+ 
+ (defun ido-next-match-dir ()
+   "Find next directory in match list.
+ If work directories have been merged, cycle through directories for
+ first matching file."
+   (interactive)
+   (if ido-use-merged-list
+       (if ido-matches
+         (let* ((elt (car ido-matches))
+                (dirs (cdr elt)))
+           (when (> (length dirs) 1)
+             (setcdr elt (ido-chop dirs (cadr dirs))))
+           (setq ido-rescan nil)))
+     (let ((cnt (length ido-matches))
+         (i 1))
+       (while (and (< i cnt) (not (ido-final-slash (nth i ido-matches))))
+       (setq i (1+ i)))
+       (if (< i cnt)
+         (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
+ 
+ (defun ido-prev-match-dir ()
+   "Find previous directory in match list.
+ If work directories have been merged, cycle through directories
+ for first matching file."
+   (interactive)
+   (if ido-use-merged-list
+       (if ido-matches
+         (let* ((elt (car ido-matches))
+                (dirs (cdr elt)))
+           (when (> (length dirs) 1)
+             (setcdr elt (ido-chop dirs (car (last dirs)))))
+           (setq ido-rescan nil)))
+     (let* ((cnt (length ido-matches))
+          (i (1- cnt)))
+       (while (and (> i 0) (not (ido-final-slash (nth i ido-matches))))
+       (setq i (1- i)))
+       (if (> i 0)
+         (setq ido-cur-list (ido-chop ido-cur-list (nth i ido-matches)))))))
+ 
+ (defun ido-restrict-to-matches ()
+   "Set current item list to the currently matched items."
+   (interactive)
+   (when ido-matches
+     (setq ido-cur-list ido-matches
+         ido-text-init ""
+         ido-rescan nil
+         ido-exit 'keep)
+     (exit-minibuffer)))
+ 
+ (defun ido-chop (items elem)
+   "Remove all elements before ELEM and put them at the end of ITEMS."
+   (let ((ret nil)
+       (next nil)
+       (sofar nil))
+     (while (not ret)
+       (setq next (car items))
+       (if (equal next elem)
+         (setq ret (append items (nreverse sofar)))
+       ;; else
+       (progn
+         (setq items (cdr items))
+         (setq sofar (cons next sofar)))))
+     ret))
+ 
+ (defun ido-name (item)
+   ;; Return file name for current item, whether in a normal list
+   ;; or a merged work directory list.
+   (if (consp item) (car item) item))
+ 
+ 
+ ;;; CREATE LIST OF ALL CURRENT FILES
+ 
+ (defun ido-all-completions ()
+   ;; Return unsorted list of all competions.
+   (let ((ido-process-ignore-lists nil))
+     (cond
+      ((eq ido-cur-item 'file)
+       (ido-make-file-list1 ido-current-directory))
+      ((eq ido-cur-item 'dir)
+       (ido-make-dir-list1 ido-current-directory))
+      ((eq ido-cur-item 'buffer)
+       (ido-make-buffer-list1))
+      (t nil))))
+ 
+ 
+ (defun ido-sort-list (items)
+   ;; Simple list of file or buffer names
+   (sort items (lambda (a b) (string-lessp (ido-no-final-slash a)
+                                         (ido-no-final-slash b)))))
+ 
+ (defun ido-sort-merged-list (items promote)
+   ;; Input is list of ("file" . "dir") cons cells.
+   ;; Output is sorted list of ("file "dir" ...) lists
+   (let ((l (sort items (lambda (a b) (string-lessp (car b) (car a)))))
+       res a cur dirs)
+     (while l
+       (setq a (car l)
+           l (cdr l))
+       (if (and res (string-equal (car (car res)) (car a)))
+         (progn
+           (setcdr (car (if cur (cdr res) res)) (cons (cdr a) (cdr (car res))))
+           (if (and promote (string-equal ido-current-directory (cdr a)))
+               (setq cur t)))
+       (setq res (cons (list (car a) (cdr a)) res)
+             cur nil)))
+     res))
+ 
+ (defun ido-wide-find-dirs-or-files (dir file &optional prefix finddir)
+   ;; As ido-run-find-command, but returns a list of cons pairs ("file" . 
"dir")
+   (let ((filenames
+        (split-string
+         (shell-command-to-string
+          (concat "find " dir " -name \"" (if prefix "" "*") file "*\" -type " 
(if finddir "d" "f") " -print"))))
+       filename d f
+       res)
+     (while filenames
+       (setq filename (car filenames)
+           filenames (cdr filenames))
+       (if (and (string-match "^/" filename)
+              (file-exists-p filename))
+         (setq d (file-name-directory filename)
+               f (file-name-nondirectory filename)
+               res (cons (cons (if finddir (ido-final-slash f t) f) d) res))))
+     res))
+ 
+ (defun ido-flatten-merged-list (items)
+   ;; Create a list of directory names based on a merged directory list.
+   (let (res)
+     (while items
+       (let* ((item (car items))
+            (file (car item))
+            (dirs (cdr item)))
+       (while dirs
+         (setq res (cons (concat (car dirs) file) res)
+               dirs (cdr dirs))))
+       (setq items (cdr items)))
+     res))
+ 
+ (defun ido-make-merged-file-list (text auto wide)
+   (let (res)
+     (message "Searching for `%s'...." text)
+     (if (and (ido-final-slash text) ido-dir-file-cache)
+       (if wide
+           (setq res (ido-wide-find-dirs-or-files
+                      ido-current-directory (substring text 0 -1) 
ido-enable-prefix t))
+         ;; Use list of cached directories
+         (let ((re (concat (regexp-quote (substring text 0 -1)) "[^/:]*/\\'"))
+               (dirs ido-dir-file-cache)
+               dir b d f)
+           (if nil ;; simple
+               (while dirs
+                 (setq dir (car (car dirs))
+                       dirs (cdr dirs))
+                 (when (and (string-match re dir)
+                            (not (ido-ignore-item-p dir 
ido-ignore-directories-merge))
+                            (file-directory-p dir))
+                   (setq b (substring dir 0 -1)
+                         f (concat (file-name-nondirectory b) "/")
+                         d (file-name-directory b)
+                         res (cons (cons f d) res))))
+             (while dirs
+               (setq dir (car dirs)
+                     d (car dir)
+                     dirs (cdr dirs))
+               (when (not (ido-ignore-item-p d ido-ignore-directories-merge))
+                 (setq dir (cdr (cdr dir)))
+                 (while dir
+                   (setq f (car dir)
+                         dir (cdr dir))
+                   (if (and (string-match re f)
+                            (not (ido-ignore-item-p f ido-ignore-directories)))
+                       (setq res (cons (cons f d) res)))))
+               (if (and auto (input-pending-p))
+                   (setq dirs nil
+                         res t))))))
+       (if wide
+         (setq res (ido-wide-find-dirs-or-files
+                    ido-current-directory text ido-enable-prefix nil))
+       (let ((ido-text text)
+             (dirs ido-work-directory-list)
+             (must-match (and text (> (length text) 0)))
+             dir fl)
+         (if (and auto (not (member ido-current-directory dirs)))
+             (setq dirs (cons ido-current-directory dirs)))
+         (while dirs
+           (setq dir (car dirs)
+                 dirs (cdr dirs))
+           (when (and dir (stringp dir)
+                      (or ido-merge-ftp-work-directories
+                          (not (ido-is-ftp-directory dir)))
+                      (file-directory-p dir)
+                      (setq fl (if (eq ido-cur-item 'file)
+                                   (ido-make-file-list1 dir t)
+                                 (ido-make-dir-list1 dir t))))
+             (if must-match
+                 (setq fl (ido-set-matches1 fl)))
+             (if fl
+                 (setq res (nconc fl res))))
+           (if (and auto (input-pending-p))
+               (setq dirs nil
+                     res t))))))
+     (if (and res (not (eq res t)))
+       (setq res (ido-sort-merged-list res auto)))
+     (when (and (or ido-rotate-temp ido-rotate-file-list-default)
+              (listp res)
+              (> (length text) 0))
+       (let ((elt (assoc text res)))
+       (when (and elt (not (eq elt (car res))))
+         (setq res (delq elt res))
+         (setq res (cons elt res)))))
+     (message nil)
+     res))
+ 
+ (defun ido-make-buffer-list1 (&optional frame visible)
+   ;; Return list of non-ignored buffer names
+   (delq nil
+       (mapcar
+        (lambda (x)
+          (let ((name (buffer-name x)))
+            (if (not (or (ido-ignore-item-p name ido-ignore-buffers) (member 
name visible)))
+                name)))
+        (buffer-list frame))))
+ 
+ (defun ido-make-buffer-list (default)
+   ;; Return the current list of buffers.
+   ;; Currently visible buffers are put at the end of the list.
+   ;; The hook `ido-make-buflist-hook' is run after the list has been
+   ;; created to allow the user to further modify the order of the buffer names
+   ;; in this list.  If DEFAULT is non-nil, and corresponds to an existing 
buffer,
+   ;; it is put to the start of the list.
+   (let* ((ido-current-buffers (ido-get-buffers-in-frames 'current))
+        (ido-temp-list (ido-make-buffer-list1 (selected-frame) 
ido-current-buffers)))
+     (if ido-temp-list
+       (nconc ido-temp-list ido-current-buffers)
+       (setq ido-temp-list ido-current-buffers))
+     (if default
+       (progn
+         (setq ido-temp-list
+               (delete default ido-temp-list))
+         (setq ido-temp-list
+               (cons default ido-temp-list))))
+     (run-hooks 'ido-make-buffer-list-hook)
+     ido-temp-list))
+ 
+ (defun ido-to-end (items)
+   ;; Move the elements from ITEMS to the end of `ido-temp-list'
+   (mapcar
+    (lambda (elem)
+      (setq ido-temp-list (delq elem ido-temp-list)))
+    items)
+   (if ido-temp-list
+       (nconc ido-temp-list items)
+     (setq ido-temp-list items)))
+ 
+ (defun ido-file-name-all-completions1 (dir)
+   (cond
+    ((ido-nonreadable-directory-p dir) '())
+    ((and ido-enable-tramp-completion
+        (string-match "\\`/\\([^/:]+:\\([^/:@address@hidden)?\\)\\'" dir))
+ 
+     ;; Trick tramp's file-name-all-completions handler to DTRT, as it
+     ;; has some pretty obscure requirements.  This seems to work...
+     ;; /ftp:          => (f-n-a-c "/ftp:" "")
+     ;; /ftp:kfs:      => (f-n-a-c "" "/ftp:kfs:")
+     ;; /ftp:kfs@      => (f-n-a-c "ftp:kfs@" "/")
+     ;; /ftp:address@hidden:  => (f-n-a-c "" "/ftp:address@hidden:")
+     ;; Currently no attempt is made to handle multi: stuff.
+ 
+     (let* ((prefix (match-string 1 dir))
+          (user-flag (match-beginning 2))
+          (len (and prefix (length prefix)))
+          compl)
+       (if user-flag
+         (setq dir (substring dir 1)))
+       (require 'tramp nil t)
+       (ido-trace "tramp complete" dir)
+       (setq compl (file-name-all-completions dir (if user-flag "/" "")))
+       (if (> len 0)
+         (mapcar (lambda (c) (substring c len)) compl)
+       compl)))
+    (t
+     (file-name-all-completions "" dir))))
+ 
+ (defun ido-file-name-all-completions (dir)
+   ;; Return name of all files in DIR
+   ;; Uses and updates ido-dir-file-cache
+   (if (and (numberp ido-max-dir-file-cache) (> ido-max-dir-file-cache 0)
+          (stringp dir) (> (length dir) 0)
+          (ido-may-cache-directory dir))
+       (let* ((cached (assoc dir ido-dir-file-cache))
+            (ctime (nth 1 cached))
+            (ftp (ido-is-ftp-directory dir))
+            (attr (if ftp nil (file-attributes dir)))
+            (mtime (nth 5 attr))
+            valid)
+       (when cached        ; should we use the cached entry ?
+         (if ftp
+             (setq valid (and (eq (car ctime) 'ftp)
+                              (ido-cache-ftp-valid (cdr ctime))))
+           (if attr
+               (setq valid (and (= (car ctime) (car mtime))
+                                (= (car (cdr ctime)) (car (cdr mtime)))))))
+         (if (not valid)
+             (setq ido-dir-file-cache (delq cached ido-dir-file-cache)
+                   cached nil)))
+       (unless cached
+         (if (and ftp (file-readable-p dir))
+             (setq mtime (cons 'ftp (ido-time-stamp))))
+         (if mtime
+             (setq cached (cons dir (cons mtime 
(ido-file-name-all-completions1 dir)))
+                   ido-dir-file-cache (cons cached ido-dir-file-cache)))
+         (if (> (length ido-dir-file-cache) ido-max-dir-file-cache)
+             (setcdr (nthcdr (1- ido-max-dir-file-cache) ido-dir-file-cache) 
nil)))
+       (and cached
+            (cdr (cdr cached))))
+     (ido-file-name-all-completions1 dir)))
+ 
+ (defun ido-remove-cached-dir (dir)
+   ;; Remove dir from ido-dir-file-cache
+   (if (and ido-dir-file-cache
+          (stringp dir) (> (length dir) 0))
+       (let ((cached (assoc dir ido-dir-file-cache)))
+       (if cached
+           (setq ido-dir-file-cache (delq cached ido-dir-file-cache))))))
+ 
+ 
+ (defun ido-make-file-list1 (dir &optional merged)
+   ;; Return list of non-ignored files in DIR
+   ;; If MERGED is non-nil, each file is cons'ed with DIR
+   (and (or (ido-is-tramp-root dir) (file-directory-p dir))
+        (delq nil
+            (mapcar
+             (lambda (name)
+               (if (not (ido-ignore-item-p name ido-ignore-files t))
+                   (if merged (cons name dir) name)))
+             (ido-file-name-all-completions dir)))))
+ 
+ (defun ido-make-file-list (default)
+   ;; Return the current list of files.
+   ;; Currently visible files are put at the end of the list.
+   ;; The hook `ido-make-file-list-hook' is run after the list has been
+   ;; created to allow the user to further modify the order of the file names
+   ;; in this list.
+   (let ((ido-temp-list (ido-make-file-list1 ido-current-directory)))
+     (setq ido-temp-list (ido-sort-list ido-temp-list))
+     (let ((default-directory ido-current-directory))
+       (ido-to-end ;; move ftp hosts and visited files to end
+        (delq nil (mapcar
+                 (lambda (x) (if (or (string-match "..:\\'" x)
+                                     (and (not (ido-final-slash x))
+                                          (get-file-buffer x))) x))
+                 ido-temp-list))))
+     (ido-to-end  ;; move . files to end
+      (delq nil (mapcar
+               (lambda (x) (if (string-equal (substring x 0 1) ".") x))
+               ido-temp-list)))
+     (if (and default (member default ido-temp-list))
+       (if (or ido-rotate-temp ido-rotate-file-list-default)
+           (unless (equal default (car ido-temp-list))
+             (let ((l ido-temp-list) k)
+               (while (and l (cdr l) (not (equal default (car (cdr l)))))
+                 (setq l (cdr l)))
+               (setq k (cdr l))
+               (setcdr l nil)
+               (nconc k ido-temp-list)
+               (setq ido-temp-list k)))
+         (setq ido-temp-list
+               (delete default ido-temp-list))
+         (setq ido-temp-list
+               (cons default ido-temp-list))))
+     (when ido-show-dot-for-dired
+       (setq ido-temp-list (delete "." ido-temp-list))
+       (setq ido-temp-list (cons "." ido-temp-list)))
+     (run-hooks 'ido-make-file-list-hook)
+     ido-temp-list))
+ 
+ (defun ido-make-dir-list1 (dir &optional merged)
+   ;; Return list of non-ignored subdirs in DIR
+   ;; If MERGED is non-nil, each subdir is cons'ed with DIR
+   (and (or (ido-is-tramp-root dir) (file-directory-p dir))
+        (delq nil
+            (mapcar
+             (lambda (name)
+               (and (ido-final-slash name) (not (ido-ignore-item-p name 
ido-ignore-directories))
+                    (if merged (cons name dir) name)))
+             (ido-file-name-all-completions dir)))))
+ 
+ (defun ido-make-dir-list (default)
+   ;; Return the current list of directories.
+   ;; The hook `ido-make-dir-list-hook' is run after the list has been
+   ;; created to allow the user to further modify the order of the
+   ;; directory names in this list.
+   (let ((ido-temp-list (ido-make-dir-list1 ido-current-directory)))
+     (setq ido-temp-list (ido-sort-list ido-temp-list))
+     (ido-to-end  ;; move . files to end
+      (delq nil (mapcar
+               (lambda (x) (if (string-equal (substring x 0 1) ".") x))
+               ido-temp-list)))
+     (if (and default (member default ido-temp-list))
+       (if (or ido-rotate-temp ido-rotate-file-list-default)
+           (unless (equal default (car ido-temp-list))
+             (let ((l ido-temp-list) k)
+               (while (and l (cdr l) (not (equal default (car (cdr l)))))
+                 (setq l (cdr l)))
+               (setq k (cdr l))
+               (setcdr l nil)
+               (nconc k ido-temp-list)
+               (setq ido-temp-list k)))
+         (setq ido-temp-list
+               (delete default ido-temp-list))
+         (setq ido-temp-list
+               (cons default ido-temp-list))))
+     (setq ido-temp-list (delete "." ido-temp-list))
+     (setq ido-temp-list (cons "." ido-temp-list))
+     (run-hooks 'ido-make-dir-list-hook)
+     ido-temp-list))
+ 
+ ;; List of the files visible in the current frame.
+ (defvar ido-bufs-in-frame)
+ 
+ (defun ido-get-buffers-in-frames (&optional current)
+   ;; Return the list of buffers that are visible in the current frame.
+   ;; If optional argument `current' is given, restrict searching to the
+   ;; current frame, rather than all frames, regardless of value of
+   ;; `ido-all-frames'.
+   (let ((ido-bufs-in-frame nil))
+     (walk-windows 'ido-get-bufname nil
+                 (if current
+                     nil
+                   ido-all-frames))
+     ido-bufs-in-frame))
+ 
+ (defun ido-get-bufname (win)
+   ;; Used by `ido-get-buffers-in-frames' to walk through all windows
+   (let ((buf (buffer-name (window-buffer win))))
+       (unless (or (member buf ido-bufs-in-frame)
+                   (member buf ido-ignore-item-temp-list))
+         ;; Only add buf if it is not already in list.
+         ;; This prevents same buf in two different windows being
+         ;; put into the list twice.
+         (setq ido-bufs-in-frame
+               (cons buf ido-bufs-in-frame)))))
+ 
+ ;;; FIND MATCHING ITEMS
+ 
+ (defun ido-set-matches1 (items &optional do-full)
+   ;; Return list of matches in items
+   (let* ((case-fold-search  ido-case-fold)
+        (slash (and (not ido-enable-prefix) (ido-final-slash ido-text)))
+        (text (if slash (substring ido-text 0 -1) ido-text))
+        (rexq (concat (if ido-enable-regexp text (regexp-quote text)) (if 
slash ".*/" "")))
+        (re (if ido-enable-prefix (concat "\\`" rexq) rexq))
+        (full-re (and do-full (not ido-enable-regexp) (not (string-match 
"\$\\'" re))
+                      (concat "\\`" re "\\'")))
+        (prefix-re (and full-re (not ido-enable-prefix)
+                        (concat "\\`" rexq)))
+        full-matches
+        prefix-matches
+        matches)
+     (mapcar
+      (lambda (item)
+        (let ((name (ido-name item)))
+        (if (string-match re name)
+            (cond
+             ((and full-re (string-match full-re name))
+              (setq full-matches (cons item full-matches)))
+             ((and prefix-re (string-match prefix-re name))
+              (setq prefix-matches (cons item prefix-matches)))
+             (t (setq matches (cons item matches))))))
+        t)
+      items)
+     (if prefix-matches
+       (setq matches (nconc prefix-matches matches)))
+     (if full-matches
+       (setq matches (nconc full-matches matches)))
+     (when (and (null matches)
+              ido-enable-flex-matching
+              (> (length ido-text) 1)
+              (not ido-enable-regexp))
+       (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
+       (if ido-enable-prefix
+         (setq re (concat "\\`" re)))
+       (mapcar
+        (lambda (item)
+        (let ((name (ido-name item)))
+          (if (string-match re name)
+              (setq matches (cons item matches)))))
+        items))
+     matches))
+ 
+ 
+ (defun ido-set-matches ()
+   ;; Set `ido-matches' to the list of items matching prompt
+   (when ido-rescan
+     (setq ido-matches (ido-set-matches1 (reverse ido-cur-list) (not 
ido-rotate))
+         ido-rotate nil)))
+ 
+ (defun ido-ignore-item-p (name re-list &optional ignore-ext)
+   ;; Return t if the buffer or file NAME should be ignored.
+   (or (member name ido-ignore-item-temp-list)
+       (and
+        ido-process-ignore-lists re-list
+        (let ((data       (match-data))
+            (ext-list   (and ignore-ext ido-ignore-extensions
+                             completion-ignored-extensions))
+            ignorep nextstr
+            (flen (length name)) slen)
+        (while ext-list
+          (setq nextstr (car ext-list))
+          (if (cond
+               ((stringp nextstr)
+                (and (>= flen (setq slen (length nextstr)))
+                     (string-equal (substring name (- flen slen)) nextstr)))
+               ((fboundp nextstr) (funcall nextstr name))
+               (t nil))
+              (setq ignorep t
+                    ext-list nil
+                    re-list nil)
+            (setq ext-list (cdr ext-list))))
+        (while re-list
+          (setq nextstr (car re-list))
+          (if (cond
+               ((stringp nextstr) (string-match nextstr name))
+               ((fboundp nextstr) (funcall nextstr name))
+               (t nil))
+              (setq ignorep t
+                    re-list nil)
+            (setq re-list (cdr re-list))))
+        ;; return the result
+        (if ignorep
+            (setq ido-ignored-list (cons name ido-ignored-list)))
+        (set-match-data data)
+        ignorep))))
+ 
+ 
+ ;; Private variable used by `ido-word-matching-substring'.
+ (defvar ido-change-word-sub)
+ 
+ (defun ido-find-common-substring (items subs)
+   ;; Return common string following SUBS in each element of ITEMS.
+   (let (res
+         alist
+         ido-change-word-sub)
+     (setq ido-change-word-sub
+           (if ido-enable-regexp
+               subs
+             (regexp-quote subs)))
+     (setq res (mapcar #'ido-word-matching-substring items))
+     (setq res (delq nil res)) ;; remove any nil elements (shouldn't happen)
+     (setq alist (mapcar #'ido-makealist res)) ;; could use an  OBARRAY
+ 
+     ;; try-completion returns t if there is an exact match.
+     (let* ((completion-ignore-case ido-case-fold)
+          (comp (try-completion subs alist)))
+       (if (eq comp t)
+         subs
+       comp))))
+ 
+ (defun ido-word-matching-substring (word)
+   ;; Return part of WORD before 1st match to `ido-change-word-sub'.
+   ;; If `ido-change-word-sub' cannot be found in WORD, return nil.
+   (let ((case-fold-search ido-case-fold))
+     (let ((m (string-match ido-change-word-sub (ido-name word))))
+       (if m
+           (substring (ido-name word) m)
+         ;; else no match
+         nil))))
+ 
+ (defun ido-makealist (res)
+   ;; Return dotted pair (RES . 1).
+   (cons res 1))
+ 
+ (defun ido-choose-completion-string (choice buffer mini-p base-size)
+   (when (ido-active)
+     ;; Insert the completion into the buffer where completion was requested.
+     (if (get-buffer ido-completion-buffer)
+       (kill-buffer ido-completion-buffer))
+     (cond
+      ((ido-active t) ;; ido-use-merged-list
+       (setq ido-current-directory ""
+           ido-text choice
+           ido-exit 'done))
+      ((not (ido-final-slash choice))
+       (setq ido-text choice
+           ido-exit 'done))
+      (t
+       (ido-set-current-directory ido-current-directory choice)
+       (setq ido-exit 'refresh)))
+     (exit-minibuffer)
+     t))
+ 
+ (defun ido-completion-help ()
+   "Show possible completions in a *File Completions* buffer."
+   (interactive)
+   (setq ido-rescan nil)
+   (let ((temp-buf (get-buffer ido-completion-buffer))
+       display-it full-list)
+     (if (and (eq last-command this-command) temp-buf)
+       ;; scroll buffer
+       (let (win (buf (current-buffer)))
+         (display-buffer temp-buf nil nil)
+         (set-buffer temp-buf)
+         (setq win (get-buffer-window temp-buf))
+         (if (pos-visible-in-window-p (point-max) win)
+             (if (or ido-completion-buffer-all-completions (boundp 
'ido-completion-buffer-full))
+                 (set-window-start win (point-min))
+               (set (make-local-variable 'ido-completion-buffer-full) t)
+               (setq full-list t
+                     display-it t))
+           (scroll-other-window))
+         (set-buffer buf))
+       (setq display-it t))
+     (if display-it
+       (with-output-to-temp-buffer ido-completion-buffer
+         (let ((completion-list (ido-sort-list
+                                 (cond
+                                  (ido-use-merged-list
+                                   (ido-flatten-merged-list (or ido-matches 
ido-cur-list)))
+                                  ((or full-list 
ido-completion-buffer-all-completions)
+                                   (ido-all-completions))
+                                  (t
+                                   (copy-sequence (or ido-matches 
ido-cur-list)))))))
+           (if (featurep 'xemacs)
+               ;; XEmacs extents are put on by default, doesn't seem to be
+               ;; any way of switching them off.
+               ;; This obscure code avoids a byte compiler warning in Emacs.
+               (let ((f 'display-completion-list))
+                 (funcall f completion-list
+                          :help-string "ido "
+                          :activate-callback
+                          '(lambda (x y z) (message "doesn't work yet, 
sorry!"))))
+             ;; else running Emacs
+             ;;(add-hook 'completion-setup-hook 'completion-setup-function)
+             (display-completion-list completion-list)))))))
+ 
+ ;;; KILL CURRENT BUFFER
+ (defun ido-kill-buffer-at-head ()
+   "Kill the buffer at the head of `ido-matches'."
+   (interactive)
+   (let ((enable-recursive-minibuffers t)
+       (buf (car ido-matches)))
+     (when buf
+       (kill-buffer buf)
+       ;; Check if buffer still exists.
+       (if (get-buffer buf)
+         ;; buffer couldn't be killed.
+         (setq ido-rescan t)
+       ;; else buffer was killed so remove name from list.
+       (setq ido-cur-list (delq buf ido-cur-list))))))
+ 
+ ;;; DELETE CURRENT FILE
+ (defun ido-delete-file-at-head ()
+   "Delete the file at the head of `ido-matches'."
+   (interactive)
+   (let ((enable-recursive-minibuffers t)
+       (file (car ido-matches)))
+     (if file
+       (setq file (concat ido-current-directory file)))
+     (when (and file
+              (file-exists-p file)
+              (not (file-directory-p file))
+              (file-writable-p ido-current-directory)
+              (yes-or-no-p (concat "Delete " file " ")))
+       (delete-file file)
+       ;; Check if file still exists.
+       (if (file-exists-p file)
+         ;; file could not be deleted
+         (setq ido-rescan t)
+       ;; else file was killed so remove name from list.
+       (setq ido-cur-list (delq (car ido-matches) ido-cur-list))))))
+ 
+ 
+ ;;; VISIT CHOSEN BUFFER
+ (defun ido-visit-buffer (buffer method &optional record)
+   "Visit file named FILE according to METHOD.
+ Record command in command-history if optional RECORD is non-nil."
+ 
+   (let (win newframe)
+     (cond
+      ((eq method 'kill)
+       (if record
+         (ido-record-command 'kill-buffer buffer))
+       (kill-buffer buffer))
+ 
+      ((eq method 'samewindow)
+       (if record
+         (ido-record-command 'switch-to-buffer buffer))
+       (switch-to-buffer buffer))
+ 
+      ((memq method '(always-frame maybe-frame))
+       (cond
+        ((and window-system
+            (setq win (ido-window-buffer-p buffer))
+            (or (eq method 'always-frame)
+                (y-or-n-p "Jump to frame? ")))
+       (setq newframe (window-frame win))
+       (if (fboundp 'select-frame-set-input-focus)
+           (select-frame-set-input-focus newframe)
+         (raise-frame newframe)
+         (select-frame newframe)
+         (unless (featurep 'xemacs)
+           (set-mouse-position (selected-frame) (1- (frame-width)) 0)))
+       (select-window win))
+        (t
+       ;;  No buffer in other frames...
+       (if record
+           (ido-record-command 'switch-to-buffer buffer))
+       (switch-to-buffer buffer)
+       )))
+ 
+      ((eq method 'otherwindow)
+       (if record
+         (ido-record-command 'switch-to-buffer buffer))
+       (switch-to-buffer-other-window buffer))
+ 
+      ((eq method 'display)
+       (display-buffer buffer))
+ 
+      ((eq method 'otherframe)
+       (switch-to-buffer-other-frame buffer)
+       (unless (featurep 'xemacs)
+       (select-frame-set-input-focus (selected-frame)))
+       ))))
+ 
+ 
+ (defun ido-window-buffer-p  (buffer)
+   ;; Return window pointer if BUFFER is visible in another frame.
+   ;; If BUFFER is visible in the current frame, return nil.
+   (let ((blist (ido-get-buffers-in-frames 'current)))
+     ;;If the buffer is visible in current frame, return nil
+     (if (member buffer blist)
+       nil
+       ;;  maybe in other frame or icon
+       (get-buffer-window buffer 0) ; better than 'visible
+       )))
+ 
+ 
+ ;;; ----------- IDONIZED FUNCTIONS ------------
+ 
+ ;;;###autoload
+ (defun ido-switch-buffer ()
+   "Switch to another buffer.
+ The buffer is displayed according to `ido-default-buffer-method' -- the
+ default is to show it in the same window, unless it is already visible
+ in another frame.
+ 
+ As you type in a string, all of the buffers matching the string are
+ displayed if substring-matching is used \(default). Look at
+ `ido-enable-prefix' and `ido-toggle-prefix'. When you have found the
+ buffer you want, it can then be selected. As you type, most keys have their
+ normal keybindings, except for the following: \\<ido-mode-map>
+ 
+ RET Select the buffer at the front of the list of matches.  If the
+ list is empty, possibly prompt to create new buffer.
+ 
+ \\[ido-select-text] Select the current prompt as the buffer.
+ If no buffer is found, prompt for a new one.
+ 
+ \\[ido-next-match] Put the first element at the end of the list.
+ \\[ido-prev-match] Put the last element at the start of the list.
+ \\[ido-complete] Complete a common suffix to the current string that
+ matches all buffers.  If there is only one match, select that buffer.
+ If there is no common suffix, show a list of all matching buffers
+ in a separate window.
+ \\[ido-edit-input] Edit input string.
+ \\[ido-fallback-command] Fallback to non-ido version of current command.
+ \\[ido-toggle-regexp] Toggle regexp searching.
+ \\[ido-toggle-prefix] Toggle between substring and prefix matching.
+ \\[ido-toggle-case] Toggle case-sensitive searching of buffer names.
+ \\[ido-completion-help] Show list of matching buffers in separate window.
+ \\[ido-enter-find-file] Drop into ido-find-file.
+ \\[ido-kill-buffer-at-head] Kill buffer at head of buffer list.
+ \\[ido-toggle-ignore] Toggle ignoring buffers listed in `ido-ignore-buffers'."
+   (interactive)
+   (ido-buffer-internal ido-default-buffer-method))
+ 
+ ;;;###autoload
+ (defun ido-switch-buffer-other-window ()
+   "Switch to another buffer and show it in another window.
+ The buffer name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido'."
+   (interactive)
+   (ido-buffer-internal 'otherwindow 'switch-to-buffer-other-window))
+ 
+ ;;;###autoload
+ (defun ido-display-buffer ()
+   "Display a buffer in another window but don't select it.
+ The buffer name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido'."
+   (interactive)
+   (ido-buffer-internal 'display 'display-buffer))
+ 
+ ;;;###autoload
+ (defun ido-kill-buffer ()
+   "Kill a buffer.
+ The buffer name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido'."
+   (interactive)
+   (ido-buffer-internal 'kill 'kill-buffer "Kill buffer: " (buffer-name 
(current-buffer))))
+ 
+ ;;;###autoload
+ (defun ido-insert-buffer ()
+   "Insert contents of a buffer in current buffer after point.
+ The buffer name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido'."
+   (interactive)
+   (ido-buffer-internal 'insert 'insert-buffer "Insert buffer: "))
+ 
+ ;;;###autoload
+ (defun ido-switch-buffer-other-frame ()
+   "Switch to another buffer and show it in another frame.
+ The buffer name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido'."
+   (interactive)
+   (if ido-mode
+       (ido-buffer-internal 'otherframe)
+     (call-interactively 'switch-to-buffer-other-frame)))
+ 
+ ;;;###autoload
+ (defun ido-find-file-in-dir (dir)
+   "Switch to another file starting from DIR."
+   (interactive "DDir: ")
+   (if (not (equal (substring dir -1) "/"))
+       (setq dir (concat dir "/")))
+   (ido-file-internal ido-default-file-method nil dir))
+ 
+ ;;;###autoload
+ (defun ido-find-file ()
+   "Edit file with name obtained via minibuffer.
+ The file is displayed according to `ido-default-file-method' -- the
+ default is to show it in the same window, unless it is already
+ visible in another frame.
+ 
+ The file name is selected interactively by typing a substring. As you type
+ in a string, all of the filenames matching the string are displayed if
+ substring-matching is used \(default). Look at `ido-enable-prefix' and
+ `ido-toggle-prefix'. When you have found the filename you want, it can
+ then be selected. As you type, most keys have their normal keybindings,
+ except for the following: \\<ido-mode-map>
+ 
+ RET Select the file at the front of the list of matches.  If the
+ list is empty, possibly prompt to create new file.
+ 
+ \\[ido-select-text] Select the current prompt as the buffer or file.
+ If no buffer or file is found, prompt for a new one.
+ 
+ \\[ido-next-match] Put the first element at the end of the list.
+ \\[ido-prev-match] Put the last element at the start of the list.
+ \\[ido-complete] Complete a common suffix to the current string that
+ matches all files.  If there is only one match, select that file.
+ If there is no common suffix, show a list of all matching files
+ in a separate window.
+ \\[ido-edit-input] Edit input string (including directory).
+ \\[ido-prev-work-directory] or \\[ido-next-work-directory] go to 
previous/next directory in work directory history.
+ \\[ido-merge-work-directories] search for file in the work directory history.
+ \\[ido-forget-work-directory] removes current directory from the work 
directory history.
+ \\[ido-prev-work-file] or \\[ido-next-work-file] cycle through the work file 
history.
+ \\[ido-wide-find-file] and \\[ido-wide-find-dir] prompts and uses find to 
locate files or directories.
+ \\[ido-make-directory] prompts for a directory to create in current directory.
+ \\[ido-fallback-command] Fallback to non-ido version of current command.
+ \\[ido-toggle-regexp] Toggle regexp searching.
+ \\[ido-toggle-prefix] Toggle between substring and prefix matching.
+ \\[ido-toggle-case] Toggle case-sensitive searching of file names.
+ \\[ido-toggle-vc] Toggle version control for this file.
+ \\[ido-toggle-literal] Toggle literal reading of this file.
+ \\[ido-completion-help] Show list of matching files in separate window.
+ \\[ido-toggle-ignore] Toggle ignoring files listed in `ido-ignore-files'."
+ 
+   (interactive)
+   (ido-file-internal ido-default-file-method))
+ 
+ ;;;###autoload
+ (defun ido-find-file-other-window ()
+   "Switch to another file and show it in another window.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'otherwindow 'find-file-other-window))
+ 
+ ;;;###autoload
+ (defun ido-find-alternate-file ()
+   "Switch to another file and show it in another window.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'alt-file 'find-alternate-file nil "Find alternate file: 
"))
+ 
+ ;;;###autoload
+ (defun ido-find-file-read-only ()
+   "Edit file read-only with name obtained via minibuffer.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'read-only 'find-file-read-only nil "Find file 
read-only: "))
+ 
+ ;;;###autoload
+ (defun ido-find-file-read-only-other-window ()
+   "Edit file read-only in other window with name obtained via minibuffer.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'read-only 'find-file-read-only-other-window nil "Find 
file read-only other window: "))
+ 
+ ;;;###autoload
+ (defun ido-find-file-read-only-other-frame ()
+   "Edit file read-only in other frame with name obtained via minibuffer.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'read-only 'find-file-read-only-other-frame nil "Find 
file read-only other frame: "))
+ 
+ ;;;###autoload
+ (defun ido-display-file ()
+   "Display a file in another window but don't select it.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'display))
+ 
+ ;;;###autoload
+ (defun ido-find-file-other-frame ()
+   "Switch to another file and show it in another frame.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'otherframe 'find-file-other-frame))
+ 
+ ;;;###autoload
+ (defun ido-write-file ()
+   "Write current buffer to a file.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (let ((ido-process-ignore-lists t)
+       (ido-work-directory-match-only nil)
+       (ido-ignore-files (cons "[^/]\\'" ido-ignore-files))
+       (ido-report-no-match nil)
+       (ido-confirm-unique-completion t)
+       (ido-auto-merge-work-directories-length -1))
+     (ido-file-internal 'write 'write-file nil "Write file: ")))
+ 
+ ;;;###autoload
+ (defun ido-insert-file ()
+   "Insert contents of file in current buffer.
+ The file name is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (ido-file-internal 'insert 'insert-file nil "Insert file: "))
+ 
+ ;;;###autoload
+ (defun ido-dired ()
+   "Call dired the ido way.
+ The directory is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (let ((ido-report-no-match nil)
+       (ido-auto-merge-work-directories-length -1))
+     (ido-file-internal 'dired 'dired nil "Dired: " 'dir)))
+ 
+ (defun ido-list-directory ()
+   "Call list-directory the ido way.
+ The directory is selected interactively by typing a substring.
+ For details of keybindings, do `\\[describe-function] ido-find-file'."
+   (interactive)
+   (let ((ido-report-no-match nil)
+       (ido-auto-merge-work-directories-length -1))
+     (ido-file-internal 'list-directory 'list-directory nil "List directory: " 
'dir)))
+ 
+ ;;; XEmacs hack for showing default buffer
+ 
+ ;; The first time we enter the minibuffer, Emacs puts up the default
+ ;; buffer to switch to, but XEmacs doesn't -- presumably there is a
+ ;; subtle difference in the two versions of post-command-hook.  The
+ ;; default is shown for both whenever we delete all of our text
+ ;; though, indicating its just a problem the first time we enter the
+ ;; function.  To solve this, we use another entry hook for emacs to
+ ;; show the default the first time we enter the minibuffer.
+ 
+ 
+ ;;; ICOMPLETE TYPE CODE
+ 
+ (defun ido-initiate-auto-merge (buffer)
+   (ido-trace "\n*merge timeout*" buffer)
+   (setq ido-auto-merge-timer nil)
+   (when (and (buffer-live-p buffer)
+            (= ido-use-mycompletion-depth (minibuffer-depth))
+            (boundp 'ido-eoinput) ido-eoinput)
+     (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) 
ido-eoinput)))
+       (ido-trace "request merge")
+       (setq ido-use-merged-list 'auto
+           ido-text-init contents
+           ido-rotate-temp t
+           ido-exit 'refresh)
+       (save-excursion
+       (set-buffer buffer)
+       (ido-tidy))
+       (throw 'ido contents))))
+ 
+ (defun ido-exhibit ()
+   "Post command hook for `ido'."
+   ;; Find matching files and display a list in the minibuffer.
+   ;; Copied from `icomplete-exhibit' with two changes:
+   ;; 1. It prints a default file name when there is no text yet entered.
+   ;; 2. It calls my completion routine rather than the standard completion.
+ 
+   (when (= ido-use-mycompletion-depth (minibuffer-depth))
+     (let ((contents (buffer-substring-no-properties (minibuffer-prompt-end) 
(point-max)))
+         (buffer-undo-list t)
+         try-single-dir-match
+         refresh)
+ 
+       (ido-trace "\nexhibit" this-command)
+       (ido-trace "dir" ido-current-directory)
+       (ido-trace "contents" contents)
+       (ido-trace "list" ido-cur-list)
+       (ido-trace "matches" ido-matches)
+       (ido-trace "rescan" ido-rescan)
+ 
+       (save-excursion
+       (goto-char (point-max))
+       ;; Register the end of input, so we know where the extra stuff 
(match-status info) begins:
+       (unless (boundp 'ido-eoinput)
+         ;; In case it got wiped out by major mode business:
+         (make-local-variable 'ido-eoinput))
+       (setq ido-eoinput (point))
+ 
+       ;; Handle explicit directory changes
+       (cond
+        ((eq ido-cur-item 'buffer)
+         )
+ 
+        ((= (length contents) 0)
+         )
+ 
+        ((= (length contents) 1)
+         (when (and (ido-is-tramp-root) (string-equal contents "/"))
+           (ido-set-current-directory ido-current-directory contents)
+           (setq refresh t))
+         )
+ 
+        ((and (string-match (if ido-enable-tramp-completion "..[:@]\\'" 
"..:\\'") contents)
+              (ido-is-root-directory)) ;; Ange-ftp or tramp
+         (ido-set-current-directory ido-current-directory contents)
+         (when (ido-is-slow-ftp-host)
+           (setq ido-exit 'fallback)
+           (exit-minibuffer))
+         (setq refresh t))
+ 
+        ((ido-final-slash contents)  ;; xxx/
+         (ido-trace "final slash" contents)
+         (cond
+          ((string-equal contents "~/")
+           (ido-set-current-home)
+           (setq refresh t))
+          ((string-equal contents "../")
+           (ido-up-directory t)
+           (setq refresh t))
+          ((string-equal contents "./")
+           (setq refresh t))
+          ((string-match "\\`~[a-zA-Z0-9]+/\\'" contents)
+           (ido-trace "new home" contents)
+           (ido-set-current-home contents)
+           (setq refresh t))
+          ((string-match "[$][A-Za-z0-9_]+/\\'" contents)
+           (let ((exp (condition-case ()
+                          (expand-file-name
+                           (substitute-in-file-name (substring contents 0 -1))
+                           ido-current-directory)
+                        (error nil))))
+             (ido-trace contents exp)
+             (when (and exp (file-directory-p exp))
+               (ido-set-current-directory (file-name-directory exp))
+               (setq ido-text-init (file-name-nondirectory exp))
+               (setq refresh t))))
+          ((and (memq system-type '(windows-nt ms-dos))
+                (string-equal (substring contents 1) ":/"))
+           (ido-set-current-directory (file-name-directory contents))
+           (setq refresh t))
+          ((string-equal (substring contents -2 -1) "/")
+           (ido-set-current-directory
+            (if (memq system-type '(windows-nt ms-dos))
+                (expand-file-name "/" ido-current-directory)
+              "/"))
+           (setq refresh t))
+          ((and ido-directory-nonreadable
+                (file-directory-p (concat ido-current-directory 
(file-name-directory contents))))
+           (ido-set-current-directory
+            (concat ido-current-directory (file-name-directory contents)))
+           (setq refresh t))
+          (t
+           (ido-trace "try single dir")
+           (setq try-single-dir-match t))))
+ 
+        ((and (string-equal (substring contents -2 -1) "/")
+              (not (string-match "[$]" contents)))
+         (ido-set-current-directory
+          (cond
+           ((= (length contents) 2)
+            "/")
+           (ido-matches
+            (concat ido-current-directory (car ido-matches)))
+           (t
+            (concat ido-current-directory (substring contents 0 -1)))))
+         (setq ido-text-init (substring contents -1))
+         (setq refresh t))
+ 
+        ((and (not ido-use-merged-list)
+              (not (ido-final-slash contents))
+              (eq ido-try-merged-list t)
+              (numberp ido-auto-merge-work-directories-length)
+              (> ido-auto-merge-work-directories-length 0)
+              (= (length contents) ido-auto-merge-work-directories-length)
+              (not (and ido-auto-merge-inhibit-characters-regexp
+                        (string-match ido-auto-merge-inhibit-characters-regexp 
contents)))
+              (not (input-pending-p)))
+         (setq ido-use-merged-list 'auto
+               ido-text-init contents
+               ido-rotate-temp t)
+         (setq refresh t))
+ 
+        (t nil))
+ 
+       (when refresh
+         (ido-trace "refresh on /" ido-text-init)
+         (setq ido-exit 'refresh)
+         (exit-minibuffer))
+ 
+       ;; Update the list of matches
+       (setq ido-text contents)
+       (ido-set-matches)
+       (ido-trace "new    " ido-matches)
+ 
+       (when (and ido-enter-single-matching-directory
+                  ido-matches
+                  (null (cdr ido-matches))
+                  (ido-final-slash (car ido-matches))
+                  (or try-single-dir-match
+                      (eq ido-enter-single-matching-directory t)))
+         (ido-trace "single match" (car ido-matches))
+         (ido-set-current-directory
+          (concat ido-current-directory (car ido-matches)))
+         (setq ido-exit 'refresh)
+         (exit-minibuffer))
+ 
+       (when (and (not ido-matches)
+                  (not ido-directory-nonreadable)
+                  ;; ido-rescan ?
+                  ido-process-ignore-lists
+                  ido-ignored-list)
+         (let ((ido-process-ignore-lists nil)
+               (ido-rotate ido-rotate)
+               (ido-cur-list ido-ignored-list))
+           (ido-trace "try all" ido-ignored-list)
+           (ido-set-matches))
+         (when ido-matches
+           (ido-trace "found  " ido-matches)
+           (setq ido-rescan t)
+           (setq ido-process-ignore-lists-inhibit t)
+           (setq ido-text-init ido-text)
+           (setq ido-exit 'refresh)
+           (exit-minibuffer)))
+ 
+       (when (and
+              ido-rescan
+              (not ido-matches)
+              (memq ido-cur-item '(file dir))
+              (not (ido-is-root-directory))
+              (> (length contents) 1)
+              (not (string-match "[$]" contents))
+              (not ido-directory-nonreadable))
+         (ido-trace "merge?")
+         (if ido-use-merged-list
+             (ido-undo-merge-work-directory contents nil)
+           (when (and (eq ido-try-merged-list t)
+                      (numberp ido-auto-merge-work-directories-length)
+                      (= ido-auto-merge-work-directories-length 0)
+                      (not (and ido-auto-merge-inhibit-characters-regexp
+                                (string-match 
ido-auto-merge-inhibit-characters-regexp contents)))
+                      (not (input-pending-p)))
+             (ido-trace "\n*start timer*")
+             (setq ido-auto-merge-timer
+                   (run-with-timer ido-auto-merge-delay-time nil 
'ido-initiate-auto-merge (current-buffer))))))
+ 
+       (setq ido-rescan t)
+ 
+       (if (and ido-use-merged-list
+                ido-matches
+                (not (string-equal (car (cdr (car ido-matches))) 
ido-current-directory)))
+           (progn
+             (ido-set-current-directory (car (cdr (car ido-matches))))
+             (setq ido-use-merged-list t
+                   ido-exit 'keep
+                   ido-text-init ido-text)
+             (exit-minibuffer)))
+ 
+       ;; Insert the match-status information:
+       (ido-set-common-completion)
+       (let ((inf (ido-completions
+                   contents
+                   minibuffer-completion-table
+                   minibuffer-completion-predicate
+                   (not minibuffer-completion-confirm))))
+         (ido-trace "inf" inf)
+         (insert inf))
+       ))))
+ 
+ (defun ido-completions (name candidates predicate require-match)
+   ;; Return the string that is displayed after the user's text.
+   ;; Modified from `icomplete-completions'.
+ 
+   (let* ((comps ido-matches)
+        (ind (and (consp (car comps)) (> (length (cdr (car comps))) 1)
+                  ido-merged-indicator))
+        first)
+ 
+     (if (and ind ido-use-faces)
+       (put-text-property 0 1 'face 'ido-indicator-face ind))
+ 
+     (if (and ido-use-faces comps)
+       (let* ((fn (ido-name (car comps)))
+              (ln (length fn)))
+         (setq first (format "%s" fn))
+         (put-text-property 0 ln 'face
+                            (if (= (length comps) 1)
+                                'ido-only-match-face
+                              'ido-first-match-face)
+                            first)
+         (if ind (setq first (concat first ind)))
+         (setq comps (cons first (cdr comps)))))
+ 
+     (cond ((null comps)
+          (cond
+           (ido-directory-nonreadable
+            (or (nth 8 ido-decorations) " [Not readable]"))
+           (ido-report-no-match
+            (nth 6 ido-decorations))  ;; [No match]
+           (t "")))
+ 
+         ((null (cdr comps))           ;one match
+          (concat (if (> (length (ido-name (car comps))) (length name))
+                      ;; when there is one match, show the matching file name 
in full
+                      (concat (nth 4 ido-decorations)  ;; [ ... ]
+                              (ido-name (car comps))
+                              (nth 5 ido-decorations))
+                    "")
+                  (if (not ido-use-faces) (nth 7 ido-decorations))))  ;; 
[Matched]
+         (t                            ;multiple matches
+          (let* ((items (if (> ido-max-prospects 0) (1+ ido-max-prospects) 
999))
+                 (alternatives
+                  (apply
+                   #'concat
+                   (cdr (apply
+                         #'nconc
+                         (mapcar
+                          (lambda (com)
+                            (setq com (ido-name com))
+                            (setq items (1- items))
+                            (cond
+                             ((< items 0) ())
+                             ((= items 0) (list (nth 3 ido-decorations))) ; " 
| ..."
+                             (t
+                              (list (or ido-separator (nth 2 ido-decorations)) 
; " | "
+                                    (let ((str (substring com 0)))
+                                      (if (and ido-use-faces
+                                               (not (string= str first))
+                                               (ido-final-slash str))
+                                          (put-text-property 0 (length str) 
'face 'ido-subdir-face str))
+                                      str)))))
+                          comps))))))
+ 
+            (concat
+             ;; put in common completion item -- what you get by pressing tab
+             (if (and (stringp ido-common-match-string)
+                      (> (length ido-common-match-string) (length name)))
+                 (concat (nth 4 ido-decorations)   ;; [ ... ]
+                         (substring ido-common-match-string (length name))
+                         (nth 5 ido-decorations)))
+             ;; list all alternatives
+             (nth 0 ido-decorations)  ;; { ... }
+             alternatives
+             (nth 1 ido-decorations)))))))
+ 
+ (defun ido-minibuffer-setup ()
+   "Minibuffer setup hook for `ido'."
+   ;; Copied from `icomplete-minibuffer-setup-hook'.
+   (when (and (boundp 'ido-completing-read)
+            (or (featurep 'xemacs)
+                (= ido-use-mycompletion-depth (minibuffer-depth))))
+     (add-hook 'pre-command-hook 'ido-tidy nil t)
+     (add-hook 'post-command-hook 'ido-exhibit nil t)
+     (setq cua-inhibit-cua-keys t)
+     (when (featurep 'xemacs)
+       (ido-exhibit)
+       (goto-char (point-min)))
+     (run-hooks 'ido-minibuffer-setup-hook)))
+ 
+ (defun ido-tidy ()
+   "Pre command hook for `ido'."
+   ;; Remove completions display, if any, prior to new user input.
+   ;; Copied from `icomplete-tidy'."
+ 
+   (when ido-auto-merge-timer
+     (ido-trace "\n*cancel timer*" this-command)
+     (cancel-timer ido-auto-merge-timer)
+     (setq ido-auto-merge-timer nil))
+ 
+   (if (and (boundp 'ido-use-mycompletion-depth)
+          (= ido-use-mycompletion-depth (minibuffer-depth)))
+       (if (and (boundp 'ido-eoinput)
+              ido-eoinput)
+ 
+         (if (> ido-eoinput (point-max))
+             ;; Oops, got rug pulled out from under us - reinit:
+             (setq ido-eoinput (point-max))
+           (let ((buffer-undo-list t))
+             (delete-region ido-eoinput (point-max))))
+ 
+       ;; Reestablish the local variable 'cause minibuffer-setup is weird:
+       (make-local-variable 'ido-eoinput)
+       (setq ido-eoinput 1))))
+ 
+ (defun ido-summary-buffers-to-end ()
+   ;; Move the summaries to the end of the buffer list.
+   ;; This is an example function which can be hooked on to
+   ;; `ido-make-buffer-list-hook'.  Any buffer matching the regexps
+   ;; `Summary' or `output\*$'are put to the end of the list.
+   (let ((summaries (delq nil (mapcar
+                             (lambda (x)
+                                (if (or
+                                     (string-match "Summary" x)
+                                     (string-match "output\\*\\'" x))
+                                    x))
+                             ido-temp-list))))
+     (ido-to-end summaries)))
+ 
+ ;;; Helper functions for other programs
+ 
+ (put 'dired-do-rename 'ido 'ignore)
+ 
+ ;;;###autoload
+ (defun ido-read-file-name (prompt &optional dir default-filename mustmatch 
initial predicate)
+   "Read file name, prompting with PROMPT and completing in directory DIR.
+ See `read-file-name' for additional parameters."
+   (cond
+   ((or (eq predicate 'file-directory-p)
+        (eq (get this-command 'ido) 'dir)
+        (memq this-command ido-read-file-name-as-directory-commands))
+    (ido-read-directory-name prompt dir default-filename mustmatch initial))
+   ((and (not (eq (get this-command 'ido) 'ignore))
+       (not (memq this-command ido-read-file-name-non-ido))
+       (or (null predicate) (eq predicate 'file-exists-p)))
+    (let* (filename
+         ido-saved-vc-hb
+         (vc-handled-backends (and (boundp 'vc-handled-backends) 
vc-handled-backends))
+         (ido-current-directory (ido-expand-directory dir))
+         (ido-directory-nonreadable (not (file-readable-p 
ido-current-directory)))
+         (ido-work-directory-index -1)
+         (ido-work-file-index -1)
+         (ido-find-literal nil))
+      (setq filename
+          (ido-read-internal 'file prompt 'ido-file-history default-filename 
mustmatch initial))
+      (if filename
+        (concat ido-current-directory filename))))
+   (t
+    (let ((read-file-name-function nil))
+      (read-file-name prompt dir default-filename mustmatch initial 
predicate)))))
+ 
+ ;;;###autoload
+ (defun ido-read-directory-name (prompt &optional dir default-dirname 
mustmatch initial)
+   "Read directory name, prompting with PROMPT and completing in directory DIR.
+ See `read-file-name' for additional parameters."
+   (let* (filename
+        ido-saved-vc-hb
+        (ido-current-directory (ido-expand-directory dir))
+        (ido-directory-nonreadable (not (file-readable-p 
ido-current-directory)))
+        (ido-work-directory-index -1)
+        (ido-work-file-index -1))
+     (setq filename
+         (ido-read-internal 'dir prompt 'ido-file-history default-dirname 
mustmatch initial))
+     (if filename
+       (if (and (stringp filename) (string-equal filename "."))
+           ido-current-directory
+         (concat ido-current-directory filename)))))
+ 
+ ;;; arch-tag: b63a3500-1735-41bd-8a01-05373f0864da
+ ;;; ido.el ends here




reply via email to

[Prev in Thread] Current Thread [Next in Thread]