/* Minibuffer input and completion.
- Copyright (C) 1985, 1986, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 93, 94, 95, 1996 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <config.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
+#include "charset.h"
#include "dispextern.h"
#include "frame.h"
#include "window.h"
#include "syntax.h"
+#include "keyboard.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
/* Depth in minibuffer invocations. */
int minibuf_level;
-/* Nonzero means display completion help for invalid input */
+/* Nonzero means display completion help for invalid input. */
int auto_help;
+/* The maximum length of a minibuffer history. */
+Lisp_Object Qhistory_length, Vhistory_length;
+
/* Fread_minibuffer leaves the input here as a string. */
Lisp_Object last_minibuf_string;
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 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;
\f
+/* Put minibuf on currently selected frame's minibuffer.
+ We do this whenever the user starts a new minibuffer
+ or when a minibuffer exits. */
+
+void
+choose_minibuf_frame ()
+{
+ if (selected_frame != 0
+ && !EQ (minibuf_window, selected_frame->minibuffer_window))
+ {
+ /* I don't think that any frames may validly have a null minibuffer
+ window anymore. */
+ if (NILP (selected_frame->minibuffer_window))
+ abort ();
+
+ Fset_window_buffer (selected_frame->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer);
+ minibuf_window = selected_frame->minibuffer_window;
+ }
+
+ /* Make sure no other frame has a minibuffer as its selected window,
+ because the text would not be displayed in it, and that would be
+ confusing. Only allow the selected frame to do this,
+ and that only if the minibuffer is active. */
+ {
+ Lisp_Object tail, frame;
+
+ FOR_EACH_FRAME (tail, frame)
+ if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
+ && !(XFRAME (frame) == selected_frame
+ && minibuf_level > 0))
+ Fset_frame_selected_window (frame, Fframe_first_window (frame));
+ }
+}
+
+DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
+ Sset_minibuffer_window, 1, 1, 0,
+ "Specify which minibuffer window to use for the minibuffer.\n\
+This effects where the minibuffer is displayed if you put text in it\n\
+without invoking the usual minibuffer commands.")
+ (window)
+ Lisp_Object window;
+{
+ CHECK_WINDOW (window, 1);
+ if (! MINI_WINDOW_P (XWINDOW (window)))
+ error ("Window is not a minibuffer window");
+
+ minibuf_window = window;
+
+ return window;
+}
+
+\f
/* Actual minibuffer invocation. */
-void read_minibuf_unwind ();
+static void 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. */
+
+static Lisp_Object
+read_minibuf (map, initial, prompt, backup_n, expflag,
+ histvar, histpos, defalt, allow_props)
Lisp_Object map;
Lisp_Object initial;
Lisp_Object prompt;
int expflag;
Lisp_Object histvar;
Lisp_Object histpos;
+ Lisp_Object defalt;
{
Lisp_Object val;
int count = specpdl_ptr - specpdl;
- Lisp_Object mini_frame;
- struct gcpro gcpro1, gcpro2, gcpro3;
+ Lisp_Object mini_frame, ambient_dir, minibuffer;
+ struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+
+ specbind (Qminibuffer_default, defalt);
single_kboard_state ();
val = Qnil;
+ ambient_dir = current_buffer->directory;
+
/* 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. */
- GCPRO3 (map, initial, val);
+ GCPRO4 (map, initial, val, ambient_dir);
if (!STRINGP (prompt))
prompt = build_string ("");
if (!enable_recursive_minibuffers
- && minibuf_level > 0
- && (EQ (selected_window, minibuf_window)))
-#if 0
- || selected_frame != XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)))
-#endif
- error ("Command attempted to use minibuffer while in minibuffer");
+ && minibuf_level > 0)
+ {
+ if (EQ (selected_window, minibuf_window))
+ error ("Command attempted to use minibuffer while in minibuffer");
+ else
+ /* If we're in another window, cancel the minibuffer that's active. */
+ Fthrow (Qexit,
+ build_string ("Command attempted to use minibuffer while in minibuffer"));
+ }
- /* Could we simply bind these variables instead? */
- minibuf_save_list
- = Fcons (minibuf_prompt,
- Fcons (make_number (minibuf_prompt_width),
- Fcons (Vhelp_form,
- Fcons (Vcurrent_prefix_arg,
- Fcons (Vminibuffer_history_position,
- Fcons (Vminibuffer_history_variable,
- Fcons (Voverriding_local_map,
- minibuf_save_list)))))));
- minibuf_prompt_width = 0; /* xdisp.c puts in the right value. */
- minibuf_prompt = Fcopy_sequence (prompt);
- Vminibuffer_history_position = histpos;
- Vminibuffer_history_variable = histvar;
+ /* Choose the minibuffer window and frame, and take action on them. */
+
+ choose_minibuf_frame ();
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
/* If the minibuffer window is on a different frame, save that
frame's configuration too. */
-#ifdef MULTI_FRAME
mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
if (XFRAME (mini_frame) != selected_frame)
record_unwind_protect (Fset_window_configuration,
if (minibuffer_auto_raise)
Fraise_frame (mini_frame);
-#endif
- val = current_buffer->directory;
- Fset_buffer (get_minibuffer (minibuf_level));
+ /* We have to do this after saving the window configuration
+ since that is what restores the current buffer. */
+
+ /* Arrange to restore a number of minibuffer-related variables.
+ We could bind each variable separately, but that would use lots of
+ specpdl slots. */
+ minibuf_save_list
+ = Fcons (Voverriding_local_map,
+ Fcons (minibuf_window, minibuf_save_list));
+ minibuf_save_list
+ = Fcons (minibuf_prompt,
+ Fcons (make_number (minibuf_prompt_width),
+ Fcons (Vhelp_form,
+ Fcons (Vcurrent_prefix_arg,
+ Fcons (Vminibuffer_history_position,
+ Fcons (Vminibuffer_history_variable,
+ minibuf_save_list))))));
+
+ record_unwind_protect (read_minibuf_unwind, Qnil);
+ minibuf_level++;
+
+ /* Now that we can restore all those variables, start changing them. */
+
+ minibuf_prompt_width = 0; /* xdisp.c puts in the right value. */
+ minibuf_prompt = Fcopy_sequence (prompt);
+ Vminibuffer_history_position = histpos;
+ Vminibuffer_history_variable = histvar;
+ Vhelp_form = Vminibuffer_help_form;
+
+ /* Switch to the minibuffer. */
+
+ 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
up Emacs and buf's default directory is Qnil. Here's a hack; can
you think of something better to do? Find another buffer with a
better directory, and use that one instead. */
- if (STRINGP (val))
- current_buffer->directory = val;
+ if (STRINGP (ambient_dir))
+ current_buffer->directory = ambient_dir;
else
{
Lisp_Object buf_list;
}
}
-#ifdef MULTI_FRAME
if (XFRAME (mini_frame) != selected_frame)
Fredirect_frame_focus (Fselected_frame (), mini_frame);
-#endif
- Fmake_local_variable (Qprint_escape_newlines);
- print_escape_newlines = 1;
-
- record_unwind_protect (read_minibuf_unwind, Qnil);
Vminibuf_scroll_window = selected_window;
Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
Fselect_window (minibuf_window);
XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
- Ferase_buffer ();
- minibuf_level++;
+ Fmake_local_variable (Qprint_escape_newlines);
+ print_escape_newlines = 1;
+
+ /* Erase the buffer. */
+ {
+ int count1 = specpdl_ptr - specpdl;
+ specbind (Qinhibit_read_only, Qt);
+ Ferase_buffer ();
+ unbind_to (count1, Qnil);
+ }
+ /* Put in the initial input. */
if (!NILP (initial))
{
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;
/* This is in case the minibuffer-setup-hook calls Fsit_for. */
previous_echo_glyphs = 0;
- Vhelp_form = Vminibuffer_help_form;
current_buffer->keymap = map;
/* 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. */
+ but it's important to save time here in the usual case). */
if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
&& !NILP (Vrun_hooks))
call1 (Vrun_hooks, Qminibuffer_setup_hook);
>= XFASTINT (XWINDOW (minibuf_window)->top))
&& !noninteractive)
{
- FRAME_CURSOR_X (selected_frame) = 0;
+ FRAME_CURSOR_X (selected_frame)
+ = FRAME_LEFT_SCROLL_BAR_WIDTH (selected_frame);
update_frame (selected_frame, 1, 1);
}
- /* Make minibuffer contents into a string */
- val = make_buffer_string (1, Z);
+ /* 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. */
last_minibuf_string = val;
if (NILP (histval)
|| (CONSP (histval)
&& NILP (Fequal (last_minibuf_string, Fcar (histval)))))
- Fset (Vminibuffer_history_variable,
- Fcons (last_minibuf_string, histval));
+ {
+ Lisp_Object length;
+
+ histval = Fcons (last_minibuf_string, histval);
+ Fset (Vminibuffer_history_variable, histval);
+
+ /* 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 Lisp form desired instead of string, parse it. */
/* This function is called on exiting minibuffer, whether normally or not,
and it restores the current window, buffer, etc. */
-void
+static void
read_minibuf_unwind (data)
Lisp_Object data;
{
Lisp_Object old_deactivate_mark;
+ Lisp_Object window;
/* We are exiting the minibuffer one way or the other,
so run the hook. */
if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
&& !NILP (Vrun_hooks))
- call1 (Vrun_hooks, Qminibuffer_exit_hook);
-
- /* Erase the minibuffer we were using at this level. */
- Fset_buffer (XWINDOW (minibuf_window)->buffer);
-
- /* Prevent error in erase-buffer. */
- current_buffer->read_only = Qnil;
-
- old_deactivate_mark = Vdeactivate_mark;
- Ferase_buffer ();
- Vdeactivate_mark = old_deactivate_mark;
+ safe_run_hooks (Qminibuffer_exit_hook);
/* If this was a recursive minibuffer,
- tie the minibuffer window back to the outer level minibuffer buffer */
+ tie the minibuffer window back to the outer level minibuffer buffer. */
minibuf_level--;
- /* Make sure minibuffer window is erased, not ignored */
- windows_or_buffers_changed++;
- XSETFASTINT (XWINDOW (minibuf_window)->last_modified, 0);
- /* Restore prompt, etc from outer minibuffer */
+ window = minibuf_window;
+ /* To keep things predictable, in case it matters, let's be in the minibuffer
+ when we reset the relevant variables. */
+ Fset_buffer (XWINDOW (window)->buffer);
+
+ /* Restore prompt, etc, from outer minibuffer level. */
minibuf_prompt = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
minibuf_save_list = Fcdr (minibuf_save_list);
Voverriding_local_map = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
+#if 0
+ temp = Fcar (minibuf_save_list);
+ if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
+ minibuf_window = temp;
+#endif
+ minibuf_save_list = Fcdr (minibuf_save_list);
+
+ /* Erase the minibuffer we were using at this level. */
+ {
+ int count = specpdl_ptr - specpdl;
+ /* Prevent error in erase-buffer. */
+ specbind (Qinhibit_read_only, Qt);
+ old_deactivate_mark = Vdeactivate_mark;
+ Ferase_buffer ();
+ Vdeactivate_mark = old_deactivate_mark;
+ 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);
}
\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, 6, 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\
If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
- is STRING, but point is placed POSITION characters into the string.\n\
+ is STRING, but point is placed at position POSITION in the minibuffer.\n\
Third arg KEYMAP is a keymap to use whilst reading;\n\
if omitted or nil, the default is `minibuffer-local-map'.\n\
If fourth arg READ is non-nil, then interpret the result as a lisp object\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\
+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. */
+
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 6, 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)
+ Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
{
int pos = 0;
- Lisp_Object histvar, histpos, position;
+ Lisp_Object histvar, histpos, position, val;
+ struct gcpro gcpro1;
+
position = Qnil;
CHECK_STRING (prompt, 0);
{
CHECK_NUMBER (position, 0);
/* Convert to distance from end of input. */
- pos = XINT (position) - 1 - XSTRING (initial_contents)->size;
+ if (XINT (position) < 1)
+ /* A number too small means the beginning of the string. */
+ pos = - XSTRING (initial_contents)->size;
+ else
+ pos = XINT (position) - 1 - XSTRING (initial_contents)->size;
}
}
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);
+ if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (default_value))
+ val = default_value;
+ 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);
}
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, 4, 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;
+ (prompt, initial_input, history, default_value)
+ Lisp_Object prompt, initial_input, history, default_value;
{
- return Fread_from_minibuffer (prompt, initial_input, Qnil, Qnil, history);
+ return Fread_from_minibuffer (prompt, initial_input, Qnil,
+ Qnil, history, default_value);
}
DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 2, 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);
}
-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),
+ return Fintern (Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
+ Qnil, Qnil, default_value),
Qnil);
}
(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);
}
#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),
+ Quser_variable_p, Qt,
+ Qnil, Qnil, default_value),
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;
if (BUFFERP (def))
def = XBUFFER (def)->name;
args[2] = def;
prompt = Fformat (3, args);
}
- GCPRO1 (def);
- tem = Fcompleting_read (prompt, Vbuffer_alist, Qnil, require_match, Qnil, Qnil);
- UNGCPRO;
- if (XSTRING (tem)->size)
- return tem;
- return def;
+ return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
+ require_match, Qnil, Qnil, def);
}
\f
DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
The match is a candidate only if PREDICATE returns non-nil.\n\
The argument given to PREDICATE is the alist element\n\
or the symbol from the obarray.")
- (string, alist, pred)
- Lisp_Object string, alist, pred;
+ (string, alist, predicate)
+ Lisp_Object string, alist, predicate;
{
Lisp_Object bestmatch, tail, elt, eltstring;
int bestmatchsize;
CHECK_STRING (string, 0);
if (!list && !VECTORP (alist))
- return call3 (alist, string, pred, Qnil);
+ return call3 (alist, string, predicate, Qnil);
bestmatch = Qnil;
/* Ignore this element if there is a predicate
and the predicate doesn't like it. */
- if (!NILP (pred))
+ if (!NILP (predicate))
{
- if (EQ (pred, Qcommandp))
+ if (EQ (predicate, Qcommandp))
tem = Fcommandp (elt);
else
{
GCPRO4 (tail, string, eltstring, bestmatch);
- tem = call1 (pred, elt);
+ tem = call1 (predicate, elt);
UNGCPRO;
}
if (NILP (tem)) continue;
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,
If the optional fourth argument HIDE-SPACES is non-nil,\n\
strings in ALIST that start with a space\n\
are ignored unless STRING itself starts with a space.")
- (string, alist, pred, hide_spaces)
- Lisp_Object string, alist, pred, hide_spaces;
+ (string, alist, predicate, hide_spaces)
+ Lisp_Object string, alist, predicate, hide_spaces;
{
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
CHECK_STRING (string, 0);
if (!list && !VECTORP (alist))
{
- return call3 (alist, string, pred, Qt);
+ return call3 (alist, string, predicate, Qt);
}
allmatches = Qnil;
/* Ignore this element if there is a predicate
and the predicate doesn't like it. */
- if (!NILP (pred))
+ if (!NILP (predicate))
{
- if (EQ (pred, Qcommandp))
+ if (EQ (predicate, Qcommandp))
tem = Fcommandp (elt);
else
{
GCPRO4 (tail, eltstring, allmatches, string);
- tem = call1 (pred, elt);
+ tem = call1 (predicate, elt);
UNGCPRO;
}
if (NILP (tem)) continue;
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, 7, 0,
"Read a string in the minibuffer, with completion.\n\
-Args: PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST.\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\
PREDICATE limits completion to a subset of TABLE.\n\
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
the input is (or completes to) an element of TABLE or is null.\n\
If it is also not t, Return does not exit if it does non-null completion.\n\
-If the input is null, `completing-read' returns nil,\n\
+If the input is null, `completing-read' returns an empty string,\n\
regardless of the value of REQUIRE-MATCH.\n\
\n\
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\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.
+
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, 7, 0,
0 /* See immediately above */)
- (prompt, table, pred, require_match, init, hist)
- Lisp_Object prompt, table, pred, require_match, init, hist;
+ (prompt, table, predicate, require_match, init, hist, def)
+ Lisp_Object prompt, table, predicate, require_match, init, hist, def;
{
Lisp_Object val, histvar, histpos, position;
int pos = 0;
int count = specpdl_ptr - specpdl;
specbind (Qminibuffer_completion_table, table);
- specbind (Qminibuffer_completion_predicate, pred);
+ specbind (Qminibuffer_completion_predicate, predicate);
specbind (Qminibuffer_completion_confirm,
EQ (require_match, Qt) ? Qnil : Qt);
last_exact_completion = Qnil;
? Vminibuffer_local_completion_map
: Vminibuffer_local_must_match_map,
init, prompt, make_number (pos), 0,
- histvar, histpos);
+ histvar, histpos, def, 0);
+ if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (def))
+ val = def;
return unbind_to (count, val);
}
\f
-/* Temporarily display the string M at the end of the current
- minibuffer contents. This is used to display things like
- "[No Match]" when the user requests a completion for a prefix
- that has no possible completions, and other quick, unobtrusive
- messages. */
-
-temp_echo_area_glyphs (m)
- char *m;
-{
- int osize = ZV;
- Lisp_Object oinhibit;
- oinhibit = Vinhibit_quit;
-
- /* Clear out any old echo-area message to make way for our new thing. */
- message (0);
-
- SET_PT (osize);
- insert_string (m);
- SET_PT (osize);
- Vinhibit_quit = Qt;
- Fsit_for (make_number (2), Qnil, Qnil);
- del_range (PT, ZV);
- if (!NILP (Vquit_flag))
- {
- Vquit_flag = Qnil;
- Vunread_command_events = Fcons (make_number (quit_char), Qnil);
- }
- Vinhibit_quit = oinhibit;
-}
-
Lisp_Object Fminibuffer_completion_help ();
Lisp_Object assoc_for_completion ();
/* A subroutine of Fintern_soft. */
/* If the previous command was not this, then mark the completion
buffer obsolete. */
- if (! EQ (last_command, this_command))
+ if (! EQ (current_kboard->Vlast_command, this_command))
Vminibuf_scroll_window = Qnil;
window = Vminibuf_scroll_window;
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);
register unsigned char *buffer_string;
int buffer_length, completion_length;
+ CHECK_STRING (completion, 0);
tem = Fbuffer_string ();
GCPRO2 (completion, tem);
/* If reading a file name,
/* 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. */
(completions)
Lisp_Object completions;
{
- register Lisp_Object tail, elt;
+ Lisp_Object tail, elt;
register int i;
int column = 0;
- struct gcpro gcpro1;
+ struct gcpro gcpro1, gcpro2;
struct buffer *old = current_buffer;
int first = 1;
/* Note that (when it matters) every variable
- points to a non-string that is pointed to by COMPLETIONS. */
- GCPRO1 (completions);
+ points to a non-string that is pointed to by COMPLETIONS,
+ except for ELT. ELT can be pointing to a string
+ when terpri or Findent_to calls a change hook. */
+ elt = Qnil;
+ GCPRO2 (completions, elt);
if (BUFFERP (Vstandard_output))
set_buffer_internal (XBUFFER (Vstandard_output));
{
Lisp_Object tem;
int length;
+ Lisp_Object startpos, endpos;
elt = Fcar (tail);
/* 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.
Sadly, the window it will appear in is not known
until after the text has been made. */
+ if (BUFFERP (Vstandard_output))
+ XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
+
/* If the previous completion was very wide,
or we have two on this line already,
don't put another on the same line. */
if (BUFFERP (Vstandard_output))
{
tem = Findent_to (make_number (35), make_number (2));
+
column = XINT (tem);
}
else
}
}
+ if (BUFFERP (Vstandard_output))
+ {
+ XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
+ Fset_text_properties (startpos, endpos,
+ Qnil, Vstandard_output);
+ }
+
/* Output this element and update COLUMN. */
if (CONSP (elt))
{
return width;
}
\f
+/* Temporarily display the string M at the end of the current
+ minibuffer contents. This is used to display things like
+ "[No Match]" when the user requests a completion for a prefix
+ that has no possible completions, and other quick, unobtrusive
+ messages. */
+
+temp_echo_area_glyphs (m)
+ char *m;
+{
+ int osize = ZV;
+ int opoint = PT;
+ Lisp_Object oinhibit;
+ oinhibit = Vinhibit_quit;
+
+ /* Clear out any old echo-area message to make way for our new thing. */
+ message (0);
+
+ SET_PT (osize);
+ insert_string (m);
+ SET_PT (opoint);
+ Vinhibit_quit = Qt;
+ Fsit_for (make_number (2), Qnil, Qnil);
+ del_range (osize, ZV);
+ SET_PT (opoint);
+ if (!NILP (Vquit_flag))
+ {
+ Vquit_flag = Qnil;
+ Vunread_command_events = Fcons (make_number (quit_char), Qnil);
+ }
+ Vinhibit_quit = oinhibit;
+}
+
+DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message,
+ 1, 1, 0,
+ "Temporarily display STRING at the end of the minibuffer.\n\
+The text is displayed for two seconds,\n\
+or until the next input event arrives, whichever comes first.")
+ (string)
+ Lisp_Object string;
+{
+ temp_echo_area_glyphs (XSTRING (string)->data);
+ return Qnil;
+}
+\f
init_minibuf_once ()
{
Vminibuffer_list = Qnil;
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);
Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
staticpro (&Qminibuffer_exit_hook);
+ Qhistory_length = intern ("history-length");
+ staticpro (&Qhistory_length);
+
DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
"Normal hook run just after entry to minibuffer.");
Vminibuffer_setup_hook = Qnil;
"Normal hook run just after exit from minibuffer.");
Vminibuffer_exit_hook = Qnil;
+ DEFVAR_LISP ("history-length", &Vhistory_length,
+ "*Maximum length for history lists before truncation takes place.\n\
+A number means that length; t means infinite. Truncation takes place\n\
+just after a new element is inserted. Setting the history-length\n\
+property of a history variable overrides this default.");
+ XSETFASTINT (Vhistory_length, 30);
+
DEFVAR_BOOL ("completion-auto-help", &auto_help,
"*Non-nil means automatically provide help for invalid completion input.");
auto_help = 1;
DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
"History list symbol to add minibuffer values to.\n\
-Each minibuffer output is added with\n\
+Each string of minibuffer input, as it appears on exit from the minibuffer,\n\
+is added with\n\
(set minibuffer-history-variable\n\
(cons STRING (symbol-value minibuffer-history-variable)))");
XSETFASTINT (Vminibuffer_history_variable, 0);
Vminibuffer_history_position = Qnil;
DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
- "*Non-nil means entering the minibuffer raises the minibuffer's frame.");
+ "*Non-nil means entering the minibuffer raises the minibuffer's frame.\n\
+Some uses of the echo area also raise that frame (since they use it too).");
minibuffer_auto_raise = 0;
DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
"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 (&Sread_minibuffer);
defsubr (&Sself_insert_and_exit);
defsubr (&Sexit_minibuffer);
+ defsubr (&Sminibuffer_message);
}
keys_of_minibuf ()
HCoop / bpt / emacs.git / blobdiff