1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
25 #include <binary-io.h>
29 #include "character.h"
31 #include "dispextern.h"
36 #include "intervals.h"
38 #include "termhooks.h"
41 /* List of buffers for use as minibuffers.
42 The first element of the list is used for the outermost minibuffer
43 invocation, the next element is used for a recursive minibuffer
44 invocation, etc. The list is extended at the end as deeper
45 minibuffer recursions are encountered. */
47 Lisp_Object Vminibuffer_list
;
49 /* Data to remember during recursive minibuffer invocations. */
51 static Lisp_Object minibuf_save_list
;
53 /* Depth in minibuffer invocations. */
55 EMACS_INT minibuf_level
;
57 /* The maximum length of a minibuffer history. */
59 static Lisp_Object Qhistory_length
;
61 /* Fread_minibuffer leaves the input here as a string. */
63 Lisp_Object last_minibuf_string
;
65 static Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
67 static Lisp_Object Qread_file_name_internal
;
69 /* Normal hooks for entry to and exit from minibuffer. */
71 static Lisp_Object Qminibuffer_setup_hook
;
72 static Lisp_Object Qminibuffer_exit_hook
;
74 Lisp_Object Qcompletion_ignore_case
;
75 static Lisp_Object Qminibuffer_completion_table
;
76 static Lisp_Object Qminibuffer_completion_predicate
;
77 static Lisp_Object Qminibuffer_completion_confirm
;
78 static Lisp_Object Qcustom_variable_p
;
80 static Lisp_Object Qminibuffer_default
;
82 static Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
84 static Lisp_Object Qcase_fold_search
;
86 static Lisp_Object Qread_expression_history
;
88 /* Prompt to display in front of the mini-buffer contents. */
90 static Lisp_Object minibuf_prompt
;
92 /* Width of current mini-buffer prompt. Only set after display_line
93 of the line that contains the prompt. */
95 static ptrdiff_t minibuf_prompt_width
;
98 /* Put minibuf on currently selected frame's minibuffer.
99 We do this whenever the user starts a new minibuffer
100 or when a minibuffer exits. */
103 choose_minibuf_frame (void)
105 if (FRAMEP (selected_frame
)
106 && FRAME_LIVE_P (XFRAME (selected_frame
))
107 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
109 struct frame
*sf
= XFRAME (selected_frame
);
112 /* I don't think that any frames may validly have a null minibuffer
114 if (NILP (sf
->minibuffer_window
))
117 /* Under X, we come here with minibuf_window being the
118 minibuffer window of the unused termcap window created in
119 init_window_once. That window doesn't have a buffer. */
120 buffer
= XWINDOW (minibuf_window
)->contents
;
121 if (BUFFERP (buffer
))
122 /* Use set_window_buffer instead of Fset_window_buffer (see
123 discussion of bug#11984, bug#12025, bug#12026). */
124 set_window_buffer (sf
->minibuffer_window
, buffer
, 0, 0);
125 minibuf_window
= sf
->minibuffer_window
;
128 /* Make sure no other frame has a minibuffer as its selected window,
129 because the text would not be displayed in it, and that would be
130 confusing. Only allow the selected frame to do this,
131 and that only if the minibuffer is active. */
133 Lisp_Object tail
, frame
;
135 FOR_EACH_FRAME (tail
, frame
)
136 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
137 && !(EQ (frame
, selected_frame
)
138 && minibuf_level
> 0))
139 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
143 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
144 Sactive_minibuffer_window
, 0, 0, 0,
145 doc
: /* Return the currently active minibuffer window, or nil if none. */)
148 return minibuf_level
? minibuf_window
: Qnil
;
151 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
152 Sset_minibuffer_window
, 1, 1, 0,
153 doc
: /* Specify which minibuffer window to use for the minibuffer.
154 This affects where the minibuffer is displayed if you put text in it
155 without invoking the usual minibuffer commands. */)
158 CHECK_WINDOW (window
);
159 if (! MINI_WINDOW_P (XWINDOW (window
)))
160 error ("Window is not a minibuffer window");
162 minibuf_window
= window
;
168 /* Actual minibuffer invocation. */
170 static void read_minibuf_unwind (void);
171 static void run_exit_minibuf_hook (void);
174 /* Read a Lisp object from VAL and return it. If VAL is an empty
175 string, and DEFALT is a string, read from DEFALT instead of VAL. */
178 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
180 struct gcpro gcpro1
, gcpro2
;
181 Lisp_Object expr_and_pos
;
184 GCPRO2 (val
, defalt
);
186 if (STRINGP (val
) && SCHARS (val
) == 0)
188 if (STRINGP (defalt
))
190 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
194 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
195 pos
= XINT (Fcdr (expr_and_pos
));
196 if (pos
!= SCHARS (val
))
198 /* Ignore trailing whitespace; any other trailing junk
201 pos
= string_char_to_byte (val
, pos
);
202 for (i
= pos
; i
< SBYTES (val
); i
++)
204 int c
= SREF (val
, i
);
205 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
206 error ("Trailing garbage following expression");
210 val
= Fcar (expr_and_pos
);
211 RETURN_UNGCPRO (val
);
215 /* Like read_minibuf but reading from stdin. This function is called
216 from read_minibuf to do the job if noninteractive. */
219 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
220 Lisp_Object prompt
, Lisp_Object backup_n
,
222 Lisp_Object histvar
, Lisp_Object histpos
,
224 bool allow_props
, bool inherit_input_method
)
230 unsigned char hide_char
= 0;
231 struct emacs_tty etty
;
234 /* Check, whether we need to suppress echoing. */
235 if (CHARACTERP (Vread_hide_char
))
236 hide_char
= XFASTINT (Vread_hide_char
);
238 /* Manipulate tty. */
241 etty_valid
= emacs_get_tty (fileno (stdin
), &etty
) == 0;
243 set_binary_mode (fileno (stdin
), O_BINARY
);
244 suppress_echo_on_tty (fileno (stdin
));
247 fprintf (stdout
, "%s", SDATA (prompt
));
253 line
= xmalloc (size
);
255 while ((c
= getchar ()) != '\n' && c
!= '\r')
265 fprintf (stdout
, "%c", hide_char
);
268 if (STRING_BYTES_BOUND
/ 2 < size
)
269 memory_full (SIZE_MAX
);
271 line
= xrealloc (line
, size
);
280 fprintf (stdout
, "\n");
283 emacs_set_tty (fileno (stdin
), &etty
, 0);
284 set_binary_mode (fileno (stdin
), O_TEXT
);
288 if (len
|| c
== '\n' || c
== '\r')
290 val
= make_string (line
, len
);
296 error ("Error reading from stdin");
299 /* If Lisp form desired instead of string, parse it. */
301 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
306 DEFUN ("minibufferp", Fminibufferp
,
307 Sminibufferp
, 0, 1, 0,
308 doc
: /* Return t if BUFFER is a minibuffer.
309 No argument or nil as argument means use current buffer as BUFFER.
310 BUFFER can be a buffer or a buffer name. */)
316 buffer
= Fcurrent_buffer ();
317 else if (STRINGP (buffer
))
318 buffer
= Fget_buffer (buffer
);
320 CHECK_BUFFER (buffer
);
322 tem
= Fmemq (buffer
, Vminibuffer_list
);
323 return ! NILP (tem
) ? Qt
: Qnil
;
326 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
327 Sminibuffer_prompt_end
, 0, 0, 0,
328 doc
: /* Return the buffer position of the end of the minibuffer prompt.
329 Return (point-min) if current buffer is not a minibuffer. */)
332 /* This function is written to be most efficient when there's a prompt. */
333 Lisp_Object beg
, end
, tem
;
334 beg
= make_number (BEGV
);
336 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
340 end
= Ffield_end (beg
, Qnil
, Qnil
);
342 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
348 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
349 Sminibuffer_contents
, 0, 0, 0,
350 doc
: /* Return the user input in a minibuffer as a string.
351 If the current buffer is not a minibuffer, return its entire contents. */)
354 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
355 return make_buffer_string (prompt_end
, ZV
, 1);
358 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
359 Sminibuffer_contents_no_properties
, 0, 0, 0,
360 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
361 If the current buffer is not a minibuffer, return its entire contents. */)
364 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
365 return make_buffer_string (prompt_end
, ZV
, 0);
368 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
369 Sminibuffer_completion_contents
, 0, 0, 0,
370 doc
: /* Return the user input in a minibuffer before point as a string.
371 That is what completion commands operate on.
372 If the current buffer is not a minibuffer, return its entire contents. */)
375 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
377 error ("Cannot do completion in the prompt");
378 return make_buffer_string (prompt_end
, PT
, 1);
382 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
383 putting point minus BACKUP_N bytes from the end of INITIAL,
384 prompting with PROMPT (a string), using history list HISTVAR
385 with initial position HISTPOS. INITIAL should be a string or a
386 cons of a string and an integer. BACKUP_N should be <= 0, or
387 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
388 ignored and replaced with an integer that puts point at one-indexed
389 position N in INITIAL, where N is the CDR of INITIAL, or at the
390 beginning of INITIAL if N <= 0.
392 Normally return the result as a string (the text that was read),
393 but if EXPFLAG, read it and return the object read.
394 If HISTVAR is given, save the value read on that history only if it doesn't
395 match the front of that history list exactly. The value is pushed onto
396 the list as the string that was read.
398 DEFALT specifies the default value for the sake of history commands.
400 If ALLOW_PROPS, do not throw away text properties.
402 if INHERIT_INPUT_METHOD, the minibuffer inherits the
403 current input method. */
406 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
408 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
409 bool allow_props
, bool inherit_input_method
)
412 ptrdiff_t count
= SPECPDL_INDEX ();
413 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
414 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
415 Lisp_Object enable_multibyte
;
417 /* String to add to the history. */
418 Lisp_Object histstring
;
421 Lisp_Object empty_minibuf
;
422 Lisp_Object dummy
, frame
;
424 specbind (Qminibuffer_default
, defalt
);
425 specbind (intern ("inhibit-read-only"), Qnil
);
427 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
428 in previous recursive minibuffer, but was not set explicitly
429 to t for this invocation, so set it to nil in this minibuffer.
430 Save the old value now, before we change it. */
431 specbind (intern ("minibuffer-completing-file-name"),
432 Vminibuffer_completing_file_name
);
433 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
434 Vminibuffer_completing_file_name
= Qnil
;
436 #ifdef HAVE_WINDOW_SYSTEM
437 if (display_hourglass_p
)
445 Lisp_Object backup_n
= XCDR (initial
);
446 initial
= XCAR (initial
);
447 CHECK_STRING (initial
);
448 if (!NILP (backup_n
))
450 CHECK_NUMBER (backup_n
);
451 /* Convert to distance from end of input. */
452 if (XINT (backup_n
) < 1)
453 /* A number too small means the beginning of the string. */
454 pos
= - SCHARS (initial
);
456 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
460 CHECK_STRING (initial
);
463 ambient_dir
= BVAR (current_buffer
, directory
);
465 enable_multibyte
= Qnil
;
467 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
468 store them away before we can GC. Don't need to protect
469 BACKUP_N because we use the value only if it is an integer. */
470 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
472 if (!STRINGP (prompt
))
473 prompt
= empty_unibyte_string
;
475 if (!enable_recursive_minibuffers
476 && minibuf_level
> 0)
478 if (EQ (selected_window
, minibuf_window
))
479 error ("Command attempted to use minibuffer while in minibuffer");
481 /* If we're in another window, cancel the minibuffer that's active. */
483 build_string ("Command attempted to use minibuffer while in minibuffer"));
487 /* In case we are running as a daemon, only do this before
488 detaching from the terminal. */
489 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
490 && NILP (Vexecuting_kbd_macro
))
492 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
494 expflag
, histvar
, histpos
, defalt
,
495 allow_props
, inherit_input_method
);
497 return unbind_to (count
, val
);
500 /* Choose the minibuffer window and frame, and take action on them. */
502 /* Prepare for restoring the current buffer since choose_minibuf_frame
503 calling Fset_frame_selected_window may change it (Bug#12766). */
504 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
506 choose_minibuf_frame ();
508 record_unwind_protect_void (choose_minibuf_frame
);
510 record_unwind_protect (restore_window_configuration
,
511 Fcurrent_window_configuration (Qnil
));
513 /* If the minibuffer window is on a different frame, save that
514 frame's configuration too. */
515 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
516 if (!EQ (mini_frame
, selected_frame
))
517 record_unwind_protect (restore_window_configuration
,
518 Fcurrent_window_configuration (mini_frame
));
520 /* If the minibuffer is on an iconified or invisible frame,
521 make it visible now. */
522 Fmake_frame_visible (mini_frame
);
524 if (minibuffer_auto_raise
)
525 Fraise_frame (mini_frame
);
527 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
529 /* We have to do this after saving the window configuration
530 since that is what restores the current buffer. */
532 /* Arrange to restore a number of minibuffer-related variables.
533 We could bind each variable separately, but that would use lots of
536 = Fcons (Voverriding_local_map
,
537 Fcons (minibuf_window
,
540 = Fcons (minibuf_prompt
,
541 Fcons (make_number (minibuf_prompt_width
),
543 Fcons (Vcurrent_prefix_arg
,
544 Fcons (Vminibuffer_history_position
,
545 Fcons (Vminibuffer_history_variable
,
546 minibuf_save_list
))))));
548 record_unwind_protect_void (read_minibuf_unwind
);
550 /* We are exiting the minibuffer one way or the other, so run the hook.
551 It should be run before unwinding the minibuf settings. Do it
552 separately from read_minibuf_unwind because we need to make sure that
553 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
554 signals an error. --Stef */
555 record_unwind_protect_void (run_exit_minibuf_hook
);
557 /* Now that we can restore all those variables, start changing them. */
559 minibuf_prompt_width
= 0;
560 minibuf_prompt
= Fcopy_sequence (prompt
);
561 Vminibuffer_history_position
= histpos
;
562 Vminibuffer_history_variable
= histvar
;
563 Vhelp_form
= Vminibuffer_help_form
;
564 /* If this minibuffer is reading a file name, that doesn't mean
565 recursive ones are. But we cannot set it to nil, because
566 completion code still need to know the minibuffer is completing a
567 file name. So use `lambda' as intermediate value meaning
568 "t" in this minibuffer, but "nil" in next minibuffer. */
569 if (!NILP (Vminibuffer_completing_file_name
))
570 Vminibuffer_completing_file_name
= Qlambda
;
572 /* If variable is unbound, make it nil. */
573 histval
= find_symbol_value (Vminibuffer_history_variable
);
574 if (EQ (histval
, Qunbound
))
576 Fset (Vminibuffer_history_variable
, Qnil
);
580 if (inherit_input_method
)
582 /* `current-input-method' is buffer local. So, remember it in
583 INPUT_METHOD before changing the current buffer. */
584 input_method
= Fsymbol_value (Qcurrent_input_method
);
585 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
588 /* Switch to the minibuffer. */
590 minibuffer
= get_minibuffer (minibuf_level
);
591 Fset_buffer (minibuffer
);
593 /* Defeat (setq-default truncate-lines t), since truncated lines do
594 not work correctly in minibuffers. (Bug#5715, etc) */
595 bset_truncate_lines (current_buffer
, Qnil
);
597 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
598 if (inherit_input_method
)
599 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
601 /* The current buffer's default directory is usually the right thing
602 for our minibuffer here. However, if you're typing a command at
603 a minibuffer-only frame when minibuf_level is zero, then buf IS
604 the current_buffer, so reset_buffer leaves buf's default
605 directory unchanged. This is a bummer when you've just started
606 up Emacs and buf's default directory is Qnil. Here's a hack; can
607 you think of something better to do? Find another buffer with a
608 better directory, and use that one instead. */
609 if (STRINGP (ambient_dir
))
610 bset_directory (current_buffer
, ambient_dir
);
613 Lisp_Object tail
, buf
;
615 FOR_EACH_LIVE_BUFFER (tail
, buf
)
616 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
618 bset_directory (current_buffer
,
619 BVAR (XBUFFER (buf
), directory
));
624 if (!EQ (mini_frame
, selected_frame
))
625 Fredirect_frame_focus (selected_frame
, mini_frame
);
627 Vminibuf_scroll_window
= selected_window
;
628 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
629 minibuf_selected_window
= selected_window
;
631 /* Empty out the minibuffers of all frames other than the one
632 where we are going to display one now.
633 Set them to point to ` *Minibuf-0*', which is always empty. */
634 empty_minibuf
= get_minibuffer (0);
636 FOR_EACH_FRAME (dummy
, frame
)
638 Lisp_Object root_window
= Fframe_root_window (frame
);
639 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
641 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
642 && !NILP (Fwindow_minibuffer_p (mini_window
)))
643 /* Use set_window_buffer instead of Fset_window_buffer (see
644 discussion of bug#11984, bug#12025, bug#12026). */
645 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
648 /* Display this minibuffer in the proper window. */
649 /* Use set_window_buffer instead of Fset_window_buffer (see
650 discussion of bug#11984, bug#12025, bug#12026). */
651 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
652 Fselect_window (minibuf_window
, Qnil
);
653 XWINDOW (minibuf_window
)->hscroll
= 0;
654 XWINDOW (minibuf_window
)->suspend_auto_hscroll
= 0;
656 Fmake_local_variable (Qprint_escape_newlines
);
657 print_escape_newlines
= 1;
659 /* Erase the buffer. */
661 ptrdiff_t count1
= SPECPDL_INDEX ();
662 specbind (Qinhibit_read_only
, Qt
);
663 specbind (Qinhibit_modification_hooks
, Qt
);
666 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
667 && ! STRING_MULTIBYTE (minibuf_prompt
))
668 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
670 /* Insert the prompt, record where it ends. */
671 Finsert (1, &minibuf_prompt
);
674 Fput_text_property (make_number (BEG
), make_number (PT
),
675 Qfront_sticky
, Qt
, Qnil
);
676 Fput_text_property (make_number (BEG
), make_number (PT
),
677 Qrear_nonsticky
, Qt
, Qnil
);
678 Fput_text_property (make_number (BEG
), make_number (PT
),
680 Fadd_text_properties (make_number (BEG
), make_number (PT
),
681 Vminibuffer_prompt_properties
, Qnil
);
683 unbind_to (count1
, Qnil
);
686 minibuf_prompt_width
= current_column ();
688 /* Put in the initial input. */
691 Finsert (1, &initial
);
692 Fforward_char (make_number (pos
));
695 clear_message (1, 1);
696 bset_keymap (current_buffer
, map
);
698 /* Turn on an input method stored in INPUT_METHOD if any. */
699 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
700 call1 (Qactivate_input_method
, input_method
);
702 Frun_hooks (1, &Qminibuffer_setup_hook
);
704 /* Don't allow the user to undo past this point. */
705 bset_undo_list (current_buffer
, Qnil
);
709 /* If cursor is on the minibuffer line,
710 show the user we have exited by putting it in column 0. */
711 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
714 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
715 XWINDOW (minibuf_window
)->cursor
.x
= 0;
716 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
717 update_frame (XFRAME (selected_frame
), 1, 1);
718 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
721 /* Make minibuffer contents into a string. */
722 Fset_buffer (minibuffer
);
724 val
= Fminibuffer_contents ();
726 val
= Fminibuffer_contents_no_properties ();
728 /* VAL is the string of minibuffer text. */
730 last_minibuf_string
= val
;
732 /* Choose the string to add to the history. */
733 if (SCHARS (val
) != 0)
735 else if (STRINGP (defalt
))
737 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
738 histstring
= XCAR (defalt
);
742 /* Add the value to the appropriate history list, if any. */
743 if (!NILP (Vhistory_add_new_input
)
744 && SYMBOLP (Vminibuffer_history_variable
)
745 && !NILP (histstring
))
747 /* If the caller wanted to save the value read on a history list,
748 then do so if the value is not already the front of the list. */
750 /* The value of the history variable must be a cons or nil. Other
751 values are unacceptable. We silently ignore these values. */
755 /* Don't duplicate the most recent entry in the history. */
756 && (NILP (Fequal (histstring
, Fcar (histval
))))))
760 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
761 histval
= Fcons (histstring
, histval
);
762 Fset (Vminibuffer_history_variable
, histval
);
764 /* Truncate if requested. */
765 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
766 if (NILP (length
)) length
= Vhistory_length
;
767 if (INTEGERP (length
))
769 if (XINT (length
) <= 0)
770 Fset (Vminibuffer_history_variable
, Qnil
);
775 temp
= Fnthcdr (Fsub1 (length
), histval
);
776 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
782 /* If Lisp form desired instead of string, parse it. */
784 val
= string_to_object (val
, defalt
);
786 /* The appropriate frame will get selected
787 in set-window-configuration. */
789 return unbind_to (count
, val
);
792 /* Return a buffer to be used as the minibuffer at depth `depth'.
793 depth = 0 is the lowest allowed argument, and that is the value
794 used for nonrecursive minibuffer invocations. */
797 get_minibuffer (EMACS_INT depth
)
799 Lisp_Object tail
, num
, buf
;
800 char name
[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT
)];
802 XSETFASTINT (num
, depth
);
803 tail
= Fnthcdr (num
, Vminibuffer_list
);
807 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
810 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
812 buf
= Fget_buffer_create
813 (make_formatted_string (name
, " *Minibuf-%"pI
"d*", depth
));
815 /* Although the buffer's name starts with a space, undo should be
817 Fbuffer_enable_undo (buf
);
823 ptrdiff_t count
= SPECPDL_INDEX ();
824 /* We have to empty both overlay lists. Otherwise we end
825 up with overlays that think they belong to this buffer
826 while the buffer doesn't know about them any more. */
827 delete_all_overlays (XBUFFER (buf
));
828 reset_buffer (XBUFFER (buf
));
829 record_unwind_current_buffer ();
831 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
832 call0 (intern ("minibuffer-inactive-mode"));
834 Fkill_all_local_variables ();
835 unbind_to (count
, Qnil
);
842 run_exit_minibuf_hook (void)
844 safe_run_hooks (Qminibuffer_exit_hook
);
847 /* This function is called on exiting minibuffer, whether normally or
848 not, and it restores the current window, buffer, etc. */
851 read_minibuf_unwind (void)
853 Lisp_Object old_deactivate_mark
;
856 /* If this was a recursive minibuffer,
857 tie the minibuffer window back to the outer level minibuffer buffer. */
860 window
= minibuf_window
;
861 /* To keep things predictable, in case it matters, let's be in the
862 minibuffer when we reset the relevant variables. */
863 Fset_buffer (XWINDOW (window
)->contents
);
865 /* Restore prompt, etc, from outer minibuffer level. */
866 minibuf_prompt
= Fcar (minibuf_save_list
);
867 minibuf_save_list
= Fcdr (minibuf_save_list
);
868 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
869 minibuf_save_list
= Fcdr (minibuf_save_list
);
870 Vhelp_form
= Fcar (minibuf_save_list
);
871 minibuf_save_list
= Fcdr (minibuf_save_list
);
872 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
873 minibuf_save_list
= Fcdr (minibuf_save_list
);
874 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
875 minibuf_save_list
= Fcdr (minibuf_save_list
);
876 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
877 minibuf_save_list
= Fcdr (minibuf_save_list
);
878 Voverriding_local_map
= Fcar (minibuf_save_list
);
879 minibuf_save_list
= Fcdr (minibuf_save_list
);
881 temp
= Fcar (minibuf_save_list
);
882 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
883 minibuf_window
= temp
;
885 minibuf_save_list
= Fcdr (minibuf_save_list
);
887 /* Erase the minibuffer we were using at this level. */
889 ptrdiff_t count
= SPECPDL_INDEX ();
890 /* Prevent error in erase-buffer. */
891 specbind (Qinhibit_read_only
, Qt
);
892 specbind (Qinhibit_modification_hooks
, Qt
);
893 old_deactivate_mark
= Vdeactivate_mark
;
895 Vdeactivate_mark
= old_deactivate_mark
;
896 unbind_to (count
, Qnil
);
899 /* When we get to the outmost level, make sure we resize the
900 mini-window back to its normal size. */
901 if (minibuf_level
== 0)
902 resize_mini_window (XWINDOW (window
), 0);
904 /* In case the previous minibuffer displayed in this miniwindow is
905 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
906 to make sure we don't leave around bindings and stuff which only
907 made sense during the read_minibuf invocation. */
908 call0 (intern ("minibuffer-inactive-mode"));
912 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
913 Sread_from_minibuffer
, 1, 7, 0,
914 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
915 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
916 DEFAULT-VALUE. It normally should be nil in new code, except when
917 HIST is a cons. It is discussed in more detail below.
919 Third arg KEYMAP is a keymap to use whilst reading;
920 if omitted or nil, the default is `minibuffer-local-map'.
922 If fourth arg READ is non-nil, interpret the result as a Lisp object
923 and return that object:
924 in other words, do `(car (read-from-string INPUT-STRING))'
926 Fifth arg HIST, if non-nil, specifies a history list and optionally
927 the initial position in the list. It can be a symbol, which is the
928 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
929 In that case, HISTVAR is the history list variable to use, and
930 HISTPOS is the initial position for use by the minibuffer history
931 commands. For consistency, you should also specify that element of
932 the history as the value of INITIAL-CONTENTS. Positions are counted
933 starting from 1 at the beginning of the list.
935 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
936 as the default to `read' if READ is non-nil and the user enters
937 empty input. But if READ is nil, this function does _not_ return
938 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
940 Whatever the value of READ, DEFAULT-VALUE is made available via the
941 minibuffer history commands. DEFAULT-VALUE can also be a list of
942 strings, in which case all the strings are available in the history,
943 and the first string is the default to `read' if READ is non-nil.
945 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
946 the current input method and the setting of `enable-multibyte-characters'.
948 If the variable `minibuffer-allow-text-properties' is non-nil,
949 then the string which is returned includes whatever text properties
950 were present in the minibuffer. Otherwise the value has no text properties.
952 The remainder of this documentation string describes the
953 INITIAL-CONTENTS argument in more detail. It is only relevant when
954 studying existing code, or when HIST is a cons. If non-nil,
955 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
956 reading input. Normally, point is put at the end of that string.
957 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
958 input is STRING, but point is placed at _one-indexed_ position
959 POSITION in the minibuffer. Any integer value less than or equal to
960 one puts point at the beginning of the string. *Note* that this
961 behavior differs from the way such arguments are used in `completing-read'
962 and some related functions, which use zero-indexing for POSITION. */)
963 (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
)
965 Lisp_Object histvar
, histpos
, val
;
968 CHECK_STRING (prompt
);
970 keymap
= Vminibuffer_local_map
;
972 keymap
= get_keymap (keymap
, 1, 0);
981 histvar
= Fcar_safe (hist
);
982 histpos
= Fcdr_safe (hist
);
985 histvar
= Qminibuffer_history
;
987 XSETFASTINT (histpos
, 0);
989 GCPRO1 (default_value
);
990 val
= read_minibuf (keymap
, initial_contents
, prompt
,
992 histvar
, histpos
, default_value
,
993 minibuffer_allow_text_properties
,
994 !NILP (inherit_input_method
));
999 /* Functions that use the minibuffer to read various things. */
1001 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1002 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1003 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1004 This argument has been superseded by DEFAULT-VALUE and should normally be nil
1005 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
1007 The third arg HISTORY, if non-nil, specifies a history list
1008 and optionally the initial position in the list.
1009 See `read-from-minibuffer' for details of HISTORY argument.
1010 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1011 If non-nil, it is used for history commands, and as the value (or the first
1012 element of the list of default values) to return if the user enters the
1014 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1015 the current input method and the setting of `enable-multibyte-characters'. */)
1016 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1019 ptrdiff_t count
= SPECPDL_INDEX ();
1021 /* Just in case we're in a recursive minibuffer, make it clear that the
1022 previous minibuffer's completion table does not apply to the new
1024 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
1025 specbind (Qminibuffer_completion_table
, Qnil
);
1027 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1028 Qnil
, history
, default_value
,
1029 inherit_input_method
);
1030 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1031 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1032 return unbind_to (count
, val
);
1035 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1036 doc
: /* Read a string from the terminal, not allowing blanks.
1037 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1038 non-nil, it should be a string, which is used as initial input, with
1039 point positioned at the end, so that SPACE will accept the input.
1040 \(Actually, INITIAL can also be a cons of a string and an integer.
1041 Such values are treated as in `read-from-minibuffer', but are normally
1042 not useful in this function.)
1043 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1044 the current input method and the setting of`enable-multibyte-characters'. */)
1045 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1047 CHECK_STRING (prompt
);
1048 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
1049 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1050 !NILP (inherit_input_method
));
1053 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1054 doc
: /* Read the name of a command and return as a symbol.
1055 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1056 if it is a list. */)
1057 (Lisp_Object prompt
, Lisp_Object default_value
)
1059 Lisp_Object name
, default_string
;
1061 if (NILP (default_value
))
1062 default_string
= Qnil
;
1063 else if (SYMBOLP (default_value
))
1064 default_string
= SYMBOL_NAME (default_value
);
1066 default_string
= default_value
;
1068 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1069 Qnil
, Qnil
, default_string
, Qnil
);
1072 return Fintern (name
, Qnil
);
1076 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1077 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1078 Prompt with PROMPT. */)
1079 (Lisp_Object prompt
)
1081 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1086 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1087 doc
: /* Read the name of a user option and return it as a symbol.
1088 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1090 A user option, or customizable variable, is one for which
1091 `custom-variable-p' returns non-nil. */)
1092 (Lisp_Object prompt
, Lisp_Object default_value
)
1094 Lisp_Object name
, default_string
;
1096 if (NILP (default_value
))
1097 default_string
= Qnil
;
1098 else if (SYMBOLP (default_value
))
1099 default_string
= SYMBOL_NAME (default_value
);
1101 default_string
= default_value
;
1103 name
= Fcompleting_read (prompt
, Vobarray
,
1104 Qcustom_variable_p
, Qt
,
1105 Qnil
, Qnil
, default_string
, Qnil
);
1108 return Fintern (name
, Qnil
);
1111 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1112 doc
: /* Read the name of a buffer and return as a string.
1114 Optional second arg DEF is value to return if user enters an empty line.
1115 If DEF is a list of default values, return its first element.
1116 Optional third arg REQUIRE-MATCH determines whether non-existing
1117 buffer names are allowed. It has the same meaning as the
1118 REQUIRE-MATCH argument of `completing-read'.
1119 The argument PROMPT should be a string ending with a colon and a space.
1120 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1121 case while reading the buffer name.
1122 If `read-buffer-function' is non-nil, this works by calling it as a
1123 function, instead of the usual behavior. */)
1124 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1129 ptrdiff_t count
= SPECPDL_INDEX ();
1132 def
= BVAR (XBUFFER (def
), name
);
1134 specbind (Qcompletion_ignore_case
,
1135 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1137 if (NILP (Vread_buffer_function
))
1141 /* A default value was provided: we must change PROMPT,
1142 editing the default value in before the colon. To achieve
1143 this, we replace PROMPT with a substring that doesn't
1144 contain the terminal space and colon (if present). They
1145 are then added back using Fformat. */
1147 if (STRINGP (prompt
))
1149 s
= SSDATA (prompt
);
1150 len
= SBYTES (prompt
);
1151 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1153 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1156 prompt
= make_specified_string (s
, -1, len
,
1157 STRING_MULTIBYTE (prompt
));
1160 prompt
= Fformat (3, ((Lisp_Object
[])
1161 { build_local_string ("%s (default %s): "),
1162 prompt
, CONSP (def
) ? XCAR (def
) : def
}));
1165 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1166 Qnil
, require_match
, Qnil
,
1167 Qbuffer_name_history
, def
, Qnil
);
1170 result
= Ffuncall (4, ((Lisp_Object
[])
1171 { Vread_buffer_function
, prompt
, def
, require_match
}));
1172 return unbind_to (count
, result
);
1176 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1178 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1181 if (STRING_MULTIBYTE (string
))
1182 return Fstring_make_unibyte (string
);
1184 return Fstring_make_multibyte (string
);
1187 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1188 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1189 Test each possible completion specified by COLLECTION
1190 to see if it begins with STRING. The possible completions may be
1191 strings or symbols. Symbols are converted to strings before testing,
1193 All that match STRING are compared together; the longest initial sequence
1194 common to all these matches is the return value.
1195 If there is no match at all, the return value is nil.
1196 For a unique match which is exact, the return value is t.
1198 If COLLECTION is an alist, the keys (cars of elements) are the
1199 possible completions. If an element is not a cons cell, then the
1200 element itself is the possible completion.
1201 If COLLECTION is a hash-table, all the keys that are strings or symbols
1202 are the possible completions.
1203 If COLLECTION is an obarray, the names of all symbols in the obarray
1204 are the possible completions.
1206 COLLECTION can also be a function to do the completion itself.
1207 It receives three arguments: the values STRING, PREDICATE and nil.
1208 Whatever it returns becomes the value of `try-completion'.
1210 If optional third argument PREDICATE is non-nil,
1211 it is used to test each possible match.
1212 The match is a candidate only if PREDICATE returns non-nil.
1213 The argument given to PREDICATE is the alist element
1214 or the symbol from the obarray. If COLLECTION is a hash-table,
1215 predicate is called with two arguments: the key and the value.
1216 Additionally to this predicate, `completion-regexp-list'
1217 is used to further constrain the set of candidates. */)
1218 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1220 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1221 /* Size in bytes of BESTMATCH. */
1222 ptrdiff_t bestmatchsize
= 0;
1223 /* These are in bytes, too. */
1224 ptrdiff_t compare
, matchsize
;
1225 enum { function_table
, list_table
, obarray_table
, hash_table
}
1226 type
= (HASH_TABLE_P (collection
) ? hash_table
1227 : VECTORP (collection
) ? obarray_table
1228 : ((NILP (collection
)
1229 || (CONSP (collection
) && !FUNCTIONP (collection
)))
1230 ? list_table
: function_table
));
1231 ptrdiff_t idx
= 0, obsize
= 0;
1233 ptrdiff_t bindcount
= -1;
1234 Lisp_Object bucket
, zero
, end
, tem
;
1235 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1237 CHECK_STRING (string
);
1238 if (type
== function_table
)
1239 return call3 (collection
, string
, predicate
, Qnil
);
1241 bestmatch
= bucket
= Qnil
;
1242 zero
= make_number (0);
1244 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1246 if (type
== obarray_table
)
1248 collection
= check_obarray (collection
);
1249 obsize
= ASIZE (collection
);
1250 bucket
= AREF (collection
, idx
);
1255 /* Get the next element of the alist, obarray, or hash-table. */
1256 /* Exit the loop if the elements are all used up. */
1257 /* elt gets the alist element or symbol.
1258 eltstring gets the name to check as a completion. */
1260 if (type
== list_table
)
1265 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1268 else if (type
== obarray_table
)
1270 if (!EQ (bucket
, zero
))
1272 if (!SYMBOLP (bucket
))
1273 error ("Bad data in guts of obarray");
1276 if (XSYMBOL (bucket
)->next
)
1277 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1279 XSETFASTINT (bucket
, 0);
1281 else if (++idx
>= obsize
)
1285 bucket
= AREF (collection
, idx
);
1289 else /* if (type == hash_table) */
1291 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1292 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1294 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1297 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1300 /* Is this element a possible completion? */
1302 if (SYMBOLP (eltstring
))
1303 eltstring
= Fsymbol_name (eltstring
);
1305 if (STRINGP (eltstring
)
1306 && SCHARS (string
) <= SCHARS (eltstring
)
1307 && (tem
= Fcompare_strings (eltstring
, zero
,
1308 make_number (SCHARS (string
)),
1310 completion_ignore_case
? Qt
: Qnil
),
1314 Lisp_Object regexps
;
1316 /* Ignore this element if it fails to match all the regexps. */
1318 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1319 regexps
= XCDR (regexps
))
1321 if (bindcount
< 0) {
1322 bindcount
= SPECPDL_INDEX ();
1323 specbind (Qcase_fold_search
,
1324 completion_ignore_case
? Qt
: Qnil
);
1326 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1330 if (CONSP (regexps
))
1334 /* Ignore this element if there is a predicate
1335 and the predicate doesn't like it. */
1337 if (!NILP (predicate
))
1339 if (EQ (predicate
, Qcommandp
))
1340 tem
= Fcommandp (elt
, Qnil
);
1345 unbind_to (bindcount
, Qnil
);
1348 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1349 tem
= (type
== hash_table
1350 ? call2 (predicate
, elt
,
1351 HASH_VALUE (XHASH_TABLE (collection
),
1353 : call1 (predicate
, elt
));
1356 if (NILP (tem
)) continue;
1359 /* Update computation of how much all possible completions match */
1361 if (NILP (bestmatch
))
1364 bestmatch
= eltstring
;
1365 bestmatchsize
= SCHARS (eltstring
);
1369 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1370 tem
= Fcompare_strings (bestmatch
, zero
,
1371 make_number (compare
),
1373 make_number (compare
),
1374 completion_ignore_case
? Qt
: Qnil
);
1375 matchsize
= EQ (tem
, Qt
) ? compare
: eabs (XINT (tem
)) - 1;
1377 if (completion_ignore_case
)
1379 /* If this is an exact match except for case,
1380 use it as the best match rather than one that is not an
1381 exact match. This way, we get the case pattern
1382 of the actual match. */
1383 if ((matchsize
== SCHARS (eltstring
)
1384 && matchsize
< SCHARS (bestmatch
))
1386 /* If there is more than one exact match ignoring case,
1387 and one of them is exact including case,
1389 /* If there is no exact match ignoring case,
1390 prefer a match that does not change the case
1392 ((matchsize
== SCHARS (eltstring
))
1394 (matchsize
== SCHARS (bestmatch
))
1395 && (tem
= Fcompare_strings (eltstring
, zero
,
1396 make_number (SCHARS (string
)),
1401 && (tem
= Fcompare_strings (bestmatch
, zero
,
1402 make_number (SCHARS (string
)),
1407 bestmatch
= eltstring
;
1409 if (bestmatchsize
!= SCHARS (eltstring
)
1410 || bestmatchsize
!= matchsize
)
1411 /* Don't count the same string multiple times. */
1412 matchcount
+= matchcount
<= 1;
1413 bestmatchsize
= matchsize
;
1414 if (matchsize
<= SCHARS (string
)
1415 /* If completion-ignore-case is non-nil, don't
1416 short-circuit because we want to find the best
1417 possible match *including* case differences. */
1418 && !completion_ignore_case
1420 /* No need to look any further. */
1426 if (bindcount
>= 0) {
1427 unbind_to (bindcount
, Qnil
);
1431 if (NILP (bestmatch
))
1432 return Qnil
; /* No completions found. */
1433 /* If we are ignoring case, and there is no exact match,
1434 and no additional text was supplied,
1435 don't change the case of what the user typed. */
1436 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1437 && SCHARS (bestmatch
) > bestmatchsize
)
1438 return minibuf_conform_representation (string
, bestmatch
);
1440 /* Return t if the supplied string is an exact match (counting case);
1441 it does not require any change to be made. */
1442 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1445 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1446 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1447 return Fsubstring (bestmatch
, zero
, end
);
1450 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1451 doc
: /* Search for partial matches to STRING in COLLECTION.
1452 Test each of the possible completions specified by COLLECTION
1453 to see if it begins with STRING. The possible completions may be
1454 strings or symbols. Symbols are converted to strings before testing,
1456 The value is a list of all the possible completions that match STRING.
1458 If COLLECTION is an alist, the keys (cars of elements) are the
1459 possible completions. If an element is not a cons cell, then the
1460 element itself is the possible completion.
1461 If COLLECTION is a hash-table, all the keys that are strings or symbols
1462 are the possible completions.
1463 If COLLECTION is an obarray, the names of all symbols in the obarray
1464 are the possible completions.
1466 COLLECTION can also be a function to do the completion itself.
1467 It receives three arguments: the values STRING, PREDICATE and t.
1468 Whatever it returns becomes the value of `all-completions'.
1470 If optional third argument PREDICATE is non-nil,
1471 it is used to test each possible match.
1472 The match is a candidate only if PREDICATE returns non-nil.
1473 The argument given to PREDICATE is the alist element
1474 or the symbol from the obarray. If COLLECTION is a hash-table,
1475 predicate is called with two arguments: the key and the value.
1476 Additionally to this predicate, `completion-regexp-list'
1477 is used to further constrain the set of candidates.
1479 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1480 backward compatibility. If non-nil, strings in COLLECTION that start
1481 with a space are ignored unless STRING itself starts with a space. */)
1482 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1484 Lisp_Object tail
, elt
, eltstring
;
1485 Lisp_Object allmatches
;
1486 int type
= HASH_TABLE_P (collection
) ? 3
1487 : VECTORP (collection
) ? 2
1488 : NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
));
1489 ptrdiff_t idx
= 0, obsize
= 0;
1490 ptrdiff_t bindcount
= -1;
1491 Lisp_Object bucket
, tem
, zero
;
1492 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1494 CHECK_STRING (string
);
1496 return call3 (collection
, string
, predicate
, Qt
);
1497 allmatches
= bucket
= Qnil
;
1498 zero
= make_number (0);
1500 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1504 collection
= check_obarray (collection
);
1505 obsize
= ASIZE (collection
);
1506 bucket
= AREF (collection
, idx
);
1511 /* Get the next element of the alist, obarray, or hash-table. */
1512 /* Exit the loop if the elements are all used up. */
1513 /* elt gets the alist element or symbol.
1514 eltstring gets the name to check as a completion. */
1521 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1526 if (!EQ (bucket
, zero
))
1528 if (!SYMBOLP (bucket
))
1529 error ("Bad data in guts of obarray");
1532 if (XSYMBOL (bucket
)->next
)
1533 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1535 XSETFASTINT (bucket
, 0);
1537 else if (++idx
>= obsize
)
1541 bucket
= AREF (collection
, idx
);
1545 else /* if (type == 3) */
1547 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1548 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1550 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1553 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1556 /* Is this element a possible completion? */
1558 if (SYMBOLP (eltstring
))
1559 eltstring
= Fsymbol_name (eltstring
);
1561 if (STRINGP (eltstring
)
1562 && SCHARS (string
) <= SCHARS (eltstring
)
1563 /* If HIDE_SPACES, reject alternatives that start with space
1564 unless the input starts with space. */
1565 && (NILP (hide_spaces
)
1566 || (SBYTES (string
) > 0
1567 && SREF (string
, 0) == ' ')
1568 || SREF (eltstring
, 0) != ' ')
1569 && (tem
= Fcompare_strings (eltstring
, zero
,
1570 make_number (SCHARS (string
)),
1572 make_number (SCHARS (string
)),
1573 completion_ignore_case
? Qt
: Qnil
),
1577 Lisp_Object regexps
;
1579 /* Ignore this element if it fails to match all the regexps. */
1581 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1582 regexps
= XCDR (regexps
))
1584 if (bindcount
< 0) {
1585 bindcount
= SPECPDL_INDEX ();
1586 specbind (Qcase_fold_search
,
1587 completion_ignore_case
? Qt
: Qnil
);
1589 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1593 if (CONSP (regexps
))
1597 /* Ignore this element if there is a predicate
1598 and the predicate doesn't like it. */
1600 if (!NILP (predicate
))
1602 if (EQ (predicate
, Qcommandp
))
1603 tem
= Fcommandp (elt
, Qnil
);
1606 if (bindcount
>= 0) {
1607 unbind_to (bindcount
, Qnil
);
1610 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1612 ? call2 (predicate
, elt
,
1613 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1614 : call1 (predicate
, elt
);
1617 if (NILP (tem
)) continue;
1619 /* Ok => put it on the list. */
1620 allmatches
= Fcons (eltstring
, allmatches
);
1624 if (bindcount
>= 0) {
1625 unbind_to (bindcount
, Qnil
);
1629 return Fnreverse (allmatches
);
1632 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1633 doc
: /* Read a string in the minibuffer, with completion.
1634 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1635 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1636 COLLECTION can also be a function to do the completion itself.
1637 PREDICATE limits completion to a subset of COLLECTION.
1638 See `try-completion' and `all-completions' for more details
1639 on completion, COLLECTION, and PREDICATE.
1641 REQUIRE-MATCH can take the following values:
1642 - t means that the user is not allowed to exit unless
1643 the input is (or completes to) an element of COLLECTION or is null.
1644 - nil means that the user can exit with any input.
1645 - `confirm' means that the user can exit with any input, but she needs
1646 to confirm her choice if the input is not an element of COLLECTION.
1647 - `confirm-after-completion' means that the user can exit with any
1648 input, but she needs to confirm her choice if she called
1649 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1650 and the input is not an element of COLLECTION.
1651 - anything else behaves like t except that typing RET does not exit if it
1652 does non-null completion.
1654 If the input is null, `completing-read' returns DEF, or the first element
1655 of the list of default values, or an empty string if DEF is nil,
1656 regardless of the value of REQUIRE-MATCH.
1658 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1659 with point positioned at the end.
1660 If it is (STRING . POSITION), the initial input is STRING, but point
1661 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1662 that this is different from `read-from-minibuffer' and related
1663 functions, which use one-indexing for POSITION.) This feature is
1664 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1665 default value DEF instead. The user can yank the default value into
1666 the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1668 HIST, if non-nil, specifies a history list and optionally the initial
1669 position in the list. It can be a symbol, which is the history list
1670 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1671 that case, HISTVAR is the history list variable to use, and HISTPOS
1672 is the initial position (the position in the list used by the
1673 minibuffer history commands). For consistency, you should also
1674 specify that element of the history as the value of
1675 INITIAL-INPUT. (This is the only case in which you should use
1676 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1677 1 at the beginning of the list. The variable `history-length'
1678 controls the maximum length of a history list.
1680 DEF, if non-nil, is the default value or the list of default values.
1682 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1683 the current input method and the setting of `enable-multibyte-characters'.
1685 Completion ignores case if the ambient value of
1686 `completion-ignore-case' is non-nil.
1688 See also `completing-read-function'. */)
1689 (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
)
1691 Lisp_Object args
[9];
1692 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1694 args
[2] = collection
;
1695 args
[3] = predicate
;
1696 args
[4] = require_match
;
1697 args
[5] = initial_input
;
1700 args
[8] = inherit_input_method
;
1701 return Ffuncall (9, args
);
1704 /* Test whether TXT is an exact completion. */
1705 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1706 doc
: /* Return non-nil if STRING is a valid completion.
1707 Takes the same arguments as `all-completions' and `try-completion'.
1708 If COLLECTION is a function, it is called with three arguments:
1709 the values STRING, PREDICATE and `lambda'. */)
1710 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1712 Lisp_Object regexps
, tail
, tem
= Qnil
;
1715 CHECK_STRING (string
);
1717 if (NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
)))
1719 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1723 else if (VECTORP (collection
))
1725 /* Bypass intern-soft as that loses for nil. */
1726 tem
= oblookup (collection
,
1732 if (STRING_MULTIBYTE (string
))
1733 string
= Fstring_make_unibyte (string
);
1735 string
= Fstring_make_multibyte (string
);
1737 tem
= oblookup (collection
,
1743 if (completion_ignore_case
&& !SYMBOLP (tem
))
1745 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1747 tail
= AREF (collection
, i
);
1751 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1752 Fsymbol_name (tail
),
1753 make_number (0) , Qnil
, Qt
),
1759 if (XSYMBOL (tail
)->next
== 0)
1761 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1769 else if (HASH_TABLE_P (collection
))
1771 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1772 Lisp_Object key
= Qnil
;
1773 i
= hash_lookup (h
, string
, NULL
);
1775 tem
= HASH_KEY (h
, i
);
1777 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1778 if (!NILP (HASH_HASH (h
, i
))
1779 && (key
= HASH_KEY (h
, i
),
1780 SYMBOLP (key
) ? key
= Fsymbol_name (key
) : key
,
1782 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1783 key
, make_number (0) , Qnil
,
1784 completion_ignore_case
? Qt
: Qnil
),
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 if (NILP (Fstring_match (XCAR (regexps
),
1805 SYMBOLP (tem
) ? string
: tem
,
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 static Lisp_Object Qmetadata
;
1825 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1826 doc
: /* Perform completion on buffer names.
1827 STRING and PREDICATE have the same meanings as in `try-completion',
1828 `all-completions', and `test-completion'.
1830 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1831 `all-completions'; otherwise invoke `test-completion'. */)
1832 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1835 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1836 else if (EQ (flag
, Qt
))
1838 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1839 if (SCHARS (string
) > 0)
1842 { /* Strip out internal buffers. */
1843 Lisp_Object bufs
= res
;
1844 /* First, look for a non-internal buffer in `res'. */
1845 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1848 return (EQ (Flength (res
), Flength (Vbuffer_alist
))
1849 /* If all bufs are internal don't strip them out. */
1852 while (CONSP (XCDR (bufs
)))
1853 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1854 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1860 else if (EQ (flag
, Qlambda
))
1861 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1862 else if (EQ (flag
, Qmetadata
))
1863 return list2 (Qmetadata
, Fcons (Qcategory
, Qbuffer
));
1868 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1870 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1871 doc
: /* Like `assoc' but specifically for strings (and symbols).
1873 This returns the first element of LIST whose car matches the string or
1874 symbol KEY, or nil if no match exists. When performing the
1875 comparison, symbols are first converted to strings, and unibyte
1876 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1879 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1880 single string, rather than a cons cell whose car is a string. */)
1881 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1883 register Lisp_Object tail
;
1886 key
= Fsymbol_name (key
);
1888 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1890 register Lisp_Object elt
, tem
, thiscar
;
1892 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1893 if (SYMBOLP (thiscar
))
1894 thiscar
= Fsymbol_name (thiscar
);
1895 else if (!STRINGP (thiscar
))
1897 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1898 key
, make_number (0), Qnil
,
1908 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1909 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1912 return make_number (minibuf_level
);
1915 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1916 doc
: /* Return the prompt string of the currently-active minibuffer.
1917 If no minibuffer is active, return nil. */)
1920 return Fcopy_sequence (minibuf_prompt
);
1925 init_minibuf_once (void)
1927 Vminibuffer_list
= Qnil
;
1928 staticpro (&Vminibuffer_list
);
1932 syms_of_minibuf (void)
1935 minibuf_prompt
= Qnil
;
1936 staticpro (&minibuf_prompt
);
1938 minibuf_save_list
= Qnil
;
1939 staticpro (&minibuf_save_list
);
1941 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1942 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1943 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1944 Fset (Qminibuffer_default
, Qnil
);
1946 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1947 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1948 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1950 staticpro (&last_minibuf_string
);
1951 last_minibuf_string
= Qnil
;
1953 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1954 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1955 Fset (Qbuffer_name_history
, Qnil
);
1957 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1958 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1959 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1960 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");
1966 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1967 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1968 For example, `eval-expression' uses this. */);
1969 Vread_expression_history
= Qnil
;
1971 DEFSYM (Qread_expression_history
, "read-expression-history");
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 enable_recursive_minibuffers
= 0;
2028 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2029 doc
: /* Alist or obarray used for completion in the minibuffer.
2030 This becomes the ALIST argument to `try-completion' and `all-completions'.
2031 The value can also be a list of strings or a hash table.
2033 The value may alternatively be a function, which is given three arguments:
2034 STRING, the current buffer contents;
2035 PREDICATE, the predicate for filtering possible matches;
2036 CODE, which says what kind of things to do.
2037 CODE can be nil, t or `lambda':
2038 nil -- return the best completion of STRING, or nil if there is none.
2039 t -- return a list of all possible completions of STRING.
2040 lambda -- return t if STRING is a valid completion as it stands. */);
2041 Vminibuffer_completion_table
= Qnil
;
2043 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2044 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2045 Vminibuffer_completion_predicate
= Qnil
;
2047 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2048 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2049 If nil, confirmation is not required.
2050 If the value is `confirm', the user may exit with an input that is not
2051 a valid completion alternative, but Emacs asks for confirmation.
2052 If the value is `confirm-after-completion', the user may exit with an
2053 input that is not a valid completion alternative, but Emacs asks for
2054 confirmation if the user submitted the input right after any of the
2055 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2056 Vminibuffer_completion_confirm
= Qnil
;
2058 DEFVAR_LISP ("minibuffer-completing-file-name",
2059 Vminibuffer_completing_file_name
,
2060 doc
: /* Non-nil means completing file names. */);
2061 Vminibuffer_completing_file_name
= Qnil
;
2063 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2064 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2065 Vminibuffer_help_form
= Qnil
;
2067 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2068 doc
: /* History list symbol to add minibuffer values to.
2069 Each string of minibuffer input, as it appears on exit from the minibuffer,
2071 (set minibuffer-history-variable
2072 (cons STRING (symbol-value minibuffer-history-variable))) */);
2073 XSETFASTINT (Vminibuffer_history_variable
, 0);
2075 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2076 doc
: /* Current position of redoing in the history list. */);
2077 Vminibuffer_history_position
= Qnil
;
2079 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2080 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2081 Some uses of the echo area also raise that frame (since they use it too). */);
2082 minibuffer_auto_raise
= 0;
2084 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2085 doc
: /* List of regexps that should restrict possible completions.
2086 The basic completion functions only consider a completion acceptable
2087 if it matches all regular expressions in this list, with
2088 `case-fold-search' bound to the value of `completion-ignore-case'.
2089 See Info node `(elisp)Basic Completion', for a description of these
2091 Vcompletion_regexp_list
= Qnil
;
2093 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2094 minibuffer_allow_text_properties
,
2095 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2096 This also affects `read-string', but it does not affect `read-minibuffer',
2097 `read-no-blanks-input', or any of the functions that do minibuffer input
2098 with completion; they always discard text properties. */);
2099 minibuffer_allow_text_properties
= 0;
2101 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2102 doc
: /* Text properties that are added to minibuffer prompts.
2103 These are in addition to the basic `field' property, and stickiness
2105 /* We use `intern' here instead of Qread_only to avoid
2106 initialization-order problems. */
2107 Vminibuffer_prompt_properties
= list2 (intern_c_string ("read-only"), Qt
);
2109 DEFVAR_LISP ("read-hide-char", Vread_hide_char
,
2110 doc
: /* Whether to hide input characters in noninteractive mode.
2111 It must be a character, which will be used to mask the input
2112 characters. This variable should never be set globally. */);
2113 Vread_hide_char
= Qnil
;
2115 defsubr (&Sactive_minibuffer_window
);
2116 defsubr (&Sset_minibuffer_window
);
2117 defsubr (&Sread_from_minibuffer
);
2118 defsubr (&Sread_string
);
2119 defsubr (&Sread_command
);
2120 defsubr (&Sread_variable
);
2121 defsubr (&Sinternal_complete_buffer
);
2122 defsubr (&Sread_buffer
);
2123 defsubr (&Sread_no_blanks_input
);
2124 defsubr (&Sminibuffer_depth
);
2125 defsubr (&Sminibuffer_prompt
);
2127 defsubr (&Sminibufferp
);
2128 defsubr (&Sminibuffer_prompt_end
);
2129 defsubr (&Sminibuffer_contents
);
2130 defsubr (&Sminibuffer_contents_no_properties
);
2131 defsubr (&Sminibuffer_completion_contents
);
2133 defsubr (&Stry_completion
);
2134 defsubr (&Sall_completions
);
2135 defsubr (&Stest_completion
);
2136 defsubr (&Sassoc_string
);
2137 defsubr (&Scompleting_read
);