(top level comment): Updated to reflect the fact that
[emacs.git] / src / minibuf.c
blob9809a3232c4638d311ba49a3f57aa18c00882497
1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include <config.h>
24 #include <stdio.h>
25 #include "lisp.h"
26 #include "commands.h"
27 #include "buffer.h"
28 #include "charset.h"
29 #include "dispextern.h"
30 #include "keyboard.h"
31 #include "frame.h"
32 #include "window.h"
33 #include "syntax.h"
34 #include "intervals.h"
36 #define min(a, b) ((a) < (b) ? (a) : (b))
38 extern int quit_char;
40 /* List of buffers for use as minibuffers.
41 The first element of the list is used for the outermost minibuffer
42 invocation, the next element is used for a recursive minibuffer
43 invocation, etc. The list is extended at the end as deeper
44 minibuffer recursions are encountered. */
46 Lisp_Object Vminibuffer_list;
48 /* Data to remember during recursive minibuffer invocations */
50 Lisp_Object minibuf_save_list;
52 /* Depth in minibuffer invocations. */
54 int minibuf_level;
56 /* Nonzero means display completion help for invalid input. */
58 Lisp_Object Vcompletion_auto_help;
60 /* The maximum length of a minibuffer history. */
62 Lisp_Object Qhistory_length, Vhistory_length;
64 /* Fread_minibuffer leaves the input here as a string. */
66 Lisp_Object last_minibuf_string;
68 /* Nonzero means let functions called when within a minibuffer
69 invoke recursive minibuffers (to read arguments, or whatever) */
71 int enable_recursive_minibuffers;
73 /* Nonzero means don't ignore text properties
74 in Fread_from_minibuffer. */
76 int minibuffer_allow_text_properties;
78 /* help-form is bound to this while in the minibuffer. */
80 Lisp_Object Vminibuffer_help_form;
82 /* Variable which is the history list to add minibuffer values to. */
84 Lisp_Object Vminibuffer_history_variable;
86 /* Current position in the history list (adjusted by M-n and M-p). */
88 Lisp_Object Vminibuffer_history_position;
90 /* Text properties that are added to minibuffer prompts.
91 These are in addition to the basic `field' property, and stickiness
92 properties. */
94 Lisp_Object Vminibuffer_prompt_properties;
96 Lisp_Object Qminibuffer_history, Qbuffer_name_history;
98 Lisp_Object Qread_file_name_internal;
100 /* Normal hooks for entry to and exit from minibuffer. */
102 Lisp_Object Qminibuffer_setup_hook, Vminibuffer_setup_hook;
103 Lisp_Object Qminibuffer_exit_hook, Vminibuffer_exit_hook;
105 /* Function to call to read a buffer name. */
106 Lisp_Object Vread_buffer_function;
108 /* Nonzero means completion ignores case. */
110 int completion_ignore_case;
112 /* List of regexps that should restrict possible completions. */
114 Lisp_Object Vcompletion_regexp_list;
116 /* Nonzero means raise the minibuffer frame when the minibuffer
117 is entered. */
119 int minibuffer_auto_raise;
121 /* If last completion attempt reported "Complete but not unique"
122 then this is the string completed then; otherwise this is nil. */
124 static Lisp_Object last_exact_completion;
126 /* Non-nil means it is the window for C-M-v to scroll
127 when the minibuffer is selected. */
129 extern Lisp_Object Vminibuf_scroll_window;
131 extern Lisp_Object Voverriding_local_map;
133 Lisp_Object Quser_variable_p;
135 Lisp_Object Qminibuffer_default;
137 Lisp_Object Qcurrent_input_method, Qactivate_input_method;
139 extern Lisp_Object Qmouse_face;
141 extern Lisp_Object Qfield;
143 /* Put minibuf on currently selected frame's minibuffer.
144 We do this whenever the user starts a new minibuffer
145 or when a minibuffer exits. */
147 void
148 choose_minibuf_frame ()
150 if (FRAMEP (selected_frame)
151 && FRAME_LIVE_P (XFRAME (selected_frame))
152 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
154 struct frame *sf = XFRAME (selected_frame);
155 Lisp_Object buffer;
157 /* I don't think that any frames may validly have a null minibuffer
158 window anymore. */
159 if (NILP (sf->minibuffer_window))
160 abort ();
162 /* Under X, we come here with minibuf_window being the
163 minibuffer window of the unused termcap window created in
164 init_window_once. That window doesn't have a buffer. */
165 buffer = XWINDOW (minibuf_window)->buffer;
166 if (BUFFERP (buffer))
167 Fset_window_buffer (sf->minibuffer_window, buffer);
168 minibuf_window = sf->minibuffer_window;
171 /* Make sure no other frame has a minibuffer as its selected window,
172 because the text would not be displayed in it, and that would be
173 confusing. Only allow the selected frame to do this,
174 and that only if the minibuffer is active. */
176 Lisp_Object tail, frame;
178 FOR_EACH_FRAME (tail, frame)
179 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
180 && !(EQ (frame, selected_frame)
181 && minibuf_level > 0))
182 Fset_frame_selected_window (frame, Fframe_first_window (frame));
186 Lisp_Object
187 choose_minibuf_frame_1 (ignore)
188 Lisp_Object ignore;
190 choose_minibuf_frame ();
191 return Qnil;
194 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
195 Sset_minibuffer_window, 1, 1, 0,
196 "Specify which minibuffer window to use for the minibuffer.\n\
197 This effects where the minibuffer is displayed if you put text in it\n\
198 without invoking the usual minibuffer commands.")
199 (window)
200 Lisp_Object window;
202 CHECK_WINDOW (window, 1);
203 if (! MINI_WINDOW_P (XWINDOW (window)))
204 error ("Window is not a minibuffer window");
206 minibuf_window = window;
208 return window;
212 /* Actual minibuffer invocation. */
214 static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
215 static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
216 Lisp_Object, Lisp_Object,
217 int, Lisp_Object,
218 Lisp_Object, Lisp_Object,
219 int, int));
220 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
221 Lisp_Object, Lisp_Object,
222 int, Lisp_Object,
223 Lisp_Object, Lisp_Object,
224 int, int));
225 static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object));
228 /* Read a Lisp object from VAL and return it. If VAL is an empty
229 string, and DEFALT is a string, read from DEFALT instead of VAL. */
231 static Lisp_Object
232 string_to_object (val, defalt)
233 Lisp_Object val, defalt;
235 struct gcpro gcpro1, gcpro2;
236 Lisp_Object expr_and_pos;
237 int pos;
239 GCPRO2 (val, defalt);
241 if (STRINGP (val) && XSTRING (val)->size == 0
242 && STRINGP (defalt))
243 val = defalt;
245 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
246 pos = XINT (Fcdr (expr_and_pos));
247 if (pos != XSTRING (val)->size)
249 /* Ignore trailing whitespace; any other trailing junk
250 is an error. */
251 int i;
252 pos = string_char_to_byte (val, pos);
253 for (i = pos; i < STRING_BYTES (XSTRING (val)); i++)
255 int c = XSTRING (val)->data[i];
256 if (c != ' ' && c != '\t' && c != '\n')
257 error ("Trailing garbage following expression");
261 val = Fcar (expr_and_pos);
262 RETURN_UNGCPRO (val);
266 /* Like read_minibuf but reading from stdin. This function is called
267 from read_minibuf to do the job if noninteractive. */
269 static Lisp_Object
270 read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
271 histvar, histpos, defalt, allow_props,
272 inherit_input_method)
273 Lisp_Object map;
274 Lisp_Object initial;
275 Lisp_Object prompt;
276 Lisp_Object backup_n;
277 int expflag;
278 Lisp_Object histvar;
279 Lisp_Object histpos;
280 Lisp_Object defalt;
281 int allow_props;
282 int inherit_input_method;
284 int size, len;
285 char *line, *s;
286 Lisp_Object val;
288 fprintf (stdout, "%s", XSTRING (prompt)->data);
289 fflush (stdout);
291 val = Qnil;
292 size = 100;
293 len = 0;
294 line = (char *) xmalloc (size * sizeof *line);
295 while ((s = fgets (line + len, size - len, stdin)) != NULL
296 && (len = strlen (line),
297 len == size - 1 && line[len - 1] != '\n'))
299 size *= 2;
300 line = (char *) xrealloc (line, size);
303 if (s)
305 len = strlen (line);
307 if (len > 0 && line[len - 1] == '\n')
308 line[--len] = '\0';
310 val = build_string (line);
311 xfree (line);
313 else
315 xfree (line);
316 error ("Error reading from stdin");
319 /* If Lisp form desired instead of string, parse it. */
320 if (expflag)
321 val = string_to_object (val, defalt);
323 return val;
327 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
328 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
329 prompting with PROMPT (a string), using history list HISTVAR
330 with initial position HISTPOS. (BACKUP_N should be <= 0.)
332 Normally return the result as a string (the text that was read),
333 but if EXPFLAG is nonzero, read it and return the object read.
334 If HISTVAR is given, save the value read on that history only if it doesn't
335 match the front of that history list exactly. The value is pushed onto
336 the list as the string that was read.
338 DEFALT specifies te default value for the sake of history commands.
340 If ALLOW_PROPS is nonzero, we do not throw away text properties.
342 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
343 current input method. */
345 static Lisp_Object
346 read_minibuf (map, initial, prompt, backup_n, expflag,
347 histvar, histpos, defalt, allow_props, inherit_input_method)
348 Lisp_Object map;
349 Lisp_Object initial;
350 Lisp_Object prompt;
351 Lisp_Object backup_n;
352 int expflag;
353 Lisp_Object histvar;
354 Lisp_Object histpos;
355 Lisp_Object defalt;
356 int allow_props;
357 int inherit_input_method;
359 Lisp_Object val;
360 int count = specpdl_ptr - specpdl;
361 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
362 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
363 Lisp_Object enable_multibyte;
364 extern Lisp_Object Qread_only, Qfront_sticky;
365 extern Lisp_Object Qrear_nonsticky;
367 specbind (Qminibuffer_default, defalt);
369 single_kboard_state ();
370 #ifdef HAVE_X_WINDOWS
371 if (display_busy_cursor_p)
372 cancel_busy_cursor ();
373 #endif
375 val = Qnil;
376 ambient_dir = current_buffer->directory;
377 input_method = Qnil;
378 enable_multibyte = Qnil;
380 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
381 store them away before we can GC. Don't need to protect
382 BACKUP_N because we use the value only if it is an integer. */
383 GCPRO5 (map, initial, val, ambient_dir, input_method);
385 if (!STRINGP (prompt))
386 prompt = build_string ("");
388 if (!enable_recursive_minibuffers
389 && minibuf_level > 0)
391 if (EQ (selected_window, minibuf_window))
392 error ("Command attempted to use minibuffer while in minibuffer");
393 else
394 /* If we're in another window, cancel the minibuffer that's active. */
395 Fthrow (Qexit,
396 build_string ("Command attempted to use minibuffer while in minibuffer"));
399 if (noninteractive)
400 return read_minibuf_noninteractive (map, initial, prompt, backup_n,
401 expflag, histvar, histpos, defalt,
402 allow_props, inherit_input_method);
404 /* Choose the minibuffer window and frame, and take action on them. */
406 choose_minibuf_frame ();
408 record_unwind_protect (choose_minibuf_frame_1, Qnil);
410 record_unwind_protect (Fset_window_configuration,
411 Fcurrent_window_configuration (Qnil));
413 /* If the minibuffer window is on a different frame, save that
414 frame's configuration too. */
415 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
416 if (!EQ (mini_frame, selected_frame))
417 record_unwind_protect (Fset_window_configuration,
418 Fcurrent_window_configuration (mini_frame));
420 /* If the minibuffer is on an iconified or invisible frame,
421 make it visible now. */
422 Fmake_frame_visible (mini_frame);
424 if (minibuffer_auto_raise)
425 Fraise_frame (mini_frame);
427 /* We have to do this after saving the window configuration
428 since that is what restores the current buffer. */
430 /* Arrange to restore a number of minibuffer-related variables.
431 We could bind each variable separately, but that would use lots of
432 specpdl slots. */
433 minibuf_save_list
434 = Fcons (Voverriding_local_map,
435 Fcons (minibuf_window, minibuf_save_list));
436 minibuf_save_list
437 = Fcons (minibuf_prompt,
438 Fcons (make_number (minibuf_prompt_width),
439 Fcons (Vhelp_form,
440 Fcons (Vcurrent_prefix_arg,
441 Fcons (Vminibuffer_history_position,
442 Fcons (Vminibuffer_history_variable,
443 minibuf_save_list))))));
445 record_unwind_protect (read_minibuf_unwind, Qnil);
446 minibuf_level++;
448 /* Now that we can restore all those variables, start changing them. */
450 minibuf_prompt_width = 0;
451 minibuf_prompt = Fcopy_sequence (prompt);
452 Vminibuffer_history_position = histpos;
453 Vminibuffer_history_variable = histvar;
454 Vhelp_form = Vminibuffer_help_form;
456 if (inherit_input_method)
458 /* `current-input-method' is buffer local. So, remeber it in
459 INPUT_METHOD before changing the current buffer. */
460 input_method = Fsymbol_value (Qcurrent_input_method);
461 enable_multibyte = current_buffer->enable_multibyte_characters;
464 /* Switch to the minibuffer. */
466 minibuffer = get_minibuffer (minibuf_level);
467 Fset_buffer (minibuffer);
469 /* The current buffer's default directory is usually the right thing
470 for our minibuffer here. However, if you're typing a command at
471 a minibuffer-only frame when minibuf_level is zero, then buf IS
472 the current_buffer, so reset_buffer leaves buf's default
473 directory unchanged. This is a bummer when you've just started
474 up Emacs and buf's default directory is Qnil. Here's a hack; can
475 you think of something better to do? Find another buffer with a
476 better directory, and use that one instead. */
477 if (STRINGP (ambient_dir))
478 current_buffer->directory = ambient_dir;
479 else
481 Lisp_Object buf_list;
483 for (buf_list = Vbuffer_alist;
484 CONSP (buf_list);
485 buf_list = XCDR (buf_list))
487 Lisp_Object other_buf;
489 other_buf = XCDR (XCAR (buf_list));
490 if (STRINGP (XBUFFER (other_buf)->directory))
492 current_buffer->directory = XBUFFER (other_buf)->directory;
493 break;
498 if (!EQ (mini_frame, selected_frame))
499 Fredirect_frame_focus (selected_frame, mini_frame);
501 Vminibuf_scroll_window = selected_window;
502 Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
503 Fselect_window (minibuf_window);
504 XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
506 Fmake_local_variable (Qprint_escape_newlines);
507 print_escape_newlines = 1;
509 /* Erase the buffer. */
511 int count1 = specpdl_ptr - specpdl;
512 specbind (Qinhibit_read_only, Qt);
513 Ferase_buffer ();
514 unbind_to (count1, Qnil);
517 if (!NILP (current_buffer->enable_multibyte_characters)
518 && ! STRING_MULTIBYTE (minibuf_prompt))
519 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
521 /* Insert the prompt, record where it ends. */
522 Finsert (1, &minibuf_prompt);
523 if (PT > BEG)
525 Fput_text_property (make_number (BEG), make_number (PT),
526 Qfront_sticky, Qt, Qnil);
527 Fput_text_property (make_number (BEG), make_number (PT),
528 Qrear_nonsticky, Qt, Qnil);
529 Fput_text_property (make_number (BEG), make_number (PT),
530 Qfield, Qt, Qnil);
531 Fadd_text_properties (make_number (BEG), make_number (PT),
532 Vminibuffer_prompt_properties, Qnil);
535 minibuf_prompt_width = current_column ();
537 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
538 if (inherit_input_method)
539 current_buffer->enable_multibyte_characters = enable_multibyte;
541 /* Put in the initial input. */
542 if (!NILP (initial))
544 Finsert (1, &initial);
545 if (INTEGERP (backup_n))
546 Fforward_char (backup_n);
549 clear_message (1, 1);
550 current_buffer->keymap = map;
552 /* Turn on an input method stored in INPUT_METHOD if any. */
553 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
554 call1 (Qactivate_input_method, input_method);
556 /* Run our hook, but not if it is empty.
557 (run-hooks would do nothing if it is empty,
558 but it's important to save time here in the usual case). */
559 if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
560 && !NILP (Vrun_hooks))
561 call1 (Vrun_hooks, Qminibuffer_setup_hook);
563 /* Don't allow the user to undo past this point. */
564 current_buffer->undo_list = Qnil;
566 recursive_edit_1 ();
568 /* If cursor is on the minibuffer line,
569 show the user we have exited by putting it in column 0. */
570 if (XWINDOW (minibuf_window)->cursor.vpos >= 0
571 && !noninteractive)
573 XWINDOW (minibuf_window)->cursor.hpos = 0;
574 XWINDOW (minibuf_window)->cursor.x = 0;
575 XWINDOW (minibuf_window)->must_be_updated_p = 1;
576 update_frame (XFRAME (selected_frame), 1, 1);
577 if (rif && rif->flush_display)
578 rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame));
581 /* Make minibuffer contents into a string. */
582 Fset_buffer (minibuffer);
583 if (allow_props)
584 val = Ffield_string (make_number (ZV));
585 else
586 val = Ffield_string_no_properties (make_number (ZV));
588 /* VAL is the string of minibuffer text. */
590 last_minibuf_string = val;
592 /* Add the value to the appropriate history list unless it is empty. */
593 if (XSTRING (val)->size != 0
594 && SYMBOLP (Vminibuffer_history_variable))
596 /* If the caller wanted to save the value read on a history list,
597 then do so if the value is not already the front of the list. */
598 Lisp_Object histval;
600 /* If variable is unbound, make it nil. */
601 if (EQ (XSYMBOL (Vminibuffer_history_variable)->value, Qunbound))
602 Fset (Vminibuffer_history_variable, Qnil);
604 histval = Fsymbol_value (Vminibuffer_history_variable);
606 /* The value of the history variable must be a cons or nil. Other
607 values are unacceptable. We silently ignore these values. */
608 if (NILP (histval)
609 || (CONSP (histval)
610 && NILP (Fequal (last_minibuf_string, Fcar (histval)))))
612 Lisp_Object length;
614 histval = Fcons (last_minibuf_string, histval);
615 Fset (Vminibuffer_history_variable, histval);
617 /* Truncate if requested. */
618 length = Fget (Vminibuffer_history_variable, Qhistory_length);
619 if (NILP (length)) length = Vhistory_length;
620 if (INTEGERP (length))
622 if (XINT (length) <= 0)
623 Fset (Vminibuffer_history_variable, Qnil);
624 else
626 Lisp_Object temp;
628 temp = Fnthcdr (Fsub1 (length), histval);
629 if (CONSP (temp)) Fsetcdr (temp, Qnil);
635 /* If Lisp form desired instead of string, parse it. */
636 if (expflag)
637 val = string_to_object (val, defalt);
639 /* The appropriate frame will get selected
640 in set-window-configuration. */
641 RETURN_UNGCPRO (unbind_to (count, val));
644 /* Return a buffer to be used as the minibuffer at depth `depth'.
645 depth = 0 is the lowest allowed argument, and that is the value
646 used for nonrecursive minibuffer invocations */
648 Lisp_Object
649 get_minibuffer (depth)
650 int depth;
652 Lisp_Object tail, num, buf;
653 char name[24];
654 extern Lisp_Object nconc2 ();
656 XSETFASTINT (num, depth);
657 tail = Fnthcdr (num, Vminibuffer_list);
658 if (NILP (tail))
660 tail = Fcons (Qnil, Qnil);
661 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
663 buf = Fcar (tail);
664 if (NILP (buf) || NILP (XBUFFER (buf)->name))
666 sprintf (name, " *Minibuf-%d*", depth);
667 buf = Fget_buffer_create (build_string (name));
669 /* Although the buffer's name starts with a space, undo should be
670 enabled in it. */
671 Fbuffer_enable_undo (buf);
673 XCAR (tail) = buf;
675 else
677 int count = specpdl_ptr - specpdl;
679 reset_buffer (XBUFFER (buf));
680 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
681 Fset_buffer (buf);
682 Fkill_all_local_variables ();
683 unbind_to (count, Qnil);
686 return buf;
689 /* This function is called on exiting minibuffer, whether normally or
690 not, and it restores the current window, buffer, etc. */
692 static Lisp_Object
693 read_minibuf_unwind (data)
694 Lisp_Object data;
696 Lisp_Object old_deactivate_mark;
697 Lisp_Object window;
699 /* We are exiting the minibuffer one way or the other,
700 so run the hook. */
701 if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
702 && !NILP (Vrun_hooks))
703 safe_run_hooks (Qminibuffer_exit_hook);
705 /* If this was a recursive minibuffer,
706 tie the minibuffer window back to the outer level minibuffer buffer. */
707 minibuf_level--;
709 window = minibuf_window;
710 /* To keep things predictable, in case it matters, let's be in the
711 minibuffer when we reset the relevant variables. */
712 Fset_buffer (XWINDOW (window)->buffer);
714 /* Restore prompt, etc, from outer minibuffer level. */
715 minibuf_prompt = Fcar (minibuf_save_list);
716 minibuf_save_list = Fcdr (minibuf_save_list);
717 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
718 minibuf_save_list = Fcdr (minibuf_save_list);
719 Vhelp_form = Fcar (minibuf_save_list);
720 minibuf_save_list = Fcdr (minibuf_save_list);
721 Vcurrent_prefix_arg = Fcar (minibuf_save_list);
722 minibuf_save_list = Fcdr (minibuf_save_list);
723 Vminibuffer_history_position = Fcar (minibuf_save_list);
724 minibuf_save_list = Fcdr (minibuf_save_list);
725 Vminibuffer_history_variable = Fcar (minibuf_save_list);
726 minibuf_save_list = Fcdr (minibuf_save_list);
727 Voverriding_local_map = Fcar (minibuf_save_list);
728 minibuf_save_list = Fcdr (minibuf_save_list);
729 #if 0
730 temp = Fcar (minibuf_save_list);
731 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
732 minibuf_window = temp;
733 #endif
734 minibuf_save_list = Fcdr (minibuf_save_list);
736 /* Erase the minibuffer we were using at this level. */
738 int count = specpdl_ptr - specpdl;
739 /* Prevent error in erase-buffer. */
740 specbind (Qinhibit_read_only, Qt);
741 old_deactivate_mark = Vdeactivate_mark;
742 Ferase_buffer ();
743 Vdeactivate_mark = old_deactivate_mark;
744 unbind_to (count, Qnil);
747 /* When we get to the outmost level, make sure we resize the
748 mini-window back to its normal size. */
749 if (minibuf_level == 0)
750 resize_mini_window (XWINDOW (window), 0);
752 /* Make sure minibuffer window is erased, not ignored. */
753 windows_or_buffers_changed++;
754 XSETFASTINT (XWINDOW (window)->last_modified, 0);
755 XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
756 return Qnil;
760 /* This comment supplies the doc string for read-from-minibuffer,
761 for make-docfile to see. We cannot put this in the real DEFUN
762 due to limits in the Unix cpp.
764 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
765 "Read a string from the minibuffer, prompting with string PROMPT.\n\
766 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
767 to be inserted into the minibuffer before reading input.\n\
768 If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
769 is STRING, but point is placed at position POSITION in the minibuffer.\n\
770 Third arg KEYMAP is a keymap to use whilst reading;\n\
771 if omitted or nil, the default is `minibuffer-local-map'.\n\
772 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
773 and return that object:\n\
774 in other words, do `(car (read-from-string INPUT-STRING))'\n\
775 Fifth arg HIST, if non-nil, specifies a history list\n\
776 and optionally the initial position in the list.\n\
777 It can be a symbol, which is the history list variable to use,\n\
778 or it can be a cons cell (HISTVAR . HISTPOS).\n\
779 In that case, HISTVAR is the history list variable to use,\n\
780 and HISTPOS is the initial position (the position in the list\n\
781 which INITIAL-CONTENTS corresponds to).\n\
782 Positions are counted starting from 1 at the beginning of the list.\n\
783 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available\n\
784 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE\n\
785 if the user enters empty input! It returns the empty string.\n\
786 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
787 the current input method and the setting of enable-multibyte-characters.\n\
788 If the variable `minibuffer-allow-text-properties' is non-nil,\n\
789 then the string which is returned includes whatever text properties\n\
790 were present in the minibuffer. Otherwise the value has no text properties.")
791 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
794 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
795 0 /* See immediately above */)
796 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
797 Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
798 Lisp_Object inherit_input_method;
800 int pos = 0;
801 Lisp_Object histvar, histpos, position, val;
802 struct gcpro gcpro1;
804 position = Qnil;
806 CHECK_STRING (prompt, 0);
807 if (!NILP (initial_contents))
809 if (CONSP (initial_contents))
811 position = Fcdr (initial_contents);
812 initial_contents = Fcar (initial_contents);
814 CHECK_STRING (initial_contents, 1);
815 if (!NILP (position))
817 CHECK_NUMBER (position, 0);
818 /* Convert to distance from end of input. */
819 if (XINT (position) < 1)
820 /* A number too small means the beginning of the string. */
821 pos = - XSTRING (initial_contents)->size;
822 else
823 pos = XINT (position) - 1 - XSTRING (initial_contents)->size;
827 if (NILP (keymap))
828 keymap = Vminibuffer_local_map;
829 else
830 keymap = get_keymap (keymap, 1, 0);
832 if (SYMBOLP (hist))
834 histvar = hist;
835 histpos = Qnil;
837 else
839 histvar = Fcar_safe (hist);
840 histpos = Fcdr_safe (hist);
842 if (NILP (histvar))
843 histvar = Qminibuffer_history;
844 if (NILP (histpos))
845 XSETFASTINT (histpos, 0);
847 GCPRO1 (default_value);
848 val = read_minibuf (keymap, initial_contents, prompt,
849 make_number (pos), !NILP (read),
850 histvar, histpos, default_value,
851 minibuffer_allow_text_properties,
852 !NILP (inherit_input_method));
853 UNGCPRO;
854 return val;
857 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
858 "Return a Lisp object read using the minibuffer.\n\
859 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
860 is a string to insert in the minibuffer before reading.")
861 (prompt, initial_contents)
862 Lisp_Object prompt, initial_contents;
864 CHECK_STRING (prompt, 0);
865 if (!NILP (initial_contents))
866 CHECK_STRING (initial_contents, 1);
867 return read_minibuf (Vminibuffer_local_map, initial_contents,
868 prompt, Qnil, 1, Qminibuffer_history,
869 make_number (0), Qnil, 0, 0);
872 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
873 "Return value of Lisp expression read using the minibuffer.\n\
874 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
875 is a string to insert in the minibuffer before reading.")
876 (prompt, initial_contents)
877 Lisp_Object prompt, initial_contents;
879 return Feval (Fread_minibuffer (prompt, initial_contents));
882 /* Functions that use the minibuffer to read various things. */
884 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
885 "Read a string from the minibuffer, prompting with string PROMPT.\n\
886 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.\n\
887 The third arg HISTORY, if non-nil, specifies a history list\n\
888 and optionally the initial position in the list.\n\
889 See `read-from-minibuffer' for details of HISTORY argument.\n\
890 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used\n\
891 for history commands, and as the value to return if the user enters\n\
892 the empty string.\n\
893 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
894 the current input method and the setting of enable-multibyte-characters.")
895 (prompt, initial_input, history, default_value, inherit_input_method)
896 Lisp_Object prompt, initial_input, history, default_value;
897 Lisp_Object inherit_input_method;
899 Lisp_Object val;
900 val = Fread_from_minibuffer (prompt, initial_input, Qnil,
901 Qnil, history, default_value,
902 inherit_input_method);
903 if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (default_value))
904 val = default_value;
905 return val;
908 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
909 "Read a string from the terminal, not allowing blanks.\n\
910 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.\n\
911 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
912 the current input method and the setting of enable-multibyte-characters.")
913 (prompt, initial, inherit_input_method)
914 Lisp_Object prompt, initial, inherit_input_method;
916 CHECK_STRING (prompt, 0);
917 if (! NILP (initial))
918 CHECK_STRING (initial, 1);
920 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
921 0, Qminibuffer_history, make_number (0), Qnil, 0,
922 !NILP (inherit_input_method));
925 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
926 "Read the name of a command and return as a symbol.\n\
927 Prompts with PROMPT. By default, return DEFAULT-VALUE.")
928 (prompt, default_value)
929 Lisp_Object prompt, default_value;
931 Lisp_Object name, default_string;
933 if (NILP (default_value))
934 default_string = Qnil;
935 else if (SYMBOLP (default_value))
936 XSETSTRING (default_string, XSYMBOL (default_value)->name);
937 else
938 default_string = default_value;
940 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
941 Qnil, Qnil, default_string, Qnil);
942 if (NILP (name))
943 return name;
944 return Fintern (name, Qnil);
947 #ifdef NOTDEF
948 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
949 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
950 Prompts with PROMPT.")
951 (prompt)
952 Lisp_Object prompt;
954 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
955 Qnil);
957 #endif /* NOTDEF */
959 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
960 "Read the name of a user variable and return it as a symbol.\n\
961 Prompts with PROMPT. By default, return DEFAULT-VALUE.\n\
962 A user variable is one whose documentation starts with a `*' character.")
963 (prompt, default_value)
964 Lisp_Object prompt, default_value;
966 Lisp_Object name, default_string;
968 if (NILP (default_value))
969 default_string = Qnil;
970 else if (SYMBOLP (default_value))
971 XSETSTRING (default_string, XSYMBOL (default_value)->name);
972 else
973 default_string = default_value;
975 name = Fcompleting_read (prompt, Vobarray,
976 Quser_variable_p, Qt,
977 Qnil, Qnil, default_string, Qnil);
978 if (NILP (name))
979 return name;
980 return Fintern (name, Qnil);
983 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
984 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
985 Prompts with PROMPT.\n\
986 Optional second arg DEF is value to return if user enters an empty line.\n\
987 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
988 (prompt, def, require_match)
989 Lisp_Object prompt, def, require_match;
991 Lisp_Object args[4];
993 if (BUFFERP (def))
994 def = XBUFFER (def)->name;
996 if (NILP (Vread_buffer_function))
998 if (!NILP (def))
1000 args[0] = build_string ("%s(default %s) ");
1001 args[1] = prompt;
1002 args[2] = def;
1003 prompt = Fformat (3, args);
1006 return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
1007 require_match, Qnil, Qbuffer_name_history,
1008 def, Qnil);
1010 else
1012 args[0] = Vread_buffer_function;
1013 args[1] = prompt;
1014 args[2] = def;
1015 args[3] = require_match;
1016 return Ffuncall(4, args);
1020 static Lisp_Object
1021 minibuf_conform_representation (string, basis)
1022 Lisp_Object string, basis;
1024 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1025 return string;
1027 if (STRING_MULTIBYTE (string))
1028 return Fstring_make_unibyte (string);
1029 else
1030 return Fstring_make_multibyte (string);
1033 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1034 "Return common substring of all completions of STRING in ALIST.\n\
1035 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1036 All that match are compared together; the longest initial sequence\n\
1037 common to all matches is returned as a string.\n\
1038 If there is no match at all, nil is returned.\n\
1039 For a unique match which is exact, t is returned.\n\
1041 ALIST can be an obarray instead of an alist.\n\
1042 Then the print names of all symbols in the obarray are the possible matches.\n\
1044 ALIST can also be a function to do the completion itself.\n\
1045 It receives three arguments: the values STRING, PREDICATE and nil.\n\
1046 Whatever it returns becomes the value of `try-completion'.\n\
1048 If optional third argument PREDICATE is non-nil,\n\
1049 it is used to test each possible match.\n\
1050 The match is a candidate only if PREDICATE returns non-nil.\n\
1051 The argument given to PREDICATE is the alist element\n\
1052 or the symbol from the obarray.\n\
1053 Additionally to this predicate, `completion-regexp-list'\n\
1054 is used to further constrain the set of candidates.")
1055 (string, alist, predicate)
1056 Lisp_Object string, alist, predicate;
1058 Lisp_Object bestmatch, tail, elt, eltstring;
1059 /* Size in bytes of BESTMATCH. */
1060 int bestmatchsize = 0;
1061 /* These are in bytes, too. */
1062 int compare, matchsize;
1063 int list = CONSP (alist) || NILP (alist);
1064 int index = 0, obsize = 0;
1065 int matchcount = 0;
1066 Lisp_Object bucket, zero, end, tem;
1067 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1069 CHECK_STRING (string, 0);
1070 if (!list && !VECTORP (alist))
1071 return call3 (alist, string, predicate, Qnil);
1073 bestmatch = bucket = Qnil;
1075 /* If ALIST is not a list, set TAIL just for gc pro. */
1076 tail = alist;
1077 if (! list)
1079 index = 0;
1080 obsize = XVECTOR (alist)->size;
1081 bucket = XVECTOR (alist)->contents[index];
1084 while (1)
1086 /* Get the next element of the alist or obarray. */
1087 /* Exit the loop if the elements are all used up. */
1088 /* elt gets the alist element or symbol.
1089 eltstring gets the name to check as a completion. */
1091 if (list)
1093 if (NILP (tail))
1094 break;
1095 elt = Fcar (tail);
1096 eltstring = Fcar (elt);
1097 tail = Fcdr (tail);
1099 else
1101 if (XFASTINT (bucket) != 0)
1103 elt = bucket;
1104 eltstring = Fsymbol_name (elt);
1105 if (XSYMBOL (bucket)->next)
1106 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1107 else
1108 XSETFASTINT (bucket, 0);
1110 else if (++index >= obsize)
1111 break;
1112 else
1114 bucket = XVECTOR (alist)->contents[index];
1115 continue;
1119 /* Is this element a possible completion? */
1121 if (STRINGP (eltstring)
1122 && XSTRING (string)->size <= XSTRING (eltstring)->size
1123 && (tem = Fcompare_strings (eltstring, make_number (0),
1124 make_number (XSTRING (string)->size),
1125 string, make_number (0), Qnil,
1126 completion_ignore_case ?Qt : Qnil),
1127 EQ (Qt, tem)))
1129 /* Yes. */
1130 Lisp_Object regexps;
1131 Lisp_Object zero;
1132 XSETFASTINT (zero, 0);
1134 /* Ignore this element if it fails to match all the regexps. */
1135 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1136 regexps = XCDR (regexps))
1138 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1139 if (NILP (tem))
1140 break;
1142 if (CONSP (regexps))
1143 continue;
1145 /* Ignore this element if there is a predicate
1146 and the predicate doesn't like it. */
1148 if (!NILP (predicate))
1150 if (EQ (predicate, Qcommandp))
1151 tem = Fcommandp (elt);
1152 else
1154 GCPRO4 (tail, string, eltstring, bestmatch);
1155 tem = call1 (predicate, elt);
1156 UNGCPRO;
1158 if (NILP (tem)) continue;
1161 /* Update computation of how much all possible completions match */
1163 matchcount++;
1164 if (NILP (bestmatch))
1166 bestmatch = eltstring;
1167 bestmatchsize = XSTRING (eltstring)->size;
1169 else
1171 compare = min (bestmatchsize, XSTRING (eltstring)->size);
1172 tem = Fcompare_strings (bestmatch, make_number (0),
1173 make_number (compare),
1174 eltstring, make_number (0),
1175 make_number (compare),
1176 completion_ignore_case ? Qt : Qnil);
1177 if (EQ (tem, Qt))
1178 matchsize = compare;
1179 else if (XINT (tem) < 0)
1180 matchsize = - XINT (tem) - 1;
1181 else
1182 matchsize = XINT (tem) - 1;
1184 if (matchsize < 0)
1185 matchsize = compare;
1186 if (completion_ignore_case)
1188 /* If this is an exact match except for case,
1189 use it as the best match rather than one that is not an
1190 exact match. This way, we get the case pattern
1191 of the actual match. */
1192 if ((matchsize == XSTRING (eltstring)->size
1193 && matchsize < XSTRING (bestmatch)->size)
1195 /* If there is more than one exact match ignoring case,
1196 and one of them is exact including case,
1197 prefer that one. */
1198 /* If there is no exact match ignoring case,
1199 prefer a match that does not change the case
1200 of the input. */
1201 ((matchsize == XSTRING (eltstring)->size)
1203 (matchsize == XSTRING (bestmatch)->size)
1204 && (tem = Fcompare_strings (eltstring, make_number (0),
1205 make_number (XSTRING (string)->size),
1206 string, make_number (0),
1207 Qnil,
1208 Qnil),
1209 EQ (Qt, tem))
1210 && (tem = Fcompare_strings (bestmatch, make_number (0),
1211 make_number (XSTRING (string)->size),
1212 string, make_number (0),
1213 Qnil,
1214 Qnil),
1215 ! EQ (Qt, tem))))
1216 bestmatch = eltstring;
1218 bestmatchsize = matchsize;
1223 if (NILP (bestmatch))
1224 return Qnil; /* No completions found */
1225 /* If we are ignoring case, and there is no exact match,
1226 and no additional text was supplied,
1227 don't change the case of what the user typed. */
1228 if (completion_ignore_case && bestmatchsize == XSTRING (string)->size
1229 && XSTRING (bestmatch)->size > bestmatchsize)
1230 return minibuf_conform_representation (string, bestmatch);
1232 /* Return t if the supplied string is an exact match (counting case);
1233 it does not require any change to be made. */
1234 if (matchcount == 1 && bestmatchsize == XSTRING (string)->size
1235 && (tem = Fcompare_strings (bestmatch, make_number (0),
1236 make_number (bestmatchsize),
1237 string, make_number (0),
1238 make_number (bestmatchsize),
1239 Qnil),
1240 EQ (Qt, tem)))
1241 return Qt;
1243 XSETFASTINT (zero, 0); /* Else extract the part in which */
1244 XSETFASTINT (end, bestmatchsize); /* all completions agree */
1245 return Fsubstring (bestmatch, zero, end);
1248 /* Compare exactly LEN chars of strings at S1 and S2,
1249 ignoring case if appropriate.
1250 Return -1 if strings match,
1251 else number of chars that match at the beginning. */
1254 scmp (s1, s2, len)
1255 register unsigned char *s1, *s2;
1256 int len;
1258 register int l = len;
1260 if (completion_ignore_case)
1262 while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
1263 l--;
1265 else
1267 while (l && *s1++ == *s2++)
1268 l--;
1270 if (l == 0)
1271 return -1;
1272 else
1274 int match = len - l;
1276 /* Now *--S1 is the unmatching byte. If it is in the middle of
1277 multi-byte form, we must say that the multi-byte character
1278 there doesn't match. */
1279 while (match && *--s1 >= 0xA0) match--;
1280 return match;
1284 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1285 "Search for partial matches to STRING in ALIST.\n\
1286 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1287 The value is a list of all the strings from ALIST that match.\n\
1289 ALIST can be an obarray instead of an alist.\n\
1290 Then the print names of all symbols in the obarray are the possible matches.\n\
1292 ALIST can also be a function to do the completion itself.\n\
1293 It receives three arguments: the values STRING, PREDICATE and t.\n\
1294 Whatever it returns becomes the value of `all-completions'.\n\
1296 If optional third argument PREDICATE is non-nil,\n\
1297 it is used to test each possible match.\n\
1298 The match is a candidate only if PREDICATE returns non-nil.\n\
1299 The argument given to PREDICATE is the alist element\n\
1300 or the symbol from the obarray.\n\
1301 Additionally to this predicate, `completion-regexp-list'\n\
1302 is used to further constrain the set of candidates.\n\
1304 If the optional fourth argument HIDE-SPACES is non-nil,\n\
1305 strings in ALIST that start with a space\n\
1306 are ignored unless STRING itself starts with a space.")
1307 (string, alist, predicate, hide_spaces)
1308 Lisp_Object string, alist, predicate, hide_spaces;
1310 Lisp_Object tail, elt, eltstring;
1311 Lisp_Object allmatches;
1312 int list = CONSP (alist) || NILP (alist);
1313 int index = 0, obsize = 0;
1314 Lisp_Object bucket, tem;
1315 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1317 CHECK_STRING (string, 0);
1318 if (!list && !VECTORP (alist))
1320 return call3 (alist, string, predicate, Qt);
1322 allmatches = bucket = Qnil;
1324 /* If ALIST is not a list, set TAIL just for gc pro. */
1325 tail = alist;
1326 if (! list)
1328 index = 0;
1329 obsize = XVECTOR (alist)->size;
1330 bucket = XVECTOR (alist)->contents[index];
1333 while (1)
1335 /* Get the next element of the alist or obarray. */
1336 /* Exit the loop if the elements are all used up. */
1337 /* elt gets the alist element or symbol.
1338 eltstring gets the name to check as a completion. */
1340 if (list)
1342 if (NILP (tail))
1343 break;
1344 elt = Fcar (tail);
1345 eltstring = Fcar (elt);
1346 tail = Fcdr (tail);
1348 else
1350 if (XFASTINT (bucket) != 0)
1352 elt = bucket;
1353 eltstring = Fsymbol_name (elt);
1354 if (XSYMBOL (bucket)->next)
1355 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1356 else
1357 XSETFASTINT (bucket, 0);
1359 else if (++index >= obsize)
1360 break;
1361 else
1363 bucket = XVECTOR (alist)->contents[index];
1364 continue;
1368 /* Is this element a possible completion? */
1370 if (STRINGP (eltstring)
1371 && XSTRING (string)->size <= XSTRING (eltstring)->size
1372 /* If HIDE_SPACES, reject alternatives that start with space
1373 unless the input starts with space. */
1374 && ((STRING_BYTES (XSTRING (string)) > 0
1375 && XSTRING (string)->data[0] == ' ')
1376 || XSTRING (eltstring)->data[0] != ' '
1377 || NILP (hide_spaces))
1378 && (tem = Fcompare_strings (eltstring, make_number (0),
1379 make_number (XSTRING (string)->size),
1380 string, make_number (0),
1381 make_number (XSTRING (string)->size),
1382 completion_ignore_case ? Qt : Qnil),
1383 EQ (Qt, tem)))
1385 /* Yes. */
1386 Lisp_Object regexps;
1387 Lisp_Object zero;
1388 XSETFASTINT (zero, 0);
1390 /* Ignore this element if it fails to match all the regexps. */
1391 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1392 regexps = XCDR (regexps))
1394 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1395 if (NILP (tem))
1396 break;
1398 if (CONSP (regexps))
1399 continue;
1401 /* Ignore this element if there is a predicate
1402 and the predicate doesn't like it. */
1404 if (!NILP (predicate))
1406 if (EQ (predicate, Qcommandp))
1407 tem = Fcommandp (elt);
1408 else
1410 GCPRO4 (tail, eltstring, allmatches, string);
1411 tem = call1 (predicate, elt);
1412 UNGCPRO;
1414 if (NILP (tem)) continue;
1416 /* Ok => put it on the list. */
1417 allmatches = Fcons (eltstring, allmatches);
1421 return Fnreverse (allmatches);
1424 Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
1425 Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
1426 Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
1427 Lisp_Object Vminibuffer_completing_file_name;
1429 /* This comment supplies the doc string for completing-read,
1430 for make-docfile to see. We cannot put this in the real DEFUN
1431 due to limits in the Unix cpp.
1433 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1434 "Read a string in the minibuffer, with completion.\n\
1435 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
1436 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
1437 TABLE can also be a function to do the completion itself.\n\
1438 PREDICATE limits completion to a subset of TABLE.\n\
1439 See `try-completion' and `all-completions' for more details\n\
1440 on completion, TABLE, and PREDICATE.\n\
1442 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
1443 the input is (or completes to) an element of TABLE or is null.\n\
1444 If it is also not t, Return does not exit if it does non-null completion.\n\
1445 If the input is null, `completing-read' returns an empty string,\n\
1446 regardless of the value of REQUIRE-MATCH.\n\
1448 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
1449 If it is (STRING . POSITION), the initial input\n\
1450 is STRING, but point is placed POSITION characters into the string.\n\
1451 HIST, if non-nil, specifies a history list\n\
1452 and optionally the initial position in the list.\n\
1453 It can be a symbol, which is the history list variable to use,\n\
1454 or it can be a cons cell (HISTVAR . HISTPOS).\n\
1455 In that case, HISTVAR is the history list variable to use,\n\
1456 and HISTPOS is the initial position (the position in the list\n\
1457 which INITIAL-INPUT corresponds to).\n\
1458 Positions are counted starting from 1 at the beginning of the list.\n\
1459 DEF, if non-nil, is the default value.\n\
1461 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits\n\
1462 the current input method and the setting of enable-multibyte-characters.\n\
1464 Completion ignores case if the ambient value of\n\
1465 `completion-ignore-case' is non-nil."
1467 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1468 0 /* See immediately above */)
1469 (prompt, table, predicate, require_match, initial_input, hist, def, inherit_input_method)
1470 Lisp_Object prompt, table, predicate, require_match, initial_input;
1471 Lisp_Object hist, def, inherit_input_method;
1473 Lisp_Object val, histvar, histpos, position;
1474 Lisp_Object init;
1475 int pos = 0;
1476 int count = specpdl_ptr - specpdl;
1477 struct gcpro gcpro1;
1479 init = initial_input;
1480 GCPRO1 (def);
1482 specbind (Qminibuffer_completion_table, table);
1483 specbind (Qminibuffer_completion_predicate, predicate);
1484 specbind (Qminibuffer_completion_confirm,
1485 EQ (require_match, Qt) ? Qnil : Qt);
1486 last_exact_completion = Qnil;
1488 position = Qnil;
1489 if (!NILP (init))
1491 if (CONSP (init))
1493 position = Fcdr (init);
1494 init = Fcar (init);
1496 CHECK_STRING (init, 0);
1497 if (!NILP (position))
1499 CHECK_NUMBER (position, 0);
1500 /* Convert to distance from end of input. */
1501 pos = XINT (position) - XSTRING (init)->size;
1505 if (SYMBOLP (hist))
1507 histvar = hist;
1508 histpos = Qnil;
1510 else
1512 histvar = Fcar_safe (hist);
1513 histpos = Fcdr_safe (hist);
1515 if (NILP (histvar))
1516 histvar = Qminibuffer_history;
1517 if (NILP (histpos))
1518 XSETFASTINT (histpos, 0);
1520 val = read_minibuf (NILP (require_match)
1521 ? Vminibuffer_local_completion_map
1522 : Vminibuffer_local_must_match_map,
1523 init, prompt, make_number (pos), 0,
1524 histvar, histpos, def, 0,
1525 !NILP (inherit_input_method));
1527 if (STRINGP (val) && XSTRING (val)->size == 0 && ! NILP (def))
1528 val = def;
1530 RETURN_UNGCPRO (unbind_to (count, val));
1533 Lisp_Object Fminibuffer_completion_help ();
1534 Lisp_Object assoc_for_completion ();
1536 /* Test whether TXT is an exact completion. */
1537 Lisp_Object
1538 test_completion (txt)
1539 Lisp_Object txt;
1541 Lisp_Object tem;
1543 if (CONSP (Vminibuffer_completion_table)
1544 || NILP (Vminibuffer_completion_table))
1545 return assoc_for_completion (txt, Vminibuffer_completion_table);
1546 else if (VECTORP (Vminibuffer_completion_table))
1548 /* Bypass intern-soft as that loses for nil */
1549 tem = oblookup (Vminibuffer_completion_table,
1550 XSTRING (txt)->data,
1551 XSTRING (txt)->size,
1552 STRING_BYTES (XSTRING (txt)));
1553 if (!SYMBOLP (tem))
1555 if (STRING_MULTIBYTE (txt))
1556 txt = Fstring_make_unibyte (txt);
1557 else
1558 txt = Fstring_make_multibyte (txt);
1560 tem = oblookup (Vminibuffer_completion_table,
1561 XSTRING (txt)->data,
1562 XSTRING (txt)->size,
1563 STRING_BYTES (XSTRING (txt)));
1564 if (!SYMBOLP (tem))
1565 return Qnil;
1567 if (!NILP (Vminibuffer_completion_predicate))
1568 return call1 (Vminibuffer_completion_predicate, tem);
1569 else
1570 return Qt;
1572 else
1573 return call3 (Vminibuffer_completion_table, txt,
1574 Vminibuffer_completion_predicate, Qlambda);
1577 /* returns:
1578 * 0 no possible completion
1579 * 1 was already an exact and unique completion
1580 * 3 was already an exact completion
1581 * 4 completed to an exact completion
1582 * 5 some completion happened
1583 * 6 no completion happened
1586 do_completion ()
1588 Lisp_Object completion, string, tem;
1589 int completedp;
1590 Lisp_Object last;
1591 struct gcpro gcpro1, gcpro2;
1593 completion = Ftry_completion (Ffield_string (make_number (ZV)),
1594 Vminibuffer_completion_table,
1595 Vminibuffer_completion_predicate);
1596 last = last_exact_completion;
1597 last_exact_completion = Qnil;
1599 GCPRO2 (completion, last);
1601 if (NILP (completion))
1603 bitch_at_user ();
1604 temp_echo_area_glyphs (" [No match]");
1605 UNGCPRO;
1606 return 0;
1609 if (EQ (completion, Qt)) /* exact and unique match */
1611 UNGCPRO;
1612 return 1;
1615 string = Ffield_string (make_number (ZV));
1617 /* COMPLETEDP should be true if some completion was done, which
1618 doesn't include simply changing the case of the entered string.
1619 However, for appearance, the string is rewritten if the case
1620 changes. */
1621 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qt);
1622 completedp = !EQ (tem, Qt);
1624 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qnil);
1625 if (!EQ (tem, Qt))
1626 /* Rewrite the user's input. */
1628 Fdelete_field (make_number (ZV)); /* Some completion happened */
1629 Finsert (1, &completion);
1631 if (! completedp)
1632 /* The case of the string changed, but that's all. We're not
1633 sure whether this is a unique completion or not, so try again
1634 using the real case (this shouldn't recurse again, because
1635 the next time try-completion will return either `t' or the
1636 exact string). */
1638 UNGCPRO;
1639 return do_completion ();
1643 /* It did find a match. Do we match some possibility exactly now? */
1644 tem = test_completion (Ffield_string (make_number (ZV)));
1645 if (NILP (tem))
1647 /* not an exact match */
1648 UNGCPRO;
1649 if (completedp)
1650 return 5;
1651 else if (!NILP (Vcompletion_auto_help))
1652 Fminibuffer_completion_help ();
1653 else
1654 temp_echo_area_glyphs (" [Next char not unique]");
1655 return 6;
1657 else if (completedp)
1659 UNGCPRO;
1660 return 4;
1662 /* If the last exact completion and this one were the same,
1663 it means we've already given a "Complete but not unique"
1664 message and the user's hit TAB again, so now we give him help. */
1665 last_exact_completion = completion;
1666 if (!NILP (last))
1668 tem = Ffield_string (make_number (ZV));
1669 if (!NILP (Fequal (tem, last)))
1670 Fminibuffer_completion_help ();
1672 UNGCPRO;
1673 return 3;
1676 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1678 Lisp_Object
1679 assoc_for_completion (key, list)
1680 register Lisp_Object key;
1681 Lisp_Object list;
1683 register Lisp_Object tail;
1685 for (tail = list; !NILP (tail); tail = Fcdr (tail))
1687 register Lisp_Object elt, tem, thiscar;
1688 elt = Fcar (tail);
1689 if (!CONSP (elt)) continue;
1690 thiscar = Fcar (elt);
1691 if (!STRINGP (thiscar))
1692 continue;
1693 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1694 key, make_number (0), Qnil,
1695 completion_ignore_case ? Qt : Qnil);
1696 if (EQ (tem, Qt))
1697 return elt;
1698 QUIT;
1700 return Qnil;
1703 DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "",
1704 "Complete the minibuffer contents as far as possible.\n\
1705 Return nil if there is no valid completion, else t.\n\
1706 If no characters can be completed, display a list of possible completions.\n\
1707 If you repeat this command after it displayed such a list,\n\
1708 scroll the window of possible completions.")
1711 register int i;
1712 Lisp_Object window, tem;
1714 /* If the previous command was not this,
1715 mark the completion buffer obsolete. */
1716 if (! EQ (current_kboard->Vlast_command, Vthis_command))
1717 Vminibuf_scroll_window = Qnil;
1719 window = Vminibuf_scroll_window;
1720 /* If there's a fresh completion window with a live buffer,
1721 and this command is repeated, scroll that window. */
1722 if (! NILP (window) && ! NILP (XWINDOW (window)->buffer)
1723 && !NILP (XBUFFER (XWINDOW (window)->buffer)->name))
1725 struct buffer *obuf = current_buffer;
1727 Fset_buffer (XWINDOW (window)->buffer);
1728 tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil);
1729 if (! NILP (tem))
1730 /* If end is in view, scroll up to the beginning. */
1731 Fset_window_start (window, make_number (BEGV), Qnil);
1732 else
1733 /* Else scroll down one screen. */
1734 Fscroll_other_window (Qnil);
1736 set_buffer_internal (obuf);
1737 return Qnil;
1740 i = do_completion ();
1741 switch (i)
1743 case 0:
1744 return Qnil;
1746 case 1:
1747 if (PT != ZV)
1748 Fgoto_char (make_number (ZV));
1749 temp_echo_area_glyphs (" [Sole completion]");
1750 break;
1752 case 3:
1753 if (PT != ZV)
1754 Fgoto_char (make_number (ZV));
1755 temp_echo_area_glyphs (" [Complete, but not unique]");
1756 break;
1759 return Qt;
1762 /* Subroutines of Fminibuffer_complete_and_exit. */
1764 /* This one is called by internal_condition_case to do the real work. */
1766 Lisp_Object
1767 complete_and_exit_1 ()
1769 return make_number (do_completion ());
1772 /* This one is called by internal_condition_case if an error happens.
1773 Pretend the current value is an exact match. */
1775 Lisp_Object
1776 complete_and_exit_2 (ignore)
1777 Lisp_Object ignore;
1779 return make_number (1);
1782 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
1783 Sminibuffer_complete_and_exit, 0, 0, "",
1784 "If the minibuffer contents is a valid completion then exit.\n\
1785 Otherwise try to complete it. If completion leads to a valid completion,\n\
1786 a repetition of this command will exit.")
1789 register int i;
1790 Lisp_Object val;
1792 /* Allow user to specify null string */
1793 if (XINT (Ffield_beginning (make_number (ZV), Qnil)) == ZV)
1794 goto exit;
1796 if (!NILP (test_completion (Ffield_string (make_number (ZV)))))
1797 goto exit;
1799 /* Call do_completion, but ignore errors. */
1800 val = internal_condition_case (complete_and_exit_1, Qerror,
1801 complete_and_exit_2);
1803 i = XFASTINT (val);
1804 switch (i)
1806 case 1:
1807 case 3:
1808 goto exit;
1810 case 4:
1811 if (!NILP (Vminibuffer_completion_confirm))
1813 temp_echo_area_glyphs (" [Confirm]");
1814 return Qnil;
1816 else
1817 goto exit;
1819 default:
1820 return Qnil;
1822 exit:
1823 return Fthrow (Qexit, Qnil);
1824 /* NOTREACHED */
1827 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word,
1828 0, 0, "",
1829 "Complete the minibuffer contents at most a single word.\n\
1830 After one word is completed as much as possible, a space or hyphen\n\
1831 is added, provided that matches some possible completion.\n\
1832 Return nil if there is no valid completion, else t.")
1835 Lisp_Object completion, tem, tem1;
1836 register int i, i_byte;
1837 register unsigned char *completion_string;
1838 struct gcpro gcpro1, gcpro2;
1839 int prompt_end_charpos;
1841 /* We keep calling Fbuffer_string rather than arrange for GC to
1842 hold onto a pointer to one of the strings thus made. */
1844 completion = Ftry_completion (Ffield_string (make_number (ZV)),
1845 Vminibuffer_completion_table,
1846 Vminibuffer_completion_predicate);
1847 if (NILP (completion))
1849 bitch_at_user ();
1850 temp_echo_area_glyphs (" [No match]");
1851 return Qnil;
1853 if (EQ (completion, Qt))
1854 return Qnil;
1856 #if 0 /* How the below code used to look, for reference. */
1857 tem = Ffield_string (make_number (ZV));
1858 b = XSTRING (tem)->data;
1859 i = ZV - 1 - XSTRING (completion)->size;
1860 p = XSTRING (completion)->data;
1861 if (i > 0 ||
1862 0 <= scmp (b, p, ZV - 1))
1864 i = 1;
1865 /* Set buffer to longest match of buffer tail and completion head. */
1866 while (0 <= scmp (b + i, p, ZV - 1 - i))
1867 i++;
1868 del_range (1, i + 1);
1869 SET_PT (ZV);
1871 #else /* Rewritten code */
1873 int buffer_nchars, completion_nchars;
1875 CHECK_STRING (completion, 0);
1876 tem = Ffield_string (make_number (ZV));
1877 GCPRO2 (completion, tem);
1878 /* If reading a file name,
1879 expand any $ENVVAR refs in the buffer and in TEM. */
1880 if (! NILP (Vminibuffer_completing_file_name))
1882 Lisp_Object substituted;
1883 substituted = Fsubstitute_in_file_name (tem);
1884 if (! EQ (substituted, tem))
1886 tem = substituted;
1887 Fdelete_field (make_number (ZV));
1888 insert_from_string (tem, 0, 0, XSTRING (tem)->size,
1889 STRING_BYTES (XSTRING (tem)), 0);
1892 buffer_nchars = XSTRING (tem)->size; /* ie ZV - BEGV */
1893 completion_nchars = XSTRING (completion)->size;
1894 i = buffer_nchars - completion_nchars;
1895 if (i > 0
1897 (tem1 = Fcompare_strings (tem, make_number (0),
1898 make_number (buffer_nchars),
1899 completion, make_number (0),
1900 make_number (buffer_nchars),
1901 completion_ignore_case ? Qt : Qnil),
1902 ! EQ (tem1, Qt)))
1904 int start_pos;
1906 /* Set buffer to longest match of buffer tail and completion head. */
1907 if (i <= 0) i = 1;
1908 start_pos= i;
1909 buffer_nchars -= i;
1910 while (i > 0)
1912 tem1 = Fcompare_strings (tem, make_number (start_pos), Qnil,
1913 completion, make_number (0),
1914 make_number (buffer_nchars),
1915 completion_ignore_case ? Qt : Qnil);
1916 start_pos++;
1917 if (EQ (tem1, Qt))
1918 break;
1919 i++;
1920 buffer_nchars--;
1922 del_range (1, i + 1);
1923 SET_PT_BOTH (ZV, ZV_BYTE);
1925 UNGCPRO;
1927 #endif /* Rewritten code */
1929 prompt_end_charpos = XINT (Ffield_beginning (make_number (ZV), Qnil));
1932 int prompt_end_bytepos;
1933 prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos);
1934 i = ZV - prompt_end_charpos;
1935 i_byte = ZV_BYTE - prompt_end_bytepos;
1938 /* If completion finds next char not unique,
1939 consider adding a space or a hyphen. */
1940 if (i == XSTRING (completion)->size)
1942 GCPRO1 (completion);
1943 tem = Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string (" ")),
1944 Vminibuffer_completion_table,
1945 Vminibuffer_completion_predicate);
1946 UNGCPRO;
1948 if (STRINGP (tem))
1949 completion = tem;
1950 else
1952 GCPRO1 (completion);
1953 tem =
1954 Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string ("-")),
1955 Vminibuffer_completion_table,
1956 Vminibuffer_completion_predicate);
1957 UNGCPRO;
1959 if (STRINGP (tem))
1960 completion = tem;
1964 /* Now find first word-break in the stuff found by completion.
1965 i gets index in string of where to stop completing. */
1967 int len, c;
1968 int bytes = STRING_BYTES (XSTRING (completion));
1969 completion_string = XSTRING (completion)->data;
1970 for (; i_byte < STRING_BYTES (XSTRING (completion)); i_byte += len, i++)
1972 c = STRING_CHAR_AND_LENGTH (completion_string + i_byte,
1973 bytes - i_byte,
1974 len);
1975 if (SYNTAX (c) != Sword)
1977 i_byte += len;
1978 i++;
1979 break;
1984 /* If got no characters, print help for user. */
1986 if (i == ZV - prompt_end_charpos)
1988 if (!NILP (Vcompletion_auto_help))
1989 Fminibuffer_completion_help ();
1990 return Qnil;
1993 /* Otherwise insert in minibuffer the chars we got */
1995 Fdelete_field (make_number (ZV));
1996 insert_from_string (completion, 0, 0, i, i_byte, 1);
1997 return Qt;
2000 DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list,
2001 1, 1, 0,
2002 "Display the list of completions, COMPLETIONS, using `standard-output'.\n\
2003 Each element may be just a symbol or string\n\
2004 or may be a list of two strings to be printed as if concatenated.\n\
2005 `standard-output' must be a buffer.\n\
2006 The actual completion alternatives, as inserted, are given `mouse-face'\n\
2007 properties of `highlight'.\n\
2008 At the end, this runs the normal hook `completion-setup-hook'.\n\
2009 It can find the completion buffer in `standard-output'.")
2010 (completions)
2011 Lisp_Object completions;
2013 Lisp_Object tail, elt;
2014 register int i;
2015 int column = 0;
2016 struct gcpro gcpro1, gcpro2;
2017 struct buffer *old = current_buffer;
2018 int first = 1;
2020 /* Note that (when it matters) every variable
2021 points to a non-string that is pointed to by COMPLETIONS,
2022 except for ELT. ELT can be pointing to a string
2023 when terpri or Findent_to calls a change hook. */
2024 elt = Qnil;
2025 GCPRO2 (completions, elt);
2027 if (BUFFERP (Vstandard_output))
2028 set_buffer_internal (XBUFFER (Vstandard_output));
2030 if (NILP (completions))
2031 write_string ("There are no possible completions of what you have typed.",
2032 -1);
2033 else
2035 write_string ("Possible completions are:", -1);
2036 for (tail = completions, i = 0; !NILP (tail); tail = Fcdr (tail), i++)
2038 Lisp_Object tem, string;
2039 int length;
2040 Lisp_Object startpos, endpos;
2042 startpos = Qnil;
2044 elt = Fcar (tail);
2045 /* Compute the length of this element. */
2046 if (CONSP (elt))
2048 tem = XCAR (elt);
2049 CHECK_STRING (tem, 0);
2050 length = XSTRING (tem)->size;
2052 tem = Fcar (XCDR (elt));
2053 CHECK_STRING (tem, 0);
2054 length += XSTRING (tem)->size;
2056 else
2058 CHECK_STRING (elt, 0);
2059 length = XSTRING (elt)->size;
2062 /* This does a bad job for narrower than usual windows.
2063 Sadly, the window it will appear in is not known
2064 until after the text has been made. */
2066 if (BUFFERP (Vstandard_output))
2067 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2069 /* If the previous completion was very wide,
2070 or we have two on this line already,
2071 don't put another on the same line. */
2072 if (column > 33 || first
2073 /* If this is really wide, don't put it second on a line. */
2074 || (column > 0 && length > 45))
2076 Fterpri (Qnil);
2077 column = 0;
2079 /* Otherwise advance to column 35. */
2080 else
2082 if (BUFFERP (Vstandard_output))
2084 tem = Findent_to (make_number (35), make_number (2));
2086 column = XINT (tem);
2088 else
2092 write_string (" ", -1);
2093 column++;
2095 while (column < 35);
2099 if (BUFFERP (Vstandard_output))
2101 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2102 Fset_text_properties (startpos, endpos,
2103 Qnil, Vstandard_output);
2106 /* Output this element.
2107 If necessary, convert it to unibyte or to multibyte first. */
2108 if (CONSP (elt))
2109 string = Fcar (elt);
2110 else
2111 string = elt;
2112 if (NILP (current_buffer->enable_multibyte_characters)
2113 && STRING_MULTIBYTE (string))
2114 string = Fstring_make_unibyte (string);
2115 else if (!NILP (current_buffer->enable_multibyte_characters)
2116 && !STRING_MULTIBYTE (string))
2117 string = Fstring_make_multibyte (string);
2119 if (BUFFERP (Vstandard_output))
2121 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2123 Fprinc (string, Qnil);
2125 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2127 Fput_text_property (startpos, endpos,
2128 Qmouse_face, intern ("highlight"),
2129 Vstandard_output);
2131 else
2133 Fprinc (string, Qnil);
2136 /* Output the annotation for this element. */
2137 if (CONSP (elt))
2139 if (BUFFERP (Vstandard_output))
2141 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2143 Fprinc (Fcar (Fcdr (elt)), Qnil);
2145 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2147 Fset_text_properties (startpos, endpos, Qnil,
2148 Vstandard_output);
2150 else
2152 Fprinc (Fcar (Fcdr (elt)), Qnil);
2157 /* Update COLUMN for what we have output. */
2158 column += length;
2160 /* If output is to a buffer, recompute COLUMN in a way
2161 that takes account of character widths. */
2162 if (BUFFERP (Vstandard_output))
2164 tem = Fcurrent_column ();
2165 column = XINT (tem);
2168 first = 0;
2172 UNGCPRO;
2174 if (BUFFERP (Vstandard_output))
2175 set_buffer_internal (old);
2177 if (!NILP (Vrun_hooks))
2178 call1 (Vrun_hooks, intern ("completion-setup-hook"));
2180 return Qnil;
2183 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
2184 0, 0, "",
2185 "Display a list of possible completions of the current minibuffer contents.")
2188 Lisp_Object completions;
2190 message ("Making completion list...");
2191 completions = Fall_completions (Ffield_string (make_number (ZV)),
2192 Vminibuffer_completion_table,
2193 Vminibuffer_completion_predicate,
2194 Qt);
2195 clear_message (1, 0);
2197 if (NILP (completions))
2199 bitch_at_user ();
2200 temp_echo_area_glyphs (" [No completions]");
2202 else
2203 internal_with_output_to_temp_buffer ("*Completions*",
2204 Fdisplay_completion_list,
2205 Fsort (completions, Qstring_lessp));
2206 return Qnil;
2209 DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "",
2210 "Terminate minibuffer input.")
2213 if (INTEGERP (last_command_char))
2214 internal_self_insert (XINT (last_command_char), 0);
2215 else
2216 bitch_at_user ();
2218 return Fthrow (Qexit, Qnil);
2221 DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
2222 "Terminate this minibuffer argument.")
2225 return Fthrow (Qexit, Qnil);
2228 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
2229 "Return current depth of activations of minibuffer, a nonnegative integer.")
2232 return make_number (minibuf_level);
2235 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
2236 "Return the prompt string of the currently-active minibuffer.\n\
2237 If no minibuffer is active, return nil.")
2240 return Fcopy_sequence (minibuf_prompt);
2244 /* Temporarily display the string M at the end of the current
2245 minibuffer contents. This is used to display things like
2246 "[No Match]" when the user requests a completion for a prefix
2247 that has no possible completions, and other quick, unobtrusive
2248 messages. */
2250 void
2251 temp_echo_area_glyphs (m)
2252 char *m;
2254 int osize = ZV;
2255 int osize_byte = ZV_BYTE;
2256 int opoint = PT;
2257 int opoint_byte = PT_BYTE;
2258 Lisp_Object oinhibit;
2259 oinhibit = Vinhibit_quit;
2261 /* Clear out any old echo-area message to make way for our new thing. */
2262 message (0);
2264 SET_PT_BOTH (osize, osize_byte);
2265 insert_string (m);
2266 SET_PT_BOTH (opoint, opoint_byte);
2267 Vinhibit_quit = Qt;
2268 Fsit_for (make_number (2), Qnil, Qnil);
2269 del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
2270 SET_PT_BOTH (opoint, opoint_byte);
2271 if (!NILP (Vquit_flag))
2273 Vquit_flag = Qnil;
2274 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
2276 Vinhibit_quit = oinhibit;
2279 DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message,
2280 1, 1, 0,
2281 "Temporarily display STRING at the end of the minibuffer.\n\
2282 The text is displayed for two seconds,\n\
2283 or until the next input event arrives, whichever comes first.")
2284 (string)
2285 Lisp_Object string;
2287 temp_echo_area_glyphs (XSTRING (string)->data);
2288 return Qnil;
2291 void
2292 init_minibuf_once ()
2294 Vminibuffer_list = Qnil;
2295 staticpro (&Vminibuffer_list);
2298 void
2299 syms_of_minibuf ()
2301 minibuf_level = 0;
2302 minibuf_prompt = Qnil;
2303 staticpro (&minibuf_prompt);
2305 minibuf_save_list = Qnil;
2306 staticpro (&minibuf_save_list);
2308 Qread_file_name_internal = intern ("read-file-name-internal");
2309 staticpro (&Qread_file_name_internal);
2311 Qminibuffer_default = intern ("minibuffer-default");
2312 staticpro (&Qminibuffer_default);
2313 Fset (Qminibuffer_default, Qnil);
2315 Qminibuffer_completion_table = intern ("minibuffer-completion-table");
2316 staticpro (&Qminibuffer_completion_table);
2318 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
2319 staticpro (&Qminibuffer_completion_confirm);
2321 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
2322 staticpro (&Qminibuffer_completion_predicate);
2324 staticpro (&last_exact_completion);
2325 last_exact_completion = Qnil;
2327 staticpro (&last_minibuf_string);
2328 last_minibuf_string = Qnil;
2330 Quser_variable_p = intern ("user-variable-p");
2331 staticpro (&Quser_variable_p);
2333 Qminibuffer_history = intern ("minibuffer-history");
2334 staticpro (&Qminibuffer_history);
2336 Qbuffer_name_history = intern ("buffer-name-history");
2337 staticpro (&Qbuffer_name_history);
2338 Fset (Qbuffer_name_history, Qnil);
2340 Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
2341 staticpro (&Qminibuffer_setup_hook);
2343 Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
2344 staticpro (&Qminibuffer_exit_hook);
2346 Qhistory_length = intern ("history-length");
2347 staticpro (&Qhistory_length);
2349 Qcurrent_input_method = intern ("current-input-method");
2350 staticpro (&Qcurrent_input_method);
2352 Qactivate_input_method = intern ("activate-input-method");
2353 staticpro (&Qactivate_input_method);
2355 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
2356 "If this is non-nil, `read-buffer' does its work by calling this function.");
2357 Vread_buffer_function = Qnil;
2359 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
2360 "Normal hook run just after entry to minibuffer.");
2361 Vminibuffer_setup_hook = Qnil;
2363 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook,
2364 "Normal hook run just after exit from minibuffer.");
2365 Vminibuffer_exit_hook = Qnil;
2367 DEFVAR_LISP ("history-length", &Vhistory_length,
2368 "*Maximum length for history lists before truncation takes place.\n\
2369 A number means that length; t means infinite. Truncation takes place\n\
2370 just after a new element is inserted. Setting the history-length\n\
2371 property of a history variable overrides this default.");
2372 XSETFASTINT (Vhistory_length, 30);
2374 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
2375 "*Non-nil means automatically provide help for invalid completion input.");
2376 Vcompletion_auto_help = Qt;
2378 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
2379 "Non-nil means don't consider case significant in completion.");
2380 completion_ignore_case = 0;
2382 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
2383 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
2384 This variable makes a difference whenever the minibuffer window is active.");
2385 enable_recursive_minibuffers = 0;
2387 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
2388 "Alist or obarray used for completion in the minibuffer.\n\
2389 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
2391 The value may alternatively be a function, which is given three arguments:\n\
2392 STRING, the current buffer contents;\n\
2393 PREDICATE, the predicate for filtering possible matches;\n\
2394 CODE, which says what kind of things to do.\n\
2395 CODE can be nil, t or `lambda'.\n\
2396 nil means to return the best completion of STRING, or nil if there is none.\n\
2397 t means to return a list of all possible completions of STRING.\n\
2398 `lambda' means to return t if STRING is a valid completion as it stands.");
2399 Vminibuffer_completion_table = Qnil;
2401 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
2402 "Within call to `completing-read', this holds the PREDICATE argument.");
2403 Vminibuffer_completion_predicate = Qnil;
2405 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
2406 "Non-nil => demand confirmation of completion before exiting minibuffer.");
2407 Vminibuffer_completion_confirm = Qnil;
2409 DEFVAR_LISP ("minibuffer-completing-file-name",
2410 &Vminibuffer_completing_file_name,
2411 "Non-nil means completing file names.");
2412 Vminibuffer_completing_file_name = Qnil;
2414 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
2415 "Value that `help-form' takes on inside the minibuffer.");
2416 Vminibuffer_help_form = Qnil;
2418 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
2419 "History list symbol to add minibuffer values to.\n\
2420 Each string of minibuffer input, as it appears on exit from the minibuffer,\n\
2421 is added with\n\
2422 (set minibuffer-history-variable\n\
2423 (cons STRING (symbol-value minibuffer-history-variable)))");
2424 XSETFASTINT (Vminibuffer_history_variable, 0);
2426 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position,
2427 "Current position of redoing in the history list.");
2428 Vminibuffer_history_position = Qnil;
2430 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
2431 "*Non-nil means entering the minibuffer raises the minibuffer's frame.\n\
2432 Some uses of the echo area also raise that frame (since they use it too).");
2433 minibuffer_auto_raise = 0;
2435 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
2436 "List of regexps that should restrict possible completions.");
2437 Vcompletion_regexp_list = Qnil;
2439 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2440 &minibuffer_allow_text_properties,
2441 "Non-nil means `read-from-minibuffer' should not discard text properties.\n\
2442 This also affects `read-string', but it does not affect `read-minibuffer',\n\
2443 `read-no-blanks-input', or any of the functions that do minibuffer input\n\
2444 with completion; they always discard text properties.");
2445 minibuffer_allow_text_properties = 0;
2447 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties,
2448 "Text properties that are added to minibuffer prompts.\n\
2449 These are in addition to the basic `field' property, and stickiness\n\
2450 properties.");
2451 /* We use `intern' here instead of Qread_only to avoid
2452 initialization-order problems. */
2453 Vminibuffer_prompt_properties
2454 = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
2456 defsubr (&Sset_minibuffer_window);
2457 defsubr (&Sread_from_minibuffer);
2458 defsubr (&Seval_minibuffer);
2459 defsubr (&Sread_minibuffer);
2460 defsubr (&Sread_string);
2461 defsubr (&Sread_command);
2462 defsubr (&Sread_variable);
2463 defsubr (&Sread_buffer);
2464 defsubr (&Sread_no_blanks_input);
2465 defsubr (&Sminibuffer_depth);
2466 defsubr (&Sminibuffer_prompt);
2468 defsubr (&Stry_completion);
2469 defsubr (&Sall_completions);
2470 defsubr (&Scompleting_read);
2471 defsubr (&Sminibuffer_complete);
2472 defsubr (&Sminibuffer_complete_word);
2473 defsubr (&Sminibuffer_complete_and_exit);
2474 defsubr (&Sdisplay_completion_list);
2475 defsubr (&Sminibuffer_completion_help);
2477 defsubr (&Sself_insert_and_exit);
2478 defsubr (&Sexit_minibuffer);
2480 defsubr (&Sminibuffer_message);
2483 void
2484 keys_of_minibuf ()
2486 initial_define_key (Vminibuffer_local_map, Ctl ('g'),
2487 "abort-recursive-edit");
2488 initial_define_key (Vminibuffer_local_map, Ctl ('m'),
2489 "exit-minibuffer");
2490 initial_define_key (Vminibuffer_local_map, Ctl ('j'),
2491 "exit-minibuffer");
2493 initial_define_key (Vminibuffer_local_ns_map, Ctl ('g'),
2494 "abort-recursive-edit");
2495 initial_define_key (Vminibuffer_local_ns_map, Ctl ('m'),
2496 "exit-minibuffer");
2497 initial_define_key (Vminibuffer_local_ns_map, Ctl ('j'),
2498 "exit-minibuffer");
2500 initial_define_key (Vminibuffer_local_ns_map, ' ',
2501 "exit-minibuffer");
2502 initial_define_key (Vminibuffer_local_ns_map, '\t',
2503 "exit-minibuffer");
2504 initial_define_key (Vminibuffer_local_ns_map, '?',
2505 "self-insert-and-exit");
2507 initial_define_key (Vminibuffer_local_completion_map, Ctl ('g'),
2508 "abort-recursive-edit");
2509 initial_define_key (Vminibuffer_local_completion_map, Ctl ('m'),
2510 "exit-minibuffer");
2511 initial_define_key (Vminibuffer_local_completion_map, Ctl ('j'),
2512 "exit-minibuffer");
2514 initial_define_key (Vminibuffer_local_completion_map, '\t',
2515 "minibuffer-complete");
2516 initial_define_key (Vminibuffer_local_completion_map, ' ',
2517 "minibuffer-complete-word");
2518 initial_define_key (Vminibuffer_local_completion_map, '?',
2519 "minibuffer-completion-help");
2521 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('g'),
2522 "abort-recursive-edit");
2523 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
2524 "minibuffer-complete-and-exit");
2525 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
2526 "minibuffer-complete-and-exit");
2527 initial_define_key (Vminibuffer_local_must_match_map, '\t',
2528 "minibuffer-complete");
2529 initial_define_key (Vminibuffer_local_must_match_map, ' ',
2530 "minibuffer-complete-word");
2531 initial_define_key (Vminibuffer_local_must_match_map, '?',
2532 "minibuffer-completion-help");