;; Names starting with "minibuffer--" are for functions and variables that
;; are meant to be for internal use only.
-;; TODO:
+;;; Todo:
+
+;; - Make read-file-name-predicate obsolete.
;; - New command minibuffer-force-complete that chooses one of all-completions.
-;; - make the `hide-spaces' arg of all-completions obsolete?
+;; - Add vc-file-name-completion-table to read-file-name-internal.
+;; - A feature like completing-help.el.
+;; - Make the `hide-spaces' arg of all-completions obsolete?
;;; Code:
argument is an element of TABLE which should be considered for completion.
STRING, PRED2, and ACTION are the usual arguments to completion tables,
as described in `try-completion', `all-completions', and `test-completion'.
-If STRICT is t, the predicate always applies, if nil it only applies if
-it doesn't reduce the set of possible completions to nothing.
+If STRICT is t, the predicate always applies; if nil it only applies if
+it does not reduce the set of possible completions to nothing.
Note: TABLE needs to be a proper completion table which obeys predicates."
(cond
((and (not strict) (eq action 'lambda))
:group 'minibuffer)
(defvar completion-styles-alist
- '((basic try-completion all-completions)
+ '((basic completion-basic-try-completion completion-basic-all-completions)
+ (emacs22 completion-emacs22-try-completion completion-emacs22-all-completions)
+ (emacs21 completion-emacs21-try-completion completion-emacs21-all-completions)
;; (partial-completion
;; completion-pcm--try-completion completion-pcm--all-completions)
)
:group 'minibuffer
:version "23.1")
-(defun minibuffer-try-completion (string table pred)
- (if (and (symbolp table) (get table 'no-completion-styles))
- (try-completion string table pred)
+(defun completion-try-completion (string table pred point)
+ "Try to complete STRING using completion table TABLE.
+Only the elements of table that satisfy predicate PRED are considered.
+POINT is the position of point within STRING.
+The return value can be either nil to indicate that there is no completion,
+t to indicate that STRING is the only possible completion,
+or a pair (STRING . NEWPOINT) of the completed result string together with
+a new position for point."
+ ;; The property `completion-styles' indicates that this functional
+ ;; completion-table claims to take care of completion styles itself.
+ ;; [I.e. It will most likely call us back at some point. ]
+ (if (and (symbolp table) (get table 'completion-styles))
+ ;; Extended semantics for functional completion-tables:
+ ;; They accept a 4th argument `point' and when called with action=nil
+ ;; and this 4th argument (a position inside `string'), they should
+ ;; return instead of a string a pair (STRING . NEWPOINT).
+ (funcall table string pred nil point)
(completion--some (lambda (style)
(funcall (nth 1 (assq style completion-styles-alist))
- string table pred))
+ string table pred point))
completion-styles)))
-(defun minibuffer-all-completions (string table pred &optional hide-spaces)
+(defun completion-all-completions (string table pred point)
+ "List the possible completions of STRING in completion table TABLE.
+Only the elements of table that satisfy predicate PRED are considered.
+POINT is the position of point within STRING.
+The return value is a list of completions and may contain the BASE-SIZE
+in the last `cdr'."
+ ;; The property `completion-styles' indicates that this functional
+ ;; completion-table claims to take care of completion styles itself.
+ ;; [I.e. It will most likely call us back at some point. ]
(let ((completion-all-completions-with-base-size t))
- (if (and (symbolp table) (get table 'no-completion-styles))
- (all-completions string table pred hide-spaces)
+ (if (and (symbolp table) (get table 'completion-styles))
+ ;; Extended semantics for functional completion-tables:
+ ;; They accept a 4th argument `point' and when called with action=t
+ ;; and this 4th argument (a position inside `string'), they may
+ ;; return BASE-SIZE in the last `cdr'.
+ (funcall table string pred t point)
(completion--some (lambda (style)
(funcall (nth 2 (assq style completion-styles-alist))
- string table pred hide-spaces))
+ string table pred point))
completion-styles))))
(defun minibuffer--bitset (modified completions exact)
(if completions 2 0)
(if exact 1 0)))
-(defun minibuffer--do-completion (&optional try-completion-function)
+(defun completion--do-completion (&optional try-completion-function)
"Do the completion and return a summary of what happened.
M = completion was performed, the text was Modified.
C = there were available Completions.
110 6 some completion happened
111 7 completed to an exact completion"
(let* ((beg (field-beginning))
- (string (buffer-substring beg (point)))
- (completion (funcall (or try-completion-function
- 'minibuffer-try-completion)
- string
- minibuffer-completion-table
- minibuffer-completion-predicate)))
+ (end (field-end))
+ (string (buffer-substring beg end))
+ (comp (funcall (or try-completion-function
+ 'completion-try-completion)
+ string
+ minibuffer-completion-table
+ minibuffer-completion-predicate
+ (- (point) beg))))
(cond
- ((null completion)
+ ((null comp)
(ding) (minibuffer-message "No match") (minibuffer--bitset nil nil nil))
- ((eq t completion) (minibuffer--bitset nil nil t)) ;Exact and unique match.
+ ((eq t comp) (minibuffer--bitset nil nil t)) ;Exact and unique match.
(t
;; `completed' should be t if some completion was done, which doesn't
;; include simply changing the case of the entered string. However,
;; for appearance, the string is rewritten if the case changes.
- (let ((completed (not (eq t (compare-strings completion nil nil
- string nil nil t))))
- (unchanged (eq t (compare-strings completion nil nil
- string nil nil nil))))
+ (let* ((comp-pos (cdr comp))
+ (completion (car comp))
+ (completed (not (eq t (compare-strings completion nil nil
+ string nil nil t))))
+ (unchanged (eq t (compare-strings completion nil nil
+ string nil nil nil))))
(unless unchanged
- ;; Merge a trailing / in completion with a / after point.
- ;; We used to only do it for word completion, but it seems to make
- ;; sense for all completions.
- (if (and (eq ?/ (aref completion (1- (length completion))))
- (< (point) (field-end))
- (eq ?/ (char-after)))
- (setq completion (substring completion 0 -1)))
;; Insert in minibuffer the chars we got.
- (let ((end (point)))
- (insert completion)
- (delete-region beg end)))
+ (goto-char end)
+ (insert completion)
+ (delete-region beg end)
+ (goto-char (+ beg comp-pos)))
(if (not (or unchanged completed))
;; The case of the string changed, but that's all. We're not sure
;; whether this is a unique completion or not, so try again using
;; the real case (this shouldn't recurse again, because the next
;; time try-completion will return either t or the exact string).
- (minibuffer--do-completion try-completion-function)
+ (completion--do-completion try-completion-function)
;; It did find a match. Do we match some possibility exactly now?
- (let ((exact (test-completion (field-string)
+ (let ((exact (test-completion completion
minibuffer-completion-table
minibuffer-completion-predicate)))
(unless completed
(scroll-other-window))
nil)
- (case (minibuffer--do-completion)
+ (case (completion--do-completion)
(0 nil)
(1 (goto-char (field-end))
(minibuffer-message "Sole completion")
Otherwise try to complete it. If completion leads to a valid completion,
a repetition of this command will exit."
(interactive)
- (cond
- ;; Allow user to specify null string
- ((= (field-beginning) (field-end)) (exit-minibuffer))
- ((test-completion (field-string)
- minibuffer-completion-table
- minibuffer-completion-predicate)
- (when completion-ignore-case
- ;; Fixup case of the field, if necessary.
- (let* ((string (field-string))
- (compl (minibuffer-try-completion
- string
- minibuffer-completion-table
- minibuffer-completion-predicate)))
- (when (and (stringp compl)
- ;; If it weren't for this piece of paranoia, I'd replace
- ;; the whole thing with a call to complete-do-completion.
- (= (length string) (length compl)))
- (let ((beg (field-beginning))
- (end (field-end)))
+ (let ((beg (field-beginning))
+ (end (field-end)))
+ (cond
+ ;; Allow user to specify null string
+ ((= beg end) (exit-minibuffer))
+ ((test-completion (buffer-substring beg end)
+ minibuffer-completion-table
+ minibuffer-completion-predicate)
+ (when completion-ignore-case
+ ;; Fixup case of the field, if necessary.
+ (let* ((string (buffer-substring beg end))
+ (compl (try-completion
+ string
+ minibuffer-completion-table
+ minibuffer-completion-predicate)))
+ (when (and (stringp compl)
+ ;; If it weren't for this piece of paranoia, I'd replace
+ ;; the whole thing with a call to do-completion.
+ (= (length string) (length compl)))
(goto-char end)
(insert compl)
- (delete-region beg end)))))
- (exit-minibuffer))
+ (delete-region beg end))))
+ (exit-minibuffer))
- ((eq minibuffer-completion-confirm 'confirm-only)
- ;; The user is permitted to exit with an input that's rejected
- ;; by test-completion, but at the condition to confirm her choice.
- (if (eq last-command this-command)
- (exit-minibuffer)
- (minibuffer-message "Confirm")
- nil))
+ ((eq minibuffer-completion-confirm 'confirm-only)
+ ;; The user is permitted to exit with an input that's rejected
+ ;; by test-completion, but at the condition to confirm her choice.
+ (if (eq last-command this-command)
+ (exit-minibuffer)
+ (minibuffer-message "Confirm")
+ nil))
- (t
- ;; Call do-completion, but ignore errors.
- (case (condition-case nil
- (minibuffer--do-completion)
- (error 1))
- ((1 3) (exit-minibuffer))
- (7 (if (not minibuffer-completion-confirm)
- (exit-minibuffer)
- (minibuffer-message "Confirm")
- nil))
- (t nil)))))
-
-(defun minibuffer-try-word-completion (string table predicate)
- (let ((completion (minibuffer-try-completion string table predicate)))
- (if (not (stringp completion))
- completion
+ (t
+ ;; Call do-completion, but ignore errors.
+ (case (condition-case nil
+ (completion--do-completion)
+ (error 1))
+ ((1 3) (exit-minibuffer))
+ (7 (if (not minibuffer-completion-confirm)
+ (exit-minibuffer)
+ (minibuffer-message "Confirm")
+ nil))
+ (t nil))))))
+
+(defun completion--try-word-completion (string table predicate point)
+ (let ((comp (completion-try-completion string table predicate point)))
+ (if (not (consp comp))
+ comp
+
+ ;; If completion finds next char not unique,
+ ;; consider adding a space or a hyphen.
+ (when (= (length string) (length (car comp)))
+ (let ((exts '(" " "-"))
+ (before (substring string 0 point))
+ (after (substring string point))
+ tem)
+ (while (and exts (not (consp tem)))
+ (setq tem (completion-try-completion
+ (concat before (pop exts) after)
+ table predicate (1+ point))))
+ (if (consp tem) (setq comp tem))))
;; Completing a single word is actually more difficult than completing
;; as much as possible, because we first have to find the "current
;; which makes it trivial to find the position, but with fancier
;; completion (plus env-var expansion, ...) `completion' might not
;; look anything like `string' at all.
-
- (when minibuffer-completing-file-name
- ;; In order to minimize the problem mentioned above, let's try to
- ;; reduce the different between `string' and `completion' by
- ;; mirroring some of the work done in read-file-name-internal.
- (let ((substituted (condition-case nil
- ;; Might fail when completing an env-var.
- (substitute-in-file-name string)
- (error string))))
- (unless (eq string substituted)
- (setq string substituted))))
-
- ;; Make buffer (before point) contain the longest match
- ;; of `string's tail and `completion's head.
- (let* ((startpos (max 0 (- (length string) (length completion))))
- (length (- (length string) startpos)))
- (while (and (> length 0)
- (not (eq t (compare-strings string startpos nil
- completion 0 length
- completion-ignore-case))))
- (setq startpos (1+ startpos))
- (setq length (1- length)))
-
- (setq string (substring string startpos)))
-
- ;; Now `string' is a prefix of `completion'.
-
- ;; If completion finds next char not unique,
- ;; consider adding a space or a hyphen.
- (when (= (length string) (length completion))
- (let ((exts '(" " "-"))
- tem)
- (while (and exts (not (stringp tem)))
- (setq tem (minibuffer-try-completion (concat string (pop exts))
- table predicate)))
- (if (stringp tem) (setq completion tem))))
-
- ;; Otherwise cut after the first word.
- (if (string-match "\\W" completion (length string))
- ;; First find first word-break in the stuff found by completion.
- ;; i gets index in string of where to stop completing.
- (substring completion 0 (match-end 0))
- completion))))
+ (let* ((comppoint (cdr comp))
+ (completion (car comp))
+ (before (substring string 0 point))
+ (combined (concat before "\n" completion)))
+ ;; Find in completion the longest text that was right before point.
+ (when (string-match "\\(.+\\)\n.*?\\1" combined)
+ (let* ((prefix (match-string 1 before))
+ ;; We used non-greedy match to make `rem' as long as possible.
+ (rem (substring combined (match-end 0)))
+ ;; Find in the remainder of completion the longest text
+ ;; that was right after point.
+ (after (substring string point))
+ (suffix (if (string-match "\\`\\(.+\\).*\n.*\\1"
+ (concat after "\n" rem))
+ (match-string 1 after))))
+ ;; The general idea is to try and guess what text was inserted
+ ;; at point by the completion. Problem is: if we guess wrong,
+ ;; we may end up treating as "added by completion" text that was
+ ;; actually painfully typed by the user. So if we then cut
+ ;; after the first word, we may throw away things the
+ ;; user wrote. So let's try to be as conservative as possible:
+ ;; only cut after the first word, if we're reasonably sure that
+ ;; our guess is correct.
+ ;; Note: a quick survey on emacs-devel seemed to indicate that
+ ;; nobody actually cares about the "word-at-a-time" feature of
+ ;; minibuffer-complete-word, whose real raison-d'ĂȘtre is that it
+ ;; tries to add "-" or " ". One more reason to only cut after
+ ;; the first word, if we're really sure we're right.
+ (when (and (or suffix (zerop (length after)))
+ (string-match (concat
+ ;; Make submatch 1 as small as possible
+ ;; to reduce the risk of cutting
+ ;; valuable text.
+ ".*" (regexp-quote prefix) "\\(.*?\\)"
+ (if suffix (regexp-quote suffix) "\\'"))
+ completion)
+ ;; The new point in `completion' should also be just
+ ;; before the suffix, otherwise something more complex
+ ;; is going on, and we're not sure where we are.
+ (eq (match-end 1) comppoint)
+ ;; (match-beginning 1)..comppoint is now the stretch
+ ;; of text in `completion' that was completed at point.
+ (string-match "\\W" completion (match-beginning 1))
+ ;; Is there really something to cut?
+ (> comppoint (match-end 0)))
+ ;; Cut after the first word.
+ (let ((cutpos (match-end 0)))
+ (setq completion (concat (substring completion 0 cutpos)
+ (substring completion comppoint)))
+ (setq comppoint cutpos)))))
+
+ (cons completion comppoint)))))
(defun minibuffer-complete-word ()
is added, provided that matches some possible completion.
Return nil if there is no valid completion, else t."
(interactive)
- (case (minibuffer--do-completion 'minibuffer-try-word-completion)
+ (case (completion--do-completion 'completion--try-word-completion)
(0 nil)
(1 (goto-char (field-end))
(minibuffer-message "Sole completion")
t)
(t t)))
-(defun minibuffer--insert-strings (strings)
+(defun completion--insert-strings (strings)
"Insert a list of STRINGS into the current buffer.
Uses columns to keep the listing readable but compact.
It also eliminates runs of equal strings."
;; Get the base-size from the tail of the list.
(set (make-local-variable 'completion-base-size) (or (cdr last) 0))
(setcdr last nil)) ;Make completions a properly nil-terminated list.
- (minibuffer--insert-strings completions))))
+ (completion--insert-strings completions))))
(let ((completion-common-substring common-substring))
(run-hooks 'completion-setup-hook))
(interactive)
(message "Making completion list...")
(let* ((string (field-string))
- (completions (minibuffer-all-completions
+ (completions (completion-all-completions
string
minibuffer-completion-table
minibuffer-completion-predicate
- t)))
+ (- (point) (field-beginning)))))
(message nil)
(if (and completions
(or (consp (cdr completions))
(substring string beg)
pred action))))
-(defun completion--file-name-table (string dir action)
+(defun completion--file-name-table (string pred action)
"Internal subroutine for `read-file-name'. Do not call this."
- (setq dir (expand-file-name dir))
(if (and (zerop (length string)) (eq 'lambda action))
nil ; FIXME: why?
- (let* ((str (condition-case nil
+ (let* ((dir (if (stringp pred)
+ ;; It used to be that `pred' was abused to pass `dir'
+ ;; as an argument.
+ (prog1 (expand-file-name pred) (setq pred nil))
+ default-directory))
+ (str (condition-case nil
(substitute-in-file-name string)
(error string)))
(name (file-name-nondirectory str))
'completion--file-name-table)
"Internal subroutine for `read-file-name'. Do not call this.")
+(defvar read-file-name-function nil
+ "If this is non-nil, `read-file-name' does its work by calling this function.")
+
+(defvar read-file-name-predicate nil
+ "Current predicate used by `read-file-name-internal'.")
+
+(defcustom read-file-name-completion-ignore-case
+ (if (memq system-type '(ms-dos windows-nt darwin macos vax-vms axp-vms))
+ t nil)
+ "Non-nil means when reading a file name completion ignores case."
+ :group 'minibuffer
+ :type 'boolean
+ :version "22.1")
+
+(defcustom insert-default-directory t
+ "Non-nil means when reading a filename start with default dir in minibuffer.
+
+When the initial minibuffer contents show a name of a file or a directory,
+typing RETURN without editing the initial contents is equivalent to typing
+the default file name.
+
+If this variable is non-nil, the minibuffer contents are always
+initially non-empty, and typing RETURN without editing will fetch the
+default name, if one is provided. Note however that this default name
+is not necessarily the same as initial contents inserted in the minibuffer,
+if the initial contents is just the default directory.
+
+If this variable is nil, the minibuffer often starts out empty. In
+that case you may have to explicitly fetch the next history element to
+request the default name; typing RETURN without editing will leave
+the minibuffer empty.
+
+For some commands, exiting with an empty minibuffer has a special meaning,
+such as making the current buffer visit no file in the case of
+`set-visited-file-name'."
+ :group 'minibuffer
+ :type 'boolean)
+
+;; Not always defined, but only called if next-read-file-uses-dialog-p says so.
+(declare-function x-file-dialog "xfns.c"
+ (prompt dir &optional default-filename mustmatch only-dir-p))
+
+(defun read-file-name (prompt &optional dir default-filename mustmatch initial predicate)
+ "Read file name, prompting with PROMPT and completing in directory DIR.
+Value is not expanded---you must call `expand-file-name' yourself.
+Default name to DEFAULT-FILENAME if user exits the minibuffer with
+the same non-empty string that was inserted by this function.
+ (If DEFAULT-FILENAME is omitted, the visited file name is used,
+ except that if INITIAL is specified, that combined with DIR is used.)
+If the user exits with an empty minibuffer, this function returns
+an empty string. (This can only happen if the user erased the
+pre-inserted contents or if `insert-default-directory' is nil.)
+Fourth arg MUSTMATCH non-nil means require existing file's name.
+ Non-nil and non-t means also require confirmation after completion.
+Fifth arg INITIAL specifies text to start with.
+If optional sixth arg PREDICATE is non-nil, possible completions and
+the resulting file name must satisfy (funcall PREDICATE NAME).
+DIR should be an absolute directory name. It defaults to the value of
+`default-directory'.
+
+If this command was invoked with the mouse, use a file dialog box if
+`use-dialog-box' is non-nil, and the window system or X toolkit in use
+provides a file dialog box.
+
+See also `read-file-name-completion-ignore-case'
+and `read-file-name-function'."
+ (unless dir (setq dir default-directory))
+ (unless (file-name-absolute-p dir) (setq dir (expand-file-name dir)))
+ (unless default-filename
+ (setq default-filename (if initial (expand-file-name initial dir)
+ buffer-file-name)))
+ ;; If dir starts with user's homedir, change that to ~.
+ (setq dir (abbreviate-file-name dir))
+ ;; Likewise for default-filename.
+ (if default-filename
+ (setq default-filename (abbreviate-file-name default-filename)))
+ (let ((insdef (cond
+ ((and insert-default-directory (stringp dir))
+ (if initial
+ (cons (minibuffer--double-dollars (concat dir initial))
+ (length (minibuffer--double-dollars dir)))
+ (minibuffer--double-dollars dir)))
+ (initial (cons (minibuffer--double-dollars initial) 0)))))
+
+ (if read-file-name-function
+ (funcall read-file-name-function
+ prompt dir default-filename mustmatch initial predicate)
+ (let ((completion-ignore-case read-file-name-completion-ignore-case)
+ (minibuffer-completing-file-name t)
+ (read-file-name-predicate (or predicate 'file-exists-p))
+ (add-to-history nil))
+
+ (let* ((val
+ (if (not (next-read-file-uses-dialog-p))
+ ;; We used to pass `dir' to `read-file-name-internal' by
+ ;; abusing the `predicate' argument. It's better to
+ ;; just use `default-directory', but in order to avoid
+ ;; changing `default-directory' in the current buffer,
+ ;; we don't let-bind it.
+ (lexical-let ((dir (file-name-as-directory
+ (expand-file-name dir))))
+ (minibuffer-with-setup-hook
+ (lambda () (setq default-directory dir))
+ (completing-read prompt 'read-file-name-internal
+ nil mustmatch insdef 'file-name-history
+ default-filename)))
+ ;; If DIR contains a file name, split it.
+ (let ((file (file-name-nondirectory dir)))
+ (when (and default-filename (not (zerop (length file))))
+ (setq default-filename file)
+ (setq dir (file-name-directory dir)))
+ (if default-filename
+ (setq default-filename
+ (expand-file-name default-filename dir)))
+ (setq add-to-history t)
+ (x-file-dialog prompt dir default-filename mustmatch
+ (eq predicate 'file-directory-p)))))
+
+ (replace-in-history (eq (car-safe file-name-history) val)))
+ ;; If completing-read returned the inserted default string itself
+ ;; (rather than a new string with the same contents),
+ ;; it has to mean that the user typed RET with the minibuffer empty.
+ ;; In that case, we really want to return ""
+ ;; so that commands such as set-visited-file-name can distinguish.
+ (when (eq val default-filename)
+ ;; In this case, completing-read has not added an element
+ ;; to the history. Maybe we should.
+ (if (not replace-in-history)
+ (setq add-to-history t))
+ (setq val ""))
+ (unless val (error "No file name specified"))
+
+ (if (and default-filename
+ (string-equal val (if (consp insdef) (car insdef) insdef)))
+ (setq val default-filename))
+ (setq val (substitute-in-file-name val))
+
+ (if replace-in-history
+ ;; Replace what Fcompleting_read added to the history
+ ;; with what we will actually return.
+ (let ((val1 (minibuffer--double-dollars val)))
+ (if history-delete-duplicates
+ (setcdr file-name-history
+ (delete val1 (cdr file-name-history))))
+ (setcar file-name-history val1))
+ (if add-to-history
+ ;; Add the value to the history--but not if it matches
+ ;; the last value already there.
+ (let ((val1 (minibuffer--double-dollars val)))
+ (unless (and (consp file-name-history)
+ (equal (car file-name-history) val1))
+ (setq file-name-history
+ (cons val1
+ (if history-delete-duplicates
+ (delete val1 file-name-history)
+ file-name-history)))))))
+ val)))))
+
+(defun internal-complete-buffer-except (&optional buffer)
+ "Perform completion on all buffers excluding BUFFER.
+Like `internal-complete-buffer', but removes BUFFER from the completion list."
+ (lexical-let ((except (if (stringp buffer) buffer (buffer-name buffer))))
+ (apply-partially 'completion-table-with-predicate
+ 'internal-complete-buffer
+ (lambda (name)
+ (not (equal (if (consp name) (car name) name) except)))
+ nil)))
+
+;;; Old-style completion, used in Emacs-21.
+
+(defun completion-emacs21-try-completion (string table pred point)
+ (let ((completion (try-completion string table pred)))
+ (if (stringp completion)
+ (cons completion (length completion))
+ completion)))
+
+(defun completion-emacs21-all-completions (string table pred point)
+ (all-completions string table pred t))
+
+;;; Basic completion, used in Emacs-22.
+
+(defun completion-emacs22-try-completion (string table pred point)
+ (let ((suffix (substring string point))
+ (completion (try-completion (substring string 0 point) table pred)))
+ (if (not (stringp completion))
+ completion
+ ;; Merge a trailing / in completion with a / after point.
+ ;; We used to only do it for word completion, but it seems to make
+ ;; sense for all completions.
+ (if (and (eq ?/ (aref completion (1- (length completion))))
+ (not (zerop (length suffix)))
+ (eq ?/ (aref suffix 0)))
+ ;; This leaves point before the / .
+ ;; Should we maybe put it after the / ? --Stef
+ (setq completion (substring completion 0 -1)))
+ (cons (concat completion suffix) (length completion)))))
+
+(defun completion-emacs22-all-completions (string table pred point)
+ (all-completions (substring string 0 point) table pred t))
+
+(defalias 'completion-basic-try-completion 'completion-emacs22-try-completion)
+(defalias 'completion-basic-all-completions 'completion-emacs22-all-completions)
+
(provide 'minibuffer)
;; arch-tag: ef8a0a15-1080-4790-a754-04017c02f08f