/* 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, 1998, 1999
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
+#include <stdio.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
+#include "charset.h"
#include "dispextern.h"
#include "frame.h"
#include "window.h"
invocation, the next element is used for a recursive minibuffer
invocation, etc. The list is extended at the end as deeper
minibuffer recursions are encountered. */
+
Lisp_Object Vminibuffer_list;
/* Data to remember during recursive minibuffer invocations */
+
Lisp_Object minibuf_save_list;
/* Depth in minibuffer invocations. */
+
int minibuf_level;
/* 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;
/* Nonzero means let functions called when within a minibuffer
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 Vminibuffer_history_position;
-Lisp_Object Qminibuffer_history;
+Lisp_Object Qminibuffer_history, Qbuffer_name_history;
Lisp_Object Qread_file_name_internal;
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;
static Lisp_Object last_exact_completion;
-Lisp_Object Quser_variable_p;
-
/* 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 Quser_variable_p;
+
+Lisp_Object Qminibuffer_default;
+
+Lisp_Object Qcurrent_input_method, Qactivate_input_method;
+
+extern Lisp_Object Qmouse_face;
+
+extern Lisp_Object Qfield;
\f
/* Put minibuf on currently selected frame's minibuffer.
We do this whenever the user starts a new minibuffer
void
choose_minibuf_frame ()
{
- if (selected_frame != 0
- && !EQ (minibuf_window, selected_frame->minibuffer_window))
+ if (FRAMEP (selected_frame)
+ && FRAME_LIVE_P (XFRAME (selected_frame))
+ && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
{
+ struct frame *sf = XFRAME (selected_frame);
+ Lisp_Object buffer;
+
/* I don't think that any frames may validly have a null minibuffer
window anymore. */
- if (NILP (selected_frame->minibuffer_window))
+ if (NILP (sf->minibuffer_window))
abort ();
- Fset_window_buffer (selected_frame->minibuffer_window,
- XWINDOW (minibuf_window)->buffer);
- minibuf_window = selected_frame->minibuffer_window;
+ /* Under X, we come here with minibuf_window being the
+ minibuffer window of the unused termcap window created in
+ init_window_once. That window doesn't have a buffer. */
+ buffer = XWINDOW (minibuf_window)->buffer;
+ if (BUFFERP (buffer))
+ Fset_window_buffer (sf->minibuffer_window, buffer);
+ minibuf_window = sf->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. */
+ 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)))))
+ if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
+ && !(EQ (frame, selected_frame)
+ && minibuf_level > 0))
Fset_frame_selected_window (frame, Fframe_first_window (frame));
}
}
+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 ();
-Lisp_Object get_minibuffer ();
-Lisp_Object read_minibuf ();
+static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
+static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, int));
+static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, int));
+static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object));
+
+
+/* Read a Lisp object from VAL and return it. If VAL is an empty
+ string, and DEFALT is a string, read from DEFALT instead of VAL. */
+
+static Lisp_Object
+string_to_object (val, defalt)
+ Lisp_Object val, defalt;
+{
+ struct gcpro gcpro1, gcpro2;
+ Lisp_Object expr_and_pos;
+ int pos;
+
+ GCPRO2 (val, defalt);
+
+ if (STRINGP (val) && XSTRING (val)->size == 0
+ && STRINGP (defalt))
+ val = defalt;
+
+ expr_and_pos = Fread_from_string (val, Qnil, Qnil);
+ pos = XINT (Fcdr (expr_and_pos));
+ if (pos != XSTRING (val)->size)
+ {
+ /* Ignore trailing whitespace; any other trailing junk
+ is an error. */
+ int i;
+ pos = string_char_to_byte (val, pos);
+ for (i = pos; i < STRING_BYTES (XSTRING (val)); i++)
+ {
+ int c = XSTRING (val)->data[i];
+ if (c != ' ' && c != '\t' && c != '\n')
+ error ("Trailing garbage following expression");
+ }
+ }
+
+ val = Fcar (expr_and_pos);
+ RETURN_UNGCPRO (val);
+}
+
+
+/* Like read_minibuf but reading from stdin. This function is called
+ from read_minibuf to do the job if noninteractive. */
+
+static Lisp_Object
+read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
+ histvar, histpos, defalt, allow_props,
+ inherit_input_method)
+ Lisp_Object map;
+ Lisp_Object initial;
+ Lisp_Object prompt;
+ Lisp_Object backup_n;
+ int expflag;
+ Lisp_Object histvar;
+ Lisp_Object histpos;
+ Lisp_Object defalt;
+ int allow_props;
+ int inherit_input_method;
+{
+ int size, len;
+ char *line, *s;
+ struct gcpro gcpro1, gcpro2;
+ Lisp_Object val;
+
+ fprintf (stdout, "%s", XSTRING (prompt)->data);
+ fflush (stdout);
+
+ size = 100;
+ len = 0;
+ line = (char *) xmalloc (size * sizeof *line);
+ while ((s = fgets (line + len, size - len, stdin)) != NULL
+ && (len = strlen (line),
+ len == size - 1 && line[len - 1] != '\n'))
+ {
+ size *= 2;
+ line = (char *) xrealloc (line, size);
+ }
+
+ if (s)
+ {
+ len = strlen (line);
+
+ if (len > 0 && line[len - 1] == '\n')
+ line[--len] = '\0';
+
+ val = build_string (line);
+ xfree (line);
+ }
+ else
+ {
+ xfree (line);
+ error ("Error reading from stdin");
+ }
+
+ /* If Lisp form desired instead of string, parse it. */
+ if (expflag)
+ val = string_to_object (val, defalt);
+
+ return val;
+}
+
/* Read from the minibuffer using keymap MAP, initial contents INITIAL
- (a string), putting point minus BACKUP_N chars from the end of INITIAL,
+ (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
prompting with PROMPT (a string), using history list HISTVAR
with initial position HISTPOS. (BACKUP_N should be <= 0.)
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 allow_props;
+ 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;
+ extern Lisp_Object Qread_only, Qfront_sticky;
+ extern Lisp_Object Qrear_nonsticky;
+
+ 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 ("");
build_string ("Command attempted to use minibuffer while in minibuffer"));
}
+ if (noninteractive)
+ return read_minibuf_noninteractive (map, initial, prompt, backup_n,
+ expflag, histvar, histpos, defalt,
+ allow_props, inherit_input_method);
+
/* Choose the minibuffer window and frame, and take action on them. */
choose_minibuf_frame ();
+ record_unwind_protect (choose_minibuf_frame_1, Qnil);
+
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. */
mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
- if (XFRAME (mini_frame) != selected_frame)
+ if (!EQ (mini_frame, selected_frame))
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (mini_frame));
/* Now that we can restore all those variables, start changing them. */
- minibuf_prompt_width = 0; /* xdisp.c puts in the right value. */
+ minibuf_prompt_width = 0;
minibuf_prompt = Fcopy_sequence (prompt);
Vminibuffer_history_position = histpos;
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
for (buf_list = Vbuffer_alist;
CONSP (buf_list);
- buf_list = XCONS (buf_list)->cdr)
+ buf_list = XCDR (buf_list))
{
Lisp_Object other_buf;
- other_buf = XCONS (XCONS (buf_list)->car)->cdr;
+ other_buf = XCDR (XCAR (buf_list));
if (STRINGP (XBUFFER (other_buf)->directory))
{
current_buffer->directory = XBUFFER (other_buf)->directory;
}
}
- if (XFRAME (mini_frame) != selected_frame)
- Fredirect_frame_focus (Fselected_frame (), mini_frame);
+ if (!EQ (mini_frame, selected_frame))
+ Fredirect_frame_focus (selected_frame, mini_frame);
Vminibuf_scroll_window = selected_window;
Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
unbind_to (count1, Qnil);
}
+ 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);
+ Fput_text_property (make_number (BEG), make_number (PT),
+ Qread_only, Qt, Qnil);
+ }
+
+ minibuf_prompt_width = current_column ();
+
+ /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
+ if (inherit_input_method)
+ current_buffer->enable_multibyte_characters = enable_multibyte;
+
/* Put in the initial input. */
if (!NILP (initial))
{
Finsert (1, &initial);
- if (!NILP (backup_n) && INTEGERP (backup_n))
+ if (INTEGERP (backup_n))
Fforward_char (backup_n);
}
- echo_area_glyphs = 0;
- /* This is in case the minibuffer-setup-hook calls Fsit_for. */
- previous_echo_glyphs = 0;
-
+ clear_message (1, 1);
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);
+
/* 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). */
&& !NILP (Vrun_hooks))
call1 (Vrun_hooks, Qminibuffer_setup_hook);
-/* ??? MCC did redraw_screen here if switching screens. */
recursive_edit_1 ();
/* If cursor is on the minibuffer line,
show the user we have exited by putting it in column 0. */
- if ((FRAME_CURSOR_Y (selected_frame)
- >= XFASTINT (XWINDOW (minibuf_window)->top))
+ if (XWINDOW (minibuf_window)->cursor.vpos >= 0
&& !noninteractive)
{
- FRAME_CURSOR_X (selected_frame)
- = FRAME_LEFT_SCROLL_BAR_WIDTH (selected_frame);
- update_frame (selected_frame, 1, 1);
+ XWINDOW (minibuf_window)->cursor.hpos = 0;
+ 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));
}
- /* Make minibuffer contents into a string */
- val = make_buffer_string (1, Z, 1);
-#if 0 /* make_buffer_string should handle the gap. */
- bcopy (GAP_END_ADDR, XSTRING (val)->data + GPT - BEG, Z - GPT);
-#endif
+ /* Make minibuffer contents into a string. */
+ Fset_buffer (minibuffer);
+ val = Ffield_string (make_number (ZV), allow_props ? Qt : Qnil);
/* VAL is the string of minibuffer text. */
+
last_minibuf_string = val;
/* Add the value to the appropriate history list unless it is empty. */
if (XSTRING (val)->size != 0
- && SYMBOLP (Vminibuffer_history_variable)
- && ! EQ (XSYMBOL (Vminibuffer_history_variable)->value, Qunbound))
+ && SYMBOLP (Vminibuffer_history_variable))
{
/* If the caller wanted to save the value read on a history list,
then do so if the value is not already the front of the list. */
Lisp_Object histval;
+
+ /* If variable is unbound, make it nil. */
+ if (EQ (XSYMBOL (Vminibuffer_history_variable)->value, Qunbound))
+ Fset (Vminibuffer_history_variable, Qnil);
+
histval = Fsymbol_value (Vminibuffer_history_variable);
/* The value of the history variable must be a cons or nil. Other
/* 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);
+ }
+ }
}
}
/* If Lisp form desired instead of string, parse it. */
if (expflag)
- {
- Lisp_Object expr_and_pos;
- unsigned char *p;
-
- expr_and_pos = Fread_from_string (val, Qnil, Qnil);
- /* Ignore trailing whitespace; any other trailing junk is an error. */
- for (p = XSTRING (val)->data + XINT (Fcdr (expr_and_pos)); *p; p++)
- if (*p != ' ' && *p != '\t' && *p != '\n')
- error ("Trailing garbage following expression");
- val = Fcar (expr_and_pos);
- }
+ val = string_to_object (val, defalt);
/* The appropriate frame will get selected
in set-window-configuration. */
enabled in it. */
Fbuffer_enable_undo (buf);
- XCONS (tail)->car = buf;
+ XCAR (tail) = buf;
}
else
{
return buf;
}
-/* This function is called on exiting minibuffer, whether normally or not,
- and it restores the current window, buffer, etc. */
+/* 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;
{
minibuf_level--;
window = minibuf_window;
- /* To keep things predictable, in case it matters, let's be in the minibuffer
- when we reset the relevant variables. */
+ /* 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. */
unbind_to (count, Qnil);
}
- /* Make the minibuffer follow the selected frame
- (in case we are exiting a recursive minibuffer). */
- choose_minibuf_frame ();
+ /* When we get to the outmost level, make sure we resize the
+ mini-window back to its normal size. */
+ if (minibuf_level == 0)
+ resize_mini_window (XWINDOW (window), 0);
/* 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 available\n\
+ for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE\n\
+ if the user enters empty input! It returns 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 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\
+Fifth 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);
+ Lisp_Object val;
+ val = Fread_from_minibuffer (prompt, initial_input, Qnil,
+ Qnil, history, default_value,
+ inherit_input_method);
+ if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (default_value))
+ val = default_value;
+ return val;
}
-DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 2, 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;
+DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
+ "Read a string from the terminal, not allowing blanks.\n\
+Prompt with PROMPT, and provide INITIAL 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, initial, inherit_input_method)
+ Lisp_Object prompt, initial, inherit_input_method;
{
CHECK_STRING (prompt, 0);
- if (! NILP (init))
- CHECK_STRING (init, 1);
+ if (! NILP (initial))
+ CHECK_STRING (initial, 1);
- return read_minibuf (Vminibuffer_local_ns_map, init, prompt, Qnil, 0,
- Qminibuffer_history, make_number (0));
+ return read_minibuf (Vminibuffer_local_ns_map, initial, 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))
+ XSETSTRING (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))
+ XSETSTRING (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))
{
- args[0] = build_string ("%s(default %s) ");
+ 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, Qbuffer_name_history,
+ def, Qnil);
+ }
+ else
+ {
+ 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
+static Lisp_Object
+minibuf_conform_representation (string, basis)
+ Lisp_Object string, basis;
+{
+ if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
+ return string;
+
+ if (STRING_MULTIBYTE (string))
+ return Fstring_make_unibyte (string);
+ else
+ return Fstring_make_multibyte (string);
+}
+
DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
"Return common substring of all completions of STRING in ALIST.\n\
Each car of each element of ALIST is tested to see if it begins with STRING.\n\
Lisp_Object string, alist, predicate;
{
Lisp_Object bestmatch, tail, elt, eltstring;
+ /* Size in bytes of BESTMATCH. */
int bestmatchsize;
+ /* These are in bytes, too. */
int compare, matchsize;
int list = CONSP (alist) || NILP (alist);
int index, obsize;
if (STRINGP (eltstring)
&& XSTRING (string)->size <= XSTRING (eltstring)->size
- && 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
- XSTRING (string)->size))
+ && (tem = Fcompare_strings (eltstring, make_number (0),
+ make_number (XSTRING (string)->size),
+ string, make_number (0), Qnil,
+ completion_ignore_case ?Qt : Qnil),
+ EQ (Qt, tem)))
{
/* Yes. */
Lisp_Object regexps;
/* Ignore this element if it fails to match all the regexps. */
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
- regexps = XCONS (regexps)->cdr)
+ regexps = XCDR (regexps))
{
- tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
+ tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
matchcount++;
if (NILP (bestmatch))
- bestmatch = eltstring, bestmatchsize = XSTRING (eltstring)->size;
+ {
+ bestmatch = eltstring;
+ bestmatchsize = XSTRING (eltstring)->size;
+ }
else
{
compare = min (bestmatchsize, XSTRING (eltstring)->size);
- matchsize = scmp (XSTRING (bestmatch)->data,
- XSTRING (eltstring)->data,
- compare);
+ tem = Fcompare_strings (bestmatch, make_number (0),
+ make_number (compare),
+ eltstring, make_number (0),
+ make_number (compare),
+ completion_ignore_case ? Qt : Qnil);
+ if (EQ (tem, Qt))
+ matchsize = compare;
+ else if (XINT (tem) < 0)
+ matchsize = - XINT (tem) - 1;
+ else
+ matchsize = XINT (tem) - 1;
+
if (matchsize < 0)
matchsize = compare;
if (completion_ignore_case)
((matchsize == XSTRING (eltstring)->size)
==
(matchsize == XSTRING (bestmatch)->size)
- && !bcmp (XSTRING (eltstring)->data,
- XSTRING (string)->data, XSTRING (string)->size)
- && bcmp (XSTRING (bestmatch)->data,
- XSTRING (string)->data, XSTRING (string)->size)))
+ && (tem = Fcompare_strings (eltstring, make_number (0),
+ make_number (XSTRING (string)->size),
+ string, make_number (0),
+ Qnil,
+ Qnil),
+ EQ (Qt, tem))
+ && (tem = Fcompare_strings (bestmatch, make_number (0),
+ make_number (XSTRING (string)->size),
+ string, make_number (0),
+ Qnil,
+ Qnil),
+ ! EQ (Qt, tem))))
bestmatch = eltstring;
}
bestmatchsize = matchsize;
don't change the case of what the user typed. */
if (completion_ignore_case && bestmatchsize == XSTRING (string)->size
&& XSTRING (bestmatch)->size > bestmatchsize)
- return string;
+ return minibuf_conform_representation (string, bestmatch);
/* Return t if the supplied string is an exact match (counting case);
it does not require any change to be made. */
if (matchcount == 1 && bestmatchsize == XSTRING (string)->size
- && !bcmp (XSTRING (bestmatch)->data, XSTRING (string)->data,
- bestmatchsize))
+ && (tem = Fcompare_strings (bestmatch, make_number (0),
+ make_number (bestmatchsize),
+ string, make_number (0),
+ make_number (bestmatchsize),
+ Qnil),
+ EQ (Qt, tem)))
return Qt;
XSETFASTINT (zero, 0); /* Else extract the part in which */
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,
&& XSTRING (string)->size <= XSTRING (eltstring)->size
/* If HIDE_SPACES, reject alternatives that start with space
unless the input starts with space. */
- && ((XSTRING (string)->size > 0 && XSTRING (string)->data[0] == ' ')
+ && ((STRING_BYTES (XSTRING (string)) > 0
+ && XSTRING (string)->data[0] == ' ')
|| XSTRING (eltstring)->data[0] != ' '
|| NILP (hide_spaces))
- && 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
- XSTRING (string)->size))
+ && (tem = Fcompare_strings (eltstring, make_number (0),
+ make_number (XSTRING (string)->size),
+ string, make_number (0),
+ make_number (XSTRING (string)->size),
+ completion_ignore_case ? Qt : Qnil),
+ EQ (Qt, tem)))
{
/* Yes. */
Lisp_Object regexps;
/* Ignore this element if it fails to match all the regexps. */
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
- regexps = XCONS (regexps)->cdr)
+ regexps = XCDR (regexps))
{
- tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
+ tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
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;
/* This comment supplies the doc string for completing-read,
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\
PREDICATE limits completion to a subset of TABLE.\n\
-See `try-completion' and `all-completions' for more details
+See `try-completion' and `all-completions' for more details\n\
on completion, TABLE, and PREDICATE.\n\
\n\
If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
or it can be a cons cell (HISTVAR . HISTPOS).\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\
+ which INITIAL-INPUT 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;
+
+ 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);
-}
-\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. */
+ histvar, histpos, def, 0,
+ !NILP (inherit_input_method));
-temp_echo_area_glyphs (m)
- char *m;
-{
- int osize = ZV;
- int opoint = PT;
- Lisp_Object oinhibit;
- oinhibit = Vinhibit_quit;
+ if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (def))
+ val = def;
- /* 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;
+ RETURN_UNGCPRO (unbind_to (count, val));
}
-
+\f
Lisp_Object Fminibuffer_completion_help ();
Lisp_Object assoc_for_completion ();
-/* A subroutine of Fintern_soft. */
-extern Lisp_Object oblookup ();
-
/* Test whether TXT is an exact completion. */
Lisp_Object
{
/* Bypass intern-soft as that loses for nil */
tem = oblookup (Vminibuffer_completion_table,
- XSTRING (txt)->data, XSTRING (txt)->size);
+ XSTRING (txt)->data,
+ XSTRING (txt)->size,
+ STRING_BYTES (XSTRING (txt)));
if (!SYMBOLP (tem))
- return Qnil;
- else if (!NILP (Vminibuffer_completion_predicate))
+ {
+ if (STRING_MULTIBYTE (txt))
+ txt = Fstring_make_unibyte (txt);
+ else
+ txt = Fstring_make_multibyte (txt);
+
+ tem = oblookup (Vminibuffer_completion_table,
+ XSTRING (txt)->data,
+ XSTRING (txt)->size,
+ STRING_BYTES (XSTRING (txt)));
+ if (!SYMBOLP (tem))
+ return Qnil;
+ }
+ if (!NILP (Vminibuffer_completion_predicate))
return call1 (Vminibuffer_completion_predicate, tem);
else
return Qt;
Lisp_Object last;
struct gcpro gcpro1, gcpro2;
- completion = Ftry_completion (Fbuffer_string (), Vminibuffer_completion_table,
+ completion = Ftry_completion (Ffield_string (ZV),
+ Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
last = last_exact_completion;
last_exact_completion = Qnil;
}
/* compiler bug */
- tem = Fstring_equal (completion, Fbuffer_string());
- if (completedp = NILP (tem))
+ tem = Fstring_equal (completion, Ffield_string(ZV));
+ completedp = NILP (tem);
+ if (completedp)
{
- Ferase_buffer (); /* Some completion happened */
+ Fdelete_field (make_number (ZV)); /* Some completion happened */
Finsert (1, &completion);
}
/* It did find a match. Do we match some possibility exactly now? */
- tem = test_completion (Fbuffer_string ());
+ tem = test_completion (Ffield_string(ZV));
if (NILP (tem))
{
/* not an exact match */
last_exact_completion = completion;
if (!NILP (last))
{
- tem = Fbuffer_string ();
+ tem = Ffield_string (ZV);
if (!NILP (Fequal (tem, last)))
Fminibuffer_completion_help ();
}
{
register Lisp_Object tail;
- if (completion_ignore_case)
- key = Fupcase (key);
-
for (tail = list; !NILP (tail); tail = Fcdr (tail))
{
register Lisp_Object elt, tem, thiscar;
thiscar = Fcar (elt);
if (!STRINGP (thiscar))
continue;
- if (completion_ignore_case)
- thiscar = Fupcase (thiscar);
- tem = Fequal (thiscar, key);
- if (!NILP (tem)) return elt;
+ tem = Fcompare_strings (thiscar, make_number (0), Qnil,
+ key, make_number (0), Qnil,
+ completion_ignore_case ? Qt : Qnil);
+ if (EQ (tem, Qt))
+ return elt;
QUIT;
}
return Qnil;
register int i;
Lisp_Object window, tem;
- /* If the previous command was not this, then mark the completion
- buffer obsolete. */
- if (! EQ (current_kboard->Vlast_command, this_command))
+ /* If the previous command was not this,
+ mark the completion buffer obsolete. */
+ if (! EQ (current_kboard->Vlast_command, Vthis_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);
Lisp_Object val;
/* Allow user to specify null string */
- if (BEGV == ZV)
+ if (Ffield_beginning (ZV, Qnil) == ZV)
goto exit;
- if (!NILP (test_completion (Fbuffer_string ())))
+ if (!NILP (test_completion (Ffield_string (ZV))))
goto exit;
/* Call do_completion, but ignore errors. */
Return nil if there is no valid completion, else t.")
()
{
- Lisp_Object completion, tem;
- register int i;
+ Lisp_Object completion, tem, tem1;
+ register int i, i_byte;
register unsigned char *completion_string;
struct gcpro gcpro1, gcpro2;
+ int prompt_end_charpos;
/* We keep calling Fbuffer_string rather than arrange for GC to
hold onto a pointer to one of the strings thus made. */
- completion = Ftry_completion (Fbuffer_string (),
+ completion = Ftry_completion (Ffield_string (ZV),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (NILP (completion))
return Qnil;
#if 0 /* How the below code used to look, for reference. */
- tem = Fbuffer_string ();
+ tem = Ffield_string (ZV);
b = XSTRING (tem)->data;
i = ZV - 1 - XSTRING (completion)->size;
p = XSTRING (completion)->data;
}
#else /* Rewritten code */
{
- register unsigned char *buffer_string;
- int buffer_length, completion_length;
+ int buffer_nchars, completion_nchars;
CHECK_STRING (completion, 0);
- tem = Fbuffer_string ();
+ tem = Ffield_string (ZV);
GCPRO2 (completion, tem);
/* If reading a file name,
expand any $ENVVAR refs in the buffer and in TEM. */
- if (EQ (Vminibuffer_completion_table, Qread_file_name_internal))
+ if (! NILP (Vminibuffer_completing_file_name))
{
Lisp_Object substituted;
substituted = Fsubstitute_in_file_name (tem);
if (! EQ (substituted, tem))
{
tem = substituted;
- Ferase_buffer ();
- insert_from_string (tem, 0, XSTRING (tem)->size, 0);
+ Fdelete_field (make_number (ZV));
+ insert_from_string (tem, 0, 0, XSTRING (tem)->size,
+ STRING_BYTES (XSTRING (tem)), 0);
}
}
- buffer_string = XSTRING (tem)->data;
- completion_string = XSTRING (completion)->data;
- buffer_length = XSTRING (tem)->size; /* ie ZV - BEGV */
- completion_length = XSTRING (completion)->size;
- i = buffer_length - completion_length;
- /* Mly: I don't understand what this is supposed to do AT ALL */
- if (i > 0 ||
- 0 <= scmp (buffer_string, completion_string, buffer_length))
+ buffer_nchars = XSTRING (tem)->size; /* ie ZV - BEGV */
+ completion_nchars = XSTRING (completion)->size;
+ i = buffer_nchars - completion_nchars;
+ if (i > 0
+ ||
+ (tem1 = Fcompare_strings (tem, make_number (0),
+ make_number (buffer_nchars),
+ completion, make_number (0),
+ make_number (buffer_nchars),
+ completion_ignore_case ? Qt : Qnil),
+ ! EQ (tem1, Qt)))
{
- /* Set buffer to longest match of buffer tail and completion head. */
+ int start_pos;
+
+ /* Set buffer to longest match of buffer tail and completion head. */
if (i <= 0) i = 1;
- buffer_string += i;
- buffer_length -= i;
- while (0 <= scmp (buffer_string++, completion_string, buffer_length--))
- i++;
+ start_pos= i;
+ buffer_nchars -= i;
+ while (i > 0)
+ {
+ tem1 = Fcompare_strings (tem, make_number (start_pos), Qnil,
+ completion, make_number (0),
+ make_number (buffer_nchars),
+ completion_ignore_case ? Qt : Qnil);
+ start_pos++;
+ if (EQ (tem1, Qt))
+ break;
+ i++;
+ buffer_nchars--;
+ }
del_range (1, i + 1);
- SET_PT (ZV);
+ SET_PT_BOTH (ZV, ZV_BYTE);
}
UNGCPRO;
}
#endif /* Rewritten code */
- i = ZV - BEGV;
+
+ prompt_end_charpos = Ffield_beginning (make_number (ZV), Qnil);
+
+ {
+ int prompt_end_bytepos;
+ prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos);
+ i = ZV - prompt_end_charpos;
+ i_byte = ZV_BYTE - prompt_end_bytepos;
+ }
/* If completion finds next char not unique,
consider adding a space or a hyphen. */
if (i == XSTRING (completion)->size)
{
GCPRO1 (completion);
- tem = Ftry_completion (concat2 (Fbuffer_string (), build_string (" ")),
+ tem = Ftry_completion (concat2 (Ffield_string (ZV), build_string (" ")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
{
GCPRO1 (completion);
tem =
- Ftry_completion (concat2 (Fbuffer_string (), build_string ("-")),
+ Ftry_completion (concat2 (Ffield_string (ZV), build_string ("-")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
/* Now find first word-break in the stuff found by completion.
i gets index in string of where to stop completing. */
-
- 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;
+ {
+ int len, c;
+ int bytes = STRING_BYTES (XSTRING (completion));
+ completion_string = XSTRING (completion)->data;
+ for (; i_byte < STRING_BYTES (XSTRING (completion)); i_byte += len, i++)
+ {
+ c = STRING_CHAR_AND_LENGTH (completion_string + i_byte,
+ bytes - i_byte,
+ len);
+ if (SYNTAX (c) != Sword)
+ {
+ i_byte += len;
+ i++;
+ break;
+ }
+ }
+ }
/* If got no characters, print help for user. */
- if (i == ZV - BEGV)
+ if (i == ZV - prompt_end_charpos)
{
if (auto_help)
Fminibuffer_completion_help ();
/* Otherwise insert in minibuffer the chars we got */
- Ferase_buffer ();
- insert_from_string (completion, 0, i, 1);
+ Fdelete_field (make_number (ZV));
+ insert_from_string (completion, 0, 0, i, i_byte, 1);
return Qt;
}
\f
Each element may be just a symbol or string\n\
or may be a list of two strings to be printed as if concatenated.\n\
`standard-output' must be a buffer.\n\
-At the end, run the normal hook `completion-setup-hook'.\n\
+The actual completion alternatives, as inserted, are given `mouse-face'\n\
+properties of `highlight'.\n\
+At the end, this runs the normal hook `completion-setup-hook'.\n\
It can find the completion buffer in `standard-output'.")
(completions)
Lisp_Object completions;
write_string ("Possible completions are:", -1);
for (tail = completions, i = 0; !NILP (tail); tail = Fcdr (tail), i++)
{
- Lisp_Object tem;
+ Lisp_Object tem, string;
int length;
Lisp_Object startpos, endpos;
/* 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.
don't put another on the same line. */
if (column > 33 || first
/* If this is really wide, don't put it second on a line. */
- || column > 0 && length > 45)
+ || (column > 0 && length > 45))
{
Fterpri (Qnil);
column = 0;
Qnil, Vstandard_output);
}
- /* Output this element and update COLUMN. */
+ /* Output this element.
+ If necessary, convert it to unibyte or to multibyte first. */
if (CONSP (elt))
+ string = Fcar (elt);
+ else
+ string = elt;
+ if (NILP (current_buffer->enable_multibyte_characters)
+ && STRING_MULTIBYTE (string))
+ string = Fstring_make_unibyte (string);
+ else if (!NILP (current_buffer->enable_multibyte_characters)
+ && !STRING_MULTIBYTE (string))
+ string = Fstring_make_multibyte (string);
+
+ if (BUFFERP (Vstandard_output))
{
- Fprinc (Fcar (elt), Qnil);
- Fprinc (Fcar (Fcdr (elt)), Qnil);
+ XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
+
+ Fprinc (string, Qnil);
+
+ XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
+
+ Fput_text_property (startpos, endpos,
+ Qmouse_face, intern ("highlight"),
+ Vstandard_output);
}
else
- Fprinc (elt, Qnil);
+ {
+ Fprinc (string, Qnil);
+ }
+
+ /* Output the annotation for this element. */
+ if (CONSP (elt))
+ {
+ if (BUFFERP (Vstandard_output))
+ {
+ XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
+
+ Fprinc (Fcar (Fcdr (elt)), Qnil);
+
+ XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
+ Fset_text_properties (startpos, endpos, Qnil,
+ Vstandard_output);
+ }
+ else
+ {
+ Fprinc (Fcar (Fcdr (elt)), Qnil);
+ }
+ }
+
+
+ /* Update COLUMN for what we have output. */
column += length;
/* If output is to a buffer, recompute COLUMN in a way
Lisp_Object completions;
message ("Making completion list...");
- completions = Fall_completions (Fbuffer_string (),
+ completions = Fall_completions (Ffield_string (ZV),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate,
Qt);
- echo_area_glyphs = 0;
+ clear_message (1, 0);
if (NILP (completions))
{
()
{
if (INTEGERP (last_command_char))
- internal_self_insert (last_command_char, 0);
+ internal_self_insert (XINT (last_command_char), 0);
else
bitch_at_user ();
return Fcopy_sequence (minibuf_prompt);
}
-DEFUN ("minibuffer-prompt-width", Fminibuffer_prompt_width,
- Sminibuffer_prompt_width, 0, 0, 0,
- "Return the display width of the minibuffer prompt.")
- ()
+\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. */
+
+void
+temp_echo_area_glyphs (m)
+ char *m;
{
- Lisp_Object width;
- XSETFASTINT (width, minibuf_prompt_width);
- return width;
+ int osize = ZV;
+ int osize_byte = ZV_BYTE;
+ int opoint = PT;
+ int opoint_byte = PT_BYTE;
+ Lisp_Object oinhibit;
+ oinhibit = Vinhibit_quit;
+
+ /* Clear out any old echo-area message to make way for our new thing. */
+ message (0);
+
+ SET_PT_BOTH (osize, osize_byte);
+ insert_string (m);
+ SET_PT_BOTH (opoint, opoint_byte);
+ Vinhibit_quit = Qt;
+ Fsit_for (make_number (2), Qnil, Qnil);
+ del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
+ SET_PT_BOTH (opoint, opoint_byte);
+ 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
+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);
Qminibuffer_history = intern ("minibuffer-history");
staticpro (&Qminibuffer_history);
+ Qbuffer_name_history = intern ("buffer-name-history");
+ staticpro (&Qbuffer_name_history);
+ Fset (Qbuffer_name_history, Qnil);
+
Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
staticpro (&Qminibuffer_setup_hook);
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,
"Non-nil => demand confirmation of completion before exiting minibuffer.");
Vminibuffer_completion_confirm = Qnil;
+ DEFVAR_LISP ("minibuffer-completing-file-name",
+ &Vminibuffer_completing_file_name,
+ "Non-nil means completing file names.");
+ Vminibuffer_completing_file_name = Qnil;
+
DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
"Value that `help-form' takes on inside the minibuffer.");
Vminibuffer_help_form = Qnil;
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-minibuffer' 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_no_blanks_input);
defsubr (&Sminibuffer_depth);
defsubr (&Sminibuffer_prompt);
- defsubr (&Sminibuffer_prompt_width);
defsubr (&Stry_completion);
defsubr (&Sall_completions);
defsubr (&Sself_insert_and_exit);
defsubr (&Sexit_minibuffer);
+ defsubr (&Sminibuffer_message);
}
+void
keys_of_minibuf ()
{
initial_define_key (Vminibuffer_local_map, Ctl ('g'),
HCoop / bpt / emacs.git / blobdiff