/* Minibuffer input and completion.
Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005,
+ 2006 Free Software Foundation, Inc.
This file is part of GNU Emacs.
int history_delete_duplicates;
+/* Non-nil means add new input to history. */
+
+Lisp_Object Vhistory_add_new_input;
+
/* Fread_minibuffer leaves the input here as a string. */
Lisp_Object last_minibuf_string;
static Lisp_Object last_exact_completion;
-extern Lisp_Object Voverriding_local_map;
+/* Keymap for reading expressions. */
+Lisp_Object Vread_expression_map;
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;
Lisp_Object, Lisp_Object,
int, Lisp_Object,
Lisp_Object, Lisp_Object,
- int, int, int));
+ int, int));
static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object,
int, Lisp_Object,
static Lisp_Object
read_minibuf (map, initial, prompt, backup_n, expflag,
- histvar, histpos, defalt, allow_props, inherit_input_method,
- keep_all)
+ histvar, histpos, defalt, allow_props, inherit_input_method)
Lisp_Object map;
Lisp_Object initial;
Lisp_Object prompt;
Lisp_Object defalt;
int allow_props;
int inherit_input_method;
- int keep_all;
{
Lisp_Object val;
int count = SPECPDL_INDEX ();
/* String to add to the history. */
Lisp_Object histstring;
+ Lisp_Object empty_minibuf;
+ Lisp_Object dummy, frame;
+
extern Lisp_Object Qfront_sticky;
extern Lisp_Object Qrear_nonsticky;
build_string ("Command attempted to use minibuffer while in minibuffer"));
}
- if (noninteractive)
+ if (noninteractive && NILP (Vexecuting_kbd_macro))
{
val = read_minibuf_noninteractive (map, initial, prompt,
make_number (pos),
Vminibuf_scroll_window = selected_window;
if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
minibuf_selected_window = selected_window;
+
+ /* Empty out the minibuffers of all frames other than the one
+ where we are going to display one now.
+ Set them to point to ` *Minibuf-0*', which is always empty. */
+ empty_minibuf = Fget_buffer (build_string (" *Minibuf-0*"));
+
+ FOR_EACH_FRAME (dummy, frame)
+ {
+ Lisp_Object root_window = Fframe_root_window (frame);
+ Lisp_Object mini_window = XWINDOW (root_window)->next;
+
+ if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
+ && !NILP (Fwindow_minibuffer_p (mini_window)))
+ Fset_window_buffer (mini_window, empty_minibuf, Qnil);
+ }
+
+ /* Display this minibuffer in the proper window. */
Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
Fselect_window (minibuf_window, Qnil);
XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
last_minibuf_string = val;
/* Choose the string to add to the history. */
- if (SCHARS (val) != 0 || keep_all)
+ if (SCHARS (val) != 0)
histstring = val;
else if (STRINGP (defalt))
histstring = defalt;
histstring = Qnil;
/* Add the value to the appropriate history list, if any. */
- if (SYMBOLP (Vminibuffer_history_variable)
+ if (!NILP (Vhistory_add_new_input)
+ && SYMBOLP (Vminibuffer_history_variable)
&& !NILP (histstring))
{
/* If the caller wanted to save the value read on a history list,
if (NILP (histval)
|| (CONSP (histval)
/* Don't duplicate the most recent entry in the history. */
- && (keep_all
- || NILP (Fequal (histstring, Fcar (histval))))))
+ && (NILP (Fequal (histstring, Fcar (histval))))))
{
Lisp_Object length;
}
\f
-DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 8, 0,
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
doc: /* Read a string from the minibuffer, prompting with string PROMPT.
The optional second arg INITIAL-CONTENTS is an obsolete alternative to
DEFAULT-VALUE. It normally should be nil in new code, except when
the empty string.
Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
the current input method and the setting of `enable-multibyte-characters'.
-Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
- even empty or duplicate inputs.
If the variable `minibuffer-allow-text-properties' is non-nil,
then the string which is returned includes whatever text properties
were present in the minibuffer. Otherwise the value has no text properties.
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, keep_all)
+ (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, keep_all;
+ Lisp_Object inherit_input_method;
{
Lisp_Object histvar, histpos, val;
struct gcpro gcpro1;
Qnil, !NILP (read),
histvar, histpos, default_value,
minibuffer_allow_text_properties,
- !NILP (inherit_input_method),
- !NILP (keep_all));
+ !NILP (inherit_input_method));
UNGCPRO;
return val;
}
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;
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_map, initial_contents,
prompt, Qnil, 1, Qminibuffer_history,
- make_number (0), Qnil, 0, 0, 0);
+ make_number (0), Qnil, 0, 0);
}
DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
(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. */
Lisp_Object val;
val = Fread_from_minibuffer (prompt, initial_input, Qnil,
Qnil, history, default_value,
- inherit_input_method, Qnil);
+ inherit_input_method);
if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
val = default_value;
return val;
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
0, Qminibuffer_history, make_number (0), Qnil, 0,
- !NILP (inherit_input_method), 0);
+ !NILP (inherit_input_method));
}
DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
prompt = Fformat (3, args);
}
- return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
- require_match, Qnil, Qbuffer_name_history,
+ return Fcompleting_read (prompt, intern ("internal-complete-buffer"),
+ Qnil, require_match, Qnil, Qbuffer_name_history,
def, Qnil);
}
else
tail = alist;
if (type == 2)
{
+ alist = check_obarray (alist);
obsize = XVECTOR (alist)->size;
bucket = XVECTOR (alist)->contents[index];
}
{
if (!EQ (bucket, zero))
{
+ if (!SYMBOLP (bucket))
+ error ("Bad data in guts of obarray");
elt = bucket;
eltstring = elt;
if (XSYMBOL (bucket)->next)
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 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.
See `try-completion' and `all-completions' for more details
: Vminibuffer_local_must_match_filename_map),
init, prompt, make_number (pos), 0,
histvar, histpos, def, 0,
- !NILP (inherit_input_method), 0);
+ !NILP (inherit_input_method));
if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
val = def;
return Qt;
}
+DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
+ doc: /* Perform completion on buffer names.
+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',
+`all-completions', and `test-completion'. */)
+ (string, predicate, flag)
+ Lisp_Object string, predicate, flag;
+{
+ if (NILP (flag))
+ return Ftry_completion (string, Vbuffer_alist, predicate);
+ else if (EQ (flag, Qt))
+ return Fall_completions (string, Vbuffer_alist, predicate, Qt);
+ else /* assume `lambda' */
+ return Ftest_completion (string, Vbuffer_alist, predicate);
+}
+
/* returns:
* 0 no possible completion
* 1 was already an exact and unique completion
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;
- Fsit_for (make_number (2), Qnil, Qnil);
+
+ 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;
DEFVAR_LISP ("history-length", &Vhistory_length,
doc: /* *Maximum length for history lists before truncation takes place.
A number means that length; t means infinite. Truncation takes place
-just after a new element is inserted. Setting the history-length
+just after a new element is inserted. Setting the `history-length'
property of a history variable overrides this default. */);
XSETFASTINT (Vhistory_length, 30);
DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
doc: /* *Non-nil means to delete duplicates in history.
If set to t when adding a new history element, all previous identical
-elements are deleted. */);
+elements are deleted from the history list. */);
history_delete_duplicates = 0;
+ DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input,
+ doc: /* *Non-nil means to add new elements in history.
+If set to nil, minibuffer reading functions don't add new elements to the
+history list, so it is possible to do this afterwards by calling
+`add-to-history' explicitly. */);
+ Vhistory_add_new_input = Qt;
+
DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
doc: /* *Non-nil means automatically provide help for invalid completion input.
Under Partial Completion mode, a non-nil, non-t value has a special meaning;
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);
defsubr (&Sread_string);
defsubr (&Sread_command);
defsubr (&Sread_variable);
+ defsubr (&Sinternal_complete_buffer);
defsubr (&Sread_buffer);
defsubr (&Sread_no_blanks_input);
defsubr (&Sminibuffer_depth);