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)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
#include "syntax.h"
#include "intervals.h"
#include "keymap.h"
+#include "termhooks.h"
extern int quit_char;
/* Keymap for reading expressions. */
Lisp_Object Vread_expression_map;
+Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
+Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
+Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
+Lisp_Object Vminibuffer_completing_file_name;
+
Lisp_Object Quser_variable_p;
Lisp_Object Qminibuffer_default;
DEFUN ("minibuffer-contents", Fminibuffer_contents,
Sminibuffer_contents, 0, 0, 0,
doc: /* Return the user input in a minibuffer as a string.
-The current buffer must be a minibuffer. */)
+If the current buffer is not a minibuffer, return its entire contents. */)
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
Sminibuffer_contents_no_properties, 0, 0, 0,
doc: /* Return the user input in a minibuffer as a string, without text-properties.
-The current buffer must be a minibuffer. */)
+If the current buffer is not a minibuffer, return its entire contents. */)
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
Sminibuffer_completion_contents, 0, 0, 0,
doc: /* Return the user input in a minibuffer before point as a string.
That is what completion commands operate on.
-The current buffer must be a minibuffer. */)
+If the current buffer is not a minibuffer, return its entire contents. */)
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents,
Sdelete_minibuffer_contents, 0, 0, 0,
doc: /* Delete all user input in a minibuffer.
-The current buffer must be a minibuffer. */)
+If the current buffer is not a minibuffer, erase its entire contents. */)
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
Lisp_Object enable_multibyte;
int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
-
/* String to add to the history. */
Lisp_Object histstring;
specbind (Qminibuffer_default, defalt);
- single_kboard_state ();
+ /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
+ in previous recursive minibuffer, but was not set explicitly
+ to t for this invocation, so set it to nil in this minibuffer.
+ Save the old value now, before we change it. */
+ specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name);
+ if (EQ (Vminibuffer_completing_file_name, Qlambda))
+ Vminibuffer_completing_file_name = Qnil;
+
#ifdef HAVE_X_WINDOWS
if (display_hourglass_p)
cancel_hourglass ();
GCPRO5 (map, initial, val, ambient_dir, input_method);
if (!STRINGP (prompt))
- prompt = empty_string;
+ prompt = empty_unibyte_string;
if (!enable_recursive_minibuffers
&& minibuf_level > 0)
if (minibuffer_auto_raise)
Fraise_frame (mini_frame);
+ temporarily_switch_to_single_kboard (XFRAME (mini_frame));
+
/* We have to do this after saving the window configuration
since that is what restores the current buffer. */
specpdl slots. */
minibuf_save_list
= Fcons (Voverriding_local_map,
- Fcons (minibuf_window, minibuf_save_list));
+ Fcons (minibuf_window,
+ minibuf_save_list));
minibuf_save_list
= Fcons (minibuf_prompt,
Fcons (make_number (minibuf_prompt_width),
Vminibuffer_history_position = histpos;
Vminibuffer_history_variable = histvar;
Vhelp_form = Vminibuffer_help_form;
+ /* If this minibuffer is reading a file name, that doesn't mean
+ recursive ones are. But we cannot set it to nil, because
+ completion code still need to know the minibuffer is completing a
+ file name. So use `lambda' as intermediate value meaning
+ "t" in this minibuffer, but "nil" in next minibuffer. */
+ if (!NILP (Vminibuffer_completing_file_name))
+ Vminibuffer_completing_file_name = Qlambda;
if (inherit_input_method)
{
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
Ferase_buffer ();
- unbind_to (count1, Qnil);
- }
- if (!NILP (current_buffer->enable_multibyte_characters)
- && ! STRING_MULTIBYTE (minibuf_prompt))
- minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
+ if (!NILP (current_buffer->enable_multibyte_characters)
+ && ! STRING_MULTIBYTE (minibuf_prompt))
+ minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
- /* Insert the prompt, record where it ends. */
- Finsert (1, &minibuf_prompt);
- if (PT > BEG)
- {
- Fput_text_property (make_number (BEG), make_number (PT),
- Qfront_sticky, Qt, Qnil);
- Fput_text_property (make_number (BEG), make_number (PT),
- Qrear_nonsticky, Qt, Qnil);
- Fput_text_property (make_number (BEG), make_number (PT),
- Qfield, Qt, Qnil);
- Fadd_text_properties (make_number (BEG), make_number (PT),
- Vminibuffer_prompt_properties, Qnil);
- }
+ /* Insert the prompt, record where it ends. */
+ Finsert (1, &minibuf_prompt);
+ if (PT > BEG)
+ {
+ Fput_text_property (make_number (BEG), make_number (PT),
+ Qfront_sticky, Qt, Qnil);
+ Fput_text_property (make_number (BEG), make_number (PT),
+ Qrear_nonsticky, Qt, Qnil);
+ Fput_text_property (make_number (BEG), make_number (PT),
+ Qfield, Qt, Qnil);
+ Fadd_text_properties (make_number (BEG), make_number (PT),
+ Vminibuffer_prompt_properties, Qnil);
+ }
+ unbind_to (count1, Qnil);
+ }
minibuf_prompt_width = (int) current_column (); /* iftc */
XWINDOW (minibuf_window)->cursor.x = 0;
XWINDOW (minibuf_window)->must_be_updated_p = 1;
update_frame (XFRAME (selected_frame), 1, 1);
- if (rif && rif->flush_display)
- rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame));
+ {
+ struct frame *f = XFRAME (XWINDOW (minibuf_window)->frame);
+ struct redisplay_interface *rif = FRAME_RIF (f);
+ if (rif && rif->flush_display)
+ rif->flush_display (f);
+ }
}
/* Make minibuffer contents into a string. */
}
DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
- doc: /* Return common substring of all completions of STRING in ALIST.
-Each car of each element of ALIST (or each element if it is not a cons cell)
-is tested to see if it begins with STRING. The possible matches may be
+ doc: /* Return common substring of all completions of STRING in COLLECTION.
+Test each possible completion specified by COLLECTION
+to see if it begins with STRING. The possible completions may be
strings or symbols. Symbols are converted to strings before testing,
see `symbol-name'.
-All that match are compared together; the longest initial sequence
-common to all matches is returned as a string.
-If there is no match at all, nil is returned.
-For a unique match which is exact, t is returned.
-
-If ALIST is a hash-table, all the string and symbol keys are the
-possible matches.
-If ALIST is an obarray, the names of all symbols in the obarray
-are the possible matches.
-
-ALIST can also be a function to do the completion itself.
+All that match STRING are compared together; the longest initial sequence
+common to all these matches is the return value.
+If there is no match at all, the return value is nil.
+For a unique match which is exact, the return value is t.
+
+If COLLECTION is an alist, the keys (cars of elements) are the
+possible completions. If an element is not a cons cell, then the
+element itself is the possible completion.
+If COLLECTION is a hash-table, all the keys that are strings or symbols
+are the possible completions.
+If COLLECTION is an obarray, the names of all symbols in the obarray
+are the possible completions.
+
+COLLECTION can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and nil.
Whatever it returns becomes the value of `try-completion'.
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element
-or the symbol from the obarray. If ALIST is a hash-table,
+or the symbol from the obarray. If COLLECTION is a hash-table,
predicate is called with two arguments: the key and the value.
Additionally to this predicate, `completion-regexp-list'
is used to further constrain the set of candidates. */)
- (string, alist, predicate)
- Lisp_Object string, alist, predicate;
+ (string, collection, predicate)
+ Lisp_Object string, collection, predicate;
{
Lisp_Object bestmatch, tail, elt, eltstring;
/* Size in bytes of BESTMATCH. */
int bestmatchsize = 0;
/* These are in bytes, too. */
int compare, matchsize;
- int type = (HASH_TABLE_P (alist) ? 3
- : VECTORP (alist) ? 2
- : NILP (alist) || (CONSP (alist)
- && (!SYMBOLP (XCAR (alist))
- || NILP (XCAR (alist)))));
+ int type = (HASH_TABLE_P (collection) ? 3
+ : VECTORP (collection) ? 2
+ : NILP (collection) || (CONSP (collection)
+ && (!SYMBOLP (XCAR (collection))
+ || NILP (XCAR (collection)))));
int index = 0, obsize = 0;
int matchcount = 0;
int bindcount = -1;
CHECK_STRING (string);
if (type == 0)
- return call3 (alist, string, predicate, Qnil);
+ return call3 (collection, string, predicate, Qnil);
bestmatch = bucket = Qnil;
zero = make_number (0);
- /* If ALIST is not a list, set TAIL just for gc pro. */
- tail = alist;
+ /* If COLLECTION is not a list, set TAIL just for gc pro. */
+ tail = collection;
if (type == 2)
{
- alist = check_obarray (alist);
- obsize = XVECTOR (alist)->size;
- bucket = XVECTOR (alist)->contents[index];
+ collection = check_obarray (collection);
+ obsize = XVECTOR (collection)->size;
+ bucket = XVECTOR (collection)->contents[index];
}
while (1)
break;
else
{
- bucket = XVECTOR (alist)->contents[index];
+ bucket = XVECTOR (collection)->contents[index];
continue;
}
}
else /* if (type == 3) */
{
- while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
- && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
+ while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
+ && NILP (HASH_HASH (XHASH_TABLE (collection), index)))
index++;
- if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
+ if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
break;
else
- elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
+ elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
}
/* Is this element a possible completion? */
GCPRO4 (tail, string, eltstring, bestmatch);
tem = type == 3
? call2 (predicate, elt,
- HASH_VALUE (XHASH_TABLE (alist), index - 1))
+ HASH_VALUE (XHASH_TABLE (collection), index - 1))
: call1 (predicate, elt);
UNGCPRO;
}
matchcount++;
bestmatchsize = matchsize;
if (matchsize <= SCHARS (string)
+ /* If completion-ignore-case is non-nil, don't
+ short-circuit because we want to find the best
+ possible match *including* case differences. */
+ && !completion_ignore_case
&& matchcount > 1)
/* No need to look any further. */
break;
}
\f
DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
- doc: /* Search for partial matches to STRING in ALIST.
-Each car of each element of ALIST (or each element if it is not a cons cell)
-is tested to see if it begins with STRING. The possible matches may be
+ doc: /* Search for partial matches to STRING in COLLECTION.
+Test each of the possible completions specified by COLLECTION
+to see if it begins with STRING. The possible completions may be
strings or symbols. Symbols are converted to strings before testing,
see `symbol-name'.
-The value is a list of all the strings from ALIST that match.
+The value is a list of all the possible completions that match STRING.
-If ALIST is a hash-table, all the string and symbol keys are the
-possible matches.
-If ALIST is an obarray, the names of all symbols in the obarray
-are the possible matches.
+If COLLECTION is an alist, the keys (cars of elements) are the
+possible completions. If an element is not a cons cell, then the
+element itself is the possible completion.
+If COLLECTION is a hash-table, all the keys that are strings or symbols
+are the possible completions.
+If COLLECTION is an obarray, the names of all symbols in the obarray
+are the possible completions.
-ALIST can also be a function to do the completion itself.
+COLLECTION can also be a function to do the completion itself.
It receives three arguments: the values STRING, PREDICATE and t.
Whatever it returns becomes the value of `all-completions'.
it is used to test each possible match.
The match is a candidate only if PREDICATE returns non-nil.
The argument given to PREDICATE is the alist element
-or the symbol from the obarray. If ALIST is a hash-table,
+or the symbol from the obarray. If COLLECTION is a hash-table,
predicate is called with two arguments: the key and the value.
Additionally to this predicate, `completion-regexp-list'
is used to further constrain the set of candidates.
If the optional fourth argument HIDE-SPACES is non-nil,
-strings in ALIST that start with a space
+strings in COLLECTION that start with a space
are ignored unless STRING itself starts with a space. */)
- (string, alist, predicate, hide_spaces)
- Lisp_Object string, alist, predicate, hide_spaces;
+ (string, collection, predicate, hide_spaces)
+ Lisp_Object string, collection, predicate, hide_spaces;
{
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
- int type = HASH_TABLE_P (alist) ? 3
- : VECTORP (alist) ? 2
- : NILP (alist) || (CONSP (alist)
- && (!SYMBOLP (XCAR (alist))
- || NILP (XCAR (alist))));
+ int type = HASH_TABLE_P (collection) ? 3
+ : VECTORP (collection) ? 2
+ : NILP (collection) || (CONSP (collection)
+ && (!SYMBOLP (XCAR (collection))
+ || NILP (XCAR (collection))));
int index = 0, obsize = 0;
int bindcount = -1;
Lisp_Object bucket, tem, zero;
CHECK_STRING (string);
if (type == 0)
- return call3 (alist, string, predicate, Qt);
+ return call3 (collection, string, predicate, Qt);
allmatches = bucket = Qnil;
zero = make_number (0);
- /* If ALIST is not a list, set TAIL just for gc pro. */
- tail = alist;
+ /* If COLLECTION is not a list, set TAIL just for gc pro. */
+ tail = collection;
if (type == 2)
{
- obsize = XVECTOR (alist)->size;
- bucket = XVECTOR (alist)->contents[index];
+ obsize = XVECTOR (collection)->size;
+ bucket = XVECTOR (collection)->contents[index];
}
while (1)
break;
else
{
- bucket = XVECTOR (alist)->contents[index];
+ bucket = XVECTOR (collection)->contents[index];
continue;
}
}
else /* if (type == 3) */
{
- while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
- && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
+ while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
+ && NILP (HASH_HASH (XHASH_TABLE (collection), index)))
index++;
- if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
+ if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
break;
else
- elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
+ elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
}
/* Is this element a possible completion? */
GCPRO4 (tail, eltstring, allmatches, string);
tem = type == 3
? call2 (predicate, elt,
- HASH_VALUE (XHASH_TABLE (alist), index - 1))
+ HASH_VALUE (XHASH_TABLE (collection), index - 1))
: call1 (predicate, elt);
UNGCPRO;
}
return Fnreverse (allmatches);
}
\f
-Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
-Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
-Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
-Lisp_Object Vminibuffer_completing_file_name;
-
DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
doc: /* Read a string in the minibuffer, with completion.
PROMPT is a string to prompt with; normally it ends in a colon and a space.
-TABLE can be a list of strings, an alist, an obarray or a hash table.
-TABLE can also be a function to do the completion itself.
-PREDICATE limits completion to a subset of TABLE.
+COLLECTION can be a list of strings, an alist, an obarray or a hash table.
+COLLECTION can also be a function to do the completion itself.
+PREDICATE limits completion to a subset of COLLECTION.
See `try-completion' and `all-completions' for more details
- on completion, TABLE, and PREDICATE.
+ on completion, COLLECTION, and PREDICATE.
+
+REQUIRE-MATCH can take the following values:
+- t means that the user is not allowed to exit unless
+ the input is (or completes to) an element of COLLECTION or is null.
+- nil means that the user can exit with any input.
+- `confirm-only' means that the user can exit with any input, but she will
+ need to confirm her choice if the input is not an element of COLLECTION.
+- anything else behaves like t except that typing RET does not exit if it
+ does non-null completion.
-If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
- the input is (or completes to) an element of TABLE or is null.
- If it is also not t, typing RET does not exit if it does non-null completion.
If the input is null, `completing-read' returns DEF, or an empty string
if DEF is nil, regardless of the value of REQUIRE-MATCH.
Completion ignores case if the ambient value of
`completion-ignore-case' is non-nil. */)
- (prompt, table, predicate, require_match, initial_input, hist, def, inherit_input_method)
- Lisp_Object prompt, table, predicate, require_match, initial_input;
+ (prompt, collection, predicate, require_match, initial_input, hist, def, inherit_input_method)
+ Lisp_Object prompt, collection, predicate, require_match, initial_input;
Lisp_Object hist, def, inherit_input_method;
{
Lisp_Object val, histvar, histpos, position;
init = initial_input;
GCPRO1 (def);
- specbind (Qminibuffer_completion_table, table);
+ specbind (Qminibuffer_completion_table, collection);
specbind (Qminibuffer_completion_predicate, predicate);
specbind (Qminibuffer_completion_confirm,
EQ (require_match, Qt) ? Qnil : require_match);
val = read_minibuf (NILP (require_match)
? (NILP (Vminibuffer_completing_file_name)
+ || EQ (Vminibuffer_completing_file_name, Qlambda)
? Vminibuffer_local_completion_map
: Vminibuffer_local_filename_completion_map)
: (NILP (Vminibuffer_completing_file_name)
+ || EQ (Vminibuffer_completing_file_name, Qlambda)
? Vminibuffer_local_must_match_map
: Vminibuffer_local_must_match_filename_map),
init, prompt, make_number (pos), 0,
DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
doc: /* Return non-nil if STRING is a valid completion.
Takes the same arguments as `all-completions' and `try-completion'.
-If ALIST is a function, it is called with three arguments:
+If COLLECTION is a function, it is called with three arguments:
the values STRING, PREDICATE and `lambda'. */)
- (string, alist, predicate)
- Lisp_Object string, alist, predicate;
+ (string, collection, predicate)
+ Lisp_Object string, collection, predicate;
{
Lisp_Object regexps, tail, tem = Qnil;
int i = 0;
CHECK_STRING (string);
- if ((CONSP (alist) && (!SYMBOLP (XCAR (alist)) || NILP (XCAR (alist))))
- || NILP (alist))
+ if ((CONSP (collection)
+ && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
+ || NILP (collection))
{
- tem = Fassoc_string (string, alist, completion_ignore_case ? Qt : Qnil);
+ tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
if (NILP (tem))
return Qnil;
}
- else if (VECTORP (alist))
+ else if (VECTORP (collection))
{
/* Bypass intern-soft as that loses for nil. */
- tem = oblookup (alist,
+ tem = oblookup (collection,
SDATA (string),
SCHARS (string),
SBYTES (string));
else
string = Fstring_make_multibyte (string);
- tem = oblookup (alist,
+ tem = oblookup (collection,
SDATA (string),
SCHARS (string),
SBYTES (string));
if (completion_ignore_case && !SYMBOLP (tem))
{
- for (i = XVECTOR (alist)->size - 1; i >= 0; i--)
+ for (i = XVECTOR (collection)->size - 1; i >= 0; i--)
{
- tail = XVECTOR (alist)->contents[i];
+ tail = XVECTOR (collection)->contents[i];
if (SYMBOLP (tail))
while (1)
{
if (!SYMBOLP (tem))
return Qnil;
}
- else if (HASH_TABLE_P (alist))
+ else if (HASH_TABLE_P (collection))
{
- struct Lisp_Hash_Table *h = XHASH_TABLE (alist);
+ struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
i = hash_lookup (h, string, NULL);
if (i >= 0)
tem = HASH_KEY (h, i);
return Qnil;
}
else
- return call3 (alist, string, predicate, Qlambda);
+ return call3 (collection, string, predicate, Qlambda);
/* Reject this element if it fails to match all the regexps. */
if (CONSP (Vcompletion_regexp_list))
/* Finally, check the predicate. */
if (!NILP (predicate))
{
- return HASH_TABLE_P (alist)
- ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (alist), i))
+ return HASH_TABLE_P (collection)
+ ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
: call1 (predicate, tem);
}
else
/* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
- doc: /* Like `assoc' but specifically for strings.
-Unibyte strings are converted to multibyte for comparison.
-And case is ignored if CASE-FOLD is non-nil.
+ doc: /* Like `assoc' but specifically for strings (and symbols).
+Symbols are converted to strings, and unibyte strings are converted to
+multibyte for comparison.
+Case is ignored if optional arg CASE-FOLD is non-nil.
As opposed to `assoc', it will also match an entry consisting of a single
string rather than a cons cell whose car is a string. */)
(key, list, case_fold)
{
register Lisp_Object tail;
+ if (SYMBOLP (key))
+ key = Fsymbol_name (key);
+
for (tail = list; !NILP (tail); tail = Fcdr (tail))
{
register Lisp_Object elt, tem, thiscar;
elt = Fcar (tail);
thiscar = CONSP (elt) ? XCAR (elt) : elt;
- if (!STRINGP (thiscar))
+ if (SYMBOLP (thiscar))
+ thiscar = Fsymbol_name (thiscar);
+ else if (!STRINGP (thiscar))
continue;
tem = Fcompare_strings (thiscar, make_number (0), Qnil,
key, make_number (0), Qnil,
goto exit;
}
+ if (EQ (Vminibuffer_completion_confirm, intern ("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 (current_kboard->Vlast_command, Vthis_command))
+ goto exit;
+ else
+ {
+ temp_echo_area_glyphs (build_string (" [Confirm]"));
+ return Qnil;
+ }
+ }
+
/* Call do_completion, but ignore errors. */
SET_PT (ZV);
val = internal_condition_case (complete_and_exit_1, Qerror,
DEFVAR_LISP ("minibuffer-completing-file-name",
&Vminibuffer_completing_file_name,
- doc: /* Non-nil means completing file names. */);
+ doc: /* Non-nil and non-`lambda' means completing file names. */);
Vminibuffer_completing_file_name = Qnil;
DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,