Merge from gnulib
[emacs.git] / src / minibuf.c
blobc03316965d376612e2aa814a464dfbdead701580
1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2015 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 3 of the License, or
10 (at your option) 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. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
25 #include <binary-io.h>
27 #include "lisp.h"
28 #include "commands.h"
29 #include "character.h"
30 #include "buffer.h"
31 #include "dispextern.h"
32 #include "keyboard.h"
33 #include "frame.h"
34 #include "window.h"
35 #include "syntax.h"
36 #include "intervals.h"
37 #include "keymap.h"
38 #include "termhooks.h"
39 #include "systty.h"
41 /* List of buffers for use as minibuffers.
42 The first element of the list is used for the outermost minibuffer
43 invocation, the next element is used for a recursive minibuffer
44 invocation, etc. The list is extended at the end as deeper
45 minibuffer recursions are encountered. */
47 Lisp_Object Vminibuffer_list;
49 /* Data to remember during recursive minibuffer invocations. */
51 static Lisp_Object minibuf_save_list;
53 /* Depth in minibuffer invocations. */
55 EMACS_INT minibuf_level;
57 /* Fread_minibuffer leaves the input here as a string. */
59 Lisp_Object last_minibuf_string;
61 /* Prompt to display in front of the mini-buffer contents. */
63 static Lisp_Object minibuf_prompt;
65 /* Width of current mini-buffer prompt. Only set after display_line
66 of the line that contains the prompt. */
68 static ptrdiff_t minibuf_prompt_width;
71 /* Put minibuf on currently selected frame's minibuffer.
72 We do this whenever the user starts a new minibuffer
73 or when a minibuffer exits. */
75 static void
76 choose_minibuf_frame (void)
78 if (FRAMEP (selected_frame)
79 && FRAME_LIVE_P (XFRAME (selected_frame))
80 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
82 struct frame *sf = XFRAME (selected_frame);
83 Lisp_Object buffer;
85 /* I don't think that any frames may validly have a null minibuffer
86 window anymore. */
87 if (NILP (sf->minibuffer_window))
88 emacs_abort ();
90 /* Under X, we come here with minibuf_window being the
91 minibuffer window of the unused termcap window created in
92 init_window_once. That window doesn't have a buffer. */
93 buffer = XWINDOW (minibuf_window)->contents;
94 if (BUFFERP (buffer))
95 /* Use set_window_buffer instead of Fset_window_buffer (see
96 discussion of bug#11984, bug#12025, bug#12026). */
97 set_window_buffer (sf->minibuffer_window, buffer, 0, 0);
98 minibuf_window = sf->minibuffer_window;
101 /* Make sure no other frame has a minibuffer as its selected window,
102 because the text would not be displayed in it, and that would be
103 confusing. Only allow the selected frame to do this,
104 and that only if the minibuffer is active. */
106 Lisp_Object tail, frame;
108 FOR_EACH_FRAME (tail, frame)
109 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
110 && !(EQ (frame, selected_frame)
111 && minibuf_level > 0))
112 Fset_frame_selected_window (frame, Fframe_first_window (frame), Qnil);
116 DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
117 Sactive_minibuffer_window, 0, 0, 0,
118 doc: /* Return the currently active minibuffer window, or nil if none. */)
119 (void)
121 return minibuf_level ? minibuf_window : Qnil;
124 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
125 Sset_minibuffer_window, 1, 1, 0,
126 doc: /* Specify which minibuffer window to use for the minibuffer.
127 This affects where the minibuffer is displayed if you put text in it
128 without invoking the usual minibuffer commands. */)
129 (Lisp_Object window)
131 CHECK_WINDOW (window);
132 if (! MINI_WINDOW_P (XWINDOW (window)))
133 error ("Window is not a minibuffer window");
135 minibuf_window = window;
137 return window;
141 /* Actual minibuffer invocation. */
143 static void read_minibuf_unwind (void);
144 static void run_exit_minibuf_hook (void);
147 /* Read a Lisp object from VAL and return it. If VAL is an empty
148 string, and DEFALT is a string, read from DEFALT instead of VAL. */
150 static Lisp_Object
151 string_to_object (Lisp_Object val, Lisp_Object defalt)
153 struct gcpro gcpro1, gcpro2;
154 Lisp_Object expr_and_pos;
155 ptrdiff_t pos;
157 GCPRO2 (val, defalt);
159 if (STRINGP (val) && SCHARS (val) == 0)
161 if (STRINGP (defalt))
162 val = defalt;
163 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
164 val = XCAR (defalt);
167 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
168 pos = XINT (Fcdr (expr_and_pos));
169 if (pos != SCHARS (val))
171 /* Ignore trailing whitespace; any other trailing junk
172 is an error. */
173 ptrdiff_t i;
174 pos = string_char_to_byte (val, pos);
175 for (i = pos; i < SBYTES (val); i++)
177 int c = SREF (val, i);
178 if (c != ' ' && c != '\t' && c != '\n')
179 error ("Trailing garbage following expression");
183 val = Fcar (expr_and_pos);
184 RETURN_UNGCPRO (val);
188 /* Like read_minibuf but reading from stdin. This function is called
189 from read_minibuf to do the job if noninteractive. */
191 static Lisp_Object
192 read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
193 Lisp_Object prompt, Lisp_Object backup_n,
194 bool expflag,
195 Lisp_Object histvar, Lisp_Object histpos,
196 Lisp_Object defalt,
197 bool allow_props, bool inherit_input_method)
199 ptrdiff_t size, len;
200 char *line;
201 Lisp_Object val;
202 int c;
203 unsigned char hide_char = 0;
204 struct emacs_tty etty;
205 bool etty_valid;
207 /* Check, whether we need to suppress echoing. */
208 if (CHARACTERP (Vread_hide_char))
209 hide_char = XFASTINT (Vread_hide_char);
211 /* Manipulate tty. */
212 if (hide_char)
214 etty_valid = emacs_get_tty (fileno (stdin), &etty) == 0;
215 if (etty_valid)
216 set_binary_mode (fileno (stdin), O_BINARY);
217 suppress_echo_on_tty (fileno (stdin));
220 fwrite (SDATA (prompt), 1, SBYTES (prompt), stdout);
221 fflush (stdout);
223 val = Qnil;
224 size = 100;
225 len = 0;
226 line = xmalloc (size);
228 while ((c = getchar ()) != '\n' && c != '\r')
230 if (c == EOF)
232 if (errno != EINTR)
233 break;
235 else
237 if (hide_char)
238 fprintf (stdout, "%c", hide_char);
239 if (len == size)
241 if (STRING_BYTES_BOUND / 2 < size)
242 memory_full (SIZE_MAX);
243 size *= 2;
244 line = xrealloc (line, size);
246 line[len++] = c;
250 /* Reset tty. */
251 if (hide_char)
253 fprintf (stdout, "\n");
254 if (etty_valid)
256 emacs_set_tty (fileno (stdin), &etty, 0);
257 set_binary_mode (fileno (stdin), O_TEXT);
261 if (len || c == '\n' || c == '\r')
263 val = make_string (line, len);
264 xfree (line);
266 else
268 xfree (line);
269 error ("Error reading from stdin");
272 /* If Lisp form desired instead of string, parse it. */
273 if (expflag)
274 val = string_to_object (val, CONSP (defalt) ? XCAR (defalt) : defalt);
276 return val;
279 DEFUN ("minibufferp", Fminibufferp,
280 Sminibufferp, 0, 1, 0,
281 doc: /* Return t if BUFFER is a minibuffer.
282 No argument or nil as argument means use current buffer as BUFFER.
283 BUFFER can be a buffer or a buffer name. */)
284 (Lisp_Object buffer)
286 Lisp_Object tem;
288 if (NILP (buffer))
289 buffer = Fcurrent_buffer ();
290 else if (STRINGP (buffer))
291 buffer = Fget_buffer (buffer);
292 else
293 CHECK_BUFFER (buffer);
295 tem = Fmemq (buffer, Vminibuffer_list);
296 return ! NILP (tem) ? Qt : Qnil;
299 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
300 Sminibuffer_prompt_end, 0, 0, 0,
301 doc: /* Return the buffer position of the end of the minibuffer prompt.
302 Return (point-min) if current buffer is not a minibuffer. */)
303 (void)
305 /* This function is written to be most efficient when there's a prompt. */
306 Lisp_Object beg, end, tem;
307 beg = make_number (BEGV);
309 tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
310 if (NILP (tem))
311 return beg;
313 end = Ffield_end (beg, Qnil, Qnil);
315 if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
316 return beg;
317 else
318 return end;
321 DEFUN ("minibuffer-contents", Fminibuffer_contents,
322 Sminibuffer_contents, 0, 0, 0,
323 doc: /* Return the user input in a minibuffer as a string.
324 If the current buffer is not a minibuffer, return its entire contents. */)
325 (void)
327 ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
328 return make_buffer_string (prompt_end, ZV, 1);
331 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
332 Sminibuffer_contents_no_properties, 0, 0, 0,
333 doc: /* Return the user input in a minibuffer as a string, without text-properties.
334 If the current buffer is not a minibuffer, return its entire contents. */)
335 (void)
337 ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
338 return make_buffer_string (prompt_end, ZV, 0);
341 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
342 Sminibuffer_completion_contents, 0, 0, 0,
343 doc: /* Return the user input in a minibuffer before point as a string.
344 That is what completion commands operate on.
345 If the current buffer is not a minibuffer, return its entire contents. */)
346 (void)
348 ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
349 if (PT < prompt_end)
350 error ("Cannot do completion in the prompt");
351 return make_buffer_string (prompt_end, PT, 1);
355 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
356 putting point minus BACKUP_N bytes from the end of INITIAL,
357 prompting with PROMPT (a string), using history list HISTVAR
358 with initial position HISTPOS. INITIAL should be a string or a
359 cons of a string and an integer. BACKUP_N should be <= 0, or
360 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
361 ignored and replaced with an integer that puts point at one-indexed
362 position N in INITIAL, where N is the CDR of INITIAL, or at the
363 beginning of INITIAL if N <= 0.
365 Normally return the result as a string (the text that was read),
366 but if EXPFLAG, read it and return the object read.
367 If HISTVAR is given, save the value read on that history only if it doesn't
368 match the front of that history list exactly. The value is pushed onto
369 the list as the string that was read.
371 DEFALT specifies the default value for the sake of history commands.
373 If ALLOW_PROPS, do not throw away text properties.
375 if INHERIT_INPUT_METHOD, the minibuffer inherits the
376 current input method. */
378 static Lisp_Object
379 read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
380 bool expflag,
381 Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
382 bool allow_props, bool inherit_input_method)
384 Lisp_Object val;
385 ptrdiff_t count = SPECPDL_INDEX ();
386 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
387 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
388 Lisp_Object enable_multibyte;
389 EMACS_INT pos = 0;
390 /* String to add to the history. */
391 Lisp_Object histstring;
392 Lisp_Object histval;
394 Lisp_Object empty_minibuf;
395 Lisp_Object dummy, frame;
397 specbind (Qminibuffer_default, defalt);
398 specbind (Qinhibit_read_only, Qnil);
400 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
401 in previous recursive minibuffer, but was not set explicitly
402 to t for this invocation, so set it to nil in this minibuffer.
403 Save the old value now, before we change it. */
404 specbind (intern ("minibuffer-completing-file-name"),
405 Vminibuffer_completing_file_name);
406 if (EQ (Vminibuffer_completing_file_name, Qlambda))
407 Vminibuffer_completing_file_name = Qnil;
409 #ifdef HAVE_WINDOW_SYSTEM
410 if (display_hourglass_p)
411 cancel_hourglass ();
412 #endif
414 if (!NILP (initial))
416 if (CONSP (initial))
418 Lisp_Object backup_n = XCDR (initial);
419 initial = XCAR (initial);
420 CHECK_STRING (initial);
421 if (!NILP (backup_n))
423 CHECK_NUMBER (backup_n);
424 /* Convert to distance from end of input. */
425 if (XINT (backup_n) < 1)
426 /* A number too small means the beginning of the string. */
427 pos = - SCHARS (initial);
428 else
429 pos = XINT (backup_n) - 1 - SCHARS (initial);
432 else
433 CHECK_STRING (initial);
435 val = Qnil;
436 ambient_dir = BVAR (current_buffer, directory);
437 input_method = Qnil;
438 enable_multibyte = Qnil;
440 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
441 store them away before we can GC. Don't need to protect
442 BACKUP_N because we use the value only if it is an integer. */
443 GCPRO5 (map, initial, val, ambient_dir, input_method);
445 if (!STRINGP (prompt))
446 prompt = empty_unibyte_string;
448 if (!enable_recursive_minibuffers
449 && minibuf_level > 0)
451 if (EQ (selected_window, minibuf_window))
452 error ("Command attempted to use minibuffer while in minibuffer");
453 else
454 /* If we're in another window, cancel the minibuffer that's active. */
455 Fthrow (Qexit,
456 build_string ("Command attempted to use minibuffer while in minibuffer"));
459 if ((noninteractive
460 /* In case we are running as a daemon, only do this before
461 detaching from the terminal. */
462 || (IS_DAEMON && DAEMON_RUNNING))
463 && NILP (Vexecuting_kbd_macro))
465 val = read_minibuf_noninteractive (map, initial, prompt,
466 make_number (pos),
467 expflag, histvar, histpos, defalt,
468 allow_props, inherit_input_method);
469 UNGCPRO;
470 return unbind_to (count, val);
473 /* Choose the minibuffer window and frame, and take action on them. */
475 /* Prepare for restoring the current buffer since choose_minibuf_frame
476 calling Fset_frame_selected_window may change it (Bug#12766). */
477 record_unwind_protect (restore_buffer, Fcurrent_buffer ());
479 choose_minibuf_frame ();
481 record_unwind_protect_void (choose_minibuf_frame);
483 record_unwind_protect (restore_window_configuration,
484 Fcurrent_window_configuration (Qnil));
486 /* If the minibuffer window is on a different frame, save that
487 frame's configuration too. */
488 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
489 if (!EQ (mini_frame, selected_frame))
490 record_unwind_protect (restore_window_configuration,
491 Fcurrent_window_configuration (mini_frame));
493 /* If the minibuffer is on an iconified or invisible frame,
494 make it visible now. */
495 Fmake_frame_visible (mini_frame);
497 if (minibuffer_auto_raise)
498 Fraise_frame (mini_frame);
500 temporarily_switch_to_single_kboard (XFRAME (mini_frame));
502 /* We have to do this after saving the window configuration
503 since that is what restores the current buffer. */
505 /* Arrange to restore a number of minibuffer-related variables.
506 We could bind each variable separately, but that would use lots of
507 specpdl slots. */
508 minibuf_save_list
509 = Fcons (Voverriding_local_map,
510 Fcons (minibuf_window,
511 minibuf_save_list));
512 minibuf_save_list
513 = Fcons (minibuf_prompt,
514 Fcons (make_number (minibuf_prompt_width),
515 Fcons (Vhelp_form,
516 Fcons (Vcurrent_prefix_arg,
517 Fcons (Vminibuffer_history_position,
518 Fcons (Vminibuffer_history_variable,
519 minibuf_save_list))))));
521 record_unwind_protect_void (read_minibuf_unwind);
522 minibuf_level++;
523 /* We are exiting the minibuffer one way or the other, so run the hook.
524 It should be run before unwinding the minibuf settings. Do it
525 separately from read_minibuf_unwind because we need to make sure that
526 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
527 signals an error. --Stef */
528 record_unwind_protect_void (run_exit_minibuf_hook);
530 /* Now that we can restore all those variables, start changing them. */
532 minibuf_prompt_width = 0;
533 minibuf_prompt = Fcopy_sequence (prompt);
534 Vminibuffer_history_position = histpos;
535 Vminibuffer_history_variable = histvar;
536 Vhelp_form = Vminibuffer_help_form;
537 /* If this minibuffer is reading a file name, that doesn't mean
538 recursive ones are. But we cannot set it to nil, because
539 completion code still need to know the minibuffer is completing a
540 file name. So use `lambda' as intermediate value meaning
541 "t" in this minibuffer, but "nil" in next minibuffer. */
542 if (!NILP (Vminibuffer_completing_file_name))
543 Vminibuffer_completing_file_name = Qlambda;
545 /* If variable is unbound, make it nil. */
546 histval = find_symbol_value (Vminibuffer_history_variable);
547 if (EQ (histval, Qunbound))
549 Fset (Vminibuffer_history_variable, Qnil);
550 histval = Qnil;
553 if (inherit_input_method)
555 /* `current-input-method' is buffer local. So, remember it in
556 INPUT_METHOD before changing the current buffer. */
557 input_method = Fsymbol_value (Qcurrent_input_method);
558 enable_multibyte = BVAR (current_buffer, enable_multibyte_characters);
561 /* Switch to the minibuffer. */
563 minibuffer = get_minibuffer (minibuf_level);
564 Fset_buffer (minibuffer);
566 /* Defeat (setq-default truncate-lines t), since truncated lines do
567 not work correctly in minibuffers. (Bug#5715, etc) */
568 bset_truncate_lines (current_buffer, Qnil);
570 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
571 if (inherit_input_method)
572 bset_enable_multibyte_characters (current_buffer, enable_multibyte);
574 /* The current buffer's default directory is usually the right thing
575 for our minibuffer here. However, if you're typing a command at
576 a minibuffer-only frame when minibuf_level is zero, then buf IS
577 the current_buffer, so reset_buffer leaves buf's default
578 directory unchanged. This is a bummer when you've just started
579 up Emacs and buf's default directory is Qnil. Here's a hack; can
580 you think of something better to do? Find another buffer with a
581 better directory, and use that one instead. */
582 if (STRINGP (ambient_dir))
583 bset_directory (current_buffer, ambient_dir);
584 else
586 Lisp_Object tail, buf;
588 FOR_EACH_LIVE_BUFFER (tail, buf)
589 if (STRINGP (BVAR (XBUFFER (buf), directory)))
591 bset_directory (current_buffer,
592 BVAR (XBUFFER (buf), directory));
593 break;
597 if (!EQ (mini_frame, selected_frame))
598 Fredirect_frame_focus (selected_frame, mini_frame);
600 Vminibuf_scroll_window = selected_window;
601 if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
602 minibuf_selected_window = selected_window;
604 /* Empty out the minibuffers of all frames other than the one
605 where we are going to display one now.
606 Set them to point to ` *Minibuf-0*', which is always empty. */
607 empty_minibuf = get_minibuffer (0);
609 FOR_EACH_FRAME (dummy, frame)
611 Lisp_Object root_window = Fframe_root_window (frame);
612 Lisp_Object mini_window = XWINDOW (root_window)->next;
614 if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
615 && !NILP (Fwindow_minibuffer_p (mini_window)))
616 /* Use set_window_buffer instead of Fset_window_buffer (see
617 discussion of bug#11984, bug#12025, bug#12026). */
618 set_window_buffer (mini_window, empty_minibuf, 0, 0);
621 /* Display this minibuffer in the proper window. */
622 /* Use set_window_buffer instead of Fset_window_buffer (see
623 discussion of bug#11984, bug#12025, bug#12026). */
624 set_window_buffer (minibuf_window, Fcurrent_buffer (), 0, 0);
625 Fselect_window (minibuf_window, Qnil);
626 XWINDOW (minibuf_window)->hscroll = 0;
627 XWINDOW (minibuf_window)->suspend_auto_hscroll = 0;
629 Fmake_local_variable (Qprint_escape_newlines);
630 print_escape_newlines = 1;
632 /* Erase the buffer. */
634 ptrdiff_t count1 = SPECPDL_INDEX ();
635 specbind (Qinhibit_read_only, Qt);
636 specbind (Qinhibit_modification_hooks, Qt);
637 Ferase_buffer ();
639 if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
640 && ! STRING_MULTIBYTE (minibuf_prompt))
641 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
643 /* Insert the prompt, record where it ends. */
644 Finsert (1, &minibuf_prompt);
645 if (PT > BEG)
647 Fput_text_property (make_number (BEG), make_number (PT),
648 Qfront_sticky, Qt, Qnil);
649 Fput_text_property (make_number (BEG), make_number (PT),
650 Qrear_nonsticky, Qt, Qnil);
651 Fput_text_property (make_number (BEG), make_number (PT),
652 Qfield, Qt, Qnil);
653 Fadd_text_properties (make_number (BEG), make_number (PT),
654 Vminibuffer_prompt_properties, Qnil);
656 unbind_to (count1, Qnil);
659 minibuf_prompt_width = current_column ();
661 /* Put in the initial input. */
662 if (!NILP (initial))
664 Finsert (1, &initial);
665 Fforward_char (make_number (pos));
668 clear_message (1, 1);
669 bset_keymap (current_buffer, map);
671 /* Turn on an input method stored in INPUT_METHOD if any. */
672 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
673 call1 (Qactivate_input_method, input_method);
675 run_hook (Qminibuffer_setup_hook);
677 /* Don't allow the user to undo past this point. */
678 bset_undo_list (current_buffer, Qnil);
680 recursive_edit_1 ();
682 /* If cursor is on the minibuffer line,
683 show the user we have exited by putting it in column 0. */
684 if (XWINDOW (minibuf_window)->cursor.vpos >= 0
685 && !noninteractive)
687 XWINDOW (minibuf_window)->cursor.hpos = 0;
688 XWINDOW (minibuf_window)->cursor.x = 0;
689 XWINDOW (minibuf_window)->must_be_updated_p = true;
690 update_frame (XFRAME (selected_frame), true, true);
691 flush_frame (XFRAME (XWINDOW (minibuf_window)->frame));
694 /* Make minibuffer contents into a string. */
695 Fset_buffer (minibuffer);
696 if (allow_props)
697 val = Fminibuffer_contents ();
698 else
699 val = Fminibuffer_contents_no_properties ();
701 /* VAL is the string of minibuffer text. */
703 last_minibuf_string = val;
705 /* Choose the string to add to the history. */
706 if (SCHARS (val) != 0)
707 histstring = val;
708 else if (STRINGP (defalt))
709 histstring = defalt;
710 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
711 histstring = XCAR (defalt);
712 else
713 histstring = Qnil;
715 /* Add the value to the appropriate history list, if any. */
716 if (!NILP (Vhistory_add_new_input)
717 && SYMBOLP (Vminibuffer_history_variable)
718 && !NILP (histstring))
720 /* If the caller wanted to save the value read on a history list,
721 then do so if the value is not already the front of the list. */
723 /* The value of the history variable must be a cons or nil. Other
724 values are unacceptable. We silently ignore these values. */
726 if (NILP (histval)
727 || (CONSP (histval)
728 /* Don't duplicate the most recent entry in the history. */
729 && (NILP (Fequal (histstring, Fcar (histval))))))
731 Lisp_Object length;
733 if (history_delete_duplicates) Fdelete (histstring, histval);
734 histval = Fcons (histstring, histval);
735 Fset (Vminibuffer_history_variable, histval);
737 /* Truncate if requested. */
738 length = Fget (Vminibuffer_history_variable, Qhistory_length);
739 if (NILP (length)) length = Vhistory_length;
740 if (INTEGERP (length))
742 if (XINT (length) <= 0)
743 Fset (Vminibuffer_history_variable, Qnil);
744 else
746 Lisp_Object temp;
748 temp = Fnthcdr (Fsub1 (length), histval);
749 if (CONSP (temp)) Fsetcdr (temp, Qnil);
755 /* If Lisp form desired instead of string, parse it. */
756 if (expflag)
757 val = string_to_object (val, defalt);
759 /* The appropriate frame will get selected
760 in set-window-configuration. */
761 UNGCPRO;
762 return unbind_to (count, val);
765 /* Return a buffer to be used as the minibuffer at depth `depth'.
766 depth = 0 is the lowest allowed argument, and that is the value
767 used for nonrecursive minibuffer invocations. */
769 Lisp_Object
770 get_minibuffer (EMACS_INT depth)
772 Lisp_Object tail, num, buf;
773 char name[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT)];
775 XSETFASTINT (num, depth);
776 tail = Fnthcdr (num, Vminibuffer_list);
777 if (NILP (tail))
779 tail = list1 (Qnil);
780 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
782 buf = Fcar (tail);
783 if (NILP (buf) || !BUFFER_LIVE_P (XBUFFER (buf)))
785 buf = Fget_buffer_create
786 (make_formatted_string (name, " *Minibuf-%"pI"d*", depth));
788 /* Although the buffer's name starts with a space, undo should be
789 enabled in it. */
790 Fbuffer_enable_undo (buf);
792 XSETCAR (tail, buf);
794 else
796 ptrdiff_t count = SPECPDL_INDEX ();
797 /* We have to empty both overlay lists. Otherwise we end
798 up with overlays that think they belong to this buffer
799 while the buffer doesn't know about them any more. */
800 delete_all_overlays (XBUFFER (buf));
801 reset_buffer (XBUFFER (buf));
802 record_unwind_current_buffer ();
803 Fset_buffer (buf);
804 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
805 call0 (intern ("minibuffer-inactive-mode"));
806 else
807 Fkill_all_local_variables ();
808 unbind_to (count, Qnil);
811 return buf;
814 static void
815 run_exit_minibuf_hook (void)
817 safe_run_hooks (Qminibuffer_exit_hook);
820 /* This function is called on exiting minibuffer, whether normally or
821 not, and it restores the current window, buffer, etc. */
823 static void
824 read_minibuf_unwind (void)
826 Lisp_Object old_deactivate_mark;
827 Lisp_Object window;
829 /* If this was a recursive minibuffer,
830 tie the minibuffer window back to the outer level minibuffer buffer. */
831 minibuf_level--;
833 window = minibuf_window;
834 /* To keep things predictable, in case it matters, let's be in the
835 minibuffer when we reset the relevant variables. */
836 Fset_buffer (XWINDOW (window)->contents);
838 /* Restore prompt, etc, from outer minibuffer level. */
839 minibuf_prompt = Fcar (minibuf_save_list);
840 minibuf_save_list = Fcdr (minibuf_save_list);
841 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
842 minibuf_save_list = Fcdr (minibuf_save_list);
843 Vhelp_form = Fcar (minibuf_save_list);
844 minibuf_save_list = Fcdr (minibuf_save_list);
845 Vcurrent_prefix_arg = Fcar (minibuf_save_list);
846 minibuf_save_list = Fcdr (minibuf_save_list);
847 Vminibuffer_history_position = Fcar (minibuf_save_list);
848 minibuf_save_list = Fcdr (minibuf_save_list);
849 Vminibuffer_history_variable = Fcar (minibuf_save_list);
850 minibuf_save_list = Fcdr (minibuf_save_list);
851 Voverriding_local_map = Fcar (minibuf_save_list);
852 minibuf_save_list = Fcdr (minibuf_save_list);
853 #if 0
854 temp = Fcar (minibuf_save_list);
855 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
856 minibuf_window = temp;
857 #endif
858 minibuf_save_list = Fcdr (minibuf_save_list);
860 /* Erase the minibuffer we were using at this level. */
862 ptrdiff_t count = SPECPDL_INDEX ();
863 /* Prevent error in erase-buffer. */
864 specbind (Qinhibit_read_only, Qt);
865 specbind (Qinhibit_modification_hooks, Qt);
866 old_deactivate_mark = Vdeactivate_mark;
867 Ferase_buffer ();
868 Vdeactivate_mark = old_deactivate_mark;
869 unbind_to (count, Qnil);
872 /* When we get to the outmost level, make sure we resize the
873 mini-window back to its normal size. */
874 if (minibuf_level == 0)
875 resize_mini_window (XWINDOW (window), 0);
877 /* In case the previous minibuffer displayed in this miniwindow is
878 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
879 to make sure we don't leave around bindings and stuff which only
880 made sense during the read_minibuf invocation. */
881 call0 (intern ("minibuffer-inactive-mode"));
885 DEFUN ("read-from-minibuffer", Fread_from_minibuffer,
886 Sread_from_minibuffer, 1, 7, 0,
887 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
888 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
889 DEFAULT-VALUE. It normally should be nil in new code, except when
890 HIST is a cons. It is discussed in more detail below.
892 Third arg KEYMAP is a keymap to use whilst reading;
893 if omitted or nil, the default is `minibuffer-local-map'.
895 If fourth arg READ is non-nil, interpret the result as a Lisp object
896 and return that object:
897 in other words, do `(car (read-from-string INPUT-STRING))'
899 Fifth arg HIST, if non-nil, specifies a history list and optionally
900 the initial position in the list. It can be a symbol, which is the
901 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
902 In that case, HISTVAR is the history list variable to use, and
903 HISTPOS is the initial position for use by the minibuffer history
904 commands. For consistency, you should also specify that element of
905 the history as the value of INITIAL-CONTENTS. Positions are counted
906 starting from 1 at the beginning of the list.
908 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
909 as the default to `read' if READ is non-nil and the user enters
910 empty input. But if READ is nil, this function does _not_ return
911 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
913 Whatever the value of READ, DEFAULT-VALUE is made available via the
914 minibuffer history commands. DEFAULT-VALUE can also be a list of
915 strings, in which case all the strings are available in the history,
916 and the first string is the default to `read' if READ is non-nil.
918 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
919 the current input method and the setting of `enable-multibyte-characters'.
921 If the variable `minibuffer-allow-text-properties' is non-nil,
922 then the string which is returned includes whatever text properties
923 were present in the minibuffer. Otherwise the value has no text properties.
925 The remainder of this documentation string describes the
926 INITIAL-CONTENTS argument in more detail. It is only relevant when
927 studying existing code, or when HIST is a cons. If non-nil,
928 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
929 reading input. Normally, point is put at the end of that string.
930 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
931 input is STRING, but point is placed at _one-indexed_ position
932 POSITION in the minibuffer. Any integer value less than or equal to
933 one puts point at the beginning of the string. *Note* that this
934 behavior differs from the way such arguments are used in `completing-read'
935 and some related functions, which use zero-indexing for POSITION. */)
936 (Lisp_Object prompt, Lisp_Object initial_contents, Lisp_Object keymap, Lisp_Object read, Lisp_Object hist, Lisp_Object default_value, Lisp_Object inherit_input_method)
938 Lisp_Object histvar, histpos, val;
939 struct gcpro gcpro1;
941 CHECK_STRING (prompt);
942 if (NILP (keymap))
943 keymap = Vminibuffer_local_map;
944 else
945 keymap = get_keymap (keymap, 1, 0);
947 if (SYMBOLP (hist))
949 histvar = hist;
950 histpos = Qnil;
952 else
954 histvar = Fcar_safe (hist);
955 histpos = Fcdr_safe (hist);
957 if (NILP (histvar))
958 histvar = Qminibuffer_history;
959 if (NILP (histpos))
960 XSETFASTINT (histpos, 0);
962 GCPRO1 (default_value);
963 val = read_minibuf (keymap, initial_contents, prompt,
964 !NILP (read),
965 histvar, histpos, default_value,
966 minibuffer_allow_text_properties,
967 !NILP (inherit_input_method));
968 UNGCPRO;
969 return val;
972 /* Functions that use the minibuffer to read various things. */
974 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
975 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
976 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
977 This argument has been superseded by DEFAULT-VALUE and should normally be nil
978 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
979 see).
980 The third arg HISTORY, if non-nil, specifies a history list
981 and optionally the initial position in the list.
982 See `read-from-minibuffer' for details of HISTORY argument.
983 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
984 If non-nil, it is used for history commands, and as the value (or the first
985 element of the list of default values) to return if the user enters the
986 empty string.
987 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
988 the current input method and the setting of `enable-multibyte-characters'. */)
989 (Lisp_Object prompt, Lisp_Object initial_input, Lisp_Object history, Lisp_Object default_value, Lisp_Object inherit_input_method)
991 Lisp_Object val;
992 ptrdiff_t count = SPECPDL_INDEX ();
994 /* Just in case we're in a recursive minibuffer, make it clear that the
995 previous minibuffer's completion table does not apply to the new
996 minibuffer.
997 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
998 specbind (Qminibuffer_completion_table, Qnil);
1000 val = Fread_from_minibuffer (prompt, initial_input, Qnil,
1001 Qnil, history, default_value,
1002 inherit_input_method);
1003 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
1004 val = CONSP (default_value) ? XCAR (default_value) : default_value;
1005 return unbind_to (count, val);
1008 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
1009 doc: /* Read a string from the terminal, not allowing blanks.
1010 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1011 non-nil, it should be a string, which is used as initial input, with
1012 point positioned at the end, so that SPACE will accept the input.
1013 \(Actually, INITIAL can also be a cons of a string and an integer.
1014 Such values are treated as in `read-from-minibuffer', but are normally
1015 not useful in this function.)
1016 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1017 the current input method and the setting of`enable-multibyte-characters'. */)
1018 (Lisp_Object prompt, Lisp_Object initial, Lisp_Object inherit_input_method)
1020 CHECK_STRING (prompt);
1021 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt,
1022 0, Qminibuffer_history, make_number (0), Qnil, 0,
1023 !NILP (inherit_input_method));
1026 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
1027 doc: /* Read the name of a command and return as a symbol.
1028 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1029 if it is a list. */)
1030 (Lisp_Object prompt, Lisp_Object default_value)
1032 Lisp_Object name, default_string;
1034 if (NILP (default_value))
1035 default_string = Qnil;
1036 else if (SYMBOLP (default_value))
1037 default_string = SYMBOL_NAME (default_value);
1038 else
1039 default_string = default_value;
1041 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
1042 Qnil, Qnil, default_string, Qnil);
1043 if (NILP (name))
1044 return name;
1045 return Fintern (name, Qnil);
1048 #ifdef NOTDEF
1049 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
1050 doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1051 Prompt with PROMPT. */)
1052 (Lisp_Object prompt)
1054 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
1055 Qnil);
1057 #endif /* NOTDEF */
1059 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
1060 doc: /* Read the name of a user option and return it as a symbol.
1061 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1062 if it is a list.
1063 A user option, or customizable variable, is one for which
1064 `custom-variable-p' returns non-nil. */)
1065 (Lisp_Object prompt, Lisp_Object default_value)
1067 Lisp_Object name, default_string;
1069 if (NILP (default_value))
1070 default_string = Qnil;
1071 else if (SYMBOLP (default_value))
1072 default_string = SYMBOL_NAME (default_value);
1073 else
1074 default_string = default_value;
1076 name = Fcompleting_read (prompt, Vobarray,
1077 Qcustom_variable_p, Qt,
1078 Qnil, Qnil, default_string, Qnil);
1079 if (NILP (name))
1080 return name;
1081 return Fintern (name, Qnil);
1084 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 4, 0,
1085 doc: /* Read the name of a buffer and return as a string.
1086 Prompt with PROMPT.
1087 Optional second arg DEF is value to return if user enters an empty line.
1088 If DEF is a list of default values, return its first element.
1089 Optional third arg REQUIRE-MATCH determines whether non-existing
1090 buffer names are allowed. It has the same meaning as the
1091 REQUIRE-MATCH argument of `completing-read'.
1092 The argument PROMPT should be a string ending with a colon and a space.
1093 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1094 case while reading the buffer name.
1095 If `read-buffer-function' is non-nil, this works by calling it as a
1096 function, instead of the usual behavior.
1097 Optional arg PREDICATE if non-nil is a function limiting the buffers that can
1098 be considered. */)
1099 (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match,
1100 Lisp_Object predicate)
1102 Lisp_Object result;
1103 char *s;
1104 ptrdiff_t len;
1105 ptrdiff_t count = SPECPDL_INDEX ();
1107 if (BUFFERP (def))
1108 def = BVAR (XBUFFER (def), name);
1110 specbind (Qcompletion_ignore_case,
1111 read_buffer_completion_ignore_case ? Qt : Qnil);
1113 if (NILP (Vread_buffer_function))
1115 if (!NILP (def))
1117 /* A default value was provided: we must change PROMPT,
1118 editing the default value in before the colon. To achieve
1119 this, we replace PROMPT with a substring that doesn't
1120 contain the terminal space and colon (if present). They
1121 are then added back using Fformat. */
1123 if (STRINGP (prompt))
1125 s = SSDATA (prompt);
1126 len = SBYTES (prompt);
1127 if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
1128 len = len - 2;
1129 else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
1130 len--;
1132 prompt = make_specified_string (s, -1, len,
1133 STRING_MULTIBYTE (prompt));
1136 AUTO_STRING (format, "%s (default %s): ");
1137 prompt = CALLN (Fformat, format, prompt,
1138 CONSP (def) ? XCAR (def) : def);
1141 result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
1142 predicate, require_match, Qnil,
1143 Qbuffer_name_history, def, Qnil);
1145 else
1146 result = (NILP (predicate)
1147 /* Partial backward compatibility for older read_buffer_functions
1148 which don't expect a `predicate' argument. */
1149 ? call3 (Vread_buffer_function, prompt, def, require_match)
1150 : call4 (Vread_buffer_function, prompt, def, require_match,
1151 predicate));
1152 return unbind_to (count, result);
1155 static Lisp_Object
1156 minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
1158 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1159 return string;
1161 if (STRING_MULTIBYTE (string))
1162 return Fstring_make_unibyte (string);
1163 else
1164 return Fstring_make_multibyte (string);
1167 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1168 doc: /* Return common substring of all completions of STRING in COLLECTION.
1169 Test each possible completion specified by COLLECTION
1170 to see if it begins with STRING. The possible completions may be
1171 strings or symbols. Symbols are converted to strings before testing,
1172 see `symbol-name'.
1173 All that match STRING are compared together; the longest initial sequence
1174 common to all these matches is the return value.
1175 If there is no match at all, the return value is nil.
1176 For a unique match which is exact, the return value is t.
1178 If COLLECTION is an alist, the keys (cars of elements) are the
1179 possible completions. If an element is not a cons cell, then the
1180 element itself is the possible completion.
1181 If COLLECTION is a hash-table, all the keys that are strings or symbols
1182 are the possible completions.
1183 If COLLECTION is an obarray, the names of all symbols in the obarray
1184 are the possible completions.
1186 COLLECTION can also be a function to do the completion itself.
1187 It receives three arguments: the values STRING, PREDICATE and nil.
1188 Whatever it returns becomes the value of `try-completion'.
1190 If optional third argument PREDICATE is non-nil,
1191 it is used to test each possible match.
1192 The match is a candidate only if PREDICATE returns non-nil.
1193 The argument given to PREDICATE is the alist element
1194 or the symbol from the obarray. If COLLECTION is a hash-table,
1195 predicate is called with two arguments: the key and the value.
1196 Additionally to this predicate, `completion-regexp-list'
1197 is used to further constrain the set of candidates. */)
1198 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1200 Lisp_Object bestmatch, tail, elt, eltstring;
1201 /* Size in bytes of BESTMATCH. */
1202 ptrdiff_t bestmatchsize = 0;
1203 /* These are in bytes, too. */
1204 ptrdiff_t compare, matchsize;
1205 enum { function_table, list_table, obarray_table, hash_table}
1206 type = (HASH_TABLE_P (collection) ? hash_table
1207 : VECTORP (collection) ? obarray_table
1208 : ((NILP (collection)
1209 || (CONSP (collection) && !FUNCTIONP (collection)))
1210 ? list_table : function_table));
1211 ptrdiff_t idx = 0, obsize = 0;
1212 int matchcount = 0;
1213 ptrdiff_t bindcount = -1;
1214 Lisp_Object bucket, zero, end, tem;
1215 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1217 CHECK_STRING (string);
1218 if (type == function_table)
1219 return call3 (collection, string, predicate, Qnil);
1221 bestmatch = bucket = Qnil;
1222 zero = make_number (0);
1224 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1225 tail = collection;
1226 if (type == obarray_table)
1228 collection = check_obarray (collection);
1229 obsize = ASIZE (collection);
1230 bucket = AREF (collection, idx);
1233 while (1)
1235 /* Get the next element of the alist, obarray, or hash-table. */
1236 /* Exit the loop if the elements are all used up. */
1237 /* elt gets the alist element or symbol.
1238 eltstring gets the name to check as a completion. */
1240 if (type == list_table)
1242 if (!CONSP (tail))
1243 break;
1244 elt = XCAR (tail);
1245 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1246 tail = XCDR (tail);
1248 else if (type == obarray_table)
1250 if (!EQ (bucket, zero))
1252 if (!SYMBOLP (bucket))
1253 error ("Bad data in guts of obarray");
1254 elt = bucket;
1255 eltstring = elt;
1256 if (XSYMBOL (bucket)->next)
1257 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1258 else
1259 XSETFASTINT (bucket, 0);
1261 else if (++idx >= obsize)
1262 break;
1263 else
1265 bucket = AREF (collection, idx);
1266 continue;
1269 else /* if (type == hash_table) */
1271 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1272 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1273 idx++;
1274 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1275 break;
1276 else
1277 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1280 /* Is this element a possible completion? */
1282 if (SYMBOLP (eltstring))
1283 eltstring = Fsymbol_name (eltstring);
1285 if (STRINGP (eltstring)
1286 && SCHARS (string) <= SCHARS (eltstring)
1287 && (tem = Fcompare_strings (eltstring, zero,
1288 make_number (SCHARS (string)),
1289 string, zero, Qnil,
1290 completion_ignore_case ? Qt : Qnil),
1291 EQ (Qt, tem)))
1293 /* Yes. */
1294 Lisp_Object regexps;
1296 /* Ignore this element if it fails to match all the regexps. */
1298 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1299 regexps = XCDR (regexps))
1301 if (bindcount < 0) {
1302 bindcount = SPECPDL_INDEX ();
1303 specbind (Qcase_fold_search,
1304 completion_ignore_case ? Qt : Qnil);
1306 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1307 if (NILP (tem))
1308 break;
1310 if (CONSP (regexps))
1311 continue;
1314 /* Ignore this element if there is a predicate
1315 and the predicate doesn't like it. */
1317 if (!NILP (predicate))
1319 if (EQ (predicate, Qcommandp))
1320 tem = Fcommandp (elt, Qnil);
1321 else
1323 if (bindcount >= 0)
1325 unbind_to (bindcount, Qnil);
1326 bindcount = -1;
1328 GCPRO4 (tail, string, eltstring, bestmatch);
1329 tem = (type == hash_table
1330 ? call2 (predicate, elt,
1331 HASH_VALUE (XHASH_TABLE (collection),
1332 idx - 1))
1333 : call1 (predicate, elt));
1334 UNGCPRO;
1336 if (NILP (tem)) continue;
1339 /* Update computation of how much all possible completions match */
1341 if (NILP (bestmatch))
1343 matchcount = 1;
1344 bestmatch = eltstring;
1345 bestmatchsize = SCHARS (eltstring);
1347 else
1349 compare = min (bestmatchsize, SCHARS (eltstring));
1350 tem = Fcompare_strings (bestmatch, zero,
1351 make_number (compare),
1352 eltstring, zero,
1353 make_number (compare),
1354 completion_ignore_case ? Qt : Qnil);
1355 matchsize = EQ (tem, Qt) ? compare : eabs (XINT (tem)) - 1;
1357 if (completion_ignore_case)
1359 /* If this is an exact match except for case,
1360 use it as the best match rather than one that is not an
1361 exact match. This way, we get the case pattern
1362 of the actual match. */
1363 if ((matchsize == SCHARS (eltstring)
1364 && matchsize < SCHARS (bestmatch))
1366 /* If there is more than one exact match ignoring case,
1367 and one of them is exact including case,
1368 prefer that one. */
1369 /* If there is no exact match ignoring case,
1370 prefer a match that does not change the case
1371 of the input. */
1372 ((matchsize == SCHARS (eltstring))
1374 (matchsize == SCHARS (bestmatch))
1375 && (tem = Fcompare_strings (eltstring, zero,
1376 make_number (SCHARS (string)),
1377 string, zero,
1378 Qnil,
1379 Qnil),
1380 EQ (Qt, tem))
1381 && (tem = Fcompare_strings (bestmatch, zero,
1382 make_number (SCHARS (string)),
1383 string, zero,
1384 Qnil,
1385 Qnil),
1386 ! EQ (Qt, tem))))
1387 bestmatch = eltstring;
1389 if (bestmatchsize != SCHARS (eltstring)
1390 || bestmatchsize != matchsize)
1391 /* Don't count the same string multiple times. */
1392 matchcount += matchcount <= 1;
1393 bestmatchsize = matchsize;
1394 if (matchsize <= SCHARS (string)
1395 /* If completion-ignore-case is non-nil, don't
1396 short-circuit because we want to find the best
1397 possible match *including* case differences. */
1398 && !completion_ignore_case
1399 && matchcount > 1)
1400 /* No need to look any further. */
1401 break;
1406 if (bindcount >= 0) {
1407 unbind_to (bindcount, Qnil);
1408 bindcount = -1;
1411 if (NILP (bestmatch))
1412 return Qnil; /* No completions found. */
1413 /* If we are ignoring case, and there is no exact match,
1414 and no additional text was supplied,
1415 don't change the case of what the user typed. */
1416 if (completion_ignore_case && bestmatchsize == SCHARS (string)
1417 && SCHARS (bestmatch) > bestmatchsize)
1418 return minibuf_conform_representation (string, bestmatch);
1420 /* Return t if the supplied string is an exact match (counting case);
1421 it does not require any change to be made. */
1422 if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
1423 return Qt;
1425 XSETFASTINT (zero, 0); /* Else extract the part in which */
1426 XSETFASTINT (end, bestmatchsize); /* all completions agree. */
1427 return Fsubstring (bestmatch, zero, end);
1430 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1431 doc: /* Search for partial matches to STRING in COLLECTION.
1432 Test each of the possible completions specified by COLLECTION
1433 to see if it begins with STRING. The possible completions may be
1434 strings or symbols. Symbols are converted to strings before testing,
1435 see `symbol-name'.
1436 The value is a list of all the possible completions that match STRING.
1438 If COLLECTION is an alist, the keys (cars of elements) are the
1439 possible completions. If an element is not a cons cell, then the
1440 element itself is the possible completion.
1441 If COLLECTION is a hash-table, all the keys that are strings or symbols
1442 are the possible completions.
1443 If COLLECTION is an obarray, the names of all symbols in the obarray
1444 are the possible completions.
1446 COLLECTION can also be a function to do the completion itself.
1447 It receives three arguments: the values STRING, PREDICATE and t.
1448 Whatever it returns becomes the value of `all-completions'.
1450 If optional third argument PREDICATE is non-nil,
1451 it is used to test each possible match.
1452 The match is a candidate only if PREDICATE returns non-nil.
1453 The argument given to PREDICATE is the alist element
1454 or the symbol from the obarray. If COLLECTION is a hash-table,
1455 predicate is called with two arguments: the key and the value.
1456 Additionally to this predicate, `completion-regexp-list'
1457 is used to further constrain the set of candidates.
1459 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1460 backward compatibility. If non-nil, strings in COLLECTION that start
1461 with a space are ignored unless STRING itself starts with a space. */)
1462 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate, Lisp_Object hide_spaces)
1464 Lisp_Object tail, elt, eltstring;
1465 Lisp_Object allmatches;
1466 int type = HASH_TABLE_P (collection) ? 3
1467 : VECTORP (collection) ? 2
1468 : NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection));
1469 ptrdiff_t idx = 0, obsize = 0;
1470 ptrdiff_t bindcount = -1;
1471 Lisp_Object bucket, tem, zero;
1472 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1474 CHECK_STRING (string);
1475 if (type == 0)
1476 return call3 (collection, string, predicate, Qt);
1477 allmatches = bucket = Qnil;
1478 zero = make_number (0);
1480 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1481 tail = collection;
1482 if (type == 2)
1484 collection = check_obarray (collection);
1485 obsize = ASIZE (collection);
1486 bucket = AREF (collection, idx);
1489 while (1)
1491 /* Get the next element of the alist, obarray, or hash-table. */
1492 /* Exit the loop if the elements are all used up. */
1493 /* elt gets the alist element or symbol.
1494 eltstring gets the name to check as a completion. */
1496 if (type == 1)
1498 if (!CONSP (tail))
1499 break;
1500 elt = XCAR (tail);
1501 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1502 tail = XCDR (tail);
1504 else if (type == 2)
1506 if (!EQ (bucket, zero))
1508 if (!SYMBOLP (bucket))
1509 error ("Bad data in guts of obarray");
1510 elt = bucket;
1511 eltstring = elt;
1512 if (XSYMBOL (bucket)->next)
1513 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1514 else
1515 XSETFASTINT (bucket, 0);
1517 else if (++idx >= obsize)
1518 break;
1519 else
1521 bucket = AREF (collection, idx);
1522 continue;
1525 else /* if (type == 3) */
1527 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1528 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1529 idx++;
1530 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1531 break;
1532 else
1533 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1536 /* Is this element a possible completion? */
1538 if (SYMBOLP (eltstring))
1539 eltstring = Fsymbol_name (eltstring);
1541 if (STRINGP (eltstring)
1542 && SCHARS (string) <= SCHARS (eltstring)
1543 /* If HIDE_SPACES, reject alternatives that start with space
1544 unless the input starts with space. */
1545 && (NILP (hide_spaces)
1546 || (SBYTES (string) > 0
1547 && SREF (string, 0) == ' ')
1548 || SREF (eltstring, 0) != ' ')
1549 && (tem = Fcompare_strings (eltstring, zero,
1550 make_number (SCHARS (string)),
1551 string, zero,
1552 make_number (SCHARS (string)),
1553 completion_ignore_case ? Qt : Qnil),
1554 EQ (Qt, tem)))
1556 /* Yes. */
1557 Lisp_Object regexps;
1559 /* Ignore this element if it fails to match all the regexps. */
1561 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1562 regexps = XCDR (regexps))
1564 if (bindcount < 0) {
1565 bindcount = SPECPDL_INDEX ();
1566 specbind (Qcase_fold_search,
1567 completion_ignore_case ? Qt : Qnil);
1569 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1570 if (NILP (tem))
1571 break;
1573 if (CONSP (regexps))
1574 continue;
1577 /* Ignore this element if there is a predicate
1578 and the predicate doesn't like it. */
1580 if (!NILP (predicate))
1582 if (EQ (predicate, Qcommandp))
1583 tem = Fcommandp (elt, Qnil);
1584 else
1586 if (bindcount >= 0) {
1587 unbind_to (bindcount, Qnil);
1588 bindcount = -1;
1590 GCPRO4 (tail, eltstring, allmatches, string);
1591 tem = type == 3
1592 ? call2 (predicate, elt,
1593 HASH_VALUE (XHASH_TABLE (collection), idx - 1))
1594 : call1 (predicate, elt);
1595 UNGCPRO;
1597 if (NILP (tem)) continue;
1599 /* Ok => put it on the list. */
1600 allmatches = Fcons (eltstring, allmatches);
1604 if (bindcount >= 0) {
1605 unbind_to (bindcount, Qnil);
1606 bindcount = -1;
1609 return Fnreverse (allmatches);
1612 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1613 doc: /* Read a string in the minibuffer, with completion.
1614 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1615 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1616 COLLECTION can also be a function to do the completion itself.
1617 PREDICATE limits completion to a subset of COLLECTION.
1618 See `try-completion' and `all-completions' for more details
1619 on completion, COLLECTION, and PREDICATE.
1621 REQUIRE-MATCH can take the following values:
1622 - t means that the user is not allowed to exit unless
1623 the input is (or completes to) an element of COLLECTION or is null.
1624 - nil means that the user can exit with any input.
1625 - `confirm' means that the user can exit with any input, but she needs
1626 to confirm her choice if the input is not an element of COLLECTION.
1627 - `confirm-after-completion' means that the user can exit with any
1628 input, but she needs to confirm her choice if she called
1629 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1630 and the input is not an element of COLLECTION.
1631 - anything else behaves like t except that typing RET does not exit if it
1632 does non-null completion.
1634 If the input is null, `completing-read' returns DEF, or the first element
1635 of the list of default values, or an empty string if DEF is nil,
1636 regardless of the value of REQUIRE-MATCH.
1638 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1639 with point positioned at the end.
1640 If it is (STRING . POSITION), the initial input is STRING, but point
1641 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1642 that this is different from `read-from-minibuffer' and related
1643 functions, which use one-indexing for POSITION.) This feature is
1644 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1645 default value DEF instead. The user can yank the default value into
1646 the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1648 HIST, if non-nil, specifies a history list and optionally the initial
1649 position in the list. It can be a symbol, which is the history list
1650 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1651 that case, HISTVAR is the history list variable to use, and HISTPOS
1652 is the initial position (the position in the list used by the
1653 minibuffer history commands). For consistency, you should also
1654 specify that element of the history as the value of
1655 INITIAL-INPUT. (This is the only case in which you should use
1656 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1657 1 at the beginning of the list. The variable `history-length'
1658 controls the maximum length of a history list.
1660 DEF, if non-nil, is the default value or the list of default values.
1662 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1663 the current input method and the setting of `enable-multibyte-characters'.
1665 Completion ignores case if the ambient value of
1666 `completion-ignore-case' is non-nil.
1668 See also `completing-read-function'. */)
1669 (Lisp_Object prompt, Lisp_Object collection, Lisp_Object predicate, Lisp_Object require_match, Lisp_Object initial_input, Lisp_Object hist, Lisp_Object def, Lisp_Object inherit_input_method)
1671 return CALLN (Ffuncall,
1672 Fsymbol_value (intern ("completing-read-function")),
1673 prompt, collection, predicate, require_match, initial_input,
1674 hist, def, inherit_input_method);
1677 /* Test whether TXT is an exact completion. */
1678 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1679 doc: /* Return non-nil if STRING is a valid completion.
1680 Takes the same arguments as `all-completions' and `try-completion'.
1681 If COLLECTION is a function, it is called with three arguments:
1682 the values STRING, PREDICATE and `lambda'. */)
1683 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1685 Lisp_Object regexps, tail, tem = Qnil;
1686 ptrdiff_t i = 0;
1688 CHECK_STRING (string);
1690 if (NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection)))
1692 tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
1693 if (NILP (tem))
1694 return Qnil;
1696 else if (VECTORP (collection))
1698 /* Bypass intern-soft as that loses for nil. */
1699 tem = oblookup (collection,
1700 SSDATA (string),
1701 SCHARS (string),
1702 SBYTES (string));
1703 if (!SYMBOLP (tem))
1705 if (STRING_MULTIBYTE (string))
1706 string = Fstring_make_unibyte (string);
1707 else
1708 string = Fstring_make_multibyte (string);
1710 tem = oblookup (collection,
1711 SSDATA (string),
1712 SCHARS (string),
1713 SBYTES (string));
1716 if (completion_ignore_case && !SYMBOLP (tem))
1718 for (i = ASIZE (collection) - 1; i >= 0; i--)
1720 tail = AREF (collection, i);
1721 if (SYMBOLP (tail))
1722 while (1)
1724 if (EQ (Fcompare_strings (string, make_number (0), Qnil,
1725 Fsymbol_name (tail),
1726 make_number (0) , Qnil, Qt),
1727 Qt))
1729 tem = tail;
1730 break;
1732 if (XSYMBOL (tail)->next == 0)
1733 break;
1734 XSETSYMBOL (tail, XSYMBOL (tail)->next);
1739 if (!SYMBOLP (tem))
1740 return Qnil;
1742 else if (HASH_TABLE_P (collection))
1744 struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
1745 Lisp_Object key = Qnil;
1746 i = hash_lookup (h, string, NULL);
1747 if (i >= 0)
1748 tem = HASH_KEY (h, i);
1749 else
1750 for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1751 if (!NILP (HASH_HASH (h, i))
1752 && (key = HASH_KEY (h, i),
1753 SYMBOLP (key) ? key = Fsymbol_name (key) : key,
1754 STRINGP (key))
1755 && EQ (Fcompare_strings (string, make_number (0), Qnil,
1756 key, make_number (0) , Qnil,
1757 completion_ignore_case ? Qt : Qnil),
1758 Qt))
1760 tem = key;
1761 break;
1763 if (!STRINGP (tem))
1764 return Qnil;
1766 else
1767 return call3 (collection, string, predicate, Qlambda);
1769 /* Reject this element if it fails to match all the regexps. */
1770 if (CONSP (Vcompletion_regexp_list))
1772 ptrdiff_t count = SPECPDL_INDEX ();
1773 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1774 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1775 regexps = XCDR (regexps))
1777 if (NILP (Fstring_match (XCAR (regexps),
1778 SYMBOLP (tem) ? string : tem,
1779 Qnil)))
1780 return unbind_to (count, Qnil);
1782 unbind_to (count, Qnil);
1785 /* Finally, check the predicate. */
1786 if (!NILP (predicate))
1788 return HASH_TABLE_P (collection)
1789 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
1790 : call1 (predicate, tem);
1792 else
1793 return Qt;
1796 DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
1797 doc: /* Perform completion on buffer names.
1798 STRING and PREDICATE have the same meanings as in `try-completion',
1799 `all-completions', and `test-completion'.
1801 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1802 `all-completions'; otherwise invoke `test-completion'. */)
1803 (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag)
1805 if (NILP (flag))
1806 return Ftry_completion (string, Vbuffer_alist, predicate);
1807 else if (EQ (flag, Qt))
1809 Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
1810 if (SCHARS (string) > 0)
1811 return res;
1812 else
1813 { /* Strip out internal buffers. */
1814 Lisp_Object bufs = res;
1815 /* First, look for a non-internal buffer in `res'. */
1816 while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
1817 bufs = XCDR (bufs);
1818 if (NILP (bufs))
1819 return (EQ (Flength (res), Flength (Vbuffer_alist))
1820 /* If all bufs are internal don't strip them out. */
1821 ? res : bufs);
1822 res = bufs;
1823 while (CONSP (XCDR (bufs)))
1824 if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
1825 XSETCDR (bufs, XCDR (XCDR (bufs)));
1826 else
1827 bufs = XCDR (bufs);
1828 return res;
1831 else if (EQ (flag, Qlambda))
1832 return Ftest_completion (string, Vbuffer_alist, predicate);
1833 else if (EQ (flag, Qmetadata))
1834 return list2 (Qmetadata, Fcons (Qcategory, Qbuffer));
1835 else
1836 return Qnil;
1839 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1841 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
1842 doc: /* Like `assoc' but specifically for strings (and symbols).
1844 This returns the first element of LIST whose car matches the string or
1845 symbol KEY, or nil if no match exists. When performing the
1846 comparison, symbols are first converted to strings, and unibyte
1847 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1848 is ignored.
1850 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1851 single string, rather than a cons cell whose car is a string. */)
1852 (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
1854 register Lisp_Object tail;
1856 if (SYMBOLP (key))
1857 key = Fsymbol_name (key);
1859 for (tail = list; CONSP (tail); tail = XCDR (tail))
1861 register Lisp_Object elt, tem, thiscar;
1862 elt = XCAR (tail);
1863 thiscar = CONSP (elt) ? XCAR (elt) : elt;
1864 if (SYMBOLP (thiscar))
1865 thiscar = Fsymbol_name (thiscar);
1866 else if (!STRINGP (thiscar))
1867 continue;
1868 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1869 key, make_number (0), Qnil,
1870 case_fold);
1871 if (EQ (tem, Qt))
1872 return elt;
1873 QUIT;
1875 return Qnil;
1879 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
1880 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1881 (void)
1883 return make_number (minibuf_level);
1886 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
1887 doc: /* Return the prompt string of the currently-active minibuffer.
1888 If no minibuffer is active, return nil. */)
1889 (void)
1891 return Fcopy_sequence (minibuf_prompt);
1895 void
1896 init_minibuf_once (void)
1898 Vminibuffer_list = Qnil;
1899 staticpro (&Vminibuffer_list);
1902 void
1903 syms_of_minibuf (void)
1905 minibuf_level = 0;
1906 minibuf_prompt = Qnil;
1907 staticpro (&minibuf_prompt);
1909 minibuf_save_list = Qnil;
1910 staticpro (&minibuf_save_list);
1912 DEFSYM (Qcompletion_ignore_case, "completion-ignore-case");
1913 DEFSYM (Qread_file_name_internal, "read-file-name-internal");
1914 DEFSYM (Qminibuffer_default, "minibuffer-default");
1915 Fset (Qminibuffer_default, Qnil);
1917 DEFSYM (Qminibuffer_completion_table, "minibuffer-completion-table");
1918 DEFSYM (Qminibuffer_completion_confirm, "minibuffer-completion-confirm");
1919 DEFSYM (Qminibuffer_completion_predicate, "minibuffer-completion-predicate");
1921 staticpro (&last_minibuf_string);
1922 last_minibuf_string = Qnil;
1924 DEFSYM (Qminibuffer_history, "minibuffer-history");
1925 DEFSYM (Qbuffer_name_history, "buffer-name-history");
1926 Fset (Qbuffer_name_history, Qnil);
1928 DEFSYM (Qcustom_variable_p, "custom-variable-p");
1930 /* Normal hooks for entry to and exit from minibuffer. */
1931 DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
1932 DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
1934 /* The maximum length of a minibuffer history. */
1935 DEFSYM (Qhistory_length, "history-length");
1937 DEFSYM (Qcurrent_input_method, "current-input-method");
1938 DEFSYM (Qactivate_input_method, "activate-input-method");
1939 DEFSYM (Qcase_fold_search, "case-fold-search");
1940 DEFSYM (Qmetadata, "metadata");
1942 DEFVAR_LISP ("read-expression-history", Vread_expression_history,
1943 doc: /* A history list for arguments that are Lisp expressions to evaluate.
1944 For example, `eval-expression' uses this. */);
1945 Vread_expression_history = Qnil;
1947 DEFSYM (Qread_expression_history, "read-expression-history");
1949 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function,
1950 doc: /* If this is non-nil, `read-buffer' does its work by calling this function.
1951 The function is called with the arguments passed to `read-buffer'. */);
1952 Vread_buffer_function = Qnil;
1954 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1955 read_buffer_completion_ignore_case,
1956 doc: /* Non-nil means completion ignores case when reading a buffer name. */);
1957 read_buffer_completion_ignore_case = 0;
1959 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook,
1960 doc: /* Normal hook run just after entry to minibuffer. */);
1961 Vminibuffer_setup_hook = Qnil;
1963 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook,
1964 doc: /* Normal hook run just after exit from minibuffer. */);
1965 Vminibuffer_exit_hook = Qnil;
1967 DEFVAR_LISP ("history-length", Vhistory_length,
1968 doc: /* Maximum length of history lists before truncation takes place.
1969 A number means truncate to that length; truncation deletes old
1970 elements, and is done just after inserting a new element.
1971 A value of t means no truncation.
1973 This variable only affects history lists that don't specify their own
1974 maximum lengths. Setting the `history-length' property of a history
1975 variable overrides this default. */);
1976 XSETFASTINT (Vhistory_length, 100);
1978 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates,
1979 doc: /* Non-nil means to delete duplicates in history.
1980 If set to t when adding a new history element, all previous identical
1981 elements are deleted from the history list. */);
1982 history_delete_duplicates = 0;
1984 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input,
1985 doc: /* Non-nil means to add new elements in history.
1986 If set to nil, minibuffer reading functions don't add new elements to the
1987 history list, so it is possible to do this afterwards by calling
1988 `add-to-history' explicitly. */);
1989 Vhistory_add_new_input = Qt;
1991 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case,
1992 doc: /* Non-nil means don't consider case significant in completion.
1993 For file-name completion, `read-file-name-completion-ignore-case'
1994 controls the behavior, rather than this variable.
1995 For buffer name completion, `read-buffer-completion-ignore-case'
1996 controls the behavior, rather than this variable. */);
1997 completion_ignore_case = 0;
1999 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers,
2000 doc: /* Non-nil means to allow minibuffer commands while in the minibuffer.
2001 This variable makes a difference whenever the minibuffer window is active. */);
2002 enable_recursive_minibuffers = 0;
2004 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table,
2005 doc: /* Alist or obarray used for completion in the minibuffer.
2006 This becomes the ALIST argument to `try-completion' and `all-completions'.
2007 The value can also be a list of strings or a hash table.
2009 The value may alternatively be a function, which is given three arguments:
2010 STRING, the current buffer contents;
2011 PREDICATE, the predicate for filtering possible matches;
2012 CODE, which says what kind of things to do.
2013 CODE can be nil, t or `lambda':
2014 nil -- return the best completion of STRING, or nil if there is none.
2015 t -- return a list of all possible completions of STRING.
2016 lambda -- return t if STRING is a valid completion as it stands. */);
2017 Vminibuffer_completion_table = Qnil;
2019 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate,
2020 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2021 Vminibuffer_completion_predicate = Qnil;
2023 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm,
2024 doc: /* Whether to demand confirmation of completion before exiting minibuffer.
2025 If nil, confirmation is not required.
2026 If the value is `confirm', the user may exit with an input that is not
2027 a valid completion alternative, but Emacs asks for confirmation.
2028 If the value is `confirm-after-completion', the user may exit with an
2029 input that is not a valid completion alternative, but Emacs asks for
2030 confirmation if the user submitted the input right after any of the
2031 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2032 Vminibuffer_completion_confirm = Qnil;
2034 DEFVAR_LISP ("minibuffer-completing-file-name",
2035 Vminibuffer_completing_file_name,
2036 doc: /* Non-nil means completing file names. */);
2037 Vminibuffer_completing_file_name = Qnil;
2039 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form,
2040 doc: /* Value that `help-form' takes on inside the minibuffer. */);
2041 Vminibuffer_help_form = Qnil;
2043 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable,
2044 doc: /* History list symbol to add minibuffer values to.
2045 Each string of minibuffer input, as it appears on exit from the minibuffer,
2046 is added with
2047 (set minibuffer-history-variable
2048 (cons STRING (symbol-value minibuffer-history-variable))) */);
2049 XSETFASTINT (Vminibuffer_history_variable, 0);
2051 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position,
2052 doc: /* Current position of redoing in the history list. */);
2053 Vminibuffer_history_position = Qnil;
2055 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise,
2056 doc: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2057 Some uses of the echo area also raise that frame (since they use it too). */);
2058 minibuffer_auto_raise = 0;
2060 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list,
2061 doc: /* List of regexps that should restrict possible completions.
2062 The basic completion functions only consider a completion acceptable
2063 if it matches all regular expressions in this list, with
2064 `case-fold-search' bound to the value of `completion-ignore-case'.
2065 See Info node `(elisp)Basic Completion', for a description of these
2066 functions. */);
2067 Vcompletion_regexp_list = Qnil;
2069 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2070 minibuffer_allow_text_properties,
2071 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2072 This also affects `read-string', but it does not affect `read-minibuffer',
2073 `read-no-blanks-input', or any of the functions that do minibuffer input
2074 with completion; they always discard text properties. */);
2075 minibuffer_allow_text_properties = 0;
2077 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties,
2078 doc: /* Text properties that are added to minibuffer prompts.
2079 These are in addition to the basic `field' property, and stickiness
2080 properties. */);
2081 Vminibuffer_prompt_properties = list2 (Qread_only, Qt);
2083 DEFVAR_LISP ("read-hide-char", Vread_hide_char,
2084 doc: /* Whether to hide input characters in noninteractive mode.
2085 It must be a character, which will be used to mask the input
2086 characters. This variable should never be set globally. */);
2087 Vread_hide_char = Qnil;
2089 defsubr (&Sactive_minibuffer_window);
2090 defsubr (&Sset_minibuffer_window);
2091 defsubr (&Sread_from_minibuffer);
2092 defsubr (&Sread_string);
2093 defsubr (&Sread_command);
2094 defsubr (&Sread_variable);
2095 defsubr (&Sinternal_complete_buffer);
2096 defsubr (&Sread_buffer);
2097 defsubr (&Sread_no_blanks_input);
2098 defsubr (&Sminibuffer_depth);
2099 defsubr (&Sminibuffer_prompt);
2101 defsubr (&Sminibufferp);
2102 defsubr (&Sminibuffer_prompt_end);
2103 defsubr (&Sminibuffer_contents);
2104 defsubr (&Sminibuffer_contents_no_properties);
2105 defsubr (&Sminibuffer_completion_contents);
2107 defsubr (&Stry_completion);
2108 defsubr (&Sall_completions);
2109 defsubr (&Stest_completion);
2110 defsubr (&Sassoc_string);
2111 defsubr (&Scompleting_read);