#include <config.h>
#include <stdio.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "charset.h"
#include "dispextern.h"
#include "keyboard.h"
#include "frame.h"
#include "window.h"
#include "syntax.h"
#include "intervals.h"
#include "keymap.h"
extern int quit_char;
Lisp_Object Vminibuffer_list;
Lisp_Object minibuf_save_list;
int minibuf_level;
Lisp_Object Vcompletion_auto_help;
Lisp_Object Qhistory_length, Vhistory_length;
int history_delete_duplicates;
Lisp_Object Vhistory_add_new_input;
Lisp_Object last_minibuf_string;
int enable_recursive_minibuffers;
int minibuffer_allow_text_properties;
Lisp_Object Vminibuffer_help_form;
Lisp_Object Vminibuffer_history_variable;
Lisp_Object Vminibuffer_history_position;
Lisp_Object Vminibuffer_prompt_properties;
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;
Lisp_Object Vread_buffer_function;
int completion_ignore_case;
Lisp_Object Vcompletion_regexp_list;
int minibuffer_auto_raise;
static Lisp_Object last_exact_completion;
Lisp_Object Vread_expression_map;
Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
Lisp_Object Vminibuffer_completing_file_name;
Lisp_Object Quser_variable_p;
Lisp_Object Qminibuffer_default;
Lisp_Object Qcurrent_input_method, Qactivate_input_method;
Lisp_Object Qcase_fold_search;
Lisp_Object Qread_expression_history;
extern Lisp_Object Voverriding_local_map;
extern Lisp_Object Qmouse_face;
extern Lisp_Object Qfield;
void
choose_minibuf_frame ()
{
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;
if (NILP (sf->minibuffer_window))
abort ();
buffer = XWINDOW (minibuf_window)->buffer;
if (BUFFERP (buffer))
Fset_window_buffer (sf->minibuffer_window, buffer, Qnil);
minibuf_window = sf->minibuffer_window;
}
{
Lisp_Object tail, frame;
FOR_EACH_FRAME (tail, 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,
doc: )
(window)
Lisp_Object window;
{
CHECK_WINDOW (window);
if (! MINI_WINDOW_P (XWINDOW (window)))
error ("Window is not a minibuffer window");
minibuf_window = window;
return window;
}
static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
static Lisp_Object run_exit_minibuf_hook 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));
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) && SCHARS (val) == 0
&& STRINGP (defalt))
val = defalt;
expr_and_pos = Fread_from_string (val, Qnil, Qnil);
pos = XINT (Fcdr (expr_and_pos));
if (pos != SCHARS (val))
{
int i;
pos = string_char_to_byte (val, pos);
for (i = pos; i < SBYTES (val); i++)
{
int c = SREF (val, i);
if (c != ' ' && c != '\t' && c != '\n')
error ("Trailing garbage following expression");
}
}
val = Fcar (expr_and_pos);
RETURN_UNGCPRO (val);
}
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;
Lisp_Object val;
fprintf (stdout, "%s", SDATA (prompt));
fflush (stdout);
val = Qnil;
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 (expflag)
val = string_to_object (val, defalt);
return val;
}
DEFUN ("minibufferp", Fminibufferp,
Sminibufferp, 0, 1, 0,
doc: )
(buffer)
Lisp_Object buffer;
{
Lisp_Object tem;
if (NILP (buffer))
buffer = Fcurrent_buffer ();
else if (STRINGP (buffer))
buffer = Fget_buffer (buffer);
else
CHECK_BUFFER (buffer);
tem = Fmemq (buffer, Vminibuffer_list);
return ! NILP (tem) ? Qt : Qnil;
}
DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
Sminibuffer_prompt_end, 0, 0, 0,
doc: )
()
{
Lisp_Object beg, end, tem;
beg = make_number (BEGV);
tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
if (NILP (tem))
return beg;
end = Ffield_end (beg, Qnil, Qnil);
if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
return beg;
else
return end;
}
DEFUN ("minibuffer-contents", Fminibuffer_contents,
Sminibuffer_contents, 0, 0, 0,
doc: )
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 1);
}
DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
Sminibuffer_contents_no_properties, 0, 0, 0,
doc: )
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 0);
}
DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
Sminibuffer_completion_contents, 0, 0, 0,
doc: )
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
if (PT < prompt_end)
error ("Cannot do completion in the prompt");
return make_buffer_string (prompt_end, PT, 1);
}
DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents,
Sdelete_minibuffer_contents, 0, 0, 0,
doc: )
()
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
if (prompt_end < ZV)
del_range (prompt_end, ZV);
return Qnil;
}
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;
Lisp_Object backup_n;
int expflag;
Lisp_Object histvar;
Lisp_Object histpos;
Lisp_Object defalt;
int allow_props;
int inherit_input_method;
{
Lisp_Object val;
int count = SPECPDL_INDEX ();
Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
Lisp_Object enable_multibyte;
int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
Lisp_Object histstring;
Lisp_Object empty_minibuf;
Lisp_Object dummy, frame;
extern Lisp_Object Qfront_sticky;
extern Lisp_Object Qrear_nonsticky;
specbind (Qminibuffer_default, defalt);
specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name);
if (EQ (Vminibuffer_completing_file_name, Qlambda))
Vminibuffer_completing_file_name = Qnil;
single_kboard_state ();
#ifdef HAVE_X_WINDOWS
if (display_hourglass_p)
cancel_hourglass ();
#endif
if (!NILP (initial))
{
if (CONSP (initial))
{
backup_n = Fcdr (initial);
initial = Fcar (initial);
CHECK_STRING (initial);
if (!NILP (backup_n))
{
CHECK_NUMBER (backup_n);
if (XINT (backup_n) < 1)
pos = - SCHARS (initial);
else
pos = XINT (backup_n) - 1 - SCHARS (initial);
}
}
else
CHECK_STRING (initial);
}
val = Qnil;
ambient_dir = current_buffer->directory;
input_method = Qnil;
enable_multibyte = Qnil;
GCPRO5 (map, initial, val, ambient_dir, input_method);
if (!STRINGP (prompt))
prompt = empty_string;
if (!enable_recursive_minibuffers
&& minibuf_level > 0)
{
if (EQ (selected_window, minibuf_window))
error ("Command attempted to use minibuffer while in minibuffer");
else
Fthrow (Qexit,
build_string ("Command attempted to use minibuffer while in minibuffer"));
}
if (noninteractive && NILP (Vexecuting_kbd_macro))
{
val = read_minibuf_noninteractive (map, initial, prompt,
make_number (pos),
expflag, histvar, histpos, defalt,
allow_props, inherit_input_method);
UNGCPRO;
return unbind_to (count, val);
}
choose_minibuf_frame ();
record_unwind_protect (choose_minibuf_frame_1, Qnil);
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (Qnil));
mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
if (!EQ (mini_frame, selected_frame))
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (mini_frame));
Fmake_frame_visible (mini_frame);
if (minibuffer_auto_raise)
Fraise_frame (mini_frame);
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++;
record_unwind_protect (run_exit_minibuf_hook, Qnil);
minibuf_prompt_width = 0;
minibuf_prompt = Fcopy_sequence (prompt);
Vminibuffer_history_position = histpos;
Vminibuffer_history_variable = histvar;
Vhelp_form = Vminibuffer_help_form;
if (!NILP (Vminibuffer_completing_file_name))
Vminibuffer_completing_file_name = Qlambda;
if (inherit_input_method)
{
input_method = Fsymbol_value (Qcurrent_input_method);
enable_multibyte = current_buffer->enable_multibyte_characters;
}
minibuffer = get_minibuffer (minibuf_level);
Fset_buffer (minibuffer);
if (inherit_input_method)
current_buffer->enable_multibyte_characters = enable_multibyte;
if (STRINGP (ambient_dir))
current_buffer->directory = ambient_dir;
else
{
Lisp_Object buf_list;
for (buf_list = Vbuffer_alist;
CONSP (buf_list);
buf_list = XCDR (buf_list))
{
Lisp_Object other_buf;
other_buf = XCDR (XCAR (buf_list));
if (STRINGP (XBUFFER (other_buf)->directory))
{
current_buffer->directory = XBUFFER (other_buf)->directory;
break;
}
}
}
if (!EQ (mini_frame, selected_frame))
Fredirect_frame_focus (selected_frame, mini_frame);
Vminibuf_scroll_window = selected_window;
if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
minibuf_selected_window = selected_window;
empty_minibuf = Fget_buffer (build_string (" *Minibuf-0*"));
FOR_EACH_FRAME (dummy, frame)
{
Lisp_Object root_window = Fframe_root_window (frame);
Lisp_Object mini_window = XWINDOW (root_window)->next;
if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
&& !NILP (Fwindow_minibuffer_p (mini_window)))
Fset_window_buffer (mini_window, empty_minibuf, Qnil);
}
Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
Fselect_window (minibuf_window, Qnil);
XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
Fmake_local_variable (Qprint_escape_newlines);
print_escape_newlines = 1;
{
int count1 = SPECPDL_INDEX ();
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
Ferase_buffer ();
if (!NILP (current_buffer->enable_multibyte_characters)
&& ! STRING_MULTIBYTE (minibuf_prompt))
minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
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);
Fadd_text_properties (make_number (BEG), make_number (PT),
Vminibuffer_prompt_properties, Qnil);
}
unbind_to (count1, Qnil);
}
minibuf_prompt_width = (int) current_column ();
if (!NILP (initial))
{
Finsert (1, &initial);
Fforward_char (make_number (pos));
}
clear_message (1, 1);
current_buffer->keymap = map;
if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
call1 (Qactivate_input_method, input_method);
if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
&& !NILP (Vrun_hooks))
call1 (Vrun_hooks, Qminibuffer_setup_hook);
current_buffer->undo_list = Qnil;
recursive_edit_1 ();
if (XWINDOW (minibuf_window)->cursor.vpos >= 0
&& !noninteractive)
{
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));
}
Fset_buffer (minibuffer);
if (allow_props)
val = Fminibuffer_contents ();
else
val = Fminibuffer_contents_no_properties ();
last_minibuf_string = val;
if (SCHARS (val) != 0)
histstring = val;
else if (STRINGP (defalt))
histstring = defalt;
else
histstring = Qnil;
if (!NILP (Vhistory_add_new_input)
&& SYMBOLP (Vminibuffer_history_variable)
&& !NILP (histstring))
{
Lisp_Object histval;
if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable), Qunbound))
Fset (Vminibuffer_history_variable, Qnil);
histval = Fsymbol_value (Vminibuffer_history_variable);
if (NILP (histval)
|| (CONSP (histval)
&& (NILP (Fequal (histstring, Fcar (histval))))))
{
Lisp_Object length;
if (history_delete_duplicates) Fdelete (histstring, histval);
histval = Fcons (histstring, histval);
Fset (Vminibuffer_history_variable, histval);
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 (expflag)
val = string_to_object (val, defalt);
UNGCPRO;
return unbind_to (count, val);
}
Lisp_Object
get_minibuffer (depth)
int depth;
{
Lisp_Object tail, num, buf;
char name[24];
extern Lisp_Object nconc2 ();
XSETFASTINT (num, depth);
tail = Fnthcdr (num, Vminibuffer_list);
if (NILP (tail))
{
tail = Fcons (Qnil, Qnil);
Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
}
buf = Fcar (tail);
if (NILP (buf) || NILP (XBUFFER (buf)->name))
{
sprintf (name, " *Minibuf-%d*", depth);
buf = Fget_buffer_create (build_string (name));
Fbuffer_enable_undo (buf);
XSETCAR (tail, buf);
}
else
{
int count = SPECPDL_INDEX ();
delete_all_overlays (XBUFFER (buf));
reset_buffer (XBUFFER (buf));
record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
Fset_buffer (buf);
Fkill_all_local_variables ();
unbind_to (count, Qnil);
}
return buf;
}
static Lisp_Object
run_exit_minibuf_hook (data)
Lisp_Object data;
{
if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
&& !NILP (Vrun_hooks))
safe_run_hooks (Qminibuffer_exit_hook);
return Qnil;
}
static Lisp_Object
read_minibuf_unwind (data)
Lisp_Object data;
{
Lisp_Object old_deactivate_mark;
Lisp_Object window;
minibuf_level--;
window = minibuf_window;
Fset_buffer (XWINDOW (window)->buffer);
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);
Vhelp_form = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
Vcurrent_prefix_arg = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
Vminibuffer_history_position = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
Vminibuffer_history_variable = 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);
{
int count = SPECPDL_INDEX ();
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
old_deactivate_mark = Vdeactivate_mark;
Ferase_buffer ();
Vdeactivate_mark = old_deactivate_mark;
unbind_to (count, Qnil);
}
if (minibuf_level == 0)
resize_mini_window (XWINDOW (window), 0);
windows_or_buffers_changed++;
XSETFASTINT (XWINDOW (window)->last_modified, 0);
XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
return Qnil;
}
DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
doc: )
(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;
{
Lisp_Object histvar, histpos, val;
struct gcpro gcpro1;
CHECK_STRING (prompt);
if (NILP (keymap))
keymap = Vminibuffer_local_map;
else
keymap = get_keymap (keymap, 1, 0);
if (SYMBOLP (hist))
{
histvar = hist;
histpos = Qnil;
}
else
{
histvar = Fcar_safe (hist);
histpos = Fcdr_safe (hist);
}
if (NILP (histvar))
histvar = Qminibuffer_history;
if (NILP (histpos))
XSETFASTINT (histpos, 0);
GCPRO1 (default_value);
val = read_minibuf (keymap, initial_contents, prompt,
Qnil, !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,
doc: )
(prompt, initial_contents)
Lisp_Object prompt, initial_contents;
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_map, initial_contents,
prompt, Qnil, 1, Qminibuffer_history,
make_number (0), Qnil, 0, 0);
}
DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
doc: )
(prompt, initial_contents)
Lisp_Object prompt, initial_contents;
{
return Feval (read_minibuf (Vread_expression_map, initial_contents,
prompt, Qnil, 1, Qread_expression_history,
make_number (0), Qnil, 0, 0));
}
DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
doc: )
(prompt, initial_input, history, default_value, inherit_input_method)
Lisp_Object prompt, initial_input, history, default_value;
Lisp_Object inherit_input_method;
{
Lisp_Object val;
val = Fread_from_minibuffer (prompt, initial_input, Qnil,
Qnil, history, default_value,
inherit_input_method);
if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
val = default_value;
return val;
}
DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
doc: )
(prompt, initial, inherit_input_method)
Lisp_Object prompt, initial, inherit_input_method;
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
0, Qminibuffer_history, make_number (0), Qnil, 0,
!NILP (inherit_input_method));
}
DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
doc: )
(prompt, default_value)
Lisp_Object prompt, default_value;
{
Lisp_Object name, default_string;
if (NILP (default_value))
default_string = Qnil;
else if (SYMBOLP (default_value))
default_string = SYMBOL_NAME (default_value);
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
DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
doc: )
(prompt)
Lisp_Object prompt;
{
return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
Qnil);
}
#endif
DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
doc: )
(prompt, default_value)
Lisp_Object prompt, default_value;
{
Lisp_Object name, default_string;
if (NILP (default_value))
default_string = Qnil;
else if (SYMBOLP (default_value))
default_string = SYMBOL_NAME (default_value);
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,
doc: )
(prompt, def, require_match)
Lisp_Object prompt, def, require_match;
{
Lisp_Object args[4];
unsigned char *s;
int len;
if (BUFFERP (def))
def = XBUFFER (def)->name;
if (NILP (Vread_buffer_function))
{
if (!NILP (def))
{
if (STRINGP (prompt))
{
s = SDATA (prompt);
len = strlen (s);
if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
len = len - 2;
else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
len--;
prompt = make_specified_string (s, -1, len,
STRING_MULTIBYTE (prompt));
}
args[0] = build_string ("%s (default %s): ");
args[1] = prompt;
args[2] = def;
prompt = Fformat (3, args);
}
return Fcompleting_read (prompt, intern ("internal-complete-buffer"),
Qnil, require_match, Qnil, Qbuffer_name_history,
def, Qnil);
}
else
{
args[0] = Vread_buffer_function;
args[1] = prompt;
args[2] = def;
args[3] = require_match;
return Ffuncall(4, args);
}
}
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,
doc: )
(string, collection, predicate)
Lisp_Object string, collection, predicate;
{
Lisp_Object bestmatch, tail, elt, eltstring;
int bestmatchsize = 0;
int compare, matchsize;
int type = (HASH_TABLE_P (collection) ? 3
: VECTORP (collection) ? 2
: NILP (collection) || (CONSP (collection)
&& (!SYMBOLP (XCAR (collection))
|| NILP (XCAR (collection)))));
int index = 0, obsize = 0;
int matchcount = 0;
int bindcount = -1;
Lisp_Object bucket, zero, end, tem;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
CHECK_STRING (string);
if (type == 0)
return call3 (collection, string, predicate, Qnil);
bestmatch = bucket = Qnil;
zero = make_number (0);
tail = collection;
if (type == 2)
{
collection = check_obarray (collection);
obsize = XVECTOR (collection)->size;
bucket = XVECTOR (collection)->contents[index];
}
while (1)
{
if (type == 1)
{
if (!CONSP (tail))
break;
elt = XCAR (tail);
eltstring = CONSP (elt) ? XCAR (elt) : elt;
tail = XCDR (tail);
}
else if (type == 2)
{
if (!EQ (bucket, zero))
{
if (!SYMBOLP (bucket))
error ("Bad data in guts of obarray");
elt = bucket;
eltstring = elt;
if (XSYMBOL (bucket)->next)
XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
else
XSETFASTINT (bucket, 0);
}
else if (++index >= obsize)
break;
else
{
bucket = XVECTOR (collection)->contents[index];
continue;
}
}
else
{
while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
&& NILP (HASH_HASH (XHASH_TABLE (collection), index)))
index++;
if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
break;
else
elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
}
if (SYMBOLP (eltstring))
eltstring = Fsymbol_name (eltstring);
if (STRINGP (eltstring)
&& SCHARS (string) <= SCHARS (eltstring)
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
string, zero, Qnil,
completion_ignore_case ? Qt : Qnil),
EQ (Qt, tem)))
{
Lisp_Object regexps;
{
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
regexps = XCDR (regexps))
{
if (bindcount < 0) {
bindcount = SPECPDL_INDEX ();
specbind (Qcase_fold_search,
completion_ignore_case ? Qt : Qnil);
}
tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
if (CONSP (regexps))
continue;
}
if (!NILP (predicate))
{
if (EQ (predicate, Qcommandp))
tem = Fcommandp (elt, Qnil);
else
{
if (bindcount >= 0) {
unbind_to (bindcount, Qnil);
bindcount = -1;
}
GCPRO4 (tail, string, eltstring, bestmatch);
tem = type == 3
? call2 (predicate, elt,
HASH_VALUE (XHASH_TABLE (collection), index - 1))
: call1 (predicate, elt);
UNGCPRO;
}
if (NILP (tem)) continue;
}
if (NILP (bestmatch))
{
matchcount = 1;
bestmatch = eltstring;
bestmatchsize = SCHARS (eltstring);
}
else
{
compare = min (bestmatchsize, SCHARS (eltstring));
tem = Fcompare_strings (bestmatch, zero,
make_number (compare),
eltstring, zero,
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)
{
if ((matchsize == SCHARS (eltstring)
&& matchsize < SCHARS (bestmatch))
||
((matchsize == SCHARS (eltstring))
==
(matchsize == SCHARS (bestmatch))
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
string, zero,
Qnil,
Qnil),
EQ (Qt, tem))
&& (tem = Fcompare_strings (bestmatch, zero,
make_number (SCHARS (string)),
string, zero,
Qnil,
Qnil),
! EQ (Qt, tem))))
bestmatch = eltstring;
}
if (bestmatchsize != SCHARS (eltstring)
|| bestmatchsize != matchsize)
matchcount++;
bestmatchsize = matchsize;
if (matchsize <= SCHARS (string)
&& !completion_ignore_case
&& matchcount > 1)
break;
}
}
}
if (bindcount >= 0) {
unbind_to (bindcount, Qnil);
bindcount = -1;
}
if (NILP (bestmatch))
return Qnil;
if (completion_ignore_case && bestmatchsize == SCHARS (string)
&& SCHARS (bestmatch) > bestmatchsize)
return minibuf_conform_representation (string, bestmatch);
if (matchcount == 1 && bestmatchsize == SCHARS (string)
&& (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);
XSETFASTINT (end, bestmatchsize);
return Fsubstring (bestmatch, zero, end);
}
DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
doc: )
(string, collection, predicate, hide_spaces)
Lisp_Object string, collection, predicate, hide_spaces;
{
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
int type = HASH_TABLE_P (collection) ? 3
: VECTORP (collection) ? 2
: NILP (collection) || (CONSP (collection)
&& (!SYMBOLP (XCAR (collection))
|| NILP (XCAR (collection))));
int index = 0, obsize = 0;
int bindcount = -1;
Lisp_Object bucket, tem, zero;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
CHECK_STRING (string);
if (type == 0)
return call3 (collection, string, predicate, Qt);
allmatches = bucket = Qnil;
zero = make_number (0);
tail = collection;
if (type == 2)
{
obsize = XVECTOR (collection)->size;
bucket = XVECTOR (collection)->contents[index];
}
while (1)
{
if (type == 1)
{
if (!CONSP (tail))
break;
elt = XCAR (tail);
eltstring = CONSP (elt) ? XCAR (elt) : elt;
tail = XCDR (tail);
}
else if (type == 2)
{
if (!EQ (bucket, zero))
{
elt = bucket;
eltstring = elt;
if (XSYMBOL (bucket)->next)
XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
else
XSETFASTINT (bucket, 0);
}
else if (++index >= obsize)
break;
else
{
bucket = XVECTOR (collection)->contents[index];
continue;
}
}
else
{
while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
&& NILP (HASH_HASH (XHASH_TABLE (collection), index)))
index++;
if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
break;
else
elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
}
if (SYMBOLP (eltstring))
eltstring = Fsymbol_name (eltstring);
if (STRINGP (eltstring)
&& SCHARS (string) <= SCHARS (eltstring)
&& ((SBYTES (string) > 0
&& SREF (string, 0) == ' ')
|| SREF (eltstring, 0) != ' '
|| NILP (hide_spaces))
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
string, zero,
make_number (SCHARS (string)),
completion_ignore_case ? Qt : Qnil),
EQ (Qt, tem)))
{
Lisp_Object regexps;
Lisp_Object zero;
XSETFASTINT (zero, 0);
{
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
regexps = XCDR (regexps))
{
if (bindcount < 0) {
bindcount = SPECPDL_INDEX ();
specbind (Qcase_fold_search,
completion_ignore_case ? Qt : Qnil);
}
tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
if (CONSP (regexps))
continue;
}
if (!NILP (predicate))
{
if (EQ (predicate, Qcommandp))
tem = Fcommandp (elt, Qnil);
else
{
if (bindcount >= 0) {
unbind_to (bindcount, Qnil);
bindcount = -1;
}
GCPRO4 (tail, eltstring, allmatches, string);
tem = type == 3
? call2 (predicate, elt,
HASH_VALUE (XHASH_TABLE (collection), index - 1))
: call1 (predicate, elt);
UNGCPRO;
}
if (NILP (tem)) continue;
}
allmatches = Fcons (eltstring, allmatches);
}
}
if (bindcount >= 0) {
unbind_to (bindcount, Qnil);
bindcount = -1;
}
return Fnreverse (allmatches);
}
DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
doc: )
(prompt, collection, predicate, require_match, initial_input, hist, def, inherit_input_method)
Lisp_Object prompt, collection, predicate, require_match, initial_input;
Lisp_Object hist, def, inherit_input_method;
{
Lisp_Object val, histvar, histpos, position;
Lisp_Object init;
int pos = 0;
int count = SPECPDL_INDEX ();
struct gcpro gcpro1;
init = initial_input;
GCPRO1 (def);
specbind (Qminibuffer_completion_table, collection);
specbind (Qminibuffer_completion_predicate, predicate);
specbind (Qminibuffer_completion_confirm,
EQ (require_match, Qt) ? Qnil : require_match);
last_exact_completion = Qnil;
position = Qnil;
if (!NILP (init))
{
if (CONSP (init))
{
position = Fcdr (init);
init = Fcar (init);
}
CHECK_STRING (init);
if (!NILP (position))
{
CHECK_NUMBER (position);
pos = XINT (position) - SCHARS (init);
}
}
if (SYMBOLP (hist))
{
histvar = hist;
histpos = Qnil;
}
else
{
histvar = Fcar_safe (hist);
histpos = Fcdr_safe (hist);
}
if (NILP (histvar))
histvar = Qminibuffer_history;
if (NILP (histpos))
XSETFASTINT (histpos, 0);
val = read_minibuf (NILP (require_match)
? (NILP (Vminibuffer_completing_file_name)
|| EQ (Vminibuffer_completing_file_name, Qlambda)
? Vminibuffer_local_completion_map
: Vminibuffer_local_filename_completion_map)
: (NILP (Vminibuffer_completing_file_name)
|| EQ (Vminibuffer_completing_file_name, Qlambda)
? Vminibuffer_local_must_match_map
: Vminibuffer_local_must_match_filename_map),
init, prompt, make_number (pos), 0,
histvar, histpos, def, 0,
!NILP (inherit_input_method));
if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
val = def;
RETURN_UNGCPRO (unbind_to (count, val));
}
Lisp_Object Fminibuffer_completion_help ();
Lisp_Object Fassoc_string ();
DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
doc: )
(string, collection, predicate)
Lisp_Object string, collection, predicate;
{
Lisp_Object regexps, tail, tem = Qnil;
int i = 0;
CHECK_STRING (string);
if ((CONSP (collection)
&& (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
|| NILP (collection))
{
tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
if (NILP (tem))
return Qnil;
}
else if (VECTORP (collection))
{
tem = oblookup (collection,
SDATA (string),
SCHARS (string),
SBYTES (string));
if (!SYMBOLP (tem))
{
if (STRING_MULTIBYTE (string))
string = Fstring_make_unibyte (string);
else
string = Fstring_make_multibyte (string);
tem = oblookup (collection,
SDATA (string),
SCHARS (string),
SBYTES (string));
}
if (completion_ignore_case && !SYMBOLP (tem))
{
for (i = XVECTOR (collection)->size - 1; i >= 0; i--)
{
tail = XVECTOR (collection)->contents[i];
if (SYMBOLP (tail))
while (1)
{
if (EQ((Fcompare_strings (string, make_number (0), Qnil,
Fsymbol_name (tail),
make_number (0) , Qnil, Qt)),
Qt))
{
tem = tail;
break;
}
if (XSYMBOL (tail)->next == 0)
break;
XSETSYMBOL (tail, XSYMBOL (tail)->next);
}
}
}
if (!SYMBOLP (tem))
return Qnil;
}
else if (HASH_TABLE_P (collection))
{
struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
i = hash_lookup (h, string, NULL);
if (i >= 0)
tem = HASH_KEY (h, i);
else
for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
if (!NILP (HASH_HASH (h, i)) &&
EQ (Fcompare_strings (string, make_number (0), Qnil,
HASH_KEY (h, i), make_number (0) , Qnil,
completion_ignore_case ? Qt : Qnil),
Qt))
{
tem = HASH_KEY (h, i);
break;
}
if (!STRINGP (tem))
return Qnil;
}
else
return call3 (collection, string, predicate, Qlambda);
if (CONSP (Vcompletion_regexp_list))
{
int count = SPECPDL_INDEX ();
specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
regexps = XCDR (regexps))
{
if (NILP (Fstring_match (XCAR (regexps),
SYMBOLP (tem) ? string : tem,
Qnil)))
return unbind_to (count, Qnil);
}
unbind_to (count, Qnil);
}
if (!NILP (predicate))
{
return HASH_TABLE_P (collection)
? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
: call1 (predicate, tem);
}
else
return Qt;
}
DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
doc: )
(string, predicate, flag)
Lisp_Object string, predicate, flag;
{
if (NILP (flag))
return Ftry_completion (string, Vbuffer_alist, predicate);
else if (EQ (flag, Qt))
return Fall_completions (string, Vbuffer_alist, predicate, Qt);
else
return Ftest_completion (string, Vbuffer_alist, predicate);
}
int
do_completion ()
{
Lisp_Object completion, string, tem;
int completedp;
Lisp_Object last;
struct gcpro gcpro1, gcpro2;
completion = Ftry_completion (Fminibuffer_completion_contents (),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
last = last_exact_completion;
last_exact_completion = Qnil;
GCPRO2 (completion, last);
if (NILP (completion))
{
bitch_at_user ();
temp_echo_area_glyphs (build_string (" [No match]"));
UNGCPRO;
return 0;
}
if (EQ (completion, Qt))
{
UNGCPRO;
return 1;
}
string = Fminibuffer_completion_contents ();
tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qt);
completedp = !EQ (tem, Qt);
tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qnil);
if (!EQ (tem, Qt))
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
if (! NILP (Vminibuffer_completing_file_name)
&& SREF (completion, SBYTES (completion) - 1) == '/'
&& PT < ZV
&& FETCH_CHAR (PT_BYTE) == '/')
{
del_range (prompt_end, PT + 1);
}
else
del_range (prompt_end, PT);
Finsert (1, &completion);
if (! completedp)
{
UNGCPRO;
return do_completion ();
}
}
tem = Ftest_completion (Fminibuffer_contents (),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (NILP (tem))
{
UNGCPRO;
if (completedp)
return 5;
else if (!NILP (Vcompletion_auto_help))
Fminibuffer_completion_help ();
else
temp_echo_area_glyphs (build_string (" [Next char not unique]"));
return 6;
}
else if (completedp)
{
UNGCPRO;
return 4;
}
last_exact_completion = completion;
if (!NILP (last))
{
tem = Fminibuffer_completion_contents ();
if (!NILP (Fequal (tem, last)))
Fminibuffer_completion_help ();
}
UNGCPRO;
return 3;
}
DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
doc: )
(key, list, case_fold)
register Lisp_Object key;
Lisp_Object list, case_fold;
{
register Lisp_Object tail;
if (SYMBOLP (key))
key = Fsymbol_name (key);
for (tail = list; !NILP (tail); tail = Fcdr (tail))
{
register Lisp_Object elt, tem, thiscar;
elt = Fcar (tail);
thiscar = CONSP (elt) ? XCAR (elt) : elt;
if (SYMBOLP (thiscar))
thiscar = Fsymbol_name (thiscar);
else if (!STRINGP (thiscar))
continue;
tem = Fcompare_strings (thiscar, make_number (0), Qnil,
key, make_number (0), Qnil,
case_fold);
if (EQ (tem, Qt))
return elt;
QUIT;
}
return Qnil;
}
DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "",
doc: )
()
{
register int i;
Lisp_Object window, tem;
if (! EQ (current_kboard->Vlast_command, Vthis_command))
Vminibuf_scroll_window = Qnil;
window = Vminibuf_scroll_window;
if (! NILP (window) && ! NILP (XWINDOW (window)->buffer)
&& !NILP (XBUFFER (XWINDOW (window)->buffer)->name))
{
struct buffer *obuf = current_buffer;
Fset_buffer (XWINDOW (window)->buffer);
tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil);
if (! NILP (tem))
Fset_window_start (window, make_number (BEGV), Qnil);
else
Fscroll_other_window (Qnil);
set_buffer_internal (obuf);
return Qnil;
}
i = do_completion ();
switch (i)
{
case 0:
return Qnil;
case 1:
if (PT != ZV)
Fgoto_char (make_number (ZV));
temp_echo_area_glyphs (build_string (" [Sole completion]"));
break;
case 3:
if (PT != ZV)
Fgoto_char (make_number (ZV));
temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
break;
}
return Qt;
}
Lisp_Object
complete_and_exit_1 ()
{
return make_number (do_completion ());
}
Lisp_Object
complete_and_exit_2 (ignore)
Lisp_Object ignore;
{
return make_number (1);
}
EXFUN (Fexit_minibuffer, 0) NO_RETURN;
DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
Sminibuffer_complete_and_exit, 0, 0, "",
doc: )
()
{
register int i;
Lisp_Object val, tem;
if (XINT (Fminibuffer_prompt_end ()) == ZV)
goto exit;
val = Fminibuffer_contents ();
tem = Ftest_completion (val,
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (!NILP (tem))
{
if (completion_ignore_case)
{
Lisp_Object compl
= Ftry_completion (val,
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (STRINGP (compl)
&& EQ (Flength (val), Flength (compl)))
{
del_range (XINT (Fminibuffer_prompt_end ()), ZV);
Finsert (1, &compl);
}
}
goto exit;
}
SET_PT (ZV);
val = internal_condition_case (complete_and_exit_1, Qerror,
complete_and_exit_2);
i = XFASTINT (val);
switch (i)
{
case 1:
case 3:
goto exit;
case 4:
if (!NILP (Vminibuffer_completion_confirm))
{
temp_echo_area_glyphs (build_string (" [Confirm]"));
return Qnil;
}
else
goto exit;
default:
return Qnil;
}
exit:
return Fexit_minibuffer ();
}
DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word,
0, 0, "",
doc: )
()
{
Lisp_Object completion, tem, tem1;
register int i, i_byte;
struct gcpro gcpro1, gcpro2;
int prompt_end_charpos = XINT (Fminibuffer_prompt_end ());
completion = Ftry_completion (Fminibuffer_completion_contents (),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (NILP (completion))
{
bitch_at_user ();
temp_echo_area_glyphs (build_string (" [No match]"));
return Qnil;
}
if (EQ (completion, Qt))
return Qnil;
#if 0
tem = Fminibuffer_contents ();
b = SDATA (tem);
i = ZV - 1 - SCHARS (completion);
p = SDATA (completion);
if (i > 0 ||
0 <= scmp (b, p, ZV - 1))
{
i = 1;
while (0 <= scmp (b + i, p, ZV - 1 - i))
i++;
del_range (1, i + 1);
SET_PT (ZV);
}
#else
{
int buffer_nchars, completion_nchars;
CHECK_STRING (completion);
tem = Fminibuffer_completion_contents ();
GCPRO2 (completion, tem);
if (! NILP (Vminibuffer_completing_file_name))
{
Lisp_Object substituted;
substituted = Fsubstitute_in_file_name (tem);
if (! EQ (substituted, tem))
{
tem = substituted;
del_range (prompt_end_charpos, PT);
Finsert (1, &tem);
}
}
buffer_nchars = SCHARS (tem);
completion_nchars = SCHARS (completion);
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)))
{
int start_pos;
if (i <= 0) i = 1;
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 (start_pos, start_pos + buffer_nchars);
}
UNGCPRO;
}
#endif
{
int prompt_end_bytepos;
prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos);
i = PT - prompt_end_charpos;
i_byte = PT_BYTE - prompt_end_bytepos;
}
if (i == SCHARS (completion))
{
GCPRO1 (completion);
tem = Ftry_completion (concat2 (Fminibuffer_completion_contents (),
build_string (" ")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
if (STRINGP (tem))
completion = tem;
else
{
GCPRO1 (completion);
tem =
Ftry_completion (concat2 (Fminibuffer_completion_contents (),
build_string ("-")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
if (STRINGP (tem))
completion = tem;
}
}
{
int len, c;
int bytes = SBYTES (completion);
register const unsigned char *completion_string = SDATA (completion);
for (; i_byte < SBYTES (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 (i == PT - prompt_end_charpos)
{
if (!NILP (Vcompletion_auto_help))
Fminibuffer_completion_help ();
return Qnil;
}
if (! NILP (Vminibuffer_completing_file_name)
&& SREF (completion, SBYTES (completion) - 1) == '/'
&& PT < ZV
&& FETCH_CHAR (PT_BYTE) == '/')
{
del_range (prompt_end_charpos, PT + 1);
}
else
del_range (prompt_end_charpos, PT);
insert_from_string (completion, 0, 0, i, i_byte, 1);
return Qt;
}
DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list,
1, 2, 0,
doc: )
(completions, common_substring)
Lisp_Object completions;
Lisp_Object common_substring;
{
Lisp_Object tail, elt;
register int i;
int column = 0;
struct gcpro gcpro1, gcpro2, gcpro3;
struct buffer *old = current_buffer;
int first = 1;
elt = Qnil;
GCPRO3 (completions, elt, common_substring);
if (BUFFERP (Vstandard_output))
set_buffer_internal (XBUFFER (Vstandard_output));
if (NILP (completions))
write_string ("There are no possible completions of what you have typed.",
-1);
else
{
write_string ("Possible completions are:", -1);
for (tail = completions, i = 0; CONSP (tail); tail = XCDR (tail), i++)
{
Lisp_Object tem, string;
int length;
Lisp_Object startpos, endpos;
startpos = Qnil;
elt = XCAR (tail);
if (SYMBOLP (elt))
elt = SYMBOL_NAME (elt);
if (CONSP (elt))
{
tem = XCAR (elt);
CHECK_STRING (tem);
length = SCHARS (tem);
tem = Fcar (XCDR (elt));
CHECK_STRING (tem);
length += SCHARS (tem);
}
else
{
CHECK_STRING (elt);
length = SCHARS (elt);
}
if (BUFFERP (Vstandard_output))
XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
if (column > 33 || first
|| (column > 0 && length > 45))
{
Fterpri (Qnil);
column = 0;
}
else
{
if (BUFFERP (Vstandard_output))
{
tem = Findent_to (make_number (35), make_number (2));
column = XINT (tem);
}
else
{
do
{
write_string (" ", -1);
column++;
}
while (column < 35);
}
}
if (BUFFERP (Vstandard_output))
{
XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
Fset_text_properties (startpos, endpos,
Qnil, Vstandard_output);
}
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))
{
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 (string, Qnil);
}
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);
}
}
column += length;
if (BUFFERP (Vstandard_output))
{
tem = Fcurrent_column ();
column = XINT (tem);
}
first = 0;
}
}
if (BUFFERP (Vstandard_output))
set_buffer_internal (old);
if (!NILP (Vrun_hooks))
{
int count1 = SPECPDL_INDEX ();
specbind (intern ("completion-common-substring"), common_substring);
call1 (Vrun_hooks, intern ("completion-setup-hook"));
unbind_to (count1, Qnil);
}
UNGCPRO;
return Qnil;
}
static Lisp_Object
display_completion_list_1 (list)
Lisp_Object list;
{
return Fdisplay_completion_list (list, Qnil);
}
DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
0, 0, "",
doc: )
()
{
Lisp_Object completions;
message ("Making completion list...");
completions = Fall_completions (Fminibuffer_completion_contents (),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate,
Qt);
clear_message (1, 0);
if (NILP (completions))
{
bitch_at_user ();
temp_echo_area_glyphs (build_string (" [No completions]"));
}
else
{
Lisp_Object tmp = completions = Fsort (completions, Qstring_lessp);
while (CONSP (tmp))
{
if (CONSP (XCDR (tmp))
&& !NILP (Fequal (XCAR (tmp), XCAR (XCDR (tmp)))))
XSETCDR (tmp, XCDR (XCDR (tmp)));
else
tmp = XCDR (tmp);
}
internal_with_output_to_temp_buffer ("*Completions*",
display_completion_list_1,
completions);
}
return Qnil;
}
DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "",
doc: )
()
{
if (INTEGERP (last_command_char))
internal_self_insert (XINT (last_command_char), 0);
else
bitch_at_user ();
return Fexit_minibuffer ();
}
DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
doc: )
()
{
Vdeactivate_mark = Qnil;
Fthrow (Qexit, Qnil);
}
DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
doc: )
()
{
return make_number (minibuf_level);
}
DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
doc: )
()
{
return Fcopy_sequence (minibuf_prompt);
}
extern Lisp_Object Vminibuffer_message_timeout;
void
temp_echo_area_glyphs (string)
Lisp_Object string;
{
int osize = ZV;
int osize_byte = ZV_BYTE;
int opoint = PT;
int opoint_byte = PT_BYTE;
Lisp_Object oinhibit;
oinhibit = Vinhibit_quit;
message (0);
SET_PT_BOTH (osize, osize_byte);
insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0);
SET_PT_BOTH (opoint, opoint_byte);
Vinhibit_quit = Qt;
if (NUMBERP (Vminibuffer_message_timeout))
sit_for (Vminibuffer_message_timeout, 0, 2);
else
sit_for (Qt, 0, 2);
del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
SET_PT_BOTH (opoint, opoint_byte);
if (!NILP (Vquit_flag))
{
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,
doc: )
(string)
Lisp_Object string;
{
CHECK_STRING (string);
temp_echo_area_glyphs (string);
return Qnil;
}
void
init_minibuf_once ()
{
Vminibuffer_list = Qnil;
staticpro (&Vminibuffer_list);
}
void
syms_of_minibuf ()
{
minibuf_level = 0;
minibuf_prompt = Qnil;
staticpro (&minibuf_prompt);
minibuf_save_list = Qnil;
staticpro (&minibuf_save_list);
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_completion_confirm = intern ("minibuffer-completion-confirm");
staticpro (&Qminibuffer_completion_confirm);
Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
staticpro (&Qminibuffer_completion_predicate);
staticpro (&last_exact_completion);
last_exact_completion = Qnil;
staticpro (&last_minibuf_string);
last_minibuf_string = Qnil;
Quser_variable_p = intern ("user-variable-p");
staticpro (&Quser_variable_p);
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);
Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
staticpro (&Qminibuffer_exit_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);
Qcase_fold_search = intern ("case-fold-search");
staticpro (&Qcase_fold_search);
Qread_expression_history = intern ("read-expression-history");
staticpro (&Qread_expression_history);
DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
doc: );
Vread_buffer_function = Qnil;
DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
doc: );
Vminibuffer_setup_hook = Qnil;
DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook,
doc: );
Vminibuffer_exit_hook = Qnil;
DEFVAR_LISP ("history-length", &Vhistory_length,
doc: );
XSETFASTINT (Vhistory_length, 30);
DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
doc: );
history_delete_duplicates = 0;
DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input,
doc: );
Vhistory_add_new_input = Qt;
DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
doc: );
Vcompletion_auto_help = Qt;
DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
doc: );
completion_ignore_case = 0;
DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
doc: );
enable_recursive_minibuffers = 0;
DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
doc: );
Vminibuffer_completion_table = Qnil;
DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
doc: );
Vminibuffer_completion_predicate = Qnil;
DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
doc: );
Vminibuffer_completion_confirm = Qnil;
DEFVAR_LISP ("minibuffer-completing-file-name",
&Vminibuffer_completing_file_name,
doc: );
Vminibuffer_completing_file_name = Qnil;
DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
doc: );
Vminibuffer_help_form = Qnil;
DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
doc: );
XSETFASTINT (Vminibuffer_history_variable, 0);
DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position,
doc: );
Vminibuffer_history_position = Qnil;
DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
doc: );
minibuffer_auto_raise = 0;
DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
doc: );
Vcompletion_regexp_list = Qnil;
DEFVAR_BOOL ("minibuffer-allow-text-properties",
&minibuffer_allow_text_properties,
doc: );
minibuffer_allow_text_properties = 0;
DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties,
doc: );
Vminibuffer_prompt_properties
= Fcons (intern ("read-only"), Fcons (Qt, Qnil));
DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
doc: );
Vread_expression_map = Qnil;
defsubr (&Sset_minibuffer_window);
defsubr (&Sread_from_minibuffer);
defsubr (&Seval_minibuffer);
defsubr (&Sread_minibuffer);
defsubr (&Sread_string);
defsubr (&Sread_command);
defsubr (&Sread_variable);
defsubr (&Sinternal_complete_buffer);
defsubr (&Sread_buffer);
defsubr (&Sread_no_blanks_input);
defsubr (&Sminibuffer_depth);
defsubr (&Sminibuffer_prompt);
defsubr (&Sminibufferp);
defsubr (&Sminibuffer_prompt_end);
defsubr (&Sminibuffer_contents);
defsubr (&Sminibuffer_contents_no_properties);
defsubr (&Sminibuffer_completion_contents);
defsubr (&Sdelete_minibuffer_contents);
defsubr (&Stry_completion);
defsubr (&Sall_completions);
defsubr (&Stest_completion);
defsubr (&Sassoc_string);
defsubr (&Scompleting_read);
defsubr (&Sminibuffer_complete);
defsubr (&Sminibuffer_complete_word);
defsubr (&Sminibuffer_complete_and_exit);
defsubr (&Sdisplay_completion_list);
defsubr (&Sminibuffer_completion_help);
defsubr (&Sself_insert_and_exit);
defsubr (&Sexit_minibuffer);
defsubr (&Sminibuffer_message);
}
void
keys_of_minibuf ()
{
initial_define_key (Vminibuffer_local_map, Ctl ('g'),
"abort-recursive-edit");
initial_define_key (Vminibuffer_local_map, Ctl ('m'),
"exit-minibuffer");
initial_define_key (Vminibuffer_local_map, Ctl ('j'),
"exit-minibuffer");
initial_define_key (Vminibuffer_local_ns_map, ' ',
"exit-minibuffer");
initial_define_key (Vminibuffer_local_ns_map, '\t',
"exit-minibuffer");
initial_define_key (Vminibuffer_local_ns_map, '?',
"self-insert-and-exit");
initial_define_key (Vminibuffer_local_completion_map, '\t',
"minibuffer-complete");
initial_define_key (Vminibuffer_local_completion_map, ' ',
"minibuffer-complete-word");
initial_define_key (Vminibuffer_local_completion_map, '?',
"minibuffer-completion-help");
Fdefine_key (Vminibuffer_local_filename_completion_map,
build_string (" "), Qnil);
initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
"minibuffer-complete-and-exit");
initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
"minibuffer-complete-and-exit");
Fdefine_key (Vminibuffer_local_must_match_filename_map,
build_string (" "), Qnil);
}