/* Minibuffer input and completion.
Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2001, 2002, 2003, 2004, 2005,
- 2006 Free Software Foundation, Inc.
+ 2006, 2007 Free Software Foundation, Inc.
This file is part of GNU Emacs.
static Lisp_Object last_exact_completion;
-extern Lisp_Object Voverriding_local_map;
+/* 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 Qcase_fold_search;
+Lisp_Object Qread_expression_history;
+
+extern Lisp_Object Voverriding_local_map;
+
extern Lisp_Object Qmouse_face;
extern Lisp_Object Qfield;
specpdl slots. */
minibuf_save_list
= Fcons (Voverriding_local_map,
- Fcons (minibuf_window, minibuf_save_list));
+ Fcons (minibuf_window,
+ Fcons (Vminibuffer_completing_file_name,
+ 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. */
+ Vminibuffer_completing_file_name = Qnil;
if (inherit_input_method)
{
minibuf_window = temp;
#endif
minibuf_save_list = Fcdr (minibuf_save_list);
+ Vminibuffer_completing_file_name = Fcar (minibuf_save_list);
+ minibuf_save_list = Fcdr (minibuf_save_list);
/* Erase the minibuffer we were using at this level. */
{
one puts point at the beginning of the string. *Note* that this
behavior differs from the way such arguments are used in `completing-read'
and some related functions, which use zero-indexing for POSITION. */)
-(prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
+ (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
Lisp_Object inherit_input_method;
{
Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
is a string to insert in the minibuffer before reading.
\(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
-arguments are used as in `read-from-minibuffer') */)
+arguments are used as in `read-from-minibuffer'.) */)
(prompt, initial_contents)
Lisp_Object prompt, initial_contents;
{
(prompt, initial_contents)
Lisp_Object prompt, initial_contents;
{
- return Feval (Fread_minibuffer (prompt, initial_contents));
+ return Feval (read_minibuf (Vread_expression_map, initial_contents,
+ prompt, Qnil, 1, Qread_expression_history,
+ make_number (0), Qnil, 0, 0));
}
/* Functions that use the minibuffer to read various things. */
}
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)
{
- obsize = XVECTOR (alist)->size;
- bucket = XVECTOR (alist)->contents[index];
+ collection = check_obarray (collection);
+ obsize = XVECTOR (collection)->size;
+ bucket = XVECTOR (collection)->contents[index];
}
while (1)
{
if (!EQ (bucket, zero))
{
+ if (!SYMBOLP (bucket))
+ error ("Bad data in guts of obarray");
elt = bucket;
eltstring = elt;
if (XSYMBOL (bucket)->next)
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;
}
}
\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 an 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.
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.
+ the input is (or completes to) an element of COLLECTION 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);
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
If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
`all-completions', otherwise invoke `test-completion'.
-The arguments STRING and PREDICATE are as in `try-completion',
+The arguments STRING and PREDICATE are as in `try-completion',
`all-completions', and `test-completion'. */)
(string, predicate, flag)
Lisp_Object string, predicate, flag;
It is used to put faces, `completions-first-difference' and
`completions-common-part' on the completion buffer. The
`completions-common-part' face is put on the common substring
-specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
+specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
and the current buffer is not the minibuffer, the faces are not put.
Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
during running `completion-setup-hook'. */)
that has no possible completions, and other quick, unobtrusive
messages. */
+extern Lisp_Object Vminibuffer_message_timeout;
+
void
temp_echo_area_glyphs (string)
Lisp_Object string;
insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0);
SET_PT_BOTH (opoint, opoint_byte);
Vinhibit_quit = Qt;
- sit_for (make_number (2), 0, 2);
+
+ if (NUMBERP (Vminibuffer_message_timeout))
+ sit_for (Vminibuffer_message_timeout, 0, 2);
+ else
+ sit_for (Qt, 0, 2);
+
del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
SET_PT_BOTH (opoint, opoint_byte);
if (!NILP (Vquit_flag))
Qcase_fold_search = intern ("case-fold-search");
staticpro (&Qcase_fold_search);
+ Qread_expression_history = intern ("read-expression-history");
+ staticpro (&Qread_expression_history);
+
DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
doc: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
Vread_buffer_function = Qnil;
STRING, the current buffer contents;
PREDICATE, the predicate for filtering possible matches;
CODE, which says what kind of things to do.
-CODE can be nil, t or `lambda'.
-nil means to return the best completion of STRING, or nil if there is none.
-t means to return a list of all possible completions of STRING.
-`lambda' means to return t if STRING is a valid completion as it stands. */);
+CODE can be nil, t or `lambda':
+ nil -- return the best completion of STRING, or nil if there is none.
+ t -- return a list of all possible completions of STRING.
+ lambda -- return t if STRING is a valid completion as it stands. */);
Vminibuffer_completion_table = Qnil;
DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
Vminibuffer_prompt_properties
= Fcons (intern ("read-only"), Fcons (Qt, Qnil));
+ DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
+ doc: /* Minibuffer keymap used for reading Lisp expressions. */);
+ Vread_expression_map = Qnil;
+
defsubr (&Sset_minibuffer_window);
defsubr (&Sread_from_minibuffer);
defsubr (&Seval_minibuffer);