1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2019 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);
328 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
329 Sminibuffer_completion_contents
, 0, 0, 0,
330 doc
: /* Return the user input in a minibuffer before point as a string.
331 That is what completion commands operate on.
332 If the current buffer is not a minibuffer, return its entire contents. */)
335 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
337 error ("Cannot do completion in the prompt");
338 return make_buffer_string (prompt_end
, PT
, 1);
342 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
343 putting point minus BACKUP_N bytes from the end of INITIAL,
344 prompting with PROMPT (a string), using history list HISTVAR
345 with initial position HISTPOS. INITIAL should be a string or a
346 cons of a string and an integer. BACKUP_N should be <= 0, or
347 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
348 ignored and replaced with an integer that puts point at one-indexed
349 position N in INITIAL, where N is the CDR of INITIAL, or at the
350 beginning of INITIAL if N <= 0.
352 Normally return the result as a string (the text that was read),
353 but if EXPFLAG, read it and return the object read.
354 If HISTVAR is given, save the value read on that history only if it doesn't
355 match the front of that history list exactly. The value is pushed onto
356 the list as the string that was read.
358 DEFALT specifies the default value for the sake of history commands.
360 If ALLOW_PROPS, do not throw away text properties.
362 if INHERIT_INPUT_METHOD, the minibuffer inherits the
363 current input method. */
366 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
368 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
369 bool allow_props
, bool inherit_input_method
)
372 ptrdiff_t count
= SPECPDL_INDEX ();
373 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
374 Lisp_Object enable_multibyte
;
376 /* String to add to the history. */
377 Lisp_Object histstring
;
380 Lisp_Object empty_minibuf
;
381 Lisp_Object dummy
, frame
;
383 specbind (Qminibuffer_default
, defalt
);
384 specbind (Qinhibit_read_only
, Qnil
);
386 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
387 in previous recursive minibuffer, but was not set explicitly
388 to t for this invocation, so set it to nil in this minibuffer.
389 Save the old value now, before we change it. */
390 specbind (intern ("minibuffer-completing-file-name"),
391 Vminibuffer_completing_file_name
);
392 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
393 Vminibuffer_completing_file_name
= Qnil
;
395 #ifdef HAVE_WINDOW_SYSTEM
396 if (display_hourglass_p
)
404 Lisp_Object backup_n
= XCDR (initial
);
405 initial
= XCAR (initial
);
406 CHECK_STRING (initial
);
407 if (!NILP (backup_n
))
409 CHECK_NUMBER (backup_n
);
410 /* Convert to distance from end of input. */
411 if (XINT (backup_n
) < 1)
412 /* A number too small means the beginning of the string. */
413 pos
= - SCHARS (initial
);
415 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
419 CHECK_STRING (initial
);
422 ambient_dir
= BVAR (current_buffer
, directory
);
424 enable_multibyte
= Qnil
;
426 if (!STRINGP (prompt
))
427 prompt
= empty_unibyte_string
;
429 if (!enable_recursive_minibuffers
430 && minibuf_level
> 0)
432 if (EQ (selected_window
, minibuf_window
))
433 error ("Command attempted to use minibuffer while in minibuffer");
435 /* If we're in another window, cancel the minibuffer that's active. */
437 build_string ("Command attempted to use minibuffer while in minibuffer"));
441 /* In case we are running as a daemon, only do this before
442 detaching from the terminal. */
443 || (IS_DAEMON
&& DAEMON_RUNNING
))
444 && NILP (Vexecuting_kbd_macro
))
446 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
448 expflag
, histvar
, histpos
, defalt
,
449 allow_props
, inherit_input_method
);
450 return unbind_to (count
, val
);
453 /* Choose the minibuffer window and frame, and take action on them. */
455 /* Prepare for restoring the current buffer since choose_minibuf_frame
456 calling Fset_frame_selected_window may change it (Bug#12766). */
457 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
459 choose_minibuf_frame ();
461 record_unwind_protect_void (choose_minibuf_frame
);
463 record_unwind_protect (restore_window_configuration
,
464 Fcurrent_window_configuration (Qnil
));
466 /* If the minibuffer window is on a different frame, save that
467 frame's configuration too. */
468 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
469 if (!EQ (mini_frame
, selected_frame
))
470 record_unwind_protect (restore_window_configuration
,
471 Fcurrent_window_configuration (mini_frame
));
473 /* If the minibuffer is on an iconified or invisible frame,
474 make it visible now. */
475 Fmake_frame_visible (mini_frame
);
477 if (minibuffer_auto_raise
)
478 Fraise_frame (mini_frame
);
480 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
482 /* We have to do this after saving the window configuration
483 since that is what restores the current buffer. */
485 /* Arrange to restore a number of minibuffer-related variables.
486 We could bind each variable separately, but that would use lots of
489 = Fcons (Voverriding_local_map
,
490 Fcons (minibuf_window
,
493 = Fcons (minibuf_prompt
,
494 Fcons (make_number (minibuf_prompt_width
),
496 Fcons (Vcurrent_prefix_arg
,
497 Fcons (Vminibuffer_history_position
,
498 Fcons (Vminibuffer_history_variable
,
499 minibuf_save_list
))))));
501 = Fcons (Fthis_command_keys_vector (), minibuf_save_list
);
503 record_unwind_protect_void (read_minibuf_unwind
);
505 /* We are exiting the minibuffer one way or the other, so run the hook.
506 It should be run before unwinding the minibuf settings. Do it
507 separately from read_minibuf_unwind because we need to make sure that
508 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
509 signals an error. --Stef */
510 record_unwind_protect_void (run_exit_minibuf_hook
);
512 /* Now that we can restore all those variables, start changing them. */
514 minibuf_prompt_width
= 0;
515 minibuf_prompt
= Fcopy_sequence (prompt
);
516 Vminibuffer_history_position
= histpos
;
517 Vminibuffer_history_variable
= histvar
;
518 Vhelp_form
= Vminibuffer_help_form
;
519 /* If this minibuffer is reading a file name, that doesn't mean
520 recursive ones are. But we cannot set it to nil, because
521 completion code still need to know the minibuffer is completing a
522 file name. So use `lambda' as intermediate value meaning
523 "t" in this minibuffer, but "nil" in next minibuffer. */
524 if (!NILP (Vminibuffer_completing_file_name
))
525 Vminibuffer_completing_file_name
= Qlambda
;
527 /* If variable is unbound, make it nil. */
528 histval
= find_symbol_value (Vminibuffer_history_variable
);
529 if (EQ (histval
, Qunbound
))
531 Fset (Vminibuffer_history_variable
, Qnil
);
535 if (inherit_input_method
)
537 /* `current-input-method' is buffer local. So, remember it in
538 INPUT_METHOD before changing the current buffer. */
539 input_method
= Fsymbol_value (Qcurrent_input_method
);
540 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
543 /* Switch to the minibuffer. */
545 minibuffer
= get_minibuffer (minibuf_level
);
546 Fset_buffer (minibuffer
);
548 /* Defeat (setq-default truncate-lines t), since truncated lines do
549 not work correctly in minibuffers. (Bug#5715, etc) */
550 bset_truncate_lines (current_buffer
, Qnil
);
552 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
553 if (inherit_input_method
)
554 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
556 /* The current buffer's default directory is usually the right thing
557 for our minibuffer here. However, if you're typing a command at
558 a minibuffer-only frame when minibuf_level is zero, then buf IS
559 the current_buffer, so reset_buffer leaves buf's default
560 directory unchanged. This is a bummer when you've just started
561 up Emacs and buf's default directory is Qnil. Here's a hack; can
562 you think of something better to do? Find another buffer with a
563 better directory, and use that one instead. */
564 if (STRINGP (ambient_dir
))
565 bset_directory (current_buffer
, ambient_dir
);
568 Lisp_Object tail
, buf
;
570 FOR_EACH_LIVE_BUFFER (tail
, buf
)
571 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
573 bset_directory (current_buffer
,
574 BVAR (XBUFFER (buf
), directory
));
579 if (!EQ (mini_frame
, selected_frame
))
580 Fredirect_frame_focus (selected_frame
, mini_frame
);
582 Vminibuf_scroll_window
= selected_window
;
583 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
584 minibuf_selected_window
= selected_window
;
586 /* Empty out the minibuffers of all frames other than the one
587 where we are going to display one now.
588 Set them to point to ` *Minibuf-0*', which is always empty. */
589 empty_minibuf
= get_minibuffer (0);
591 FOR_EACH_FRAME (dummy
, frame
)
593 Lisp_Object root_window
= Fframe_root_window (frame
);
594 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
596 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
597 && !NILP (Fwindow_minibuffer_p (mini_window
)))
598 /* Use set_window_buffer instead of Fset_window_buffer (see
599 discussion of bug#11984, bug#12025, bug#12026). */
600 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
603 /* Display this minibuffer in the proper window. */
604 /* Use set_window_buffer instead of Fset_window_buffer (see
605 discussion of bug#11984, bug#12025, bug#12026). */
606 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
607 Fselect_window (minibuf_window
, Qnil
);
608 XWINDOW (minibuf_window
)->hscroll
= 0;
609 XWINDOW (minibuf_window
)->suspend_auto_hscroll
= 0;
611 Fmake_local_variable (Qprint_escape_newlines
);
612 print_escape_newlines
= 1;
614 /* Erase the buffer. */
616 ptrdiff_t count1
= SPECPDL_INDEX ();
617 specbind (Qinhibit_read_only
, Qt
);
618 specbind (Qinhibit_modification_hooks
, Qt
);
621 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
622 && ! STRING_MULTIBYTE (minibuf_prompt
))
623 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
625 /* Insert the prompt, record where it ends. */
626 Finsert (1, &minibuf_prompt
);
629 Fput_text_property (make_number (BEG
), make_number (PT
),
630 Qfront_sticky
, Qt
, Qnil
);
631 Fput_text_property (make_number (BEG
), make_number (PT
),
632 Qrear_nonsticky
, Qt
, Qnil
);
633 Fput_text_property (make_number (BEG
), make_number (PT
),
635 if (CONSP (Vminibuffer_prompt_properties
))
637 /* We want to apply all properties from
638 `minibuffer-prompt-properties' to the region normally,
639 but if the `face' property is present, add that
640 property to the end of the face properties to avoid
641 overwriting faces. */
642 Lisp_Object list
= Vminibuffer_prompt_properties
;
645 Lisp_Object key
= XCAR (list
);
649 Lisp_Object val
= XCAR (list
);
652 Fadd_face_text_property (make_number (BEG
),
653 make_number (PT
), val
, Qt
, Qnil
);
655 Fput_text_property (make_number (BEG
), make_number (PT
),
661 unbind_to (count1
, Qnil
);
664 minibuf_prompt_width
= current_column ();
666 /* Put in the initial input. */
669 Finsert (1, &initial
);
670 Fforward_char (make_number (pos
));
673 clear_message (1, 1);
674 bset_keymap (current_buffer
, map
);
676 /* Turn on an input method stored in INPUT_METHOD if any. */
677 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
678 call1 (Qactivate_input_method
, input_method
);
680 run_hook (Qminibuffer_setup_hook
);
682 /* Don't allow the user to undo past this point. */
683 bset_undo_list (current_buffer
, Qnil
);
687 /* If cursor is on the minibuffer line,
688 show the user we have exited by putting it in column 0. */
689 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
692 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
693 XWINDOW (minibuf_window
)->cursor
.x
= 0;
694 XWINDOW (minibuf_window
)->must_be_updated_p
= true;
695 update_frame (XFRAME (selected_frame
), true, true);
696 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
699 /* Make minibuffer contents into a string. */
700 Fset_buffer (minibuffer
);
702 val
= Fminibuffer_contents ();
704 val
= Fminibuffer_contents_no_properties ();
706 /* VAL is the string of minibuffer text. */
708 last_minibuf_string
= val
;
710 /* Choose the string to add to the history. */
711 if (SCHARS (val
) != 0)
713 else if (STRINGP (defalt
))
715 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
716 histstring
= XCAR (defalt
);
720 /* Add the value to the appropriate history list, if any. */
721 if (!NILP (Vhistory_add_new_input
)
722 && SYMBOLP (Vminibuffer_history_variable
)
723 && !NILP (histstring
))
725 /* If the caller wanted to save the value read on a history list,
726 then do so if the value is not already the front of the list. */
728 /* The value of the history variable must be a cons or nil. Other
729 values are unacceptable. We silently ignore these values. */
733 /* Don't duplicate the most recent entry in the history. */
734 && (NILP (Fequal (histstring
, Fcar (histval
))))))
738 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
739 histval
= Fcons (histstring
, histval
);
740 Fset (Vminibuffer_history_variable
, histval
);
742 /* Truncate if requested. */
743 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
744 if (NILP (length
)) length
= Vhistory_length
;
745 if (INTEGERP (length
))
747 if (XINT (length
) <= 0)
748 Fset (Vminibuffer_history_variable
, Qnil
);
753 temp
= Fnthcdr (Fsub1 (length
), histval
);
754 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
760 /* If Lisp form desired instead of string, parse it. */
762 val
= string_to_object (val
, defalt
);
764 /* The appropriate frame will get selected
765 in set-window-configuration. */
766 return unbind_to (count
, val
);
769 /* Return a buffer to be used as the minibuffer at depth `depth'.
770 depth = 0 is the lowest allowed argument, and that is the value
771 used for nonrecursive minibuffer invocations. */
774 get_minibuffer (EMACS_INT depth
)
776 Lisp_Object tail
= Fnthcdr (make_number (depth
), Vminibuffer_list
);
780 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
782 Lisp_Object buf
= Fcar (tail
);
783 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
785 static char const name_fmt
[] = " *Minibuf-%"pI
"d*";
786 char name
[sizeof name_fmt
+ INT_STRLEN_BOUND (EMACS_INT
)];
787 AUTO_STRING_WITH_LEN (lname
, name
, sprintf (name
, name_fmt
, depth
));
788 buf
= Fget_buffer_create (lname
);
790 /* Although the buffer's name starts with a space, undo should be
792 Fbuffer_enable_undo (buf
);
798 ptrdiff_t count
= SPECPDL_INDEX ();
799 /* We have to empty both overlay lists. Otherwise we end
800 up with overlays that think they belong to this buffer
801 while the buffer doesn't know about them any more. */
802 delete_all_overlays (XBUFFER (buf
));
803 reset_buffer (XBUFFER (buf
));
804 record_unwind_current_buffer ();
806 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
807 call0 (intern ("minibuffer-inactive-mode"));
809 Fkill_all_local_variables ();
810 unbind_to (count
, Qnil
);
817 run_exit_minibuf_hook (void)
819 safe_run_hooks (Qminibuffer_exit_hook
);
822 /* This function is called on exiting minibuffer, whether normally or
823 not, and it restores the current window, buffer, etc. */
826 read_minibuf_unwind (void)
828 Lisp_Object old_deactivate_mark
;
831 /* If this was a recursive minibuffer,
832 tie the minibuffer window back to the outer level minibuffer buffer. */
835 window
= minibuf_window
;
836 /* To keep things predictable, in case it matters, let's be in the
837 minibuffer when we reset the relevant variables. */
838 Fset_buffer (XWINDOW (window
)->contents
);
840 /* Restore prompt, etc, from outer minibuffer level. */
841 Lisp_Object key_vec
= Fcar (minibuf_save_list
);
842 eassert (VECTORP (key_vec
));
843 this_command_key_count
= XFASTINT (Flength (key_vec
));
844 this_command_keys
= key_vec
;
845 minibuf_save_list
= Fcdr (minibuf_save_list
);
846 minibuf_prompt
= Fcar (minibuf_save_list
);
847 minibuf_save_list
= Fcdr (minibuf_save_list
);
848 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
849 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 Vhelp_form
= Fcar (minibuf_save_list
);
851 minibuf_save_list
= Fcdr (minibuf_save_list
);
852 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
853 minibuf_save_list
= Fcdr (minibuf_save_list
);
854 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
855 minibuf_save_list
= Fcdr (minibuf_save_list
);
856 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
857 minibuf_save_list
= Fcdr (minibuf_save_list
);
858 Voverriding_local_map
= Fcar (minibuf_save_list
);
859 minibuf_save_list
= Fcdr (minibuf_save_list
);
861 temp
= Fcar (minibuf_save_list
);
862 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
863 minibuf_window
= temp
;
865 minibuf_save_list
= Fcdr (minibuf_save_list
);
867 /* Erase the minibuffer we were using at this level. */
869 ptrdiff_t count
= SPECPDL_INDEX ();
870 /* Prevent error in erase-buffer. */
871 specbind (Qinhibit_read_only
, Qt
);
872 specbind (Qinhibit_modification_hooks
, Qt
);
873 old_deactivate_mark
= Vdeactivate_mark
;
875 Vdeactivate_mark
= old_deactivate_mark
;
876 unbind_to (count
, Qnil
);
879 /* When we get to the outmost level, make sure we resize the
880 mini-window back to its normal size. */
881 if (minibuf_level
== 0)
882 resize_mini_window (XWINDOW (window
), 0);
884 /* Deal with frames that should be removed when exiting the
887 Lisp_Object frames
, frame1
, val
;
890 FOR_EACH_FRAME (frames
, frame1
)
892 f1
= XFRAME (frame1
);
894 if ((FRAME_PARENT_FRAME (f1
)
895 || !NILP (get_frame_param (f1
, Qdelete_before
)))
896 && !NILP (val
= (get_frame_param (f1
, Qminibuffer_exit
))))
898 if (EQ (val
, Qiconify_frame
))
899 Ficonify_frame (frame1
);
900 else if (EQ (val
, Qdelete_frame
))
901 Fdelete_frame (frame1
, Qnil
);
903 Fmake_frame_invisible (frame1
, Qnil
);
908 /* In case the previous minibuffer displayed in this miniwindow is
909 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
910 to make sure we don't leave around bindings and stuff which only
911 made sense during the read_minibuf invocation. */
912 call0 (intern ("minibuffer-inactive-mode"));
916 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
917 Sread_from_minibuffer
, 1, 7, 0,
918 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
919 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
920 DEFAULT-VALUE. It normally should be nil in new code, except when
921 HIST is a cons. It is discussed in more detail below.
923 Third arg KEYMAP is a keymap to use whilst reading;
924 if omitted or nil, the default is `minibuffer-local-map'.
926 If fourth arg READ is non-nil, interpret the result as a Lisp object
927 and return that object:
928 in other words, do `(car (read-from-string INPUT-STRING))'
930 Fifth arg HIST, if non-nil, specifies a history list and optionally
931 the initial position in the list. It can be a symbol, which is the
932 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
933 In that case, HISTVAR is the history list variable to use, and
934 HISTPOS is the initial position for use by the minibuffer history
935 commands. For consistency, you should also specify that element of
936 the history as the value of INITIAL-CONTENTS. Positions are counted
937 starting from 1 at the beginning of the list.
939 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
940 as the default to `read' if READ is non-nil and the user enters
941 empty input. But if READ is nil, this function does _not_ return
942 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
944 Whatever the value of READ, DEFAULT-VALUE is made available via the
945 minibuffer history commands. DEFAULT-VALUE can also be a list of
946 strings, in which case all the strings are available in the history,
947 and the first string is the default to `read' if READ is non-nil.
949 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
950 the current input method and the setting of `enable-multibyte-characters'.
952 If the variable `minibuffer-allow-text-properties' is non-nil,
953 then the string which is returned includes whatever text properties
954 were present in the minibuffer. Otherwise the value has no text properties.
956 The remainder of this documentation string describes the
957 INITIAL-CONTENTS argument in more detail. It is only relevant when
958 studying existing code, or when HIST is a cons. If non-nil,
959 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
960 reading input. Normally, point is put at the end of that string.
961 However, if INITIAL-CONTENTS is (STRING . POSITION), the initial
962 input is STRING, but point is placed at _one-indexed_ position
963 POSITION in the minibuffer. Any integer value less than or equal to
964 one puts point at the beginning of the string. *Note* that this
965 behavior differs from the way such arguments are used in `completing-read'
966 and some related functions, which use zero-indexing for POSITION. */)
967 (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
)
969 Lisp_Object histvar
, histpos
, val
;
971 CHECK_STRING (prompt
);
973 keymap
= Vminibuffer_local_map
;
975 keymap
= get_keymap (keymap
, 1, 0);
984 histvar
= Fcar_safe (hist
);
985 histpos
= Fcdr_safe (hist
);
988 histvar
= Qminibuffer_history
;
990 XSETFASTINT (histpos
, 0);
992 val
= read_minibuf (keymap
, initial_contents
, prompt
,
994 histvar
, histpos
, default_value
,
995 minibuffer_allow_text_properties
,
996 !NILP (inherit_input_method
));
1000 /* Functions that use the minibuffer to read various things. */
1002 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1003 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1004 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1005 This argument has been superseded by DEFAULT-VALUE and should normally be nil
1006 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
1008 The third arg HISTORY, if non-nil, specifies a history list
1009 and optionally the initial position in the list.
1010 See `read-from-minibuffer' for details of HISTORY argument.
1011 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1012 If non-nil, it is used for history commands, and as the value (or the first
1013 element of the list of default values) to return if the user enters the
1015 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1016 the current input method and the setting of `enable-multibyte-characters'. */)
1017 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1020 ptrdiff_t count
= SPECPDL_INDEX ();
1022 /* Just in case we're in a recursive minibuffer, make it clear that the
1023 previous minibuffer's completion table does not apply to the new
1025 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
1026 specbind (Qminibuffer_completion_table
, Qnil
);
1028 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1029 Qnil
, history
, default_value
,
1030 inherit_input_method
);
1031 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1032 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1033 return unbind_to (count
, val
);
1036 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1037 doc
: /* Read a string from the terminal, not allowing blanks.
1038 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1039 non-nil, it should be a string, which is used as initial input, with
1040 point positioned at the end, so that SPACE will accept the input.
1041 \(Actually, INITIAL can also be a cons of a string and an integer.
1042 Such values are treated as in `read-from-minibuffer', but are normally
1043 not useful in this function.)
1044 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1045 the current input method and the setting of`enable-multibyte-characters'. */)
1046 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1048 CHECK_STRING (prompt
);
1049 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
1050 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1051 !NILP (inherit_input_method
));
1054 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1055 doc
: /* Read the name of a command and return as a symbol.
1056 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1057 if it is a list. */)
1058 (Lisp_Object prompt
, Lisp_Object default_value
)
1060 Lisp_Object name
, default_string
;
1062 if (NILP (default_value
))
1063 default_string
= Qnil
;
1064 else if (SYMBOLP (default_value
))
1065 default_string
= SYMBOL_NAME (default_value
);
1067 default_string
= default_value
;
1069 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1070 Qnil
, Qnil
, default_string
, Qnil
);
1073 return Fintern (name
, Qnil
);
1077 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1078 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1079 Prompt with PROMPT. */)
1080 (Lisp_Object prompt
)
1082 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1087 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1088 doc
: /* Read the name of a user option and return it as a symbol.
1089 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1091 A user option, or customizable variable, is one for which
1092 `custom-variable-p' returns non-nil. */)
1093 (Lisp_Object prompt
, Lisp_Object default_value
)
1095 Lisp_Object name
, default_string
;
1097 if (NILP (default_value
))
1098 default_string
= Qnil
;
1099 else if (SYMBOLP (default_value
))
1100 default_string
= SYMBOL_NAME (default_value
);
1102 default_string
= default_value
;
1104 name
= Fcompleting_read (prompt
, Vobarray
,
1105 Qcustom_variable_p
, Qt
,
1106 Qnil
, Qnil
, default_string
, Qnil
);
1109 return Fintern (name
, Qnil
);
1112 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 4, 0,
1113 doc
: /* Read the name of a buffer and return it as a string.
1114 Prompt with PROMPT, which should be a string ending with a colon and a space.
1115 Provides completion on buffer names the user types.
1116 Optional second arg DEF is value to return if user enters an empty line,
1117 instead of that empty string.
1118 If DEF is a list of default values, return its first element.
1119 Optional third arg REQUIRE-MATCH has the same meaning as the
1120 REQUIRE-MATCH argument of `completing-read'.
1121 Optional arg PREDICATE, if non-nil, is a function limiting the buffers that
1122 can be considered. It will be called with each potential candidate, and
1123 should return non-nil to accept the candidate for completion, nil otherwise.
1124 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1125 case while reading the buffer name.
1126 If `read-buffer-function' is non-nil, this works by calling it as a
1127 function, instead of the usual behavior. */)
1128 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
,
1129 Lisp_Object predicate
)
1134 ptrdiff_t count
= SPECPDL_INDEX ();
1137 def
= BVAR (XBUFFER (def
), name
);
1139 specbind (Qcompletion_ignore_case
,
1140 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1142 if (NILP (Vread_buffer_function
))
1146 /* A default value was provided: we must change PROMPT,
1147 editing the default value in before the colon. To achieve
1148 this, we replace PROMPT with a substring that doesn't
1149 contain the terminal space and colon (if present). They
1150 are then added back using Fformat. */
1152 if (STRINGP (prompt
))
1154 s
= SSDATA (prompt
);
1155 len
= SBYTES (prompt
);
1156 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1158 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1161 prompt
= make_specified_string (s
, -1, len
,
1162 STRING_MULTIBYTE (prompt
));
1165 AUTO_STRING (format
, "%s (default %s): ");
1166 prompt
= CALLN (Fformat
, format
, prompt
,
1167 CONSP (def
) ? XCAR (def
) : def
);
1170 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1171 predicate
, require_match
, Qnil
,
1172 Qbuffer_name_history
, def
, Qnil
);
1175 result
= (NILP (predicate
)
1176 /* Partial backward compatibility for older read_buffer_functions
1177 which don't expect a `predicate' argument. */
1178 ? call3 (Vread_buffer_function
, prompt
, def
, require_match
)
1179 : call4 (Vread_buffer_function
, prompt
, def
, require_match
,
1181 return unbind_to (count
, result
);
1185 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1187 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1190 if (STRING_MULTIBYTE (string
))
1191 return Fstring_make_unibyte (string
);
1193 return Fstring_make_multibyte (string
);
1196 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1197 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1198 Test each possible completion specified by COLLECTION
1199 to see if it begins with STRING. The possible completions may be
1200 strings or symbols. Symbols are converted to strings before testing,
1202 All that match STRING are compared together; the longest initial sequence
1203 common to all these matches is the return value.
1204 If there is no match at all, the return value is nil.
1205 For a unique match which is exact, the return value is t.
1207 If COLLECTION is an alist, the keys (cars of elements) are the
1208 possible completions. If an element is not a cons cell, then the
1209 element itself is the possible completion.
1210 If COLLECTION is a hash-table, all the keys that are strings or symbols
1211 are the possible completions.
1212 If COLLECTION is an obarray, the names of all symbols in the obarray
1213 are the possible completions.
1215 COLLECTION can also be a function to do the completion itself.
1216 It receives three arguments: the values STRING, PREDICATE and nil.
1217 Whatever it returns becomes the value of `try-completion'.
1219 If optional third argument PREDICATE is non-nil,
1220 it is used to test each possible match.
1221 The match is a candidate only if PREDICATE returns non-nil.
1222 The argument given to PREDICATE is the alist element
1223 or the symbol from the obarray. If COLLECTION is a hash-table,
1224 predicate is called with two arguments: the key and the value.
1225 Additionally to this predicate, `completion-regexp-list'
1226 is used to further constrain the set of candidates. */)
1227 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1229 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1230 /* Size in bytes of BESTMATCH. */
1231 ptrdiff_t bestmatchsize
= 0;
1232 /* These are in bytes, too. */
1233 ptrdiff_t compare
, matchsize
;
1234 enum { function_table
, list_table
, obarray_table
, hash_table
}
1235 type
= (HASH_TABLE_P (collection
) ? hash_table
1236 : VECTORP (collection
) ? obarray_table
1237 : ((NILP (collection
)
1238 || (CONSP (collection
) && !FUNCTIONP (collection
)))
1239 ? list_table
: function_table
));
1240 ptrdiff_t idx
= 0, obsize
= 0;
1242 ptrdiff_t bindcount
= -1;
1243 Lisp_Object bucket
, zero
, end
, tem
;
1245 CHECK_STRING (string
);
1246 if (type
== function_table
)
1247 return call3 (collection
, string
, predicate
, Qnil
);
1249 bestmatch
= bucket
= Qnil
;
1250 zero
= make_number (0);
1252 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1254 if (type
== obarray_table
)
1256 collection
= check_obarray (collection
);
1257 obsize
= ASIZE (collection
);
1258 bucket
= AREF (collection
, idx
);
1263 /* Get the next element of the alist, obarray, or hash-table. */
1264 /* Exit the loop if the elements are all used up. */
1265 /* elt gets the alist element or symbol.
1266 eltstring gets the name to check as a completion. */
1268 if (type
== list_table
)
1273 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1276 else if (type
== obarray_table
)
1278 if (!EQ (bucket
, zero
))
1280 if (!SYMBOLP (bucket
))
1281 error ("Bad data in guts of obarray");
1284 if (XSYMBOL (bucket
)->u
.s
.next
)
1285 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->u
.s
.next
);
1287 XSETFASTINT (bucket
, 0);
1289 else if (++idx
>= obsize
)
1293 bucket
= AREF (collection
, idx
);
1297 else /* if (type == hash_table) */
1299 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1300 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1302 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1305 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1308 /* Is this element a possible completion? */
1310 if (SYMBOLP (eltstring
))
1311 eltstring
= Fsymbol_name (eltstring
);
1313 if (STRINGP (eltstring
)
1314 && SCHARS (string
) <= SCHARS (eltstring
)
1315 && (tem
= Fcompare_strings (eltstring
, zero
,
1316 make_number (SCHARS (string
)),
1318 completion_ignore_case
? Qt
: Qnil
),
1322 Lisp_Object regexps
;
1324 /* Ignore this element if it fails to match all the regexps. */
1326 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1327 regexps
= XCDR (regexps
))
1329 if (bindcount
< 0) {
1330 bindcount
= SPECPDL_INDEX ();
1331 specbind (Qcase_fold_search
,
1332 completion_ignore_case
? Qt
: Qnil
);
1334 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1338 if (CONSP (regexps
))
1342 /* Ignore this element if there is a predicate
1343 and the predicate doesn't like it. */
1345 if (!NILP (predicate
))
1347 if (EQ (predicate
, Qcommandp
))
1348 tem
= Fcommandp (elt
, Qnil
);
1353 unbind_to (bindcount
, Qnil
);
1356 tem
= (type
== hash_table
1357 ? call2 (predicate
, elt
,
1358 HASH_VALUE (XHASH_TABLE (collection
),
1360 : call1 (predicate
, elt
));
1362 if (NILP (tem
)) continue;
1365 /* Update computation of how much all possible completions match */
1367 if (NILP (bestmatch
))
1370 bestmatch
= eltstring
;
1371 bestmatchsize
= SCHARS (eltstring
);
1375 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1376 tem
= Fcompare_strings (bestmatch
, zero
,
1377 make_number (compare
),
1379 make_number (compare
),
1380 completion_ignore_case
? Qt
: Qnil
);
1381 matchsize
= EQ (tem
, Qt
) ? compare
: eabs (XINT (tem
)) - 1;
1383 if (completion_ignore_case
)
1385 /* If this is an exact match except for case,
1386 use it as the best match rather than one that is not an
1387 exact match. This way, we get the case pattern
1388 of the actual match. */
1389 if ((matchsize
== SCHARS (eltstring
)
1390 && matchsize
< SCHARS (bestmatch
))
1392 /* If there is more than one exact match ignoring case,
1393 and one of them is exact including case,
1395 /* If there is no exact match ignoring case,
1396 prefer a match that does not change the case
1398 ((matchsize
== SCHARS (eltstring
))
1400 (matchsize
== SCHARS (bestmatch
))
1401 && (tem
= Fcompare_strings (eltstring
, zero
,
1402 make_number (SCHARS (string
)),
1407 && (tem
= Fcompare_strings (bestmatch
, zero
,
1408 make_number (SCHARS (string
)),
1413 bestmatch
= eltstring
;
1415 if (bestmatchsize
!= SCHARS (eltstring
)
1416 || bestmatchsize
!= matchsize
)
1417 /* Don't count the same string multiple times. */
1418 matchcount
+= matchcount
<= 1;
1419 bestmatchsize
= matchsize
;
1420 if (matchsize
<= SCHARS (string
)
1421 /* If completion-ignore-case is non-nil, don't
1422 short-circuit because we want to find the best
1423 possible match *including* case differences. */
1424 && !completion_ignore_case
1426 /* No need to look any further. */
1432 if (bindcount
>= 0) {
1433 unbind_to (bindcount
, Qnil
);
1437 if (NILP (bestmatch
))
1438 return Qnil
; /* No completions found. */
1439 /* If we are ignoring case, and there is no exact match,
1440 and no additional text was supplied,
1441 don't change the case of what the user typed. */
1442 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1443 && SCHARS (bestmatch
) > bestmatchsize
)
1444 return minibuf_conform_representation (string
, bestmatch
);
1446 /* Return t if the supplied string is an exact match (counting case);
1447 it does not require any change to be made. */
1448 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1451 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1452 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1453 return Fsubstring (bestmatch
, zero
, end
);
1456 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1457 doc
: /* Search for partial matches to STRING in COLLECTION.
1458 Test each of the possible completions specified by COLLECTION
1459 to see if it begins with STRING. The possible completions may be
1460 strings or symbols. Symbols are converted to strings before testing,
1462 The value is a list of all the possible completions that match STRING.
1464 If COLLECTION is an alist, the keys (cars of elements) are the
1465 possible completions. If an element is not a cons cell, then the
1466 element itself is the possible completion.
1467 If COLLECTION is a hash-table, all the keys that are strings or symbols
1468 are the possible completions.
1469 If COLLECTION is an obarray, the names of all symbols in the obarray
1470 are the possible completions.
1472 COLLECTION can also be a function to do the completion itself.
1473 It receives three arguments: the values STRING, PREDICATE and t.
1474 Whatever it returns becomes the value of `all-completions'.
1476 If optional third argument PREDICATE is non-nil,
1477 it is used to test each possible match.
1478 The match is a candidate only if PREDICATE returns non-nil.
1479 The argument given to PREDICATE is the alist element
1480 or the symbol from the obarray. If COLLECTION is a hash-table,
1481 predicate is called with two arguments: the key and the value.
1482 Additionally to this predicate, `completion-regexp-list'
1483 is used to further constrain the set of candidates.
1485 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1486 backward compatibility. If non-nil, strings in COLLECTION that start
1487 with a space are ignored unless STRING itself starts with a space. */)
1488 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1490 Lisp_Object tail
, elt
, eltstring
;
1491 Lisp_Object allmatches
;
1492 int type
= HASH_TABLE_P (collection
) ? 3
1493 : VECTORP (collection
) ? 2
1494 : NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
));
1495 ptrdiff_t idx
= 0, obsize
= 0;
1496 ptrdiff_t bindcount
= -1;
1497 Lisp_Object bucket
, tem
, zero
;
1499 CHECK_STRING (string
);
1501 return call3 (collection
, string
, predicate
, Qt
);
1502 allmatches
= bucket
= Qnil
;
1503 zero
= make_number (0);
1505 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1509 collection
= check_obarray (collection
);
1510 obsize
= ASIZE (collection
);
1511 bucket
= AREF (collection
, idx
);
1516 /* Get the next element of the alist, obarray, or hash-table. */
1517 /* Exit the loop if the elements are all used up. */
1518 /* elt gets the alist element or symbol.
1519 eltstring gets the name to check as a completion. */
1526 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1531 if (!EQ (bucket
, zero
))
1533 if (!SYMBOLP (bucket
))
1534 error ("Bad data in guts of obarray");
1537 if (XSYMBOL (bucket
)->u
.s
.next
)
1538 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->u
.s
.next
);
1540 XSETFASTINT (bucket
, 0);
1542 else if (++idx
>= obsize
)
1546 bucket
= AREF (collection
, idx
);
1550 else /* if (type == 3) */
1552 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1553 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1555 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1558 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1561 /* Is this element a possible completion? */
1563 if (SYMBOLP (eltstring
))
1564 eltstring
= Fsymbol_name (eltstring
);
1566 if (STRINGP (eltstring
)
1567 && SCHARS (string
) <= SCHARS (eltstring
)
1568 /* If HIDE_SPACES, reject alternatives that start with space
1569 unless the input starts with space. */
1570 && (NILP (hide_spaces
)
1571 || (SBYTES (string
) > 0
1572 && SREF (string
, 0) == ' ')
1573 || SREF (eltstring
, 0) != ' ')
1574 && (tem
= Fcompare_strings (eltstring
, zero
,
1575 make_number (SCHARS (string
)),
1577 make_number (SCHARS (string
)),
1578 completion_ignore_case
? Qt
: Qnil
),
1582 Lisp_Object regexps
;
1584 /* Ignore this element if it fails to match all the regexps. */
1586 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1587 regexps
= XCDR (regexps
))
1589 if (bindcount
< 0) {
1590 bindcount
= SPECPDL_INDEX ();
1591 specbind (Qcase_fold_search
,
1592 completion_ignore_case
? Qt
: Qnil
);
1594 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1598 if (CONSP (regexps
))
1602 /* Ignore this element if there is a predicate
1603 and the predicate doesn't like it. */
1605 if (!NILP (predicate
))
1607 if (EQ (predicate
, Qcommandp
))
1608 tem
= Fcommandp (elt
, Qnil
);
1611 if (bindcount
>= 0) {
1612 unbind_to (bindcount
, Qnil
);
1616 ? call2 (predicate
, elt
,
1617 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1618 : call1 (predicate
, elt
);
1620 if (NILP (tem
)) continue;
1622 /* Ok => put it on the list. */
1623 allmatches
= Fcons (eltstring
, allmatches
);
1627 if (bindcount
>= 0) {
1628 unbind_to (bindcount
, Qnil
);
1632 return Fnreverse (allmatches
);
1635 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1636 doc
: /* Read a string in the minibuffer, with completion.
1637 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1638 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1639 COLLECTION can also be a function to do the completion itself.
1640 PREDICATE limits completion to a subset of COLLECTION.
1641 See `try-completion', `all-completions', `test-completion',
1642 and `completion-boundaries', for more details on completion,
1643 COLLECTION, and PREDICATE. See also Info node `(elisp)Basic Completion'
1644 for the details about completion, and Info node `(elisp)Programmed
1645 Completion' for expectations from COLLECTION when it's a function.
1647 REQUIRE-MATCH can take the following values:
1648 - t means that the user is not allowed to exit unless the input is (or
1649 completes to) an element of COLLECTION or is null.
1650 - nil means that the user can exit with any input.
1651 - `confirm' means that the user can exit with any input, but she needs
1652 to confirm her choice if the input is not an element of COLLECTION.
1653 - `confirm-after-completion' means that the user can exit with any
1654 input, but she needs to confirm her choice if she called
1655 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1656 and the input is not an element of COLLECTION.
1657 - anything else behaves like t except that typing RET does not exit if it
1658 does non-null completion.
1660 If the input is null, `completing-read' returns DEF, or the first
1661 element of the list of default values, or an empty string if DEF is
1662 nil, regardless of the value of REQUIRE-MATCH.
1664 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1665 with point positioned at the end. If it is (STRING . POSITION), the
1666 initial input is STRING, but point is placed at _zero-indexed_
1667 position POSITION in STRING. (*Note* that this is different from
1668 `read-from-minibuffer' and related functions, which use one-indexing
1669 for POSITION.) This feature is deprecated--it is best to pass nil
1670 for INITIAL-INPUT and supply the default value DEF instead. The
1671 user can yank the default value into the minibuffer easily using
1672 \\<minibuffer-local-map>\\[next-history-element].
1674 HIST, if non-nil, specifies a history list and optionally the initial
1675 position in the list. It can be a symbol, which is the history list
1676 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1677 that case, HISTVAR is the history list variable to use, and HISTPOS
1678 is the initial position (the position in the list used by the
1679 minibuffer history commands). For consistency, you should also
1680 specify that element of the history as the value of INITIAL-INPUT.
1681 (This is the only case in which you should use INITIAL-INPUT instead
1682 of DEF.) Positions are counted starting from 1 at the beginning of
1683 the list. The variable `history-length' controls the maximum length
1686 DEF, if non-nil, is the default value or the list of default values.
1688 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits the
1689 current input method and the setting of `enable-multibyte-characters'.
1691 Completion ignores case if the ambient value of
1692 `completion-ignore-case' is non-nil.
1694 See also `completing-read-function'. */)
1695 (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
)
1697 return CALLN (Ffuncall
,
1698 Fsymbol_value (intern ("completing-read-function")),
1699 prompt
, collection
, predicate
, require_match
, initial_input
,
1700 hist
, def
, inherit_input_method
);
1703 /* Test whether TXT is an exact completion. */
1704 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1705 doc
: /* Return non-nil if STRING is a valid completion.
1706 Takes the same arguments as `all-completions' and `try-completion'.
1707 If COLLECTION is a function, it is called with three arguments:
1708 the values STRING, PREDICATE and `lambda'. */)
1709 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1711 Lisp_Object regexps
, tail
, tem
= Qnil
;
1714 CHECK_STRING (string
);
1716 if (NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
)))
1718 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1722 else if (VECTORP (collection
))
1724 /* Bypass intern-soft as that loses for nil. */
1725 tem
= oblookup (collection
,
1731 if (STRING_MULTIBYTE (string
))
1732 string
= Fstring_make_unibyte (string
);
1734 string
= Fstring_make_multibyte (string
);
1736 tem
= oblookup (collection
,
1742 if (completion_ignore_case
&& !SYMBOLP (tem
))
1744 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1746 tail
= AREF (collection
, i
);
1750 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1751 Fsymbol_name (tail
),
1752 make_number (0) , Qnil
, Qt
),
1758 if (XSYMBOL (tail
)->u
.s
.next
== 0)
1760 XSETSYMBOL (tail
, XSYMBOL (tail
)->u
.s
.next
);
1768 else if (HASH_TABLE_P (collection
))
1770 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1771 i
= hash_lookup (h
, string
, NULL
);
1774 tem
= HASH_KEY (h
, i
);
1775 goto found_matching_key
;
1778 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1780 if (NILP (HASH_HASH (h
, i
))) continue;
1781 tem
= HASH_KEY (h
, i
);
1782 Lisp_Object strkey
= (SYMBOLP (tem
) ? Fsymbol_name (tem
) : tem
);
1783 if (!STRINGP (strkey
)) continue;
1784 if (EQ (Fcompare_strings (string
, Qnil
, Qnil
,
1786 completion_ignore_case
? Qt
: Qnil
),
1788 goto found_matching_key
;
1791 found_matching_key
: ;
1794 return call3 (collection
, string
, predicate
, Qlambda
);
1796 /* Reject this element if it fails to match all the regexps. */
1797 if (CONSP (Vcompletion_regexp_list
))
1799 ptrdiff_t count
= SPECPDL_INDEX ();
1800 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1801 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1802 regexps
= XCDR (regexps
))
1804 /* We can test against STRING, because if we got here, then
1805 the element is equivalent to it. */
1806 if (NILP (Fstring_match (XCAR (regexps
), string
, Qnil
)))
1807 return unbind_to (count
, Qnil
);
1809 unbind_to (count
, Qnil
);
1812 /* Finally, check the predicate. */
1813 if (!NILP (predicate
))
1815 return HASH_TABLE_P (collection
)
1816 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1817 : call1 (predicate
, tem
);
1823 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1824 doc
: /* Perform completion on buffer names.
1825 STRING and PREDICATE have the same meanings as in `try-completion',
1826 `all-completions', and `test-completion'.
1828 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1829 `all-completions'; otherwise invoke `test-completion'. */)
1830 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1833 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1834 else if (EQ (flag
, Qt
))
1836 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1837 if (SCHARS (string
) > 0)
1840 { /* Strip out internal buffers. */
1841 Lisp_Object bufs
= res
;
1842 /* First, look for a non-internal buffer in `res'. */
1843 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1846 return (EQ (Flength (res
), Flength (Vbuffer_alist
))
1847 /* If all bufs are internal don't strip them out. */
1850 while (CONSP (XCDR (bufs
)))
1851 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1852 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1858 else if (EQ (flag
, Qlambda
))
1859 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1860 else if (EQ (flag
, Qmetadata
))
1861 return list2 (Qmetadata
, Fcons (Qcategory
, Qbuffer
));
1866 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1868 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1869 doc
: /* Like `assoc' but specifically for strings (and symbols).
1871 This returns the first element of LIST whose car matches the string or
1872 symbol KEY, or nil if no match exists. When performing the
1873 comparison, symbols are first converted to strings, and unibyte
1874 strings to multibyte. If the optional arg CASE-FOLD is non-nil, both
1875 KEY and the elements of LIST are upcased for comparison.
1877 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1878 single string, rather than a cons cell whose car is a string. */)
1879 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1881 register Lisp_Object tail
;
1884 key
= Fsymbol_name (key
);
1886 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1888 register Lisp_Object elt
, tem
, thiscar
;
1890 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1891 if (SYMBOLP (thiscar
))
1892 thiscar
= Fsymbol_name (thiscar
);
1893 else if (!STRINGP (thiscar
))
1895 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1896 key
, make_number (0), Qnil
,
1906 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1907 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1910 return make_number (minibuf_level
);
1913 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1914 doc
: /* Return the prompt string of the currently-active minibuffer.
1915 If no minibuffer is active, return nil. */)
1918 return Fcopy_sequence (minibuf_prompt
);
1923 init_minibuf_once (void)
1925 Vminibuffer_list
= Qnil
;
1926 staticpro (&Vminibuffer_list
);
1930 syms_of_minibuf (void)
1933 minibuf_prompt
= Qnil
;
1934 staticpro (&minibuf_prompt
);
1936 minibuf_save_list
= Qnil
;
1937 staticpro (&minibuf_save_list
);
1939 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1940 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1941 Fset (Qminibuffer_default
, Qnil
);
1943 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1945 staticpro (&last_minibuf_string
);
1946 last_minibuf_string
= Qnil
;
1948 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1949 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1950 Fset (Qbuffer_name_history
, Qnil
);
1952 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1954 /* Normal hooks for entry to and exit from minibuffer. */
1955 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1956 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1958 /* The maximum length of a minibuffer history. */
1959 DEFSYM (Qhistory_length
, "history-length");
1961 DEFSYM (Qcurrent_input_method
, "current-input-method");
1962 DEFSYM (Qactivate_input_method
, "activate-input-method");
1963 DEFSYM (Qcase_fold_search
, "case-fold-search");
1964 DEFSYM (Qmetadata
, "metadata");
1965 /* A frame parameter. */
1966 DEFSYM (Qminibuffer_exit
, "minibuffer-exit");
1968 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1969 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1970 For example, `eval-expression' uses this. */);
1971 Vread_expression_history
= Qnil
;
1973 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1974 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1975 The function is called with the arguments passed to `read-buffer'. */);
1976 Vread_buffer_function
= Qnil
;
1978 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1979 read_buffer_completion_ignore_case
,
1980 doc
: /* Non-nil means completion ignores case when reading a buffer name. */);
1981 read_buffer_completion_ignore_case
= 0;
1983 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1984 doc
: /* Normal hook run just after entry to minibuffer. */);
1985 Vminibuffer_setup_hook
= Qnil
;
1987 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1988 doc
: /* Normal hook run just after exit from minibuffer. */);
1989 Vminibuffer_exit_hook
= Qnil
;
1991 DEFVAR_LISP ("history-length", Vhistory_length
,
1992 doc
: /* Maximum length of history lists before truncation takes place.
1993 A number means truncate to that length; truncation deletes old
1994 elements, and is done just after inserting a new element.
1995 A value of t means no truncation.
1997 This variable only affects history lists that don't specify their own
1998 maximum lengths. Setting the `history-length' property of a history
1999 variable overrides this default. */);
2000 XSETFASTINT (Vhistory_length
, 100);
2002 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
2003 doc
: /* Non-nil means to delete duplicates in history.
2004 If set to t when adding a new history element, all previous identical
2005 elements are deleted from the history list. */);
2006 history_delete_duplicates
= 0;
2008 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
2009 doc
: /* Non-nil means to add new elements in history.
2010 If set to nil, minibuffer reading functions don't add new elements to the
2011 history list, so it is possible to do this afterwards by calling
2012 `add-to-history' explicitly. */);
2013 Vhistory_add_new_input
= Qt
;
2015 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
2016 doc
: /* Non-nil means don't consider case significant in completion.
2017 For file-name completion, `read-file-name-completion-ignore-case'
2018 controls the behavior, rather than this variable.
2019 For buffer name completion, `read-buffer-completion-ignore-case'
2020 controls the behavior, rather than this variable. */);
2021 completion_ignore_case
= 0;
2023 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
2024 doc
: /* Non-nil means to allow minibuffer commands while in the minibuffer.
2025 This variable makes a difference whenever the minibuffer window is active.
2026 Also see `minibuffer-depth-indicate-mode', which may be handy if this
2027 variable is non-nil. */);
2028 enable_recursive_minibuffers
= 0;
2030 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2031 doc
: /* Alist or obarray used for completion in the minibuffer.
2032 This becomes the ALIST argument to `try-completion' and `all-completions'.
2033 The value can also be a list of strings or a hash table.
2035 The value may alternatively be a function, which is given three arguments:
2036 STRING, the current buffer contents;
2037 PREDICATE, the predicate for filtering possible matches;
2038 CODE, which says what kind of things to do.
2039 CODE can be nil, t or `lambda':
2040 nil -- return the best completion of STRING, or nil if there is none.
2041 t -- return a list of all possible completions of STRING.
2042 lambda -- return t if STRING is a valid completion as it stands. */);
2043 Vminibuffer_completion_table
= Qnil
;
2045 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2046 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2047 Vminibuffer_completion_predicate
= Qnil
;
2049 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2050 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2051 If nil, confirmation is not required.
2052 If the value is `confirm', the user may exit with an input that is not
2053 a valid completion alternative, but Emacs asks for confirmation.
2054 If the value is `confirm-after-completion', the user may exit with an
2055 input that is not a valid completion alternative, but Emacs asks for
2056 confirmation if the user submitted the input right after any of the
2057 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2058 Vminibuffer_completion_confirm
= Qnil
;
2060 DEFVAR_LISP ("minibuffer-completing-file-name",
2061 Vminibuffer_completing_file_name
,
2062 doc
: /* Non-nil means completing file names. */);
2063 Vminibuffer_completing_file_name
= Qnil
;
2065 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2066 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2067 Vminibuffer_help_form
= Qnil
;
2069 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2070 doc
: /* History list symbol to add minibuffer values to.
2071 Each string of minibuffer input, as it appears on exit from the minibuffer,
2073 (set minibuffer-history-variable
2074 (cons STRING (symbol-value minibuffer-history-variable))) */);
2075 XSETFASTINT (Vminibuffer_history_variable
, 0);
2077 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2078 doc
: /* Current position of redoing in the history list. */);
2079 Vminibuffer_history_position
= Qnil
;
2081 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2082 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2083 Some uses of the echo area also raise that frame (since they use it too). */);
2084 minibuffer_auto_raise
= 0;
2086 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2087 doc
: /* List of regexps that should restrict possible completions.
2088 The basic completion functions only consider a completion acceptable
2089 if it matches all regular expressions in this list, with
2090 `case-fold-search' bound to the value of `completion-ignore-case'.
2091 See Info node `(elisp)Basic Completion', for a description of these
2093 Vcompletion_regexp_list
= Qnil
;
2095 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2096 minibuffer_allow_text_properties
,
2097 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2098 This also affects `read-string', but it does not affect `read-minibuffer',
2099 `read-no-blanks-input', or any of the functions that do minibuffer input
2100 with completion; they always discard text properties. */);
2101 minibuffer_allow_text_properties
= 0;
2103 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2104 doc
: /* Text properties that are added to minibuffer prompts.
2105 These are in addition to the basic `field' property, and stickiness
2107 Vminibuffer_prompt_properties
= list2 (Qread_only
, Qt
);
2109 DEFVAR_LISP ("read-hide-char", Vread_hide_char
,
2110 doc
: /* Whether to hide input characters in noninteractive mode.
2111 If non-nil, it must be a character, which will be used to mask the
2112 input characters. This variable should never be set globally.
2114 This variable also overrides the default character that `read-passwd'
2115 uses to hide passwords. */);
2116 Vread_hide_char
= Qnil
;
2118 defsubr (&Sactive_minibuffer_window
);
2119 defsubr (&Sset_minibuffer_window
);
2120 defsubr (&Sread_from_minibuffer
);
2121 defsubr (&Sread_string
);
2122 defsubr (&Sread_command
);
2123 defsubr (&Sread_variable
);
2124 defsubr (&Sinternal_complete_buffer
);
2125 defsubr (&Sread_buffer
);
2126 defsubr (&Sread_no_blanks_input
);
2127 defsubr (&Sminibuffer_depth
);
2128 defsubr (&Sminibuffer_prompt
);
2130 defsubr (&Sminibufferp
);
2131 defsubr (&Sminibuffer_prompt_end
);
2132 defsubr (&Sminibuffer_contents
);
2133 defsubr (&Sminibuffer_contents_no_properties
);
2134 defsubr (&Sminibuffer_completion_contents
);
2136 defsubr (&Stry_completion
);
2137 defsubr (&Sall_completions
);
2138 defsubr (&Stest_completion
);
2139 defsubr (&Sassoc_string
);
2140 defsubr (&Scompleting_read
);