-;;; ido.el --- interactively do things with buffers and files.
+;;; ido.el --- interactively do things with buffers and files
-;; Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
-;; 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+;; Copyright (C) 1996-2013 Free Software Foundation, Inc.
;; Author: Kim F. Storm <storm@cua.dk>
;; Based on: iswitchb by Stephen Eglen <stephen@cns.ed.ac.uk>
;; The highlighting of matching items is controlled via ido-use-faces.
;; The faces used are ido-first-match, ido-only-match and
;; ido-subdir.
-;; Colouring of the matching item was suggested by
+;; Coloring of the matching item was suggested by
;; Carsten Dominik (dominik@strw.leidenuniv.nl).
;; Replacement for read-buffer and read-file-name
;; can be used by other packages to read a buffer name, a file name,
;; or a directory name in the `ido' way.
-;;; Acknowledgements
+;;; Acknowledgments
;; Infinite amounts of gratitude goes to Stephen Eglen <stephen@cns.ed.ac.uk>
;; who wrote iswitch-buffer mode - from which I ripped off 99% of the code
;; 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,
+;; found it awkward 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
Setting this variable directly does not take effect;
use either \\[customize] or the function `ido-mode'."
- :set #'(lambda (symbol value)
+ :set #'(lambda (_symbol value)
(ido-mode value))
:initialize 'custom-initialize-default
:require 'ido
(const :tag "Show in other frame" other-frame)
(const :tag "Ask to show in other frame" maybe-frame)
(const :tag "Raise frame if already shown" raise-frame))
- :type '(choice (const selected-window)
- (const other-window)
- (const display)
- (const other-frame)
- (const maybe-frame)
- (const raise-frame))
:group 'ido)
(defcustom ido-enable-flex-matching nil
:type 'boolean
:group 'ido)
+;; See http://debbugs.gnu.org/2042 for more info.
+(defcustom ido-buffer-disable-smart-matches t
+ "Non-nil means not to re-order matches for buffer switching.
+By default, ido arranges matches in the following order:
+
+ full-matches > suffix matches > prefix matches > remaining matches
+
+which can get in the way for buffer switching."
+ :version "24.3"
+ :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]
:type 'integer
:group 'ido)
-(defcustom ido-max-directory-size 30000
+(defcustom ido-max-directory-size nil
"Maximum size (in bytes) for directories to use ido completion.
If you enter a directory with a size larger than this size, ido will
not provide the normal completion. To show the completions, use C-a."
(defcustom ido-use-virtual-buffers nil
"If non-nil, refer to past buffers as well as existing ones.
Essentially it works as follows: Say you are visiting a file and
-the buffer gets cleaned up by mignight.el. Later, you want to
+the buffer gets cleaned up by midnight.el. Later, you want to
switch to that buffer, but find it's no longer open. With
virtual buffers enabled, the buffer name stays in the buffer
list (using the `ido-virtual' face, and always at the end), and if
:type 'boolean
:group 'ido)
-(defface ido-first-match '((t (:bold t)))
+(defface ido-first-match '((t :weight bold))
"Face used by ido for highlighting first match."
:group 'ido)
(defface ido-only-match '((((class color))
- (:foreground "ForestGreen"))
- (t (:italic t)))
+ :foreground "ForestGreen")
+ (t :slant italic))
"Face used by ido for highlighting only match."
:group 'ido)
(defface ido-subdir '((((min-colors 88) (class color))
- (:foreground "red1"))
- (((class color))
- (:foreground "red"))
- (t (:underline t)))
+ :foreground "red1")
+ (((class color))
+ :foreground "red")
+ (t :underline t))
"Face used by ido for highlighting subdirs in the alternatives."
:group 'ido)
-(defface ido-virtual '((t (:inherit font-lock-builtin-face)))
+(defface ido-virtual '((t :inherit font-lock-builtin-face))
"Face used by ido for matching virtual buffer names."
:version "24.1"
:group 'ido)
-(defface ido-indicator '((((min-colors 88) (class color))
- (:foreground "yellow1"
- :background "red1"
- :width condensed))
- (((class color))
- (:foreground "yellow"
- :background "red"
- :width condensed))
- (t (:inverse-video t)))
+(defface ido-indicator '((((min-colors 88) (class color))
+ :foreground "yellow1" :background "red1" :width condensed)
+ (((class color))
+ :foreground "yellow" :background "red" :width condensed)
+ (t :inverse-video t))
"Face used by ido for highlighting its indicators."
:group 'ido)
(defface ido-incomplete-regexp
- '((t
- (:inherit font-lock-warning-face)))
+ '((t :inherit font-lock-warning-face))
"Ido face for indicating incomplete regexps."
:group 'ido)
:group 'ido)
(defvar ido-rewrite-file-prompt-rules nil
- "*Alist of rewriting rules for directory names in ido prompts.
+ "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
: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-all-frames 'visible
+ "Argument to pass to `walk-windows' when Ido is finding buffers.
+See documentation of `walk-windows' for useful values."
+ :type '(choice (const :tag "Selected frame only" nil)
+ (const :tag "All existing frames" t)
+ (const :tag "All visible frames" visible)
+ (const :tag "All frames on this terminal" 0))
+ :group 'ido)
(defcustom ido-minibuffer-setup-hook nil
"Ido-specific customization of minibuffer setup.
;; Set to 'ignore to inhibit switching between find-file/switch-buffer.
(defvar ido-context-switch-command)
+;; Dynamically bound in ido-read-internal.
+(defvar ido-completing-read)
+
;;; FUNCTIONS
(defun ido-active (&optional merge)
(defun ido-may-cache-directory (&optional dir)
(setq dir (or dir ido-current-directory))
(cond
- ((ido-directory-too-big-p dir)
- nil)
((and (ido-is-root-directory dir)
(or ido-enable-tramp-completion
(memq system-type '(windows-nt ms-dos))))
(ido-cache-unc-valid))
((ido-is-ftp-directory dir)
(ido-cache-ftp-valid))
+ ((ido-directory-too-big-p dir)
+ nil)
(t t)))
(defun ido-pp (list &optional sep)
;; ido kill emacs hook
(ido-save-history))
+(defun ido-common-initialization ()
+ (ido-init-completion-maps)
+ (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
+ (add-hook 'choose-completion-string-functions 'ido-choose-completion-string))
+
(define-minor-mode ido-everywhere
- "Toggle using ido speed-ups everywhere file and directory names are read.
-With ARG, turn ido speed-up on if arg is positive, off otherwise."
+ "Toggle use of Ido for all buffer/file reading.
+With a prefix argument ARG, enable this feature if ARG is
+positive, and disable it otherwise. If called from Lisp, enable
+the mode if ARG is omitted or nil."
:global t
:group 'ido
(when (get 'ido-everywhere 'file)
;;;###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.
+ "Toggle ido mode on or off.
+With ARG, turn ido-mode 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.
(t nil)))
(ido-everywhere (if ido-everywhere 1 -1))
- (when ido-mode
- (ido-init-completion-maps))
(when ido-mode
- (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
- (add-hook 'choose-completion-string-functions 'ido-choose-completion-string)
+ (ido-common-initialization)
(ido-load-history)
(add-hook 'kill-emacs-hook 'ido-kill-emacs-hook)
(setq ido-minor-mode-map-entry (cons 'ido-mode map))
(add-to-list 'minor-mode-map-alist ido-minor-mode-map-entry))))
- (message "Ido mode %s" (if ido-mode "enabled" "disabled")))
+ (when (called-interactively-p 'any)
+ (message "Ido mode %s" (if ido-mode "enabled" "disabled"))))
;;; IDO KEYMAP
(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:).
+ ;; connect on incomplete tramp paths (after entering just method:).
(let ((ido-enable-tramp-completion nil))
(and (ido-final-slash dir)
(not (ido-is-unc-host dir))
(defun ido-directory-too-big-p (dir)
;; Return t if dir is a directory, but too big to show
;; Do not check for non-readable directories via tramp, as this causes a premature
- ;; connect on incomplete tramp paths (after entring just method:).
+ ;; connect on incomplete tramp paths (after entering just method:).
(let ((ido-enable-tramp-completion nil))
(and (numberp ido-max-directory-size)
(ido-final-slash dir)
(not (ido-is-unc-host dir))
(file-directory-p dir)
- (> (nth 7 (file-attributes dir)) ido-max-directory-size))))
+ (> (nth 7 (file-attributes (file-truename dir))) ido-max-directory-size))))
(defun ido-set-current-directory (dir &optional subdir no-merge)
;; Set ido's current directory to DIR or DIR/SUBDIR
(unless (and ido-enable-tramp-completion
(string-match "\\`/[^/]*@\\'" dir))
(setq dir (ido-final-slash dir t))))
- (if (get-buffer ido-completion-buffer)
- (kill-buffer ido-completion-buffer))
+ (and ido-completion-buffer
+ (get-buffer ido-completion-buffer)
+ (kill-buffer ido-completion-buffer))
(cond
((equal dir ido-current-directory)
nil)
(t
(ido-trace "cd" dir)
(setq ido-current-directory dir)
- (if (get-buffer ido-completion-buffer)
- (kill-buffer ido-completion-buffer))
+ (and ido-completion-buffer
+ (get-buffer ido-completion-buffer)
+ (kill-buffer ido-completion-buffer))
(setq ido-directory-nonreadable (ido-nonreadable-directory-p dir))
(setq ido-directory-too-big (and (not ido-directory-nonreadable)
(ido-directory-too-big-p dir)))
;; 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)
+(defun ido-read-internal (item prompt hist &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.
(ido-set-matches)
(if (and ido-matches (eq ido-try-merged-list 'auto))
(setq ido-try-merged-list t))
- (let
- ((minibuffer-local-completion-map
- (if (memq ido-cur-item '(file dir))
- minibuffer-local-completion-map
- ido-completion-map))
- (minibuffer-local-filename-completion-map
- (if (memq ido-cur-item '(file dir))
- ido-completion-map
- minibuffer-local-filename-completion-map))
- (max-mini-window-height (or ido-max-window-height
- (and (boundp 'max-mini-window-height) max-mini-window-height)))
+ (let ((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))
+ (show-paren-mode nil)
+ ;; Postpone history adding till later
+ (history-add-new-input 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))
+ (read-from-minibuffer (ido-make-prompt item prompt)
+ (prog1 ido-text-init
+ (setq ido-text-init nil))
+ ido-completion-map nil hist))))
+ (ido-trace "read-from-minibuffer" ido-final-text)
+ (and ido-completion-buffer
+ (get-buffer ido-completion-buffer)
+ (kill-buffer ido-completion-buffer))
(ido-trace "\n_EXIT_" ido-exit)
(t
(setq done t))))))
+ (add-to-history (cond
+ ((consp hist)
+ (or (car hist) 'minibuffer-history))
+ (hist hist)
+ (t 'minibuffer-history))
+ ido-selected)
ido-selected))
(defun ido-edit-input ()
(ido-current-directory nil)
(ido-directory-nonreadable nil)
(ido-directory-too-big nil)
- (ido-use-virtual-buffers (if (eq method 'kill)
- nil ;; Don't consider virtual buffers for killing
- ido-use-virtual-buffers))
+ (ido-use-virtual-buffers ido-use-virtual-buffers)
(require-match (confirm-nonexistent-file-or-buffer))
(buf (ido-read-internal 'buffer (or prompt "Buffer: ") 'ido-buffer-history default
require-match initial))
(ido-record-command 'write-file filename)
(add-to-history 'file-name-history filename)
(ido-record-work-directory)
- (write-file filename))
+ (write-file filename t))
((eq method 'read-only)
(ido-record-work-file filename)
(setq ido-rotate-temp t)
(exit-minibuffer)))
-(defun ido-wide-find-dir-or-delete-dir (&optional dir)
+(defun ido-wide-find-dir-or-delete-dir (&optional _dir)
"Prompt for DIR to search for using find, starting from current directory.
If input stack is non-empty, delete current directory component."
(interactive)
ido-try-merged-list nil)
(exit-minibuffer))))
-(defun ido-copy-current-word (all)
+(defun ido-copy-current-word (_all)
"Insert current word (file or directory name) from current buffer."
(interactive "P")
(let ((word (with-current-buffer ido-entry-buffer
- (let ((p (point)) start-line end-line start-name name)
+ (let ((p (point)) start-line end-line start-name)
(if (and mark-active (/= p (mark)))
(setq start-name (mark))
(beginning-of-line)
(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))))
+ (setq ido-matches (ido-chop ido-matches next))
+ (setq ido-rescan nil))))
(defun ido-prev-match ()
"Put last element of `ido-matches' at the front of the list."
(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))))
+ (setq ido-matches (ido-chop ido-matches prev))
+ (setq ido-rescan nil))))
(defun ido-next-match-dir ()
"Find next directory in match list.
;;; CREATE LIST OF ALL CURRENT FILES
(defun ido-all-completions ()
- ;; Return unsorted list of all competions.
+ ;; Return unsorted list of all completions.
(let ((ido-process-ignore-lists nil)
(ido-directory-too-big nil))
(cond
;; 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)
+ res a cur)
(while l
(setq a (car l)
l (cdr l))
(while filenames
(setq filename (car filenames)
filenames (cdr filenames))
- (if (and (string-match "^/" filename)
+ (if (and (file-name-absolute-p filename)
(file-exists-p filename))
(setq d (file-name-directory filename)
f (file-name-nondirectory filename)
(nconc ido-temp-list items)
(setq ido-temp-list items)))
-(declare-function tramp-tramp-file-p "tramp" (name))
-
(defun ido-file-name-all-completions-1 (dir)
(cond
((ido-nonreadable-directory-p dir) '())
;; Caller must have done that if necessary.
((and ido-enable-tramp-completion
- (or (fboundp 'tramp-completion-mode-p)
- (require 'tramp nil t))
(string-match "\\`/[^/]+[:@]\\'" dir))
;; Strip method:user@host: part of tramp completions.
;; Tramp completions do not include leading slash.
;; /ftp:user@host:./ => ok
(and
(not (string= "/ftp:" dir))
- (tramp-tramp-file-p dir)
+ (file-remote-p dir)
+ ;; tramp-ftp-file-name-p is available only when tramp
+ ;; has been loaded.
(fboundp 'tramp-ftp-file-name-p)
(funcall 'tramp-ftp-file-name-p dir)
(string-match ":\\'" dir)
(rex0 (if ido-enable-regexp text (regexp-quote text)))
(rexq (concat rex0 (if slash ".*/" "")))
(re (if ido-enable-prefix (concat "\\`" rexq) rexq))
- (full-re (and do-full (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (full-re (and do-full
+ (not (and (eq ido-cur-item 'buffer)
+ ido-buffer-disable-smart-matches))
+ (not ido-enable-regexp)
+ (not (string-match "\$\\'" rex0))
(concat "\\`" rex0 (if slash "/" "") "\\'")))
(suffix-re (and do-full slash
- (not ido-enable-regexp) (not (string-match "\$\\'" rex0))
+ (not (and (eq ido-cur-item 'buffer)
+ ido-buffer-disable-smart-matches))
+ (not ido-enable-regexp)
+ (not (string-match "\$\\'" rex0))
(concat rex0 "/\\'")))
(prefix-re (and full-re (not ido-enable-prefix)
(concat "\\`" rexq)))
ido-enable-flex-matching
(> (length ido-text) 1)
(not ido-enable-regexp))
- (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
+ (setq re (mapconcat #'regexp-quote (split-string ido-text "" t) ".*"))
(if ido-enable-prefix
(setq re (concat "\\`" re)))
(mapc
(defun ido-choose-completion-string (choice &rest ignored)
(when (ido-active)
;; Insert the completion into the buffer where completion was requested.
- (if (get-buffer ido-completion-buffer)
- (kill-buffer ido-completion-buffer))
+ (and ido-completion-buffer
+ (get-buffer ido-completion-buffer)
+ (kill-buffer ido-completion-buffer))
(cond
((ido-active t) ;; ido-use-merged-list
(setq ido-current-directory ""
"Show possible completions in a *File Completions* buffer."
(interactive)
(setq ido-rescan nil)
- (let ((temp-buf (get-buffer ido-completion-buffer))
+ (let ((temp-buf (and ido-completion-buffer
+ (get-buffer ido-completion-buffer)))
display-it full-list)
(if (and (eq last-command this-command) temp-buf)
;; scroll buffer
(scroll-other-window))
(set-buffer buf))
(setq display-it t))
- (if display-it
+ (if (and ido-completion-buffer display-it)
(with-output-to-temp-buffer ido-completion-buffer
(let ((completion-list (sort
(cond
(funcall f completion-list
:help-string "ido "
:activate-callback
- '(lambda (x y z) (message "Doesn't work yet, sorry!"))))
+ (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)))))))
(let ((enable-recursive-minibuffers t)
(buf (ido-name (car ido-matches)))
(nextbuf (cadr ido-matches)))
- (when (get-buffer buf)
+ (cond
+ ((get-buffer buf)
;; If next match names a buffer use the buffer object; buffer
- ;; name may be changed by packages such as uniquify; mindful
- ;; of virtual buffers.
+ ;; name may be changed by packages such as uniquify.
(when (and nextbuf (get-buffer nextbuf))
(setq nextbuf (get-buffer nextbuf)))
(if (null (kill-buffer buf))
(setq ido-default-item nextbuf
ido-text-init ido-text
ido-exit 'refresh)
- (exit-minibuffer))))))
+ (exit-minibuffer)))
+ ;; Handle virtual buffers
+ ((assoc buf ido-virtual-buffers)
+ (setq recentf-list
+ (delete (cdr (assoc buf ido-virtual-buffers)) recentf-list))
+ (setq ido-cur-list (delete buf ido-cur-list))
+ (setq ido-rescan t))))))
;;; DELETE CURRENT FILE
(defun ido-delete-file-at-head ()
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-select-text] Use the current input string verbatim.
\\[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.
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-select-text] Use the current input string verbatim.
\\[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.
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-magic-delete-char] Open the specified directory in Dired mode.
\\[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-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'."
;; Insert the match-status information:
(ido-set-common-completion)
- (let ((inf (ido-completions
- contents
- minibuffer-completion-table
- minibuffer-completion-predicate
- (not minibuffer-completion-confirm))))
+ (let ((inf (ido-completions contents)))
(setq ido-show-confirm-message nil)
(ido-trace "inf" inf)
(insert inf))
))))
-(defun ido-completions (name candidates predicate require-match)
+(defun ido-completions (name)
;; Return the string that is displayed after the user's text.
;; Modified from `icomplete-completions'.
(concat ido-current-directory filename)))))
;;;###autoload
-(defun ido-completing-read (prompt choices &optional predicate require-match initial-input hist def)
+(defun ido-completing-read (prompt choices &optional _predicate require-match
+ initial-input hist def _inherit-input-method)
"Ido replacement for the built-in `completing-read'.
Read a string in the minibuffer with ido-style completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
CHOICES is a list of strings which are the possible completions.
-PREDICATE is currently ignored; it is included to be compatible
- with `completing-read'.
+PREDICATE and INHERIT-INPUT-METHOD is currently ignored; it is included
+ to be compatible with `completing-read'.
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
the input is (or completes to) an element of CHOICES or is null.
If the input is null, `ido-completing-read' returns DEF, or an empty
(ido-directory-too-big nil)
(ido-context-switch-command 'ignore)
(ido-choice-list choices))
+ ;; Initialize ido before invoking ido-read-internal
+ (ido-common-initialization)
(ido-read-internal 'list prompt hist def require-match initial-input)))
(defun ido-unload-function ()
(provide 'ido)
-;; arch-tag: b63a3500-1735-41bd-8a01-05373f0864da
;;; ido.el ends here