1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2018 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 (at
10 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 <https://www.gnu.org/licenses/>. */
24 #include <binary-io.h>
27 #include "character.h"
36 /* List of buffers for use as minibuffers.
37 The first element of the list is used for the outermost minibuffer
38 invocation, the next element is used for a recursive minibuffer
39 invocation, etc. The list is extended at the end as deeper
40 minibuffer recursions are encountered. */
42 Lisp_Object Vminibuffer_list
;
44 /* Data to remember during recursive minibuffer invocations. */
46 static Lisp_Object minibuf_save_list
;
48 /* Depth in minibuffer invocations. */
50 EMACS_INT minibuf_level
;
52 /* Fread_minibuffer leaves the input here as a string. */
54 Lisp_Object last_minibuf_string
;
56 /* Prompt to display in front of the mini-buffer contents. */
58 static Lisp_Object minibuf_prompt
;
60 /* Width of current mini-buffer prompt. Only set after display_line
61 of the line that contains the prompt. */
63 static ptrdiff_t minibuf_prompt_width
;
66 /* Put minibuf on currently selected frame's minibuffer.
67 We do this whenever the user starts a new minibuffer
68 or when a minibuffer exits. */
71 choose_minibuf_frame (void)
73 if (FRAMEP (selected_frame
)
74 && FRAME_LIVE_P (XFRAME (selected_frame
))
75 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
77 struct frame
*sf
= XFRAME (selected_frame
);
80 /* I don't think that any frames may validly have a null minibuffer
82 if (NILP (sf
->minibuffer_window
))
85 /* Under X, we come here with minibuf_window being the
86 minibuffer window of the unused termcap window created in
87 init_window_once. That window doesn't have a buffer. */
88 buffer
= XWINDOW (minibuf_window
)->contents
;
90 /* Use set_window_buffer instead of Fset_window_buffer (see
91 discussion of bug#11984, bug#12025, bug#12026). */
92 set_window_buffer (sf
->minibuffer_window
, buffer
, 0, 0);
93 minibuf_window
= sf
->minibuffer_window
;
96 /* Make sure no other frame has a minibuffer as its selected window,
97 because the text would not be displayed in it, and that would be
98 confusing. Only allow the selected frame to do this,
99 and that only if the minibuffer is active. */
101 Lisp_Object tail
, frame
;
103 FOR_EACH_FRAME (tail
, frame
)
104 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
105 && !(EQ (frame
, selected_frame
)
106 && minibuf_level
> 0))
107 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
111 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
112 Sactive_minibuffer_window
, 0, 0, 0,
113 doc
: /* Return the currently active minibuffer window, or nil if none. */)
116 return minibuf_level
? minibuf_window
: Qnil
;
119 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
120 Sset_minibuffer_window
, 1, 1, 0,
121 doc
: /* Specify which minibuffer window to use for the minibuffer.
122 This affects where the minibuffer is displayed if you put text in it
123 without invoking the usual minibuffer commands. */)
126 CHECK_WINDOW (window
);
127 if (! MINI_WINDOW_P (XWINDOW (window
)))
128 error ("Window is not a minibuffer window");
130 minibuf_window
= window
;
136 /* Actual minibuffer invocation. */
138 static void read_minibuf_unwind (void);
139 static void run_exit_minibuf_hook (void);
142 /* Read a Lisp object from VAL and return it. If VAL is an empty
143 string, and DEFALT is a string, read from DEFALT instead of VAL. */
146 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
148 Lisp_Object expr_and_pos
;
151 if (STRINGP (val
) && SCHARS (val
) == 0)
153 if (STRINGP (defalt
))
155 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
159 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
160 pos
= XINT (Fcdr (expr_and_pos
));
161 if (pos
!= SCHARS (val
))
163 /* Ignore trailing whitespace; any other trailing junk
166 pos
= string_char_to_byte (val
, pos
);
167 for (i
= pos
; i
< SBYTES (val
); i
++)
169 int c
= SREF (val
, i
);
170 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
171 error ("Trailing garbage following expression");
175 val
= Fcar (expr_and_pos
);
180 /* Like read_minibuf but reading from stdin. This function is called
181 from read_minibuf to do the job if noninteractive. */
184 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
185 Lisp_Object prompt
, Lisp_Object backup_n
,
187 Lisp_Object histvar
, Lisp_Object histpos
,
189 bool allow_props
, bool inherit_input_method
)
195 unsigned char hide_char
= 0;
196 struct emacs_tty etty
;
197 bool etty_valid UNINIT
;
199 /* Check, whether we need to suppress echoing. */
200 if (CHARACTERP (Vread_hide_char
))
201 hide_char
= XFASTINT (Vread_hide_char
);
203 /* Manipulate tty. */
206 etty_valid
= emacs_get_tty (STDIN_FILENO
, &etty
) == 0;
208 set_binary_mode (STDIN_FILENO
, O_BINARY
);
209 suppress_echo_on_tty (STDIN_FILENO
);
212 fwrite_unlocked (SDATA (prompt
), 1, SBYTES (prompt
), stdout
);
213 fflush_unlocked (stdout
);
218 line
= xmalloc (size
);
220 while ((c
= getchar_unlocked ()) != '\n' && c
!= '\r')
230 fprintf (stdout
, "%c", hide_char
);
232 line
= xpalloc (line
, &size
, 1, -1, sizeof *line
);
240 fprintf (stdout
, "\n");
243 emacs_set_tty (STDIN_FILENO
, &etty
, 0);
244 set_binary_mode (STDIN_FILENO
, O_TEXT
);
248 if (len
|| c
== '\n' || c
== '\r')
250 val
= make_string (line
, len
);
256 error ("Error reading from stdin");
259 /* If Lisp form desired instead of string, parse it. */
261 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
266 DEFUN ("minibufferp", Fminibufferp
,
267 Sminibufferp
, 0, 1, 0,
268 doc
: /* Return t if BUFFER is a minibuffer.
269 No argument or nil as argument means use current buffer as BUFFER.
270 BUFFER can be a buffer or a buffer name. */)
276 buffer
= Fcurrent_buffer ();
277 else if (STRINGP (buffer
))
278 buffer
= Fget_buffer (buffer
);
280 CHECK_BUFFER (buffer
);
282 tem
= Fmemq (buffer
, Vminibuffer_list
);
283 return ! NILP (tem
) ? Qt
: Qnil
;
286 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
287 Sminibuffer_prompt_end
, 0, 0, 0,
288 doc
: /* Return the buffer position of the end of the minibuffer prompt.
289 Return (point-min) if current buffer is not a minibuffer. */)
292 /* This function is written to be most efficient when there's a prompt. */
293 Lisp_Object beg
, end
, tem
;
294 beg
= make_number (BEGV
);
296 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
300 end
= Ffield_end (beg
, Qnil
, Qnil
);
302 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
308 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
309 Sminibuffer_contents
, 0, 0, 0,
310 doc
: /* Return the user input in a minibuffer as a string.
311 If the current buffer is not a minibuffer, return its entire contents. */)
314 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
315 return make_buffer_string (prompt_end
, ZV
, 1);
318 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
319 Sminibuffer_contents_no_properties
, 0, 0, 0,
320 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
321 If the current buffer is not a minibuffer, return its entire contents. */)
324 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
325 return make_buffer_string (prompt_end
, ZV
, 0);
329 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
330 putting point minus BACKUP_N bytes from the end of INITIAL,
331 prompting with PROMPT (a string), using history list HISTVAR
332 with initial position HISTPOS. INITIAL should be a string or a
333 cons of a string and an integer. BACKUP_N should be <= 0, or
334 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
335 ignored and replaced with an integer that puts point at one-indexed
336 position N in INITIAL, where N is the CDR of INITIAL, or at the
337 beginning of INITIAL if N <= 0.
339 Normally return the result as a string (the text that was read),
340 but if EXPFLAG, read it and return the object read.
341 If HISTVAR is given, save the value read on that history only if it doesn't
342 match the front of that history list exactly. The value is pushed onto
343 the list as the string that was read.
345 DEFALT specifies the default value for the sake of history commands.
347 If ALLOW_PROPS, do not throw away text properties.
349 if INHERIT_INPUT_METHOD, the minibuffer inherits the
350 current input method. */
353 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
355 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
356 bool allow_props
, bool inherit_input_method
)
359 ptrdiff_t count
= SPECPDL_INDEX ();
360 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
361 Lisp_Object enable_multibyte
;
363 /* String to add to the history. */
364 Lisp_Object histstring
;
367 Lisp_Object empty_minibuf
;
368 Lisp_Object dummy
, frame
;
370 specbind (Qminibuffer_default
, defalt
);
371 specbind (Qinhibit_read_only
, Qnil
);
373 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
374 in previous recursive minibuffer, but was not set explicitly
375 to t for this invocation, so set it to nil in this minibuffer.
376 Save the old value now, before we change it. */
377 specbind (intern ("minibuffer-completing-file-name"),
378 Vminibuffer_completing_file_name
);
379 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
380 Vminibuffer_completing_file_name
= Qnil
;
382 #ifdef HAVE_WINDOW_SYSTEM
383 if (display_hourglass_p
)
391 Lisp_Object backup_n
= XCDR (initial
);
392 initial
= XCAR (initial
);
393 CHECK_STRING (initial
);
394 if (!NILP (backup_n
))
396 CHECK_NUMBER (backup_n
);
397 /* Convert to distance from end of input. */
398 if (XINT (backup_n
) < 1)
399 /* A number too small means the beginning of the string. */
400 pos
= - SCHARS (initial
);
402 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
406 CHECK_STRING (initial
);
409 ambient_dir
= BVAR (current_buffer
, directory
);
411 enable_multibyte
= Qnil
;
413 if (!STRINGP (prompt
))
414 prompt
= empty_unibyte_string
;
416 if (!enable_recursive_minibuffers
417 && minibuf_level
> 0)
419 if (EQ (selected_window
, minibuf_window
))
420 error ("Command attempted to use minibuffer while in minibuffer");
422 /* If we're in another window, cancel the minibuffer that's active. */
424 build_string ("Command attempted to use minibuffer while in minibuffer"));
428 /* In case we are running as a daemon, only do this before
429 detaching from the terminal. */
430 || (IS_DAEMON
&& DAEMON_RUNNING
))
431 && NILP (Vexecuting_kbd_macro
))
433 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
435 expflag
, histvar
, histpos
, defalt
,
436 allow_props
, inherit_input_method
);
437 return unbind_to (count
, val
);
440 /* Choose the minibuffer window and frame, and take action on them. */
442 /* Prepare for restoring the current buffer since choose_minibuf_frame
443 calling Fset_frame_selected_window may change it (Bug#12766). */
444 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
446 choose_minibuf_frame ();
448 record_unwind_protect_void (choose_minibuf_frame
);
450 record_unwind_protect (restore_window_configuration
,
451 Fcurrent_window_configuration (Qnil
));
453 /* If the minibuffer window is on a different frame, save that
454 frame's configuration too. */
455 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
456 if (!EQ (mini_frame
, selected_frame
))
457 record_unwind_protect (restore_window_configuration
,
458 Fcurrent_window_configuration (mini_frame
));
460 /* If the minibuffer is on an iconified or invisible frame,
461 make it visible now. */
462 Fmake_frame_visible (mini_frame
);
464 if (minibuffer_auto_raise
)
465 Fraise_frame (mini_frame
);
467 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
469 /* We have to do this after saving the window configuration
470 since that is what restores the current buffer. */
472 /* Arrange to restore a number of minibuffer-related variables.
473 We could bind each variable separately, but that would use lots of
476 = Fcons (Voverriding_local_map
,
477 Fcons (minibuf_window
,
480 = Fcons (minibuf_prompt
,
481 Fcons (make_number (minibuf_prompt_width
),
483 Fcons (Vcurrent_prefix_arg
,
484 Fcons (Vminibuffer_history_position
,
485 Fcons (Vminibuffer_history_variable
,
486 minibuf_save_list
))))));
488 = Fcons (Fthis_command_keys_vector (), minibuf_save_list
);
490 record_unwind_protect_void (read_minibuf_unwind
);
492 /* We are exiting the minibuffer one way or the other, so run the hook.
493 It should be run before unwinding the minibuf settings. Do it
494 separately from read_minibuf_unwind because we need to make sure that
495 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
496 signals an error. --Stef */
497 record_unwind_protect_void (run_exit_minibuf_hook
);
499 /* Now that we can restore all those variables, start changing them. */
501 minibuf_prompt_width
= 0;
502 minibuf_prompt
= Fcopy_sequence (prompt
);
503 Vminibuffer_history_position
= histpos
;
504 Vminibuffer_history_variable
= histvar
;
505 Vhelp_form
= Vminibuffer_help_form
;
506 /* If this minibuffer is reading a file name, that doesn't mean
507 recursive ones are. But we cannot set it to nil, because
508 completion code still need to know the minibuffer is completing a
509 file name. So use `lambda' as intermediate value meaning
510 "t" in this minibuffer, but "nil" in next minibuffer. */
511 if (!NILP (Vminibuffer_completing_file_name
))
512 Vminibuffer_completing_file_name
= Qlambda
;
514 /* If variable is unbound, make it nil. */
515 histval
= find_symbol_value (Vminibuffer_history_variable
);
516 if (EQ (histval
, Qunbound
))
518 Fset (Vminibuffer_history_variable
, Qnil
);
522 if (inherit_input_method
)
524 /* `current-input-method' is buffer local. So, remember it in
525 INPUT_METHOD before changing the current buffer. */
526 input_method
= Fsymbol_value (Qcurrent_input_method
);
527 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
530 /* Switch to the minibuffer. */
532 minibuffer
= get_minibuffer (minibuf_level
);
533 Fset_buffer (minibuffer
);
535 /* Defeat (setq-default truncate-lines t), since truncated lines do
536 not work correctly in minibuffers. (Bug#5715, etc) */
537 bset_truncate_lines (current_buffer
, Qnil
);
539 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
540 if (inherit_input_method
)
541 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
543 /* The current buffer's default directory is usually the right thing
544 for our minibuffer here. However, if you're typing a command at
545 a minibuffer-only frame when minibuf_level is zero, then buf IS
546 the current_buffer, so reset_buffer leaves buf's default
547 directory unchanged. This is a bummer when you've just started
548 up Emacs and buf's default directory is Qnil. Here's a hack; can
549 you think of something better to do? Find another buffer with a
550 better directory, and use that one instead. */
551 if (STRINGP (ambient_dir
))
552 bset_directory (current_buffer
, ambient_dir
);
555 Lisp_Object tail
, buf
;
557 FOR_EACH_LIVE_BUFFER (tail
, buf
)
558 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
560 bset_directory (current_buffer
,
561 BVAR (XBUFFER (buf
), directory
));
566 if (!EQ (mini_frame
, selected_frame
))
567 Fredirect_frame_focus (selected_frame
, mini_frame
);
569 Vminibuf_scroll_window
= selected_window
;
570 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
571 minibuf_selected_window
= selected_window
;
573 /* Empty out the minibuffers of all frames other than the one
574 where we are going to display one now.
575 Set them to point to ` *Minibuf-0*', which is always empty. */
576 empty_minibuf
= get_minibuffer (0);
578 FOR_EACH_FRAME (dummy
, frame
)
580 Lisp_Object root_window
= Fframe_root_window (frame
);
581 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
583 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
584 && !NILP (Fwindow_minibuffer_p (mini_window
)))
585 /* Use set_window_buffer instead of Fset_window_buffer (see
586 discussion of bug#11984, bug#12025, bug#12026). */
587 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
590 /* Display this minibuffer in the proper window. */
591 /* Use set_window_buffer instead of Fset_window_buffer (see
592 discussion of bug#11984, bug#12025, bug#12026). */
593 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
594 Fselect_window (minibuf_window
, Qnil
);
595 XWINDOW (minibuf_window
)->hscroll
= 0;
596 XWINDOW (minibuf_window
)->suspend_auto_hscroll
= 0;
598 /* Erase the buffer. */
600 ptrdiff_t count1
= SPECPDL_INDEX ();
601 specbind (Qinhibit_read_only
, Qt
);
602 specbind (Qinhibit_modification_hooks
, Qt
);
605 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
606 && ! STRING_MULTIBYTE (minibuf_prompt
))
607 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
609 /* Insert the prompt, record where it ends. */
610 Finsert (1, &minibuf_prompt
);
613 Fput_text_property (make_number (BEG
), make_number (PT
),
614 Qfront_sticky
, Qt
, Qnil
);
615 Fput_text_property (make_number (BEG
), make_number (PT
),
616 Qrear_nonsticky
, Qt
, Qnil
);
617 Fput_text_property (make_number (BEG
), make_number (PT
),
619 if (CONSP (Vminibuffer_prompt_properties
))
621 /* We want to apply all properties from
622 `minibuffer-prompt-properties' to the region normally,
623 but if the `face' property is present, add that
624 property to the end of the face properties to avoid
625 overwriting faces. */
626 Lisp_Object list
= Vminibuffer_prompt_properties
;
629 Lisp_Object key
= XCAR (list
);
633 Lisp_Object val
= XCAR (list
);
636 Fadd_face_text_property (make_number (BEG
),
637 make_number (PT
), val
, Qt
, Qnil
);
639 Fput_text_property (make_number (BEG
), make_number (PT
),
645 unbind_to (count1
, Qnil
);
648 minibuf_prompt_width
= current_column ();
650 /* Put in the initial input. */
653 Finsert (1, &initial
);
654 Fforward_char (make_number (pos
));
657 clear_message (1, 1);
658 bset_keymap (current_buffer
, map
);
660 /* Turn on an input method stored in INPUT_METHOD if any. */
661 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
662 call1 (Qactivate_input_method
, input_method
);
664 run_hook (Qminibuffer_setup_hook
);
666 /* Don't allow the user to undo past this point. */
667 bset_undo_list (current_buffer
, Qnil
);
671 /* If cursor is on the minibuffer line,
672 show the user we have exited by putting it in column 0. */
673 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
676 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
677 XWINDOW (minibuf_window
)->cursor
.x
= 0;
678 XWINDOW (minibuf_window
)->must_be_updated_p
= true;
679 update_frame (XFRAME (selected_frame
), true, true);
680 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
683 /* Make minibuffer contents into a string. */
684 Fset_buffer (minibuffer
);
686 val
= Fminibuffer_contents ();
688 val
= Fminibuffer_contents_no_properties ();
690 /* VAL is the string of minibuffer text. */
692 last_minibuf_string
= val
;
694 /* Choose the string to add to the history. */
695 if (SCHARS (val
) != 0)
697 else if (STRINGP (defalt
))
699 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
700 histstring
= XCAR (defalt
);
704 /* Add the value to the appropriate history list, if any. */
705 if (! (NILP (Vhistory_add_new_input
) || NILP (histstring
)))
706 call2 (intern ("add-to-history"), Vminibuffer_history_variable
, histstring
);
708 /* If Lisp form desired instead of string, parse it. */
710 val
= string_to_object (val
, defalt
);
712 /* The appropriate frame will get selected
713 in set-window-configuration. */
714 return unbind_to (count
, val
);
717 /* Return a buffer to be used as the minibuffer at depth `depth'.
718 depth = 0 is the lowest allowed argument, and that is the value
719 used for nonrecursive minibuffer invocations. */
722 get_minibuffer (EMACS_INT depth
)
724 Lisp_Object tail
= Fnthcdr (make_number (depth
), Vminibuffer_list
);
728 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
730 Lisp_Object buf
= Fcar (tail
);
731 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
733 static char const name_fmt
[] = " *Minibuf-%"pI
"d*";
734 char name
[sizeof name_fmt
+ INT_STRLEN_BOUND (EMACS_INT
)];
735 AUTO_STRING_WITH_LEN (lname
, name
, sprintf (name
, name_fmt
, depth
));
736 buf
= Fget_buffer_create (lname
);
738 /* Although the buffer's name starts with a space, undo should be
740 Fbuffer_enable_undo (buf
);
746 ptrdiff_t count
= SPECPDL_INDEX ();
747 /* We have to empty both overlay lists. Otherwise we end
748 up with overlays that think they belong to this buffer
749 while the buffer doesn't know about them any more. */
750 delete_all_overlays (XBUFFER (buf
));
751 reset_buffer (XBUFFER (buf
));
752 record_unwind_current_buffer ();
754 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
755 call0 (intern ("minibuffer-inactive-mode"));
757 Fkill_all_local_variables ();
758 buf
= unbind_to (count
, buf
);
765 run_exit_minibuf_hook (void)
767 safe_run_hooks (Qminibuffer_exit_hook
);
770 /* This function is called on exiting minibuffer, whether normally or
771 not, and it restores the current window, buffer, etc. */
774 read_minibuf_unwind (void)
776 Lisp_Object old_deactivate_mark
;
779 /* If this was a recursive minibuffer,
780 tie the minibuffer window back to the outer level minibuffer buffer. */
783 window
= minibuf_window
;
784 /* To keep things predictable, in case it matters, let's be in the
785 minibuffer when we reset the relevant variables. */
786 Fset_buffer (XWINDOW (window
)->contents
);
788 /* Restore prompt, etc, from outer minibuffer level. */
789 Lisp_Object key_vec
= Fcar (minibuf_save_list
);
790 eassert (VECTORP (key_vec
));
791 this_command_key_count
= XFASTINT (Flength (key_vec
));
792 this_command_keys
= key_vec
;
793 minibuf_save_list
= Fcdr (minibuf_save_list
);
794 minibuf_prompt
= Fcar (minibuf_save_list
);
795 minibuf_save_list
= Fcdr (minibuf_save_list
);
796 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
797 minibuf_save_list
= Fcdr (minibuf_save_list
);
798 Vhelp_form
= Fcar (minibuf_save_list
);
799 minibuf_save_list
= Fcdr (minibuf_save_list
);
800 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
801 minibuf_save_list
= Fcdr (minibuf_save_list
);
802 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
803 minibuf_save_list
= Fcdr (minibuf_save_list
);
804 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
805 minibuf_save_list
= Fcdr (minibuf_save_list
);
806 Voverriding_local_map
= Fcar (minibuf_save_list
);
807 minibuf_save_list
= Fcdr (minibuf_save_list
);
809 temp
= Fcar (minibuf_save_list
);
810 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
811 minibuf_window
= temp
;
813 minibuf_save_list
= Fcdr (minibuf_save_list
);
815 /* Erase the minibuffer we were using at this level. */
817 ptrdiff_t count
= SPECPDL_INDEX ();
818 /* Prevent error in erase-buffer. */
819 specbind (Qinhibit_read_only
, Qt
);
820 specbind (Qinhibit_modification_hooks
, Qt
);
821 old_deactivate_mark
= Vdeactivate_mark
;
823 Vdeactivate_mark
= old_deactivate_mark
;
824 unbind_to (count
, Qnil
);
827 /* When we get to the outmost level, make sure we resize the
828 mini-window back to its normal size. */
829 if (minibuf_level
== 0)
830 resize_mini_window (XWINDOW (window
), 0);
832 /* Deal with frames that should be removed when exiting the
835 Lisp_Object frames
, frame1
, val
;
838 FOR_EACH_FRAME (frames
, frame1
)
840 f1
= XFRAME (frame1
);
842 if ((FRAME_PARENT_FRAME (f1
)
843 || !NILP (get_frame_param (f1
, Qdelete_before
)))
844 && !NILP (val
= (get_frame_param (f1
, Qminibuffer_exit
))))
846 if (EQ (val
, Qiconify_frame
))
847 Ficonify_frame (frame1
);
848 else if (EQ (val
, Qdelete_frame
))
849 Fdelete_frame (frame1
, Qnil
);
851 Fmake_frame_invisible (frame1
, Qnil
);
856 /* In case the previous minibuffer displayed in this miniwindow is
857 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
858 to make sure we don't leave around bindings and stuff which only
859 made sense during the read_minibuf invocation. */
860 call0 (intern ("minibuffer-inactive-mode"));
864 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
865 Sread_from_minibuffer
, 1, 7, 0,
866 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
867 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
868 DEFAULT-VALUE. It normally should be nil in new code, except when
869 HIST is a cons. It is discussed in more detail below.
871 Third arg KEYMAP is a keymap to use whilst reading;
872 if omitted or nil, the default is `minibuffer-local-map'.
874 If fourth arg READ is non-nil, interpret the result as a Lisp object
875 and return that object:
876 in other words, do `(car (read-from-string INPUT-STRING))'
878 Fifth arg HIST, if non-nil, specifies a history list and optionally
879 the initial position in the list. It can be a symbol, which is the
880 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
881 In that case, HISTVAR is the history list variable to use, and
882 HISTPOS is the initial position for use by the minibuffer history
883 commands. For consistency, you should also specify that element of
884 the history as the value of INITIAL-CONTENTS. Positions are counted
885 starting from 1 at the beginning of the list.
887 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
888 as the default to `read' if READ is non-nil and the user enters
889 empty input. But if READ is nil, this function does _not_ return
890 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
892 Whatever the value of READ, DEFAULT-VALUE is made available via the
893 minibuffer history commands. DEFAULT-VALUE can also be a list of
894 strings, in which case all the strings are available in the history,
895 and the first string is the default to `read' if READ is non-nil.
897 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
898 the current input method and the setting of `enable-multibyte-characters'.
900 If the variable `minibuffer-allow-text-properties' is non-nil,
901 then the string which is returned includes whatever text properties
902 were present in the minibuffer. Otherwise the value has no text properties.
904 The remainder of this documentation string describes the
905 INITIAL-CONTENTS argument in more detail. It is only relevant when
906 studying existing code, or when HIST is a cons. If non-nil,
907 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
908 reading input. Normally, point is put at the end of that string.
909 However, if INITIAL-CONTENTS is (STRING . POSITION), the initial
910 input is STRING, but point is placed at _one-indexed_ position
911 POSITION in the minibuffer. Any integer value less than or equal to
912 one puts point at the beginning of the string. *Note* that this
913 behavior differs from the way such arguments are used in `completing-read'
914 and some related functions, which use zero-indexing for POSITION. */)
915 (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
)
917 Lisp_Object histvar
, histpos
, val
;
919 CHECK_STRING (prompt
);
921 keymap
= Vminibuffer_local_map
;
923 keymap
= get_keymap (keymap
, 1, 0);
932 histvar
= Fcar_safe (hist
);
933 histpos
= Fcdr_safe (hist
);
936 histvar
= Qminibuffer_history
;
938 XSETFASTINT (histpos
, 0);
940 val
= read_minibuf (keymap
, initial_contents
, prompt
,
942 histvar
, histpos
, default_value
,
943 minibuffer_allow_text_properties
,
944 !NILP (inherit_input_method
));
948 /* Functions that use the minibuffer to read various things. */
950 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
951 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
952 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
953 This argument has been superseded by DEFAULT-VALUE and should normally be nil
954 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
956 The third arg HISTORY, if non-nil, specifies a history list
957 and optionally the initial position in the list.
958 See `read-from-minibuffer' for details of HISTORY argument.
959 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
960 If non-nil, it is used for history commands, and as the value (or the first
961 element of the list of default values) to return if the user enters the
963 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
964 the current input method and the setting of `enable-multibyte-characters'. */)
965 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
968 ptrdiff_t count
= SPECPDL_INDEX ();
970 /* Just in case we're in a recursive minibuffer, make it clear that the
971 previous minibuffer's completion table does not apply to the new
973 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
974 specbind (Qminibuffer_completion_table
, Qnil
);
976 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
977 Qnil
, history
, default_value
,
978 inherit_input_method
);
979 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
980 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
981 return unbind_to (count
, val
);
984 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
985 doc
: /* Read a string from the terminal, not allowing blanks.
986 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
987 non-nil, it should be a string, which is used as initial input, with
988 point positioned at the end, so that SPACE will accept the input.
989 \(Actually, INITIAL can also be a cons of a string and an integer.
990 Such values are treated as in `read-from-minibuffer', but are normally
991 not useful in this function.)
992 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
993 the current input method and the setting of`enable-multibyte-characters'. */)
994 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
996 CHECK_STRING (prompt
);
997 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
998 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
999 !NILP (inherit_input_method
));
1002 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1003 doc
: /* Read the name of a command and return as a symbol.
1004 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1005 if it is a list. */)
1006 (Lisp_Object prompt
, Lisp_Object default_value
)
1008 Lisp_Object name
, default_string
;
1010 if (NILP (default_value
))
1011 default_string
= Qnil
;
1012 else if (SYMBOLP (default_value
))
1013 default_string
= SYMBOL_NAME (default_value
);
1015 default_string
= default_value
;
1017 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1018 Qnil
, Qnil
, default_string
, Qnil
);
1021 return Fintern (name
, Qnil
);
1025 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1026 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1027 Prompt with PROMPT. */)
1028 (Lisp_Object prompt
)
1030 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1035 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1036 doc
: /* Read the name of a user option and return it as a symbol.
1037 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1039 A user option, or customizable variable, is one for which
1040 `custom-variable-p' returns non-nil. */)
1041 (Lisp_Object prompt
, Lisp_Object default_value
)
1043 Lisp_Object name
, default_string
;
1045 if (NILP (default_value
))
1046 default_string
= Qnil
;
1047 else if (SYMBOLP (default_value
))
1048 default_string
= SYMBOL_NAME (default_value
);
1050 default_string
= default_value
;
1052 name
= Fcompleting_read (prompt
, Vobarray
,
1053 Qcustom_variable_p
, Qt
,
1054 Qnil
, Qcustom_variable_history
,
1055 default_string
, Qnil
);
1058 return Fintern (name
, Qnil
);
1061 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 4, 0,
1062 doc
: /* Read the name of a buffer and return as a string.
1064 Optional second arg DEF is value to return if user enters an empty line.
1065 If DEF is a list of default values, return its first element.
1066 Optional third arg REQUIRE-MATCH determines whether non-existing
1067 buffer names are allowed. It has the same meaning as the
1068 REQUIRE-MATCH argument of `completing-read'.
1069 The argument PROMPT should be a string ending with a colon and a space.
1070 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1071 case while reading the buffer name.
1072 If `read-buffer-function' is non-nil, this works by calling it as a
1073 function, instead of the usual behavior.
1074 Optional arg PREDICATE if non-nil is a function limiting the buffers that can
1076 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
,
1077 Lisp_Object predicate
)
1082 ptrdiff_t count
= SPECPDL_INDEX ();
1085 def
= BVAR (XBUFFER (def
), name
);
1087 specbind (Qcompletion_ignore_case
,
1088 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1090 if (NILP (Vread_buffer_function
))
1094 /* A default value was provided: we must change PROMPT,
1095 editing the default value in before the colon. To achieve
1096 this, we replace PROMPT with a substring that doesn't
1097 contain the terminal space and colon (if present). They
1098 are then added back using Fformat. */
1100 if (STRINGP (prompt
))
1102 s
= SSDATA (prompt
);
1103 len
= SBYTES (prompt
);
1104 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1106 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1109 prompt
= make_specified_string (s
, -1, len
,
1110 STRING_MULTIBYTE (prompt
));
1113 AUTO_STRING (format
, "%s (default %s): ");
1114 prompt
= CALLN (Fformat
, format
, prompt
,
1115 CONSP (def
) ? XCAR (def
) : def
);
1118 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1119 predicate
, require_match
, Qnil
,
1120 Qbuffer_name_history
, def
, Qnil
);
1123 result
= (NILP (predicate
)
1124 /* Partial backward compatibility for older read_buffer_functions
1125 which don't expect a `predicate' argument. */
1126 ? call3 (Vread_buffer_function
, prompt
, def
, require_match
)
1127 : call4 (Vread_buffer_function
, prompt
, def
, require_match
,
1129 return unbind_to (count
, result
);
1133 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1135 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1138 if (STRING_MULTIBYTE (string
))
1139 return Fstring_make_unibyte (string
);
1141 return Fstring_make_multibyte (string
);
1144 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1145 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1146 Test each possible completion specified by COLLECTION
1147 to see if it begins with STRING. The possible completions may be
1148 strings or symbols. Symbols are converted to strings before testing,
1150 All that match STRING are compared together; the longest initial sequence
1151 common to all these matches is the return value.
1152 If there is no match at all, the return value is nil.
1153 For a unique match which is exact, the return value is t.
1155 If COLLECTION is an alist, the keys (cars of elements) are the
1156 possible completions. If an element is not a cons cell, then the
1157 element itself is the possible completion.
1158 If COLLECTION is a hash-table, all the keys that are strings or symbols
1159 are the possible completions.
1160 If COLLECTION is an obarray, the names of all symbols in the obarray
1161 are the possible completions.
1163 COLLECTION can also be a function to do the completion itself.
1164 It receives three arguments: the values STRING, PREDICATE and nil.
1165 Whatever it returns becomes the value of `try-completion'.
1167 If optional third argument PREDICATE is non-nil,
1168 it is used to test each possible match.
1169 The match is a candidate only if PREDICATE returns non-nil.
1170 The argument given to PREDICATE is the alist element
1171 or the symbol from the obarray. If COLLECTION is a hash-table,
1172 predicate is called with two arguments: the key and the value.
1173 Additionally to this predicate, `completion-regexp-list'
1174 is used to further constrain the set of candidates. */)
1175 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1177 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1178 /* Size in bytes of BESTMATCH. */
1179 ptrdiff_t bestmatchsize
= 0;
1180 /* These are in bytes, too. */
1181 ptrdiff_t compare
, matchsize
;
1182 enum { function_table
, list_table
, obarray_table
, hash_table
}
1183 type
= (HASH_TABLE_P (collection
) ? hash_table
1184 : VECTORP (collection
) ? obarray_table
1185 : ((NILP (collection
)
1186 || (CONSP (collection
) && !FUNCTIONP (collection
)))
1187 ? list_table
: function_table
));
1188 ptrdiff_t idx
= 0, obsize
= 0;
1190 ptrdiff_t bindcount
= -1;
1191 Lisp_Object bucket
, zero
, end
, tem
;
1193 CHECK_STRING (string
);
1194 if (type
== function_table
)
1195 return call3 (collection
, string
, predicate
, Qnil
);
1197 bestmatch
= bucket
= Qnil
;
1198 zero
= make_number (0);
1200 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1202 if (type
== obarray_table
)
1204 collection
= check_obarray (collection
);
1205 obsize
= ASIZE (collection
);
1206 bucket
= AREF (collection
, idx
);
1211 /* Get the next element of the alist, obarray, or hash-table. */
1212 /* Exit the loop if the elements are all used up. */
1213 /* elt gets the alist element or symbol.
1214 eltstring gets the name to check as a completion. */
1216 if (type
== list_table
)
1221 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1224 else if (type
== obarray_table
)
1226 if (!EQ (bucket
, zero
))
1228 if (!SYMBOLP (bucket
))
1229 error ("Bad data in guts of obarray");
1232 if (XSYMBOL (bucket
)->u
.s
.next
)
1233 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->u
.s
.next
);
1235 XSETFASTINT (bucket
, 0);
1237 else if (++idx
>= obsize
)
1241 bucket
= AREF (collection
, idx
);
1245 else /* if (type == hash_table) */
1247 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1248 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1250 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1253 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1256 /* Is this element a possible completion? */
1258 if (SYMBOLP (eltstring
))
1259 eltstring
= Fsymbol_name (eltstring
);
1261 if (STRINGP (eltstring
)
1262 && SCHARS (string
) <= SCHARS (eltstring
)
1263 && (tem
= Fcompare_strings (eltstring
, zero
,
1264 make_number (SCHARS (string
)),
1266 completion_ignore_case
? Qt
: Qnil
),
1270 Lisp_Object regexps
;
1272 /* Ignore this element if it fails to match all the regexps. */
1274 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1275 regexps
= XCDR (regexps
))
1279 bindcount
= SPECPDL_INDEX ();
1280 specbind (Qcase_fold_search
,
1281 completion_ignore_case
? Qt
: Qnil
);
1283 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1287 if (CONSP (regexps
))
1291 /* Ignore this element if there is a predicate
1292 and the predicate doesn't like it. */
1294 if (!NILP (predicate
))
1296 if (EQ (predicate
, Qcommandp
))
1297 tem
= Fcommandp (elt
, Qnil
);
1302 unbind_to (bindcount
, Qnil
);
1305 tem
= (type
== hash_table
1306 ? call2 (predicate
, elt
,
1307 HASH_VALUE (XHASH_TABLE (collection
),
1309 : call1 (predicate
, elt
));
1311 if (NILP (tem
)) continue;
1314 /* Update computation of how much all possible completions match */
1316 if (NILP (bestmatch
))
1319 bestmatch
= eltstring
;
1320 bestmatchsize
= SCHARS (eltstring
);
1324 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1325 tem
= Fcompare_strings (bestmatch
, zero
,
1326 make_number (compare
),
1328 make_number (compare
),
1329 completion_ignore_case
? Qt
: Qnil
);
1330 matchsize
= EQ (tem
, Qt
) ? compare
: eabs (XINT (tem
)) - 1;
1332 if (completion_ignore_case
)
1334 /* If this is an exact match except for case,
1335 use it as the best match rather than one that is not an
1336 exact match. This way, we get the case pattern
1337 of the actual match. */
1338 if ((matchsize
== SCHARS (eltstring
)
1339 && matchsize
< SCHARS (bestmatch
))
1341 /* If there is more than one exact match ignoring case,
1342 and one of them is exact including case,
1344 /* If there is no exact match ignoring case,
1345 prefer a match that does not change the case
1347 ((matchsize
== SCHARS (eltstring
))
1349 (matchsize
== SCHARS (bestmatch
))
1350 && (tem
= Fcompare_strings (eltstring
, zero
,
1351 make_number (SCHARS (string
)),
1356 && (tem
= Fcompare_strings (bestmatch
, zero
,
1357 make_number (SCHARS (string
)),
1362 bestmatch
= eltstring
;
1364 if (bestmatchsize
!= SCHARS (eltstring
)
1365 || bestmatchsize
!= matchsize
)
1366 /* Don't count the same string multiple times. */
1367 matchcount
+= matchcount
<= 1;
1368 bestmatchsize
= matchsize
;
1369 if (matchsize
<= SCHARS (string
)
1370 /* If completion-ignore-case is non-nil, don't
1371 short-circuit because we want to find the best
1372 possible match *including* case differences. */
1373 && !completion_ignore_case
1375 /* No need to look any further. */
1382 unbind_to (bindcount
, Qnil
);
1384 if (NILP (bestmatch
))
1385 return Qnil
; /* No completions found. */
1386 /* If we are ignoring case, and there is no exact match,
1387 and no additional text was supplied,
1388 don't change the case of what the user typed. */
1389 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1390 && SCHARS (bestmatch
) > bestmatchsize
)
1391 return minibuf_conform_representation (string
, bestmatch
);
1393 /* Return t if the supplied string is an exact match (counting case);
1394 it does not require any change to be made. */
1395 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1398 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1399 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1400 return Fsubstring (bestmatch
, zero
, end
);
1403 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1404 doc
: /* Search for partial matches to STRING in COLLECTION.
1405 Test each of the possible completions specified by COLLECTION
1406 to see if it begins with STRING. The possible completions may be
1407 strings or symbols. Symbols are converted to strings before testing,
1409 The value is a list of all the possible completions that match STRING.
1411 If COLLECTION is an alist, the keys (cars of elements) are the
1412 possible completions. If an element is not a cons cell, then the
1413 element itself is the possible completion.
1414 If COLLECTION is a hash-table, all the keys that are strings or symbols
1415 are the possible completions.
1416 If COLLECTION is an obarray, the names of all symbols in the obarray
1417 are the possible completions.
1419 COLLECTION can also be a function to do the completion itself.
1420 It receives three arguments: the values STRING, PREDICATE and t.
1421 Whatever it returns becomes the value of `all-completions'.
1423 If optional third argument PREDICATE is non-nil,
1424 it is used to test each possible match.
1425 The match is a candidate only if PREDICATE returns non-nil.
1426 The argument given to PREDICATE is the alist element
1427 or the symbol from the obarray. If COLLECTION is a hash-table,
1428 predicate is called with two arguments: the key and the value.
1429 Additionally to this predicate, `completion-regexp-list'
1430 is used to further constrain the set of candidates.
1432 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1433 backward compatibility. If non-nil, strings in COLLECTION that start
1434 with a space are ignored unless STRING itself starts with a space. */)
1435 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1437 Lisp_Object tail
, elt
, eltstring
;
1438 Lisp_Object allmatches
;
1439 int type
= HASH_TABLE_P (collection
) ? 3
1440 : VECTORP (collection
) ? 2
1441 : NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
));
1442 ptrdiff_t idx
= 0, obsize
= 0;
1443 ptrdiff_t bindcount
= -1;
1444 Lisp_Object bucket
, tem
, zero
;
1446 CHECK_STRING (string
);
1448 return call3 (collection
, string
, predicate
, Qt
);
1449 allmatches
= bucket
= Qnil
;
1450 zero
= make_number (0);
1452 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1456 collection
= check_obarray (collection
);
1457 obsize
= ASIZE (collection
);
1458 bucket
= AREF (collection
, idx
);
1463 /* Get the next element of the alist, obarray, or hash-table. */
1464 /* Exit the loop if the elements are all used up. */
1465 /* elt gets the alist element or symbol.
1466 eltstring gets the name to check as a completion. */
1473 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1478 if (!EQ (bucket
, zero
))
1480 if (!SYMBOLP (bucket
))
1481 error ("Bad data in guts of obarray");
1484 if (XSYMBOL (bucket
)->u
.s
.next
)
1485 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->u
.s
.next
);
1487 XSETFASTINT (bucket
, 0);
1489 else if (++idx
>= obsize
)
1493 bucket
= AREF (collection
, idx
);
1497 else /* if (type == 3) */
1499 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1500 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1502 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1505 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1508 /* Is this element a possible completion? */
1510 if (SYMBOLP (eltstring
))
1511 eltstring
= Fsymbol_name (eltstring
);
1513 if (STRINGP (eltstring
)
1514 && SCHARS (string
) <= SCHARS (eltstring
)
1515 /* If HIDE_SPACES, reject alternatives that start with space
1516 unless the input starts with space. */
1517 && (NILP (hide_spaces
)
1518 || (SBYTES (string
) > 0
1519 && SREF (string
, 0) == ' ')
1520 || SREF (eltstring
, 0) != ' ')
1521 && (tem
= Fcompare_strings (eltstring
, zero
,
1522 make_number (SCHARS (string
)),
1524 make_number (SCHARS (string
)),
1525 completion_ignore_case
? Qt
: Qnil
),
1529 Lisp_Object regexps
;
1531 /* Ignore this element if it fails to match all the regexps. */
1533 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1534 regexps
= XCDR (regexps
))
1538 bindcount
= SPECPDL_INDEX ();
1539 specbind (Qcase_fold_search
,
1540 completion_ignore_case
? Qt
: Qnil
);
1542 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1546 if (CONSP (regexps
))
1550 /* Ignore this element if there is a predicate
1551 and the predicate doesn't like it. */
1553 if (!NILP (predicate
))
1555 if (EQ (predicate
, Qcommandp
))
1556 tem
= Fcommandp (elt
, Qnil
);
1561 unbind_to (bindcount
, Qnil
);
1565 ? call2 (predicate
, elt
,
1566 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1567 : call1 (predicate
, elt
);
1569 if (NILP (tem
)) continue;
1571 /* Ok => put it on the list. */
1572 allmatches
= Fcons (eltstring
, allmatches
);
1577 unbind_to (bindcount
, Qnil
);
1579 return Fnreverse (allmatches
);
1582 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1583 doc
: /* Read a string in the minibuffer, with completion.
1584 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1585 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1586 COLLECTION can also be a function to do the completion itself.
1587 PREDICATE limits completion to a subset of COLLECTION.
1588 See `try-completion', `all-completions', `test-completion',
1589 and `completion-boundaries', for more details on completion,
1590 COLLECTION, and PREDICATE. See also Info node `(elisp)Basic Completion'
1591 for the details about completion, and Info node `(elisp)Programmed
1592 Completion' for expectations from COLLECTION when it's a function.
1594 REQUIRE-MATCH can take the following values:
1595 - t means that the user is not allowed to exit unless the input is (or
1596 completes to) an element of COLLECTION or is null.
1597 - nil means that the user can exit with any input.
1598 - `confirm' means that the user can exit with any input, but she needs
1599 to confirm her choice if the input is not an element of COLLECTION.
1600 - `confirm-after-completion' means that the user can exit with any
1601 input, but she needs to confirm her choice if she called
1602 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1603 and the input is not an element of COLLECTION.
1604 - anything else behaves like t except that typing RET does not exit if it
1605 does non-null completion.
1607 If the input is null, `completing-read' returns DEF, or the first
1608 element of the list of default values, or an empty string if DEF is
1609 nil, regardless of the value of REQUIRE-MATCH.
1611 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1612 with point positioned at the end. If it is (STRING . POSITION), the
1613 initial input is STRING, but point is placed at _zero-indexed_
1614 position POSITION in STRING. (*Note* that this is different from
1615 `read-from-minibuffer' and related functions, which use one-indexing
1616 for POSITION.) This feature is deprecated--it is best to pass nil
1617 for INITIAL-INPUT and supply the default value DEF instead. The
1618 user can yank the default value into the minibuffer easily using
1619 \\<minibuffer-local-map>\\[next-history-element].
1621 HIST, if non-nil, specifies a history list and optionally the initial
1622 position in the list. It can be a symbol, which is the history list
1623 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1624 that case, HISTVAR is the history list variable to use, and HISTPOS
1625 is the initial position (the position in the list used by the
1626 minibuffer history commands). For consistency, you should also
1627 specify that element of the history as the value of INITIAL-INPUT.
1628 (This is the only case in which you should use INITIAL-INPUT instead
1629 of DEF.) Positions are counted starting from 1 at the beginning of
1630 the list. The variable `history-length' controls the maximum length
1633 DEF, if non-nil, is the default value or the list of default values.
1635 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits the
1636 current input method and the setting of `enable-multibyte-characters'.
1638 Completion ignores case if the ambient value of
1639 `completion-ignore-case' is non-nil.
1641 See also `completing-read-function'. */)
1642 (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
)
1644 return CALLN (Ffuncall
,
1645 Fsymbol_value (intern ("completing-read-function")),
1646 prompt
, collection
, predicate
, require_match
, initial_input
,
1647 hist
, def
, inherit_input_method
);
1650 /* Test whether TXT is an exact completion. */
1651 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1652 doc
: /* Return non-nil if STRING is a valid completion.
1653 Takes the same arguments as `all-completions' and `try-completion'.
1654 If COLLECTION is a function, it is called with three arguments:
1655 the values STRING, PREDICATE and `lambda'. */)
1656 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1658 Lisp_Object regexps
, tail
, tem
= Qnil
;
1661 CHECK_STRING (string
);
1663 if (NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
)))
1665 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1669 else if (VECTORP (collection
))
1671 /* Bypass intern-soft as that loses for nil. */
1672 tem
= oblookup (collection
,
1678 if (STRING_MULTIBYTE (string
))
1679 string
= Fstring_make_unibyte (string
);
1681 string
= Fstring_make_multibyte (string
);
1683 tem
= oblookup (collection
,
1689 if (completion_ignore_case
&& !SYMBOLP (tem
))
1691 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1693 tail
= AREF (collection
, i
);
1697 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1698 Fsymbol_name (tail
),
1699 make_number (0) , Qnil
, Qt
),
1705 if (XSYMBOL (tail
)->u
.s
.next
== 0)
1707 XSETSYMBOL (tail
, XSYMBOL (tail
)->u
.s
.next
);
1715 else if (HASH_TABLE_P (collection
))
1717 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1718 i
= hash_lookup (h
, string
, NULL
);
1721 tem
= HASH_KEY (h
, i
);
1722 goto found_matching_key
;
1725 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1727 if (NILP (HASH_HASH (h
, i
))) continue;
1728 tem
= HASH_KEY (h
, i
);
1729 Lisp_Object strkey
= (SYMBOLP (tem
) ? Fsymbol_name (tem
) : tem
);
1730 if (!STRINGP (strkey
)) continue;
1731 if (EQ (Fcompare_strings (string
, Qnil
, Qnil
,
1733 completion_ignore_case
? Qt
: Qnil
),
1735 goto found_matching_key
;
1738 found_matching_key
: ;
1741 return call3 (collection
, string
, predicate
, Qlambda
);
1743 /* Reject this element if it fails to match all the regexps. */
1744 if (CONSP (Vcompletion_regexp_list
))
1746 ptrdiff_t count
= SPECPDL_INDEX ();
1747 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1748 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1749 regexps
= XCDR (regexps
))
1751 /* We can test against STRING, because if we got here, then
1752 the element is equivalent to it. */
1753 if (NILP (Fstring_match (XCAR (regexps
), string
, Qnil
)))
1754 return unbind_to (count
, Qnil
);
1756 unbind_to (count
, Qnil
);
1759 /* Finally, check the predicate. */
1760 if (!NILP (predicate
))
1762 return HASH_TABLE_P (collection
)
1763 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1764 : call1 (predicate
, tem
);
1770 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1771 doc
: /* Perform completion on buffer names.
1772 STRING and PREDICATE have the same meanings as in `try-completion',
1773 `all-completions', and `test-completion'.
1775 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1776 `all-completions'; otherwise invoke `test-completion'. */)
1777 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1780 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1781 else if (EQ (flag
, Qt
))
1783 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1784 if (SCHARS (string
) > 0)
1787 { /* Strip out internal buffers. */
1788 Lisp_Object bufs
= res
;
1789 /* First, look for a non-internal buffer in `res'. */
1790 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1793 return (EQ (Flength (res
), Flength (Vbuffer_alist
))
1794 /* If all bufs are internal don't strip them out. */
1797 while (CONSP (XCDR (bufs
)))
1798 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1799 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1805 else if (EQ (flag
, Qlambda
))
1806 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1807 else if (EQ (flag
, Qmetadata
))
1808 return list2 (Qmetadata
, Fcons (Qcategory
, Qbuffer
));
1813 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1815 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1816 doc
: /* Like `assoc' but specifically for strings (and symbols).
1818 This returns the first element of LIST whose car matches the string or
1819 symbol KEY, or nil if no match exists. When performing the
1820 comparison, symbols are first converted to strings, and unibyte
1821 strings to multibyte. If the optional arg CASE-FOLD is non-nil, both
1822 KEY and the elements of LIST are upcased for comparison.
1824 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1825 single string, rather than a cons cell whose car is a string. */)
1826 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1828 register Lisp_Object tail
;
1831 key
= Fsymbol_name (key
);
1833 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1835 register Lisp_Object elt
, tem
, thiscar
;
1837 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1838 if (SYMBOLP (thiscar
))
1839 thiscar
= Fsymbol_name (thiscar
);
1840 else if (!STRINGP (thiscar
))
1842 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1843 key
, make_number (0), Qnil
,
1853 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1854 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1857 return make_number (minibuf_level
);
1860 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1861 doc
: /* Return the prompt string of the currently-active minibuffer.
1862 If no minibuffer is active, return nil. */)
1865 return Fcopy_sequence (minibuf_prompt
);
1870 init_minibuf_once (void)
1872 Vminibuffer_list
= Qnil
;
1873 staticpro (&Vminibuffer_list
);
1877 syms_of_minibuf (void)
1880 minibuf_prompt
= Qnil
;
1881 staticpro (&minibuf_prompt
);
1883 minibuf_save_list
= Qnil
;
1884 staticpro (&minibuf_save_list
);
1886 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1887 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1888 Fset (Qminibuffer_default
, Qnil
);
1890 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1892 staticpro (&last_minibuf_string
);
1893 last_minibuf_string
= Qnil
;
1895 DEFSYM (Qcustom_variable_history
, "custom-variable-history");
1896 Fset (Qcustom_variable_history
, Qnil
);
1898 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1899 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1900 Fset (Qbuffer_name_history
, Qnil
);
1902 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1904 /* Normal hooks for entry to and exit from minibuffer. */
1905 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1906 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1908 /* The maximum length of a minibuffer history. */
1909 DEFSYM (Qhistory_length
, "history-length");
1911 DEFSYM (Qcurrent_input_method
, "current-input-method");
1912 DEFSYM (Qactivate_input_method
, "activate-input-method");
1913 DEFSYM (Qcase_fold_search
, "case-fold-search");
1914 DEFSYM (Qmetadata
, "metadata");
1915 /* A frame parameter. */
1916 DEFSYM (Qminibuffer_exit
, "minibuffer-exit");
1918 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1919 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1920 For example, `eval-expression' uses this. */);
1921 Vread_expression_history
= Qnil
;
1923 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1924 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1925 The function is called with the arguments passed to `read-buffer'. */);
1926 Vread_buffer_function
= Qnil
;
1928 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1929 read_buffer_completion_ignore_case
,
1930 doc
: /* Non-nil means completion ignores case when reading a buffer name. */);
1931 read_buffer_completion_ignore_case
= 0;
1933 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1934 doc
: /* Normal hook run just after entry to minibuffer. */);
1935 Vminibuffer_setup_hook
= Qnil
;
1937 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1938 doc
: /* Normal hook run just after exit from minibuffer. */);
1939 Vminibuffer_exit_hook
= Qnil
;
1941 DEFVAR_LISP ("history-length", Vhistory_length
,
1942 doc
: /* Maximum length of history lists before truncation takes place.
1943 A number means truncate to that length; truncation deletes old
1944 elements, and is done just after inserting a new element.
1945 A value of t means no truncation.
1947 This variable only affects history lists that don't specify their own
1948 maximum lengths. Setting the `history-length' property of a history
1949 variable overrides this default. */);
1950 XSETFASTINT (Vhistory_length
, 100);
1952 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
1953 doc
: /* Non-nil means to delete duplicates in history.
1954 If set to t when adding a new history element, all previous identical
1955 elements are deleted from the history list. */);
1956 history_delete_duplicates
= 0;
1958 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
1959 doc
: /* Non-nil means to add new elements in history.
1960 If set to nil, minibuffer reading functions don't add new elements to the
1961 history list, so it is possible to do this afterwards by calling
1962 `add-to-history' explicitly. */);
1963 Vhistory_add_new_input
= Qt
;
1965 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
1966 doc
: /* Non-nil means don't consider case significant in completion.
1967 For file-name completion, `read-file-name-completion-ignore-case'
1968 controls the behavior, rather than this variable.
1969 For buffer name completion, `read-buffer-completion-ignore-case'
1970 controls the behavior, rather than this variable. */);
1971 completion_ignore_case
= 0;
1973 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
1974 doc
: /* Non-nil means to allow minibuffer commands while in the minibuffer.
1975 This variable makes a difference whenever the minibuffer window is active.
1976 Also see `minibuffer-depth-indicate-mode', which may be handy if this
1977 variable is non-nil. */);
1978 enable_recursive_minibuffers
= 0;
1980 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
1981 doc
: /* Alist or obarray used for completion in the minibuffer.
1982 This becomes the ALIST argument to `try-completion' and `all-completions'.
1983 The value can also be a list of strings or a hash table.
1985 The value may alternatively be a function, which is given three arguments:
1986 STRING, the current buffer contents;
1987 PREDICATE, the predicate for filtering possible matches;
1988 CODE, which says what kind of things to do.
1989 CODE can be nil, t or `lambda':
1990 nil -- return the best completion of STRING, or nil if there is none.
1991 t -- return a list of all possible completions of STRING.
1992 lambda -- return t if STRING is a valid completion as it stands. */);
1993 Vminibuffer_completion_table
= Qnil
;
1995 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
1996 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
1997 Vminibuffer_completion_predicate
= Qnil
;
1999 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2000 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2001 If nil, confirmation is not required.
2002 If the value is `confirm', the user may exit with an input that is not
2003 a valid completion alternative, but Emacs asks for confirmation.
2004 If the value is `confirm-after-completion', the user may exit with an
2005 input that is not a valid completion alternative, but Emacs asks for
2006 confirmation if the user submitted the input right after any of the
2007 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2008 Vminibuffer_completion_confirm
= Qnil
;
2010 DEFVAR_LISP ("minibuffer-completing-file-name",
2011 Vminibuffer_completing_file_name
,
2012 doc
: /* Non-nil means completing file names. */);
2013 Vminibuffer_completing_file_name
= Qnil
;
2015 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2016 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2017 Vminibuffer_help_form
= Qnil
;
2019 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2020 doc
: /* History list symbol to add minibuffer values to.
2021 Each string of minibuffer input, as it appears on exit from the minibuffer,
2023 (set minibuffer-history-variable
2024 (cons STRING (symbol-value minibuffer-history-variable))) */);
2025 XSETFASTINT (Vminibuffer_history_variable
, 0);
2027 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2028 doc
: /* Current position of redoing in the history list. */);
2029 Vminibuffer_history_position
= Qnil
;
2031 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2032 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2033 Some uses of the echo area also raise that frame (since they use it too). */);
2034 minibuffer_auto_raise
= 0;
2036 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2037 doc
: /* List of regexps that should restrict possible completions.
2038 The basic completion functions only consider a completion acceptable
2039 if it matches all regular expressions in this list, with
2040 `case-fold-search' bound to the value of `completion-ignore-case'.
2041 See Info node `(elisp)Basic Completion', for a description of these
2043 Vcompletion_regexp_list
= Qnil
;
2045 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2046 minibuffer_allow_text_properties
,
2047 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2048 This also affects `read-string', but it does not affect `read-minibuffer',
2049 `read-no-blanks-input', or any of the functions that do minibuffer input
2050 with completion; they always discard text properties. */);
2051 minibuffer_allow_text_properties
= 0;
2053 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2054 doc
: /* Text properties that are added to minibuffer prompts.
2055 These are in addition to the basic `field' property, and stickiness
2057 Vminibuffer_prompt_properties
= list2 (Qread_only
, Qt
);
2059 DEFVAR_LISP ("read-hide-char", Vread_hide_char
,
2060 doc
: /* Whether to hide input characters in noninteractive mode.
2061 It must be a character, which will be used to mask the input
2062 characters. This variable should never be set globally. */);
2063 Vread_hide_char
= Qnil
;
2065 defsubr (&Sactive_minibuffer_window
);
2066 defsubr (&Sset_minibuffer_window
);
2067 defsubr (&Sread_from_minibuffer
);
2068 defsubr (&Sread_string
);
2069 defsubr (&Sread_command
);
2070 defsubr (&Sread_variable
);
2071 defsubr (&Sinternal_complete_buffer
);
2072 defsubr (&Sread_buffer
);
2073 defsubr (&Sread_no_blanks_input
);
2074 defsubr (&Sminibuffer_depth
);
2075 defsubr (&Sminibuffer_prompt
);
2077 defsubr (&Sminibufferp
);
2078 defsubr (&Sminibuffer_prompt_end
);
2079 defsubr (&Sminibuffer_contents
);
2080 defsubr (&Sminibuffer_contents_no_properties
);
2082 defsubr (&Stry_completion
);
2083 defsubr (&Sall_completions
);
2084 defsubr (&Stest_completion
);
2085 defsubr (&Sassoc_string
);
2086 defsubr (&Scompleting_read
);