/* Minibuffer input and completion.
- Copyright (C) 1985, 1986, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
+#include "charset.h"
#include "dispextern.h"
#include "frame.h"
#include "window.h"
invoke recursive minibuffers (to read arguments, or whatever) */
int enable_recursive_minibuffers;
+/* Nonzero means don't ignore text properties
+ in Fread_from_minibuffer. */
+int minibuffer_allow_text_properties;
+
/* help-form is bound to this while in the minibuffer. */
Lisp_Object Vminibuffer_help_form;
Lisp_Object Qminibuffer_setup_hook, Vminibuffer_setup_hook;
Lisp_Object Qminibuffer_exit_hook, Vminibuffer_exit_hook;
+/* Function to call to read a buffer name. */
+Lisp_Object Vread_buffer_function;
+
/* Nonzero means completion ignores case. */
int completion_ignore_case;
Lisp_Object Quser_variable_p;
+Lisp_Object Qminibuffer_default;
+
/* Non-nil means it is the window for C-M-v to scroll
when the minibuffer is selected. */
extern Lisp_Object Vminibuf_scroll_window;
extern Lisp_Object Voverriding_local_map;
+
+Lisp_Object Qcurrent_input_method, Qactivate_input_method;
+
\f
/* Put minibuf on currently selected frame's minibuffer.
We do this whenever the user starts a new minibuffer
}
}
+Lisp_Object
+choose_minibuf_frame_1 (ignore)
+ Lisp_Object ignore;
+{
+ choose_minibuf_frame ();
+ return Qnil;
+}
+
DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
Sset_minibuffer_window, 1, 1, 0,
"Specify which minibuffer window to use for the minibuffer.\n\
\f
/* Actual minibuffer invocation. */
-void read_minibuf_unwind ();
+static Lisp_Object read_minibuf_unwind ();
Lisp_Object get_minibuffer ();
-Lisp_Object read_minibuf ();
+static Lisp_Object read_minibuf ();
/* Read from the minibuffer using keymap MAP, initial contents INITIAL
(a string), putting point minus BACKUP_N chars from the end of INITIAL,
but if EXPFLAG is nonzero, read it and return the object read.
If HISTVAR is given, save the value read on that history only if it doesn't
match the front of that history list exactly. The value is pushed onto
- the list as the string that was read. */
+ the list as the string that was read.
-Lisp_Object
-read_minibuf (map, initial, prompt, backup_n, expflag, histvar, histpos)
+ DEFALT specifies te default value for the sake of history commands.
+
+ If ALLOW_PROPS is nonzero, we do not throw away text properties.
+
+ if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
+ current input method. */
+
+static Lisp_Object
+read_minibuf (map, initial, prompt, backup_n, expflag,
+ histvar, histpos, defalt, allow_props, inherit_input_method)
Lisp_Object map;
Lisp_Object initial;
Lisp_Object prompt;
int expflag;
Lisp_Object histvar;
Lisp_Object histpos;
+ Lisp_Object defalt;
+ int inherit_input_method;
{
Lisp_Object val;
int count = specpdl_ptr - specpdl;
- Lisp_Object mini_frame, ambient_dir;
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+ Lisp_Object enable_multibyte;
+
+ specbind (Qminibuffer_default, defalt);
single_kboard_state ();
val = Qnil;
ambient_dir = current_buffer->directory;
+ input_method = Qnil;
+ enable_multibyte = Qnil;
/* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
store them away before we can GC. Don't need to protect
BACKUP_N because we use the value only if it is an integer. */
- GCPRO4 (map, initial, val, ambient_dir);
+ GCPRO5 (map, initial, val, ambient_dir, input_method);
if (!STRINGP (prompt))
prompt = build_string ("");
choose_minibuf_frame ();
+ record_unwind_protect (choose_minibuf_frame_1, Qnil);
+
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
Vminibuffer_history_variable = histvar;
Vhelp_form = Vminibuffer_help_form;
+ if (inherit_input_method)
+ {
+ /* `current-input-method' is buffer local. So, remeber it in
+ INPUT_METHOD before changing the current buffer. */
+ input_method = Fsymbol_value (Qcurrent_input_method);
+ enable_multibyte = current_buffer->enable_multibyte_characters;
+ }
+
/* Switch to the minibuffer. */
- Fset_buffer (get_minibuffer (minibuf_level));
+ minibuffer = get_minibuffer (minibuf_level);
+ Fset_buffer (minibuffer);
/* The current buffer's default directory is usually the right thing
for our minibuffer here. However, if you're typing a command at
{
Finsert (1, &initial);
if (!NILP (backup_n) && INTEGERP (backup_n))
- Fforward_char (backup_n);
+ Fgoto_char (make_number (PT + XFASTINT (backup_n)));
}
echo_area_glyphs = 0;
current_buffer->keymap = map;
+ /* Turn on an input method stored in INPUT_METHOD if any. */
+ if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
+ call1 (Qactivate_input_method, input_method);
+
+ /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
+ if (inherit_input_method)
+ current_buffer->enable_multibyte_characters = enable_multibyte;
+
/* Run our hook, but not if it is empty.
(run-hooks would do nothing if it is empty,
but it's important to save time here in the usual case). */
update_frame (selected_frame, 1, 1);
}
- /* Make minibuffer contents into a string */
- val = make_buffer_string (1, Z, 1);
+ /* Make minibuffer contents into a string. */
+ Fset_buffer (minibuffer);
+ val = make_buffer_string (1, Z, allow_props);
#if 0 /* make_buffer_string should handle the gap. */
bcopy (GAP_END_ADDR, XSTRING (val)->data + GPT - BEG, Z - GPT);
#endif
/* VAL is the string of minibuffer text. */
+
+ if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (defalt))
+ val = defalt;
+
last_minibuf_string = val;
/* Add the value to the appropriate history list unless it is empty. */
/* Truncate if requested. */
length = Fget (Vminibuffer_history_variable, Qhistory_length);
if (NILP (length)) length = Vhistory_length;
- if (INTEGERP (length)) {
- if (XINT (length) <= 0)
- Fset (Vminibuffer_history_variable, Qnil);
- else
- {
- Lisp_Object temp;
-
- temp = Fnthcdr (Fsub1 (length), histval);
- if (CONSP (temp)) Fsetcdr (temp, Qnil);
- }
- }
+ if (INTEGERP (length))
+ {
+ if (XINT (length) <= 0)
+ Fset (Vminibuffer_history_variable, Qnil);
+ else
+ {
+ Lisp_Object temp;
+
+ temp = Fnthcdr (Fsub1 (length), histval);
+ if (CONSP (temp)) Fsetcdr (temp, Qnil);
+ }
+ }
}
}
/* This function is called on exiting minibuffer, whether normally or not,
and it restores the current window, buffer, etc. */
-void
+static Lisp_Object
read_minibuf_unwind (data)
Lisp_Object data;
{
unbind_to (count, Qnil);
}
- /* Make the minibuffer follow the selected frame
- (in case we are exiting a recursive minibuffer). */
- choose_minibuf_frame ();
-
/* Make sure minibuffer window is erased, not ignored. */
windows_or_buffers_changed++;
XSETFASTINT (XWINDOW (window)->last_modified, 0);
XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
+
+ return Qnil;
}
\f
for make-docfile to see. We cannot put this in the real DEFUN
due to limits in the Unix cpp.
-DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 5, 0,
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
"Read a string from the minibuffer, prompting with string PROMPT.\n\
If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
to be inserted into the minibuffer before reading input.\n\
In that case, HISTVAR is the history list variable to use,\n\
and HISTPOS is the initial position (the position in the list\n\
which INITIAL-CONTENTS corresponds to).\n\
- Positions are counted starting from 1 at the beginning of the list."
-*/
-
-DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 5, 0,
+ Positions are counted starting from 1 at the beginning of the list.\n\
+Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is used\n\
+ for history commands, and as the value to return if the user enters\n\
+ the empty string.\n\
+Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
+ the current input method and the setting of enable-multibyte-characters.\n\
+If the variable `minibuffer-allow-text-properties is non-nil,\n\
+ then the string which is returned includes whatever text properties\n\
+ were present in the minibuffer. Otherwise the value has no text properties.")
+ (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
+ */
+
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
0 /* See immediately above */)
- (prompt, initial_contents, keymap, read, hist)
- Lisp_Object prompt, initial_contents, keymap, read, hist;
+ (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;
{
int pos = 0;
- Lisp_Object histvar, histpos, position;
+ Lisp_Object histvar, histpos, position, val;
+ struct gcpro gcpro1;
+
position = Qnil;
CHECK_STRING (prompt, 0);
if (NILP (keymap))
keymap = Vminibuffer_local_map;
else
- keymap = get_keymap (keymap,2);
+ keymap = get_keymap (keymap);
if (SYMBOLP (hist))
{
if (NILP (histpos))
XSETFASTINT (histpos, 0);
- return read_minibuf (keymap, initial_contents, prompt,
- make_number (pos), !NILP (read), histvar, histpos);
+ GCPRO1 (default_value);
+ val = read_minibuf (keymap, initial_contents, prompt,
+ make_number (pos), !NILP (read),
+ histvar, histpos, default_value,
+ minibuffer_allow_text_properties,
+ !NILP (inherit_input_method));
+ UNGCPRO;
+ return val;
}
DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
if (!NILP (initial_contents))
CHECK_STRING (initial_contents, 1);
return read_minibuf (Vminibuffer_local_map, initial_contents,
- prompt, Qnil, 1, Qminibuffer_history, make_number (0));
+ prompt, Qnil, 1, Qminibuffer_history,
+ make_number (0), Qnil, 0, 0);
}
DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
/* Functions that use the minibuffer to read various things. */
-DEFUN ("read-string", Fread_string, Sread_string, 1, 3, 0,
+DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
"Read a string from the minibuffer, prompting with string PROMPT.\n\
If non-nil, second arg INITIAL-INPUT is a string to insert before reading.\n\
The third arg HISTORY, if non-nil, specifies a history list\n\
and optionally the initial position in the list.\n\
-See `read-from-minibuffer' for details of HISTORY argument.")
- (prompt, initial_input, history)
- Lisp_Object prompt, initial_input, history;
+See `read-from-minibuffer' for details of HISTORY argument.\n\
+Fourth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
+ the current input method and the setting of enable-multibyte-characters.")
+ (prompt, initial_input, history, default_value, inherit_input_method)
+ Lisp_Object prompt, initial_input, history, default_value;
+ Lisp_Object inherit_input_method;
{
- return Fread_from_minibuffer (prompt, initial_input, Qnil, Qnil, history);
+ return Fread_from_minibuffer (prompt, initial_input, Qnil,
+ Qnil, history, default_value,
+ inherit_input_method);
}
-DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 2, 0,
+DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
"Args PROMPT and INIT, strings. Read a string from the terminal, not allowing blanks.\n\
-Prompt with PROMPT, and provide INIT as an initial value of the input string.")
- (prompt, init)
- Lisp_Object prompt, init;
+Prompt with PROMPT, and provide INIT as an initial value of the input string.\n\
+Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
+the current input method and the setting of enable-multibyte-characters.")
+ (prompt, init, inherit_input_method)
+ Lisp_Object prompt, init, inherit_input_method;
{
CHECK_STRING (prompt, 0);
if (! NILP (init))
CHECK_STRING (init, 1);
- return read_minibuf (Vminibuffer_local_ns_map, init, prompt, Qnil, 0,
- Qminibuffer_history, make_number (0));
+ return read_minibuf (Vminibuffer_local_ns_map, init, prompt, Qnil,
+ 0, Qminibuffer_history, make_number (0), Qnil, 0,
+ !NILP (inherit_input_method));
}
-DEFUN ("read-command", Fread_command, Sread_command, 1, 1, 0,
- "One arg PROMPT, a string. Read the name of a command and return as a symbol.\n\
-Prompts with PROMPT.")
- (prompt)
- Lisp_Object prompt;
+DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
+ "Read the name of a command and return as a symbol.\n\
+Prompts with PROMPT. By default, return DEFAULT-VALUE.")
+ (prompt, default_value)
+ Lisp_Object prompt, default_value;
{
- return Fintern (Fcompleting_read (prompt, Vobarray, Qcommandp, Qt, Qnil, Qnil),
- Qnil);
+ Lisp_Object name, default_string;
+
+ if (NILP (default_value))
+ default_string = Qnil;
+ else if (SYMBOLP (default_value))
+ default_string = XSYMBOL (default_value)->name;
+ else
+ default_string = default_value;
+
+ name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
+ Qnil, Qnil, default_string, Qnil);
+ if (NILP (name))
+ return name;
+ return Fintern (name, Qnil);
}
#ifdef NOTDEF
(prompt)
Lisp_Object prompt;
{
- return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil),
+ return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
Qnil);
}
#endif /* NOTDEF */
-DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 1, 0,
- "One arg PROMPT, a string. Read the name of a user variable and return\n\
-it as a symbol. Prompts with PROMPT.\n\
+DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
+ "Read the name of a user variable and return it as a symbol.\n\
+Prompts with PROMPT. By default, return DEFAULT-VALUE.\n\
A user variable is one whose documentation starts with a `*' character.")
- (prompt)
- Lisp_Object prompt;
+ (prompt, default_value)
+ Lisp_Object prompt, default_value;
{
- return Fintern (Fcompleting_read (prompt, Vobarray,
- Quser_variable_p, Qt, Qnil, Qnil),
- Qnil);
+ Lisp_Object name, default_string;
+
+ if (NILP (default_value))
+ default_string = Qnil;
+ else if (SYMBOLP (default_value))
+ default_string = XSYMBOL (default_value)->name;
+ else
+ default_string = default_value;
+
+ name = Fcompleting_read (prompt, Vobarray,
+ Quser_variable_p, Qt,
+ Qnil, Qnil, default_string, Qnil);
+ if (NILP (name))
+ return name;
+ return Fintern (name, Qnil);
}
DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
"One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
Prompts with PROMPT.\n\
-Optional second arg is value to return if user enters an empty line.\n\
+Optional second arg DEF is value to return if user enters an empty line.\n\
If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
(prompt, def, require_match)
Lisp_Object prompt, def, require_match;
{
Lisp_Object tem;
- Lisp_Object args[3];
- struct gcpro gcpro1;
-
+ Lisp_Object args[4];
+
if (BUFFERP (def))
def = XBUFFER (def)->name;
- if (!NILP (def))
+
+ if (NILP (Vread_buffer_function))
+ {
+ if (!NILP (def))
+ {
+ args[0] = build_string ("%s(default %s) ");
+ args[1] = prompt;
+ args[2] = def;
+ prompt = Fformat (3, args);
+ }
+
+ return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
+ require_match, Qnil, Qnil, def, Qnil);
+ }
+ else
{
- args[0] = build_string ("%s(default %s) ");
+ args[0] = Vread_buffer_function;
args[1] = prompt;
args[2] = def;
- prompt = Fformat (3, args);
+ args[3] = require_match;
+ return Ffuncall(4, args);
}
- GCPRO1 (def);
- tem = Fcompleting_read (prompt, Vbuffer_alist, Qnil, require_match, Qnil, Qnil);
- UNGCPRO;
- if (XSTRING (tem)->size)
- return tem;
- return def;
}
\f
DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
int len;
{
register int l = len;
+ register unsigned char *start = s1;
if (completion_ignore_case)
{
if (l == 0)
return -1;
else
- return len - l;
+ {
+ int match = len - l;
+
+ /* Now *--S1 is the unmatching byte. If it is in the middle of
+ multi-byte form, we must say that the multi-byte character
+ there doesn't match. */
+ while (match && *--s1 >= 0xA0) match--;
+ return match;
+ }
}
\f
DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
for make-docfile to see. We cannot put this in the real DEFUN
due to limits in the Unix cpp.
-DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 6, 0,
+DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
"Read a string in the minibuffer, with completion.\n\
PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
TABLE is an alist whose elements' cars are strings, or an obarray.\n\
and HISTPOS is the initial position (the position in the list\n\
which INITIAL-CONTENTS corresponds to).\n\
Positions are counted starting from 1 at the beginning of the list.\n\
+DEF, if non-nil, is the default value.\n\
+\n\
+If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits\n\
+ the current input method and the setting of enable-multibyte-characters.\n\
+\n\
Completion ignores case if the ambient value of\n\
`completion-ignore-case' is non-nil."
*/
-DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 6, 0,
+DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
0 /* See immediately above */)
- (prompt, table, predicate, require_match, init, hist)
- Lisp_Object prompt, table, predicate, require_match, init, hist;
+ (prompt, table, predicate, require_match, init, hist, def, inherit_input_method)
+ Lisp_Object prompt, table, predicate, require_match, init, hist, def;
+ Lisp_Object inherit_input_method;
{
Lisp_Object val, histvar, histpos, position;
int pos = 0;
int count = specpdl_ptr - specpdl;
+ struct gcpro gcpro1;
+ int disable_multibyte = EQ (table, Qread_file_name_internal);
+
+ GCPRO1 (def);
+
specbind (Qminibuffer_completion_table, table);
specbind (Qminibuffer_completion_predicate, predicate);
specbind (Qminibuffer_completion_confirm,
? Vminibuffer_local_completion_map
: Vminibuffer_local_must_match_map,
init, prompt, make_number (pos), 0,
- histvar, histpos);
- return unbind_to (count, val);
+ histvar, histpos, def, 0,
+ !NILP (inherit_input_method));
+ RETURN_UNGCPRO (unbind_to (count, val));
}
\f
Lisp_Object Fminibuffer_completion_help ();
tem = Fpos_visible_in_window_p (make_number (ZV), window);
if (! NILP (tem))
/* If end is in view, scroll up to the beginning. */
- Fset_window_start (window, BEGV, Qnil);
+ Fset_window_start (window, make_number (BEGV), Qnil);
else
/* Else scroll down one screen. */
Fscroll_other_window (Qnil);
/* Now find first word-break in the stuff found by completion.
i gets index in string of where to stop completing. */
+ {
+ int len, c;
- completion_string = XSTRING (completion)->data;
-
- for (; i < XSTRING (completion)->size; i++)
- if (SYNTAX (completion_string[i]) != Sword) break;
- if (i < XSTRING (completion)->size)
- i = i + 1;
+ completion_string = XSTRING (completion)->data;
+ for (; i < XSTRING (completion)->size; i += len)
+ {
+ c = STRING_CHAR_AND_LENGTH (completion_string + i,
+ XSTRING (completion)->size - i,
+ len);
+ if (SYNTAX (c) != Sword)
+ {
+ i += len;
+ break;
+ }
+ }
+ }
/* If got no characters, print help for user. */
/* Compute the length of this element. */
if (CONSP (elt))
{
- tem = Fcar (elt);
+ tem = XCAR (elt);
CHECK_STRING (tem, 0);
- length = XINT (XSTRING (tem)->size);
+ length = XSTRING (tem)->size;
- tem = Fcar (Fcdr (elt));
+ tem = Fcar (XCDR (elt));
CHECK_STRING (tem, 0);
- length += XINT (XSTRING (tem)->size);
+ length += XSTRING (tem)->size;
}
else
{
CHECK_STRING (elt, 0);
- length = XINT (XSTRING (elt)->size);
+ length = XSTRING (elt)->size;
}
/* This does a bad job for narrower than usual windows.
that has no possible completions, and other quick, unobtrusive
messages. */
+void
temp_echo_area_glyphs (m)
char *m;
{
return Qnil;
}
\f
+void
init_minibuf_once ()
{
Vminibuffer_list = Qnil;
staticpro (&Vminibuffer_list);
}
+void
syms_of_minibuf ()
{
minibuf_level = 0;
Qread_file_name_internal = intern ("read-file-name-internal");
staticpro (&Qread_file_name_internal);
+ Qminibuffer_default = intern ("minibuffer-default");
+ staticpro (&Qminibuffer_default);
+ Fset (Qminibuffer_default, Qnil);
+
Qminibuffer_completion_table = intern ("minibuffer-completion-table");
staticpro (&Qminibuffer_completion_table);
Qhistory_length = intern ("history-length");
staticpro (&Qhistory_length);
+ Qcurrent_input_method = intern ("current-input-method");
+ staticpro (&Qcurrent_input_method);
+
+ Qactivate_input_method = intern ("activate-input-method");
+ staticpro (&Qactivate_input_method);
+
+ DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
+ "If this is non-nil, `read-buffer' does its work by calling this function.");
+ Vread_buffer_function = Qnil;
+
DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
"Normal hook run just after entry to minibuffer.");
Vminibuffer_setup_hook = Qnil;
DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
"*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
-More precisely, this variable makes a difference when the minibuffer window\n\
-is the selected window. If you are in some other window, minibuffer commands\n\
-are allowed even if a minibuffer is active.");
+This variable makes a difference whenever the minibuffer window is active.");
enable_recursive_minibuffers = 0;
DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
"List of regexps that should restrict possible completions.");
Vcompletion_regexp_list = Qnil;
+ DEFVAR_BOOL ("minibuffer-allow-text-properties",
+ &minibuffer_allow_text_properties,
+ "Non-nil means `read-from-miniffer' should not discard text properties.\n\
+This also affects `read-string', but it does not affect `read-minibuffer',\n\
+`read-no-blanks-input', or any of the functions that do minibuffer input\n\
+with completion; they always discard text properties.");
+ minibuffer_allow_text_properties = 0;
+
defsubr (&Sset_minibuffer_window);
defsubr (&Sread_from_minibuffer);
defsubr (&Seval_minibuffer);
defsubr (&Sminibuffer_message);
}
+void
keys_of_minibuf ()
{
initial_define_key (Vminibuffer_local_map, Ctl ('g'),