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/>. */
27 #include "character.h"
29 #include "dispextern.h"
34 #include "intervals.h"
36 #include "termhooks.h"
38 /* List of buffers for use as minibuffers.
39 The first element of the list is used for the outermost minibuffer
40 invocation, the next element is used for a recursive minibuffer
41 invocation, etc. The list is extended at the end as deeper
42 minibuffer recursions are encountered. */
44 Lisp_Object Vminibuffer_list
;
46 /* Data to remember during recursive minibuffer invocations. */
48 static Lisp_Object minibuf_save_list
;
50 /* Depth in minibuffer invocations. */
52 EMACS_INT minibuf_level
;
54 /* The maximum length of a minibuffer history. */
56 static Lisp_Object Qhistory_length
;
58 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string
;
62 static Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
64 static Lisp_Object Qread_file_name_internal
;
66 /* Normal hooks for entry to and exit from minibuffer. */
68 static Lisp_Object Qminibuffer_setup_hook
;
69 static Lisp_Object Qminibuffer_exit_hook
;
71 Lisp_Object Qcompletion_ignore_case
;
72 static Lisp_Object Qminibuffer_completion_table
;
73 static Lisp_Object Qminibuffer_completion_predicate
;
74 static Lisp_Object Qminibuffer_completion_confirm
;
75 static Lisp_Object Qcustom_variable_p
;
77 static Lisp_Object Qminibuffer_default
;
79 static Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
81 static Lisp_Object Qcase_fold_search
;
83 static Lisp_Object Qread_expression_history
;
85 /* Prompt to display in front of the mini-buffer contents. */
87 static Lisp_Object minibuf_prompt
;
89 /* Width of current mini-buffer prompt. Only set after display_line
90 of the line that contains the prompt. */
92 static ptrdiff_t minibuf_prompt_width
;
95 /* Put minibuf on currently selected frame's minibuffer.
96 We do this whenever the user starts a new minibuffer
97 or when a minibuffer exits. */
100 choose_minibuf_frame (void)
102 if (FRAMEP (selected_frame
)
103 && FRAME_LIVE_P (XFRAME (selected_frame
))
104 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
106 struct frame
*sf
= XFRAME (selected_frame
);
109 /* I don't think that any frames may validly have a null minibuffer
111 if (NILP (sf
->minibuffer_window
))
114 /* Under X, we come here with minibuf_window being the
115 minibuffer window of the unused termcap window created in
116 init_window_once. That window doesn't have a buffer. */
117 buffer
= XWINDOW (minibuf_window
)->contents
;
118 if (BUFFERP (buffer
))
119 /* Use set_window_buffer instead of Fset_window_buffer (see
120 discussion of bug#11984, bug#12025, bug#12026). */
121 set_window_buffer (sf
->minibuffer_window
, buffer
, 0, 0);
122 minibuf_window
= sf
->minibuffer_window
;
125 /* Make sure no other frame has a minibuffer as its selected window,
126 because the text would not be displayed in it, and that would be
127 confusing. Only allow the selected frame to do this,
128 and that only if the minibuffer is active. */
130 Lisp_Object tail
, frame
;
132 FOR_EACH_FRAME (tail
, frame
)
133 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
134 && !(EQ (frame
, selected_frame
)
135 && minibuf_level
> 0))
136 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
140 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
141 Sactive_minibuffer_window
, 0, 0, 0,
142 doc
: /* Return the currently active minibuffer window, or nil if none. */)
145 return minibuf_level
? minibuf_window
: Qnil
;
148 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
149 Sset_minibuffer_window
, 1, 1, 0,
150 doc
: /* Specify which minibuffer window to use for the minibuffer.
151 This affects where the minibuffer is displayed if you put text in it
152 without invoking the usual minibuffer commands. */)
155 CHECK_WINDOW (window
);
156 if (! MINI_WINDOW_P (XWINDOW (window
)))
157 error ("Window is not a minibuffer window");
159 minibuf_window
= window
;
165 /* Actual minibuffer invocation. */
167 static void read_minibuf_unwind (void);
168 static void run_exit_minibuf_hook (void);
171 /* Read a Lisp object from VAL and return it. If VAL is an empty
172 string, and DEFALT is a string, read from DEFALT instead of VAL. */
175 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
177 struct gcpro gcpro1
, gcpro2
;
178 Lisp_Object expr_and_pos
;
181 GCPRO2 (val
, defalt
);
183 if (STRINGP (val
) && SCHARS (val
) == 0)
185 if (STRINGP (defalt
))
187 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
191 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
192 pos
= XINT (Fcdr (expr_and_pos
));
193 if (pos
!= SCHARS (val
))
195 /* Ignore trailing whitespace; any other trailing junk
198 pos
= string_char_to_byte (val
, pos
);
199 for (i
= pos
; i
< SBYTES (val
); i
++)
201 int c
= SREF (val
, i
);
202 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
203 error ("Trailing garbage following expression");
207 val
= Fcar (expr_and_pos
);
212 /* Like read_minibuf but reading from stdin. This function is called
213 from read_minibuf to do the job if noninteractive. */
216 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
217 Lisp_Object prompt
, Lisp_Object backup_n
,
219 Lisp_Object histvar
, Lisp_Object histpos
,
221 bool allow_props
, bool inherit_input_method
)
228 fprintf (stdout
, "%s", SDATA (prompt
));
234 line
= xmalloc_atomic (size
);
236 while ((c
= getchar ()) != '\n')
247 if (STRING_BYTES_BOUND
/ 2 < size
)
248 memory_full (SIZE_MAX
);
250 line
= xrealloc (line
, size
);
256 if (len
|| c
== '\n')
258 val
= make_string (line
, len
);
264 error ("Error reading from stdin");
267 /* If Lisp form desired instead of string, parse it. */
269 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
274 DEFUN ("minibufferp", Fminibufferp
,
275 Sminibufferp
, 0, 1, 0,
276 doc
: /* Return t if BUFFER is a minibuffer.
277 No argument or nil as argument means use current buffer as BUFFER.
278 BUFFER can be a buffer or a buffer name. */)
284 buffer
= Fcurrent_buffer ();
285 else if (STRINGP (buffer
))
286 buffer
= Fget_buffer (buffer
);
288 CHECK_BUFFER (buffer
);
290 tem
= Fmemq (buffer
, Vminibuffer_list
);
291 return ! NILP (tem
) ? Qt
: Qnil
;
294 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
295 Sminibuffer_prompt_end
, 0, 0, 0,
296 doc
: /* Return the buffer position of the end of the minibuffer prompt.
297 Return (point-min) if current buffer is not a minibuffer. */)
300 /* This function is written to be most efficient when there's a prompt. */
301 Lisp_Object beg
, end
, tem
;
302 beg
= make_number (BEGV
);
304 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
308 end
= Ffield_end (beg
, Qnil
, Qnil
);
310 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
316 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
317 Sminibuffer_contents
, 0, 0, 0,
318 doc
: /* Return the user input in a minibuffer as a string.
319 If the current buffer is not a minibuffer, return its entire contents. */)
322 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
323 return make_buffer_string (prompt_end
, ZV
, 1);
326 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
327 Sminibuffer_contents_no_properties
, 0, 0, 0,
328 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
329 If the current buffer is not a minibuffer, return its entire contents. */)
332 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
333 return make_buffer_string (prompt_end
, ZV
, 0);
336 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
337 Sminibuffer_completion_contents
, 0, 0, 0,
338 doc
: /* Return the user input in a minibuffer before point as a string.
339 That is what completion commands operate on.
340 If the current buffer is not a minibuffer, return its entire contents. */)
343 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
345 error ("Cannot do completion in the prompt");
346 return make_buffer_string (prompt_end
, PT
, 1);
350 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
351 putting point minus BACKUP_N bytes from the end of INITIAL,
352 prompting with PROMPT (a string), using history list HISTVAR
353 with initial position HISTPOS. INITIAL should be a string or a
354 cons of a string and an integer. BACKUP_N should be <= 0, or
355 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
356 ignored and replaced with an integer that puts point at one-indexed
357 position N in INITIAL, where N is the CDR of INITIAL, or at the
358 beginning of INITIAL if N <= 0.
360 Normally return the result as a string (the text that was read),
361 but if EXPFLAG, read it and return the object read.
362 If HISTVAR is given, save the value read on that history only if it doesn't
363 match the front of that history list exactly. The value is pushed onto
364 the list as the string that was read.
366 DEFALT specifies the default value for the sake of history commands.
368 If ALLOW_PROPS, do not throw away text properties.
370 if INHERIT_INPUT_METHOD, the minibuffer inherits the
371 current input method. */
374 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
376 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
377 bool allow_props
, bool inherit_input_method
)
381 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
382 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
383 Lisp_Object enable_multibyte
;
385 /* String to add to the history. */
386 Lisp_Object histstring
;
389 Lisp_Object empty_minibuf
;
390 Lisp_Object dummy
, frame
;
392 specbind (Qminibuffer_default
, defalt
);
393 specbind (intern ("inhibit-read-only"), Qnil
);
395 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
396 in previous recursive minibuffer, but was not set explicitly
397 to t for this invocation, so set it to nil in this minibuffer.
398 Save the old value now, before we change it. */
399 specbind (intern ("minibuffer-completing-file-name"),
400 Vminibuffer_completing_file_name
);
401 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
402 Vminibuffer_completing_file_name
= Qnil
;
404 #ifdef HAVE_WINDOW_SYSTEM
405 if (display_hourglass_p
)
413 Lisp_Object backup_n
= XCDR (initial
);
414 initial
= XCAR (initial
);
415 CHECK_STRING (initial
);
416 if (!NILP (backup_n
))
418 CHECK_NUMBER (backup_n
);
419 /* Convert to distance from end of input. */
420 if (XINT (backup_n
) < 1)
421 /* A number too small means the beginning of the string. */
422 pos
= - SCHARS (initial
);
424 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
428 CHECK_STRING (initial
);
431 ambient_dir
= BVAR (current_buffer
, directory
);
433 enable_multibyte
= Qnil
;
435 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
436 store them away before we can GC. Don't need to protect
437 BACKUP_N because we use the value only if it is an integer. */
438 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
440 if (!STRINGP (prompt
))
441 prompt
= empty_unibyte_string
;
443 if (!enable_recursive_minibuffers
444 && minibuf_level
> 0)
446 if (EQ (selected_window
, minibuf_window
))
447 error ("Command attempted to use minibuffer while in minibuffer");
449 /* If we're in another window, cancel the minibuffer that's active. */
451 build_string ("Command attempted to use minibuffer while in minibuffer"));
455 /* In case we are running as a daemon, only do this before
456 detaching from the terminal. */
457 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
458 && NILP (Vexecuting_kbd_macro
))
460 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
462 expflag
, histvar
, histpos
, defalt
,
463 allow_props
, inherit_input_method
);
469 /* Choose the minibuffer window and frame, and take action on them. */
471 /* Prepare for restoring the current buffer since choose_minibuf_frame
472 calling Fset_frame_selected_window may change it (Bug#12766). */
473 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
475 choose_minibuf_frame ();
477 record_unwind_protect_void (choose_minibuf_frame
);
479 record_unwind_protect (restore_window_configuration
,
480 Fcurrent_window_configuration (Qnil
));
482 /* If the minibuffer window is on a different frame, save that
483 frame's configuration too. */
484 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
485 if (!EQ (mini_frame
, selected_frame
))
486 record_unwind_protect (restore_window_configuration
,
487 Fcurrent_window_configuration (mini_frame
));
489 /* If the minibuffer is on an iconified or invisible frame,
490 make it visible now. */
491 Fmake_frame_visible (mini_frame
);
493 if (minibuffer_auto_raise
)
494 Fraise_frame (mini_frame
);
496 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
498 /* We have to do this after saving the window configuration
499 since that is what restores the current buffer. */
501 /* Arrange to restore a number of minibuffer-related variables.
502 We could bind each variable separately, but that would use lots of
505 = Fcons (Voverriding_local_map
,
506 Fcons (minibuf_window
,
509 = Fcons (minibuf_prompt
,
510 Fcons (make_number (minibuf_prompt_width
),
512 Fcons (Vcurrent_prefix_arg
,
513 Fcons (Vminibuffer_history_position
,
514 Fcons (Vminibuffer_history_variable
,
515 minibuf_save_list
))))));
517 record_unwind_protect_void (read_minibuf_unwind
);
519 /* We are exiting the minibuffer one way or the other, so run the hook.
520 It should be run before unwinding the minibuf settings. Do it
521 separately from read_minibuf_unwind because we need to make sure that
522 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
523 signals an error. --Stef */
524 record_unwind_protect_void (run_exit_minibuf_hook
);
526 /* Now that we can restore all those variables, start changing them. */
528 minibuf_prompt_width
= 0;
529 minibuf_prompt
= Fcopy_sequence (prompt
);
530 Vminibuffer_history_position
= histpos
;
531 Vminibuffer_history_variable
= histvar
;
532 Vhelp_form
= Vminibuffer_help_form
;
533 /* If this minibuffer is reading a file name, that doesn't mean
534 recursive ones are. But we cannot set it to nil, because
535 completion code still need to know the minibuffer is completing a
536 file name. So use `lambda' as intermediate value meaning
537 "t" in this minibuffer, but "nil" in next minibuffer. */
538 if (!NILP (Vminibuffer_completing_file_name
))
539 Vminibuffer_completing_file_name
= Qlambda
;
541 /* If variable is unbound, make it nil. */
542 histval
= find_symbol_value (Vminibuffer_history_variable
);
543 if (EQ (histval
, Qunbound
))
545 Fset (Vminibuffer_history_variable
, Qnil
);
549 if (inherit_input_method
)
551 /* `current-input-method' is buffer local. So, remember it in
552 INPUT_METHOD before changing the current buffer. */
553 input_method
= Fsymbol_value (Qcurrent_input_method
);
554 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
557 /* Switch to the minibuffer. */
559 minibuffer
= get_minibuffer (minibuf_level
);
560 Fset_buffer (minibuffer
);
562 /* Defeat (setq-default truncate-lines t), since truncated lines do
563 not work correctly in minibuffers. (Bug#5715, etc) */
564 bset_truncate_lines (current_buffer
, Qnil
);
566 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
567 if (inherit_input_method
)
568 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
570 /* The current buffer's default directory is usually the right thing
571 for our minibuffer here. However, if you're typing a command at
572 a minibuffer-only frame when minibuf_level is zero, then buf IS
573 the current_buffer, so reset_buffer leaves buf's default
574 directory unchanged. This is a bummer when you've just started
575 up Emacs and buf's default directory is Qnil. Here's a hack; can
576 you think of something better to do? Find another buffer with a
577 better directory, and use that one instead. */
578 if (STRINGP (ambient_dir
))
579 bset_directory (current_buffer
, ambient_dir
);
582 Lisp_Object tail
, buf
;
584 FOR_EACH_LIVE_BUFFER (tail
, buf
)
585 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
587 bset_directory (current_buffer
,
588 BVAR (XBUFFER (buf
), directory
));
593 if (!EQ (mini_frame
, selected_frame
))
594 Fredirect_frame_focus (selected_frame
, mini_frame
);
596 Vminibuf_scroll_window
= selected_window
;
597 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
598 minibuf_selected_window
= selected_window
;
600 /* Empty out the minibuffers of all frames other than the one
601 where we are going to display one now.
602 Set them to point to ` *Minibuf-0*', which is always empty. */
603 empty_minibuf
= get_minibuffer (0);
605 FOR_EACH_FRAME (dummy
, frame
)
607 Lisp_Object root_window
= Fframe_root_window (frame
);
608 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
610 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
611 && !NILP (Fwindow_minibuffer_p (mini_window
)))
612 /* Use set_window_buffer instead of Fset_window_buffer (see
613 discussion of bug#11984, bug#12025, bug#12026). */
614 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
617 /* Display this minibuffer in the proper window. */
618 /* Use set_window_buffer instead of Fset_window_buffer (see
619 discussion of bug#11984, bug#12025, bug#12026). */
620 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
621 Fselect_window (minibuf_window
, Qnil
);
622 XWINDOW (minibuf_window
)->hscroll
= 0;
624 Fmake_local_variable (Qprint_escape_newlines
);
625 print_escape_newlines
= 1;
627 /* Erase the buffer. */
630 specbind (Qinhibit_read_only
, Qt
);
631 specbind (Qinhibit_modification_hooks
, Qt
);
634 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
635 && ! STRING_MULTIBYTE (minibuf_prompt
))
636 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
638 /* Insert the prompt, record where it ends. */
639 Finsert (1, &minibuf_prompt
);
642 Fput_text_property (make_number (BEG
), make_number (PT
),
643 Qfront_sticky
, Qt
, Qnil
);
644 Fput_text_property (make_number (BEG
), make_number (PT
),
645 Qrear_nonsticky
, Qt
, Qnil
);
646 Fput_text_property (make_number (BEG
), make_number (PT
),
648 Fadd_text_properties (make_number (BEG
), make_number (PT
),
649 Vminibuffer_prompt_properties
, Qnil
);
654 minibuf_prompt_width
= current_column ();
656 /* Put in the initial input. */
659 Finsert (1, &initial
);
660 Fforward_char (make_number (pos
));
663 clear_message (1, 1);
664 bset_keymap (current_buffer
, map
);
666 /* Turn on an input method stored in INPUT_METHOD if any. */
667 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
668 call1 (Qactivate_input_method
, input_method
);
670 Frun_hooks (1, &Qminibuffer_setup_hook
);
672 /* Don't allow the user to undo past this point. */
673 bset_undo_list (current_buffer
, Qnil
);
677 /* If cursor is on the minibuffer line,
678 show the user we have exited by putting it in column 0. */
679 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
682 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
683 XWINDOW (minibuf_window
)->cursor
.x
= 0;
684 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
685 update_frame (XFRAME (selected_frame
), 1, 1);
686 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
689 /* Make minibuffer contents into a string. */
690 Fset_buffer (minibuffer
);
692 val
= Fminibuffer_contents ();
694 val
= Fminibuffer_contents_no_properties ();
696 /* VAL is the string of minibuffer text. */
698 last_minibuf_string
= val
;
700 /* Choose the string to add to the history. */
701 if (SCHARS (val
) != 0)
703 else if (STRINGP (defalt
))
705 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
706 histstring
= XCAR (defalt
);
710 /* Add the value to the appropriate history list, if any. */
711 if (!NILP (Vhistory_add_new_input
)
712 && SYMBOLP (Vminibuffer_history_variable
)
713 && !NILP (histstring
))
715 /* If the caller wanted to save the value read on a history list,
716 then do so if the value is not already the front of the list. */
718 /* The value of the history variable must be a cons or nil. Other
719 values are unacceptable. We silently ignore these values. */
723 /* Don't duplicate the most recent entry in the history. */
724 && (NILP (Fequal (histstring
, Fcar (histval
))))))
728 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
729 histval
= Fcons (histstring
, histval
);
730 Fset (Vminibuffer_history_variable
, histval
);
732 /* Truncate if requested. */
733 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
734 if (NILP (length
)) length
= Vhistory_length
;
735 if (INTEGERP (length
))
737 if (XINT (length
) <= 0)
738 Fset (Vminibuffer_history_variable
, Qnil
);
743 temp
= Fnthcdr (Fsub1 (length
), histval
);
744 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
750 /* If Lisp form desired instead of string, parse it. */
752 val
= string_to_object (val
, defalt
);
754 /* The appropriate frame will get selected
755 in set-window-configuration. */
761 /* Return a buffer to be used as the minibuffer at depth `depth'.
762 depth = 0 is the lowest allowed argument, and that is the value
763 used for nonrecursive minibuffer invocations. */
766 get_minibuffer (EMACS_INT depth
)
768 Lisp_Object tail
, num
, buf
;
769 char name
[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT
)];
771 XSETFASTINT (num
, depth
);
772 tail
= Fnthcdr (num
, Vminibuffer_list
);
776 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
779 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
781 buf
= Fget_buffer_create
782 (make_formatted_string (name
, " *Minibuf-%"pI
"d*", depth
));
784 /* Although the buffer's name starts with a space, undo should be
786 Fbuffer_enable_undo (buf
);
793 /* We have to empty both overlay lists. Otherwise we end
794 up with overlays that think they belong to this buffer
795 while the buffer doesn't know about them any more. */
796 delete_all_overlays (XBUFFER (buf
));
797 reset_buffer (XBUFFER (buf
));
798 record_unwind_current_buffer ();
800 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
801 call0 (intern ("minibuffer-inactive-mode"));
803 Fkill_all_local_variables ();
811 run_exit_minibuf_hook (void)
813 safe_run_hooks (Qminibuffer_exit_hook
);
816 /* This function is called on exiting minibuffer, whether normally or
817 not, and it restores the current window, buffer, etc. */
820 read_minibuf_unwind (void)
822 Lisp_Object old_deactivate_mark
;
825 /* If this was a recursive minibuffer,
826 tie the minibuffer window back to the outer level minibuffer buffer. */
829 window
= minibuf_window
;
830 /* To keep things predictable, in case it matters, let's be in the
831 minibuffer when we reset the relevant variables. */
832 Fset_buffer (XWINDOW (window
)->contents
);
834 /* Restore prompt, etc, from outer minibuffer level. */
835 minibuf_prompt
= Fcar (minibuf_save_list
);
836 minibuf_save_list
= Fcdr (minibuf_save_list
);
837 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
838 minibuf_save_list
= Fcdr (minibuf_save_list
);
839 Vhelp_form
= Fcar (minibuf_save_list
);
840 minibuf_save_list
= Fcdr (minibuf_save_list
);
841 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
842 minibuf_save_list
= Fcdr (minibuf_save_list
);
843 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
844 minibuf_save_list
= Fcdr (minibuf_save_list
);
845 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
846 minibuf_save_list
= Fcdr (minibuf_save_list
);
847 Voverriding_local_map
= Fcar (minibuf_save_list
);
848 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 temp
= Fcar (minibuf_save_list
);
851 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
852 minibuf_window
= temp
;
854 minibuf_save_list
= Fcdr (minibuf_save_list
);
856 /* Erase the minibuffer we were using at this level. */
859 /* Prevent error in erase-buffer. */
860 specbind (Qinhibit_read_only
, Qt
);
861 specbind (Qinhibit_modification_hooks
, Qt
);
862 old_deactivate_mark
= Vdeactivate_mark
;
864 Vdeactivate_mark
= old_deactivate_mark
;
868 /* When we get to the outmost level, make sure we resize the
869 mini-window back to its normal size. */
870 if (minibuf_level
== 0)
871 resize_mini_window (XWINDOW (window
), 0);
873 /* In case the previous minibuffer displayed in this miniwindow is
874 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
875 to make sure we don't leave around bindings and stuff which only
876 made sense during the read_minibuf invocation. */
877 call0 (intern ("minibuffer-inactive-mode"));
881 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
882 Sread_from_minibuffer
, 1, 7, 0,
883 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
884 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
885 DEFAULT-VALUE. It normally should be nil in new code, except when
886 HIST is a cons. It is discussed in more detail below.
888 Third arg KEYMAP is a keymap to use whilst reading;
889 if omitted or nil, the default is `minibuffer-local-map'.
891 If fourth arg READ is non-nil, interpret the result as a Lisp object
892 and return that object:
893 in other words, do `(car (read-from-string INPUT-STRING))'
895 Fifth arg HIST, if non-nil, specifies a history list and optionally
896 the initial position in the list. It can be a symbol, which is the
897 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
898 In that case, HISTVAR is the history list variable to use, and
899 HISTPOS is the initial position for use by the minibuffer history
900 commands. For consistency, you should also specify that element of
901 the history as the value of INITIAL-CONTENTS. Positions are counted
902 starting from 1 at the beginning of the list.
904 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
905 as the default to `read' if READ is non-nil and the user enters
906 empty input. But if READ is nil, this function does _not_ return
907 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
909 Whatever the value of READ, DEFAULT-VALUE is made available via the
910 minibuffer history commands. DEFAULT-VALUE can also be a list of
911 strings, in which case all the strings are available in the history,
912 and the first string is the default to `read' if READ is non-nil.
914 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
915 the current input method and the setting of `enable-multibyte-characters'.
917 If the variable `minibuffer-allow-text-properties' is non-nil,
918 then the string which is returned includes whatever text properties
919 were present in the minibuffer. Otherwise the value has no text properties.
921 The remainder of this documentation string describes the
922 INITIAL-CONTENTS argument in more detail. It is only relevant when
923 studying existing code, or when HIST is a cons. If non-nil,
924 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
925 reading input. Normally, point is put at the end of that string.
926 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
927 input is STRING, but point is placed at _one-indexed_ position
928 POSITION in the minibuffer. Any integer value less than or equal to
929 one puts point at the beginning of the string. *Note* that this
930 behavior differs from the way such arguments are used in `completing-read'
931 and some related functions, which use zero-indexing for POSITION. */)
932 (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
)
934 Lisp_Object histvar
, histpos
, val
;
937 CHECK_STRING (prompt
);
939 keymap
= Vminibuffer_local_map
;
941 keymap
= get_keymap (keymap
, 1, 0);
950 histvar
= Fcar_safe (hist
);
951 histpos
= Fcdr_safe (hist
);
954 histvar
= Qminibuffer_history
;
956 XSETFASTINT (histpos
, 0);
958 GCPRO1 (default_value
);
959 val
= read_minibuf (keymap
, initial_contents
, prompt
,
961 histvar
, histpos
, default_value
,
962 minibuffer_allow_text_properties
,
963 !NILP (inherit_input_method
));
968 /* Functions that use the minibuffer to read various things. */
970 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
971 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
972 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
973 This argument has been superseded by DEFAULT-VALUE and should normally be nil
974 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
976 The third arg HISTORY, if non-nil, specifies a history list
977 and optionally the initial position in the list.
978 See `read-from-minibuffer' for details of HISTORY argument.
979 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
980 If non-nil, it is used for history commands, and as the value (or the first
981 element of the list of default values) to return if the user enters the
983 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
984 the current input method and the setting of `enable-multibyte-characters'. */)
985 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
990 /* Just in case we're in a recursive minibuffer, make it clear that the
991 previous minibuffer's completion table does not apply to the new
993 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
994 specbind (Qminibuffer_completion_table
, Qnil
);
996 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
997 Qnil
, history
, default_value
,
998 inherit_input_method
);
999 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1000 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1005 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1006 doc
: /* Read a string from the terminal, not allowing blanks.
1007 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1008 non-nil, it should be a string, which is used as initial input, with
1009 point positioned at the end, so that SPACE will accept the input.
1010 \(Actually, INITIAL can also be a cons of a string and an integer.
1011 Such values are treated as in `read-from-minibuffer', but are normally
1012 not useful in this function.)
1013 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1014 the current input method and the setting of`enable-multibyte-characters'. */)
1015 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1017 CHECK_STRING (prompt
);
1018 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
1019 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1020 !NILP (inherit_input_method
));
1023 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1024 doc
: /* Read the name of a command and return as a symbol.
1025 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1026 if it is a list. */)
1027 (Lisp_Object prompt
, Lisp_Object default_value
)
1029 Lisp_Object name
, default_string
;
1031 if (NILP (default_value
))
1032 default_string
= Qnil
;
1033 else if (SYMBOLP (default_value
))
1034 default_string
= SYMBOL_NAME (default_value
);
1036 default_string
= default_value
;
1038 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1039 Qnil
, Qnil
, default_string
, Qnil
);
1042 return Fintern (name
, Qnil
);
1046 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1047 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1048 Prompt with PROMPT. */)
1049 (Lisp_Object prompt
)
1051 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1056 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1057 doc
: /* Read the name of a user option and return it as a symbol.
1058 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1060 A user option, or customizable variable, is one for which
1061 `custom-variable-p' returns non-nil. */)
1062 (Lisp_Object prompt
, Lisp_Object default_value
)
1064 Lisp_Object name
, default_string
;
1066 if (NILP (default_value
))
1067 default_string
= Qnil
;
1068 else if (SYMBOLP (default_value
))
1069 default_string
= SYMBOL_NAME (default_value
);
1071 default_string
= default_value
;
1073 name
= Fcompleting_read (prompt
, Vobarray
,
1074 Qcustom_variable_p
, Qt
,
1075 Qnil
, Qnil
, default_string
, Qnil
);
1078 return Fintern (name
, Qnil
);
1081 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1082 doc
: /* Read the name of a buffer and return as a string.
1084 Optional second arg DEF is value to return if user enters an empty line.
1085 If DEF is a list of default values, return its first element.
1086 Optional third arg REQUIRE-MATCH determines whether non-existing
1087 buffer names are allowed. It has the same meaning as the
1088 REQUIRE-MATCH argument of `completing-read'.
1089 The argument PROMPT should be a string ending with a colon and a space.
1090 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1091 case while reading the buffer name.
1092 If `read-buffer-function' is non-nil, this works by calling it as a
1093 function, instead of the usual behavior. */)
1094 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1096 Lisp_Object args
[4], result
;
1102 def
= BVAR (XBUFFER (def
), name
);
1104 specbind (Qcompletion_ignore_case
,
1105 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1107 if (NILP (Vread_buffer_function
))
1111 /* A default value was provided: we must change PROMPT,
1112 editing the default value in before the colon. To achieve
1113 this, we replace PROMPT with a substring that doesn't
1114 contain the terminal space and colon (if present). They
1115 are then added back using Fformat. */
1117 if (STRINGP (prompt
))
1119 s
= SSDATA (prompt
);
1120 len
= SBYTES (prompt
);
1121 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1123 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1126 prompt
= make_specified_string (s
, -1, len
,
1127 STRING_MULTIBYTE (prompt
));
1130 args
[0] = build_string ("%s (default %s): ");
1132 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1133 prompt
= Fformat (3, args
);
1136 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1137 Qnil
, require_match
, Qnil
,
1138 Qbuffer_name_history
, def
, Qnil
);
1142 args
[0] = Vread_buffer_function
;
1145 args
[3] = require_match
;
1146 result
= Ffuncall (4, args
);
1152 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1153 doc
: /* Read a string in the minibuffer, with completion.
1154 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1155 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1156 COLLECTION can also be a function to do the completion itself.
1157 PREDICATE limits completion to a subset of COLLECTION.
1158 See `try-completion' and `all-completions' for more details
1159 on completion, COLLECTION, and PREDICATE.
1161 REQUIRE-MATCH can take the following values:
1162 - t means that the user is not allowed to exit unless
1163 the input is (or completes to) an element of COLLECTION or is null.
1164 - nil means that the user can exit with any input.
1165 - `confirm' means that the user can exit with any input, but she needs
1166 to confirm her choice if the input is not an element of COLLECTION.
1167 - `confirm-after-completion' means that the user can exit with any
1168 input, but she needs to confirm her choice if she called
1169 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1170 and the input is not an element of COLLECTION.
1171 - anything else behaves like t except that typing RET does not exit if it
1172 does non-null completion.
1174 If the input is null, `completing-read' returns DEF, or the first element
1175 of the list of default values, or an empty string if DEF is nil,
1176 regardless of the value of REQUIRE-MATCH.
1178 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1179 with point positioned at the end.
1180 If it is (STRING . POSITION), the initial input is STRING, but point
1181 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1182 that this is different from `read-from-minibuffer' and related
1183 functions, which use one-indexing for POSITION.) This feature is
1184 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1185 default value DEF instead. The user can yank the default value into
1186 the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1188 HIST, if non-nil, specifies a history list and optionally the initial
1189 position in the list. It can be a symbol, which is the history list
1190 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1191 that case, HISTVAR is the history list variable to use, and HISTPOS
1192 is the initial position (the position in the list used by the
1193 minibuffer history commands). For consistency, you should also
1194 specify that element of the history as the value of
1195 INITIAL-INPUT. (This is the only case in which you should use
1196 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1197 1 at the beginning of the list. The variable `history-length'
1198 controls the maximum length of a history list.
1200 DEF, if non-nil, is the default value or the list of default values.
1202 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1203 the current input method and the setting of `enable-multibyte-characters'.
1205 Completion ignores case if the ambient value of
1206 `completion-ignore-case' is non-nil.
1208 See also `completing-read-function'. */)
1209 (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
)
1211 Lisp_Object args
[9];
1212 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1214 args
[2] = collection
;
1215 args
[3] = predicate
;
1216 args
[4] = require_match
;
1217 args
[5] = initial_input
;
1220 args
[8] = inherit_input_method
;
1221 return Ffuncall (9, args
);
1224 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1226 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1227 doc
: /* Like `assoc' but specifically for strings (and symbols).
1229 This returns the first element of LIST whose car matches the string or
1230 symbol KEY, or nil if no match exists. When performing the
1231 comparison, symbols are first converted to strings, and unibyte
1232 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1235 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1236 single string, rather than a cons cell whose car is a string. */)
1237 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1239 register Lisp_Object tail
;
1242 key
= Fsymbol_name (key
);
1244 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1246 register Lisp_Object elt
, tem
, thiscar
;
1248 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1249 if (SYMBOLP (thiscar
))
1250 thiscar
= Fsymbol_name (thiscar
);
1251 else if (!STRINGP (thiscar
))
1253 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1254 key
, make_number (0), Qnil
,
1264 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1265 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1268 return make_number (minibuf_level
);
1271 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1272 doc
: /* Return the prompt string of the currently-active minibuffer.
1273 If no minibuffer is active, return nil. */)
1276 return Fcopy_sequence (minibuf_prompt
);
1281 init_minibuf_once (void)
1283 Vminibuffer_list
= Qnil
;
1284 staticpro (&Vminibuffer_list
);
1288 syms_of_minibuf (void)
1290 #include "minibuf.x"
1293 minibuf_prompt
= Qnil
;
1294 staticpro (&minibuf_prompt
);
1296 minibuf_save_list
= Qnil
;
1297 staticpro (&minibuf_save_list
);
1299 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1300 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1301 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1302 Fset (Qminibuffer_default
, Qnil
);
1304 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1305 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1306 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1308 staticpro (&last_minibuf_string
);
1309 last_minibuf_string
= Qnil
;
1311 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1312 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1313 Fset (Qbuffer_name_history
, Qnil
);
1315 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1316 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1317 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1318 DEFSYM (Qhistory_length
, "history-length");
1319 DEFSYM (Qcurrent_input_method
, "current-input-method");
1320 DEFSYM (Qactivate_input_method
, "activate-input-method");
1321 DEFSYM (Qcase_fold_search
, "case-fold-search");
1323 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1324 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1325 For example, `eval-expression' uses this. */);
1326 Vread_expression_history
= Qnil
;
1328 DEFSYM (Qread_expression_history
, "read-expression-history");
1330 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1331 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1332 The function is called with the arguments passed to `read-buffer'. */);
1333 Vread_buffer_function
= Qnil
;
1335 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1336 read_buffer_completion_ignore_case
,
1337 doc
: /* Non-nil means completion ignores case when reading a buffer name. */);
1338 read_buffer_completion_ignore_case
= 0;
1340 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1341 doc
: /* Normal hook run just after entry to minibuffer. */);
1342 Vminibuffer_setup_hook
= Qnil
;
1344 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1345 doc
: /* Normal hook run just after exit from minibuffer. */);
1346 Vminibuffer_exit_hook
= Qnil
;
1348 DEFVAR_LISP ("history-length", Vhistory_length
,
1349 doc
: /* Maximum length of history lists before truncation takes place.
1350 A number means truncate to that length; truncation deletes old
1351 elements, and is done just after inserting a new element.
1352 A value of t means no truncation.
1354 This variable only affects history lists that don't specify their own
1355 maximum lengths. Setting the `history-length' property of a history
1356 variable overrides this default. */);
1357 XSETFASTINT (Vhistory_length
, 100);
1359 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
1360 doc
: /* Non-nil means to delete duplicates in history.
1361 If set to t when adding a new history element, all previous identical
1362 elements are deleted from the history list. */);
1363 history_delete_duplicates
= 0;
1365 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
1366 doc
: /* Non-nil means to add new elements in history.
1367 If set to nil, minibuffer reading functions don't add new elements to the
1368 history list, so it is possible to do this afterwards by calling
1369 `add-to-history' explicitly. */);
1370 Vhistory_add_new_input
= Qt
;
1372 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
1373 doc
: /* Non-nil means don't consider case significant in completion.
1374 For file-name completion, `read-file-name-completion-ignore-case'
1375 controls the behavior, rather than this variable.
1376 For buffer name completion, `read-buffer-completion-ignore-case'
1377 controls the behavior, rather than this variable. */);
1378 completion_ignore_case
= 0;
1380 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
1381 doc
: /* Non-nil means to allow minibuffer commands while in the minibuffer.
1382 This variable makes a difference whenever the minibuffer window is active. */);
1383 enable_recursive_minibuffers
= 0;
1385 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
1386 doc
: /* Alist or obarray used for completion in the minibuffer.
1387 This becomes the ALIST argument to `try-completion' and `all-completions'.
1388 The value can also be a list of strings or a hash table.
1390 The value may alternatively be a function, which is given three arguments:
1391 STRING, the current buffer contents;
1392 PREDICATE, the predicate for filtering possible matches;
1393 CODE, which says what kind of things to do.
1394 CODE can be nil, t or `lambda':
1395 nil -- return the best completion of STRING, or nil if there is none.
1396 t -- return a list of all possible completions of STRING.
1397 lambda -- return t if STRING is a valid completion as it stands. */);
1398 Vminibuffer_completion_table
= Qnil
;
1400 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
1401 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
1402 Vminibuffer_completion_predicate
= Qnil
;
1404 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
1405 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
1406 If nil, confirmation is not required.
1407 If the value is `confirm', the user may exit with an input that is not
1408 a valid completion alternative, but Emacs asks for confirmation.
1409 If the value is `confirm-after-completion', the user may exit with an
1410 input that is not a valid completion alternative, but Emacs asks for
1411 confirmation if the user submitted the input right after any of the
1412 completion commands listed in `minibuffer-confirm-exit-commands'. */);
1413 Vminibuffer_completion_confirm
= Qnil
;
1415 DEFVAR_LISP ("minibuffer-completing-file-name",
1416 Vminibuffer_completing_file_name
,
1417 doc
: /* Non-nil means completing file names. */);
1418 Vminibuffer_completing_file_name
= Qnil
;
1420 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
1421 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
1422 Vminibuffer_help_form
= Qnil
;
1424 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
1425 doc
: /* History list symbol to add minibuffer values to.
1426 Each string of minibuffer input, as it appears on exit from the minibuffer,
1428 (set minibuffer-history-variable
1429 (cons STRING (symbol-value minibuffer-history-variable))) */);
1430 XSETFASTINT (Vminibuffer_history_variable
, 0);
1432 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
1433 doc
: /* Current position of redoing in the history list. */);
1434 Vminibuffer_history_position
= Qnil
;
1436 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
1437 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
1438 Some uses of the echo area also raise that frame (since they use it too). */);
1439 minibuffer_auto_raise
= 0;
1441 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
1442 doc
: /* List of regexps that should restrict possible completions.
1443 The basic completion functions only consider a completion acceptable
1444 if it matches all regular expressions in this list, with
1445 `case-fold-search' bound to the value of `completion-ignore-case'.
1446 See Info node `(elisp)Basic Completion', for a description of these
1448 Vcompletion_regexp_list
= Qnil
;
1450 DEFVAR_BOOL ("minibuffer-allow-text-properties",
1451 minibuffer_allow_text_properties
,
1452 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
1453 This also affects `read-string', but it does not affect `read-minibuffer',
1454 `read-no-blanks-input', or any of the functions that do minibuffer input
1455 with completion; they always discard text properties. */);
1456 minibuffer_allow_text_properties
= 0;
1458 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
1459 doc
: /* Text properties that are added to minibuffer prompts.
1460 These are in addition to the basic `field' property, and stickiness
1462 /* We use `intern' here instead of Qread_only to avoid
1463 initialization-order problems. */
1464 Vminibuffer_prompt_properties
= list2 (intern_c_string ("read-only"), Qt
);