1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2011 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/>. */
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 Quser_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 EMACS_INT 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
)->buffer
;
118 if (BUFFERP (buffer
))
119 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
120 minibuf_window
= sf
->minibuffer_window
;
123 /* Make sure no other frame has a minibuffer as its selected window,
124 because the text would not be displayed in it, and that would be
125 confusing. Only allow the selected frame to do this,
126 and that only if the minibuffer is active. */
128 Lisp_Object tail
, frame
;
130 FOR_EACH_FRAME (tail
, frame
)
131 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
132 && !(EQ (frame
, selected_frame
)
133 && minibuf_level
> 0))
134 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
139 choose_minibuf_frame_1 (Lisp_Object ignore
)
141 choose_minibuf_frame ();
145 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
146 Sactive_minibuffer_window
, 0, 0, 0,
147 doc
: /* Return the currently active minibuffer window, or nil if none. */)
150 return minibuf_level
? minibuf_window
: Qnil
;
153 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
154 Sset_minibuffer_window
, 1, 1, 0,
155 doc
: /* Specify which minibuffer window to use for the minibuffer.
156 This affects where the minibuffer is displayed if you put text in it
157 without invoking the usual minibuffer commands. */)
160 CHECK_WINDOW (window
);
161 if (! MINI_WINDOW_P (XWINDOW (window
)))
162 error ("Window is not a minibuffer window");
164 minibuf_window
= window
;
170 /* Actual minibuffer invocation. */
172 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
173 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
174 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
175 Lisp_Object
, Lisp_Object
,
177 Lisp_Object
, Lisp_Object
,
179 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
180 Lisp_Object
, Lisp_Object
,
182 Lisp_Object
, Lisp_Object
,
184 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
187 /* Read a Lisp object from VAL and return it. If VAL is an empty
188 string, and DEFALT is a string, read from DEFALT instead of VAL. */
191 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
193 struct gcpro gcpro1
, gcpro2
;
194 Lisp_Object expr_and_pos
;
197 GCPRO2 (val
, defalt
);
199 if (STRINGP (val
) && SCHARS (val
) == 0)
201 if (STRINGP (defalt
))
203 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
207 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
208 pos
= XINT (Fcdr (expr_and_pos
));
209 if (pos
!= SCHARS (val
))
211 /* Ignore trailing whitespace; any other trailing junk
214 pos
= string_char_to_byte (val
, pos
);
215 for (i
= pos
; i
< SBYTES (val
); i
++)
217 int c
= SREF (val
, i
);
218 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
219 error ("Trailing garbage following expression");
223 val
= Fcar (expr_and_pos
);
224 RETURN_UNGCPRO (val
);
228 /* Like read_minibuf but reading from stdin. This function is called
229 from read_minibuf to do the job if noninteractive. */
232 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
233 Lisp_Object prompt
, Lisp_Object backup_n
,
235 Lisp_Object histvar
, Lisp_Object histpos
,
237 int allow_props
, int inherit_input_method
)
244 fprintf (stdout
, "%s", SDATA (prompt
));
250 line
= (char *) xmalloc (size
);
252 while ((c
= getchar ()) != '\n')
263 if (STRING_BYTES_BOUND
/ 2 < size
)
264 memory_full (SIZE_MAX
);
266 line
= (char *) xrealloc (line
, size
);
274 val
= make_string (line
, len
);
280 error ("Error reading from stdin");
283 /* If Lisp form desired instead of string, parse it. */
285 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
290 DEFUN ("minibufferp", Fminibufferp
,
291 Sminibufferp
, 0, 1, 0,
292 doc
: /* Return t if BUFFER is a minibuffer.
293 No argument or nil as argument means use current buffer as BUFFER.
294 BUFFER can be a buffer or a buffer name. */)
300 buffer
= Fcurrent_buffer ();
301 else if (STRINGP (buffer
))
302 buffer
= Fget_buffer (buffer
);
304 CHECK_BUFFER (buffer
);
306 tem
= Fmemq (buffer
, Vminibuffer_list
);
307 return ! NILP (tem
) ? Qt
: Qnil
;
310 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
311 Sminibuffer_prompt_end
, 0, 0, 0,
312 doc
: /* Return the buffer position of the end of the minibuffer prompt.
313 Return (point-min) if current buffer is not a minibuffer. */)
316 /* This function is written to be most efficient when there's a prompt. */
317 Lisp_Object beg
, end
, tem
;
318 beg
= make_number (BEGV
);
320 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
324 end
= Ffield_end (beg
, Qnil
, Qnil
);
326 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
332 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
333 Sminibuffer_contents
, 0, 0, 0,
334 doc
: /* Return the user input in a minibuffer as a string.
335 If the current buffer is not a minibuffer, return its entire contents. */)
338 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
339 return make_buffer_string (prompt_end
, ZV
, 1);
342 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
343 Sminibuffer_contents_no_properties
, 0, 0, 0,
344 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
345 If the current buffer is not a minibuffer, return its entire contents. */)
348 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
349 return make_buffer_string (prompt_end
, ZV
, 0);
352 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
353 Sminibuffer_completion_contents
, 0, 0, 0,
354 doc
: /* Return the user input in a minibuffer before point as a string.
355 That is what completion commands operate on.
356 If the current buffer is not a minibuffer, return its entire contents. */)
359 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
361 error ("Cannot do completion in the prompt");
362 return make_buffer_string (prompt_end
, PT
, 1);
366 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
367 putting point minus BACKUP_N bytes from the end of INITIAL,
368 prompting with PROMPT (a string), using history list HISTVAR
369 with initial position HISTPOS. INITIAL should be a string or a
370 cons of a string and an integer. BACKUP_N should be <= 0, or
371 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
372 ignored and replaced with an integer that puts point at one-indexed
373 position N in INITIAL, where N is the CDR of INITIAL, or at the
374 beginning of INITIAL if N <= 0.
376 Normally return the result as a string (the text that was read),
377 but if EXPFLAG is nonzero, read it and return the object read.
378 If HISTVAR is given, save the value read on that history only if it doesn't
379 match the front of that history list exactly. The value is pushed onto
380 the list as the string that was read.
382 DEFALT specifies the default value for the sake of history commands.
384 If ALLOW_PROPS is nonzero, we do not throw away text properties.
386 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
387 current input method. */
390 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
391 Lisp_Object backup_n
, int expflag
,
392 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
393 int allow_props
, int inherit_input_method
)
396 int count
= SPECPDL_INDEX ();
397 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
398 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
399 Lisp_Object enable_multibyte
;
400 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
401 /* String to add to the history. */
402 Lisp_Object histstring
;
404 Lisp_Object empty_minibuf
;
405 Lisp_Object dummy
, frame
;
407 specbind (Qminibuffer_default
, defalt
);
409 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
410 in previous recursive minibuffer, but was not set explicitly
411 to t for this invocation, so set it to nil in this minibuffer.
412 Save the old value now, before we change it. */
413 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
414 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
415 Vminibuffer_completing_file_name
= Qnil
;
417 #ifdef HAVE_WINDOW_SYSTEM
418 if (display_hourglass_p
)
426 backup_n
= Fcdr (initial
);
427 initial
= Fcar (initial
);
428 CHECK_STRING (initial
);
429 if (!NILP (backup_n
))
431 CHECK_NUMBER (backup_n
);
432 /* Convert to distance from end of input. */
433 if (XINT (backup_n
) < 1)
434 /* A number too small means the beginning of the string. */
435 pos
= - SCHARS (initial
);
437 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
441 CHECK_STRING (initial
);
444 ambient_dir
= BVAR (current_buffer
, directory
);
446 enable_multibyte
= Qnil
;
448 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
449 store them away before we can GC. Don't need to protect
450 BACKUP_N because we use the value only if it is an integer. */
451 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
453 if (!STRINGP (prompt
))
454 prompt
= empty_unibyte_string
;
456 if (!enable_recursive_minibuffers
457 && minibuf_level
> 0)
459 if (EQ (selected_window
, minibuf_window
))
460 error ("Command attempted to use minibuffer while in minibuffer");
462 /* If we're in another window, cancel the minibuffer that's active. */
464 build_string ("Command attempted to use minibuffer while in minibuffer"));
468 /* In case we are running as a daemon, only do this before
469 detaching from the terminal. */
470 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
471 && NILP (Vexecuting_kbd_macro
))
473 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
475 expflag
, histvar
, histpos
, defalt
,
476 allow_props
, inherit_input_method
);
478 return unbind_to (count
, val
);
481 /* Choose the minibuffer window and frame, and take action on them. */
483 choose_minibuf_frame ();
485 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
487 record_unwind_protect (Fset_window_configuration
,
488 Fcurrent_window_configuration (Qnil
));
490 /* If the minibuffer window is on a different frame, save that
491 frame's configuration too. */
492 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
493 if (!EQ (mini_frame
, selected_frame
))
494 record_unwind_protect (Fset_window_configuration
,
495 Fcurrent_window_configuration (mini_frame
));
497 /* If the minibuffer is on an iconified or invisible frame,
498 make it visible now. */
499 Fmake_frame_visible (mini_frame
);
501 if (minibuffer_auto_raise
)
502 Fraise_frame (mini_frame
);
504 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
506 /* We have to do this after saving the window configuration
507 since that is what restores the current buffer. */
509 /* Arrange to restore a number of minibuffer-related variables.
510 We could bind each variable separately, but that would use lots of
513 = Fcons (Voverriding_local_map
,
514 Fcons (minibuf_window
,
517 = Fcons (minibuf_prompt
,
518 Fcons (make_number (minibuf_prompt_width
),
520 Fcons (Vcurrent_prefix_arg
,
521 Fcons (Vminibuffer_history_position
,
522 Fcons (Vminibuffer_history_variable
,
523 minibuf_save_list
))))));
525 record_unwind_protect (read_minibuf_unwind
, Qnil
);
527 /* We are exiting the minibuffer one way or the other, so run the hook.
528 It should be run before unwinding the minibuf settings. Do it
529 separately from read_minibuf_unwind because we need to make sure that
530 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
531 signals an error. --Stef */
532 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
534 /* Now that we can restore all those variables, start changing them. */
536 minibuf_prompt_width
= 0;
537 minibuf_prompt
= Fcopy_sequence (prompt
);
538 Vminibuffer_history_position
= histpos
;
539 Vminibuffer_history_variable
= histvar
;
540 Vhelp_form
= Vminibuffer_help_form
;
541 /* If this minibuffer is reading a file name, that doesn't mean
542 recursive ones are. But we cannot set it to nil, because
543 completion code still need to know the minibuffer is completing a
544 file name. So use `lambda' as intermediate value meaning
545 "t" in this minibuffer, but "nil" in next minibuffer. */
546 if (!NILP (Vminibuffer_completing_file_name
))
547 Vminibuffer_completing_file_name
= Qlambda
;
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 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
563 if (inherit_input_method
)
564 BVAR (current_buffer
, enable_multibyte_characters
) = enable_multibyte
;
566 /* The current buffer's default directory is usually the right thing
567 for our minibuffer here. However, if you're typing a command at
568 a minibuffer-only frame when minibuf_level is zero, then buf IS
569 the current_buffer, so reset_buffer leaves buf's default
570 directory unchanged. This is a bummer when you've just started
571 up Emacs and buf's default directory is Qnil. Here's a hack; can
572 you think of something better to do? Find another buffer with a
573 better directory, and use that one instead. */
574 if (STRINGP (ambient_dir
))
575 BVAR (current_buffer
, directory
) = ambient_dir
;
578 Lisp_Object buf_list
;
580 for (buf_list
= Vbuffer_alist
;
582 buf_list
= XCDR (buf_list
))
584 Lisp_Object other_buf
;
586 other_buf
= XCDR (XCAR (buf_list
));
587 if (STRINGP (BVAR (XBUFFER (other_buf
), directory
)))
589 BVAR (current_buffer
, directory
) = BVAR (XBUFFER (other_buf
), directory
);
595 if (!EQ (mini_frame
, selected_frame
))
596 Fredirect_frame_focus (selected_frame
, mini_frame
);
598 Vminibuf_scroll_window
= selected_window
;
599 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
600 minibuf_selected_window
= selected_window
;
602 /* Empty out the minibuffers of all frames other than the one
603 where we are going to display one now.
604 Set them to point to ` *Minibuf-0*', which is always empty. */
605 empty_minibuf
= get_minibuffer (0);
607 FOR_EACH_FRAME (dummy
, frame
)
609 Lisp_Object root_window
= Fframe_root_window (frame
);
610 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
612 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
613 && !NILP (Fwindow_minibuffer_p (mini_window
)))
614 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
617 /* Display this minibuffer in the proper window. */
618 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
619 Fselect_window (minibuf_window
, Qnil
);
620 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
622 Fmake_local_variable (Qprint_escape_newlines
);
623 print_escape_newlines
= 1;
625 /* Erase the buffer. */
627 int count1
= SPECPDL_INDEX ();
628 specbind (Qinhibit_read_only
, Qt
);
629 specbind (Qinhibit_modification_hooks
, Qt
);
632 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
633 && ! STRING_MULTIBYTE (minibuf_prompt
))
634 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
636 /* Insert the prompt, record where it ends. */
637 Finsert (1, &minibuf_prompt
);
640 Fput_text_property (make_number (BEG
), make_number (PT
),
641 Qfront_sticky
, Qt
, Qnil
);
642 Fput_text_property (make_number (BEG
), make_number (PT
),
643 Qrear_nonsticky
, Qt
, Qnil
);
644 Fput_text_property (make_number (BEG
), make_number (PT
),
646 Fadd_text_properties (make_number (BEG
), make_number (PT
),
647 Vminibuffer_prompt_properties
, Qnil
);
649 unbind_to (count1
, Qnil
);
652 minibuf_prompt_width
= current_column ();
654 /* Put in the initial input. */
657 Finsert (1, &initial
);
658 Fforward_char (make_number (pos
));
661 clear_message (1, 1);
662 BVAR (current_buffer
, keymap
) = map
;
664 /* Turn on an input method stored in INPUT_METHOD if any. */
665 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
666 call1 (Qactivate_input_method
, input_method
);
668 Frun_hooks (1, &Qminibuffer_setup_hook
);
670 /* Don't allow the user to undo past this point. */
671 BVAR (current_buffer
, undo_list
) = Qnil
;
675 /* If cursor is on the minibuffer line,
676 show the user we have exited by putting it in column 0. */
677 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
680 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
681 XWINDOW (minibuf_window
)->cursor
.x
= 0;
682 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
683 update_frame (XFRAME (selected_frame
), 1, 1);
685 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
686 struct redisplay_interface
*rif
= FRAME_RIF (f
);
687 if (rif
&& rif
->flush_display
)
688 rif
->flush_display (f
);
692 /* Make minibuffer contents into a string. */
693 Fset_buffer (minibuffer
);
695 val
= Fminibuffer_contents ();
697 val
= Fminibuffer_contents_no_properties ();
699 /* VAL is the string of minibuffer text. */
701 last_minibuf_string
= val
;
703 /* Choose the string to add to the history. */
704 if (SCHARS (val
) != 0)
706 else if (STRINGP (defalt
))
708 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
709 histstring
= XCAR (defalt
);
713 /* Add the value to the appropriate history list, if any. */
714 if (!NILP (Vhistory_add_new_input
)
715 && SYMBOLP (Vminibuffer_history_variable
)
716 && !NILP (histstring
))
718 /* If the caller wanted to save the value read on a history list,
719 then do so if the value is not already the front of the list. */
722 /* If variable is unbound, make it nil. */
724 histval
= find_symbol_value (Vminibuffer_history_variable
);
725 if (EQ (histval
, Qunbound
))
726 Fset (Vminibuffer_history_variable
, Qnil
);
728 /* The value of the history variable must be a cons or nil. Other
729 values are unacceptable. We silently ignore these values. */
733 /* Don't duplicate the most recent entry in the history. */
734 && (NILP (Fequal (histstring
, Fcar (histval
))))))
738 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
739 histval
= Fcons (histstring
, histval
);
740 Fset (Vminibuffer_history_variable
, histval
);
742 /* Truncate if requested. */
743 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
744 if (NILP (length
)) length
= Vhistory_length
;
745 if (INTEGERP (length
))
747 if (XINT (length
) <= 0)
748 Fset (Vminibuffer_history_variable
, Qnil
);
753 temp
= Fnthcdr (Fsub1 (length
), histval
);
754 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
760 /* If Lisp form desired instead of string, parse it. */
762 val
= string_to_object (val
, defalt
);
764 /* The appropriate frame will get selected
765 in set-window-configuration. */
767 return unbind_to (count
, val
);
770 /* Return a buffer to be used as the minibuffer at depth `depth'.
771 depth = 0 is the lowest allowed argument, and that is the value
772 used for nonrecursive minibuffer invocations. */
775 get_minibuffer (EMACS_INT depth
)
777 Lisp_Object tail
, num
, buf
;
778 char name
[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT
)];
780 XSETFASTINT (num
, depth
);
781 tail
= Fnthcdr (num
, Vminibuffer_list
);
784 tail
= Fcons (Qnil
, Qnil
);
785 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
788 if (NILP (buf
) || NILP (BVAR (XBUFFER (buf
), name
)))
790 sprintf (name
, " *Minibuf-%"pI
"d*", depth
);
791 buf
= Fget_buffer_create (build_string (name
));
793 /* Although the buffer's name starts with a space, undo should be
795 Fbuffer_enable_undo (buf
);
801 int count
= SPECPDL_INDEX ();
802 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
803 have to empty the list, otherwise we end up with overlays that
804 think they belong to this buffer while the buffer doesn't know about
806 delete_all_overlays (XBUFFER (buf
));
807 reset_buffer (XBUFFER (buf
));
808 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
810 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
811 call0 (intern ("minibuffer-inactive-mode"));
813 Fkill_all_local_variables ();
814 unbind_to (count
, Qnil
);
821 run_exit_minibuf_hook (Lisp_Object data
)
823 safe_run_hooks (Qminibuffer_exit_hook
);
827 /* This function is called on exiting minibuffer, whether normally or
828 not, and it restores the current window, buffer, etc. */
831 read_minibuf_unwind (Lisp_Object data
)
833 Lisp_Object old_deactivate_mark
;
836 /* If this was a recursive minibuffer,
837 tie the minibuffer window back to the outer level minibuffer buffer. */
840 window
= minibuf_window
;
841 /* To keep things predictable, in case it matters, let's be in the
842 minibuffer when we reset the relevant variables. */
843 Fset_buffer (XWINDOW (window
)->buffer
);
845 /* Restore prompt, etc, from outer minibuffer level. */
846 minibuf_prompt
= Fcar (minibuf_save_list
);
847 minibuf_save_list
= Fcdr (minibuf_save_list
);
848 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
849 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 Vhelp_form
= Fcar (minibuf_save_list
);
851 minibuf_save_list
= Fcdr (minibuf_save_list
);
852 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
853 minibuf_save_list
= Fcdr (minibuf_save_list
);
854 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
855 minibuf_save_list
= Fcdr (minibuf_save_list
);
856 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
857 minibuf_save_list
= Fcdr (minibuf_save_list
);
858 Voverriding_local_map
= Fcar (minibuf_save_list
);
859 minibuf_save_list
= Fcdr (minibuf_save_list
);
861 temp
= Fcar (minibuf_save_list
);
862 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
863 minibuf_window
= temp
;
865 minibuf_save_list
= Fcdr (minibuf_save_list
);
867 /* Erase the minibuffer we were using at this level. */
869 int count
= SPECPDL_INDEX ();
870 /* Prevent error in erase-buffer. */
871 specbind (Qinhibit_read_only
, Qt
);
872 specbind (Qinhibit_modification_hooks
, Qt
);
873 old_deactivate_mark
= Vdeactivate_mark
;
875 Vdeactivate_mark
= old_deactivate_mark
;
876 unbind_to (count
, Qnil
);
879 /* When we get to the outmost level, make sure we resize the
880 mini-window back to its normal size. */
881 if (minibuf_level
== 0)
882 resize_mini_window (XWINDOW (window
), 0);
884 /* Make sure minibuffer window is erased, not ignored. */
885 windows_or_buffers_changed
++;
886 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
887 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
889 /* In case the previous minibuffer displayed in this miniwindow is
890 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
891 to make sure we don't leave around bindings and stuff which only
892 made sense during the read_minibuf invocation. */
893 call0 (intern ("minibuffer-inactive-mode"));
898 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
899 Sread_from_minibuffer
, 1, 7, 0,
900 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
901 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
902 DEFAULT-VALUE. It normally should be nil in new code, except when
903 HIST is a cons. It is discussed in more detail below.
904 Third arg KEYMAP is a keymap to use whilst reading;
905 if omitted or nil, the default is `minibuffer-local-map'.
906 If fourth arg READ is non-nil, then interpret the result as a Lisp object
907 and return that object:
908 in other words, do `(car (read-from-string INPUT-STRING))'
909 Fifth arg HIST, if non-nil, specifies a history list and optionally
910 the initial position in the list. It can be a symbol, which is the
911 history list variable to use, or it can be a cons cell
912 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
913 to use, and HISTPOS is the initial position for use by the minibuffer
914 history commands. For consistency, you should also specify that
915 element of the history as the value of INITIAL-CONTENTS. Positions
916 are counted starting from 1 at the beginning of the list.
917 Sixth arg DEFAULT-VALUE is a default value or list of default values.
918 If non-nil, it is available via history commands. If READ is
919 non-nil, it is also the default to `read' if the user enters empty
920 input. If READ is non-nil, `read-from-minibuffer' does NOT return
921 DEFAULT-VALUE for empty input! It returns the empty string.
922 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
923 the current input method and the setting of `enable-multibyte-characters'.
924 If the variable `minibuffer-allow-text-properties' is non-nil,
925 then the string which is returned includes whatever text properties
926 were present in the minibuffer. Otherwise the value has no text properties.
928 The remainder of this documentation string describes the
929 INITIAL-CONTENTS argument in more detail. It is only relevant when
930 studying existing code, or when HIST is a cons. If non-nil,
931 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
932 reading input. Normally, point is put at the end of that string.
933 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
934 input is STRING, but point is placed at _one-indexed_ position
935 POSITION in the minibuffer. Any integer value less than or equal to
936 one puts point at the beginning of the string. *Note* that this
937 behavior differs from the way such arguments are used in `completing-read'
938 and some related functions, which use zero-indexing for POSITION. */)
939 (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
)
941 Lisp_Object histvar
, histpos
, val
;
944 CHECK_STRING (prompt
);
946 keymap
= Vminibuffer_local_map
;
948 keymap
= get_keymap (keymap
, 1, 0);
957 histvar
= Fcar_safe (hist
);
958 histpos
= Fcdr_safe (hist
);
961 histvar
= Qminibuffer_history
;
963 XSETFASTINT (histpos
, 0);
965 GCPRO1 (default_value
);
966 val
= read_minibuf (keymap
, initial_contents
, prompt
,
968 histvar
, histpos
, default_value
,
969 minibuffer_allow_text_properties
,
970 !NILP (inherit_input_method
));
975 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
976 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
977 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
978 is a string to insert in the minibuffer before reading.
979 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
980 Such arguments are used as in `read-from-minibuffer'.) */)
981 (Lisp_Object prompt
, Lisp_Object initial_contents
)
983 CHECK_STRING (prompt
);
984 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
985 prompt
, Qnil
, 1, Qminibuffer_history
,
986 make_number (0), Qnil
, 0, 0);
989 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
990 doc
: /* Return value of Lisp expression read using the minibuffer.
991 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
992 is a string to insert in the minibuffer before reading.
993 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
994 Such arguments are used as in `read-from-minibuffer'.) */)
995 (Lisp_Object prompt
, Lisp_Object initial_contents
)
997 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
998 prompt
, Qnil
, 1, Qread_expression_history
,
999 make_number (0), Qnil
, 0, 0),
1003 /* Functions that use the minibuffer to read various things. */
1005 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1006 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1007 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1008 This argument has been superseded by DEFAULT-VALUE and should normally
1009 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1010 documentation string of that function for details.
1011 The third arg HISTORY, if non-nil, specifies a history list
1012 and optionally the initial position in the list.
1013 See `read-from-minibuffer' for details of HISTORY argument.
1014 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1015 If non-nil, it is used for history commands, and as the value (or the first
1016 element of the list of default values) to return if the user enters the
1018 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1019 the current input method and the setting of `enable-multibyte-characters'. */)
1020 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1023 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1024 Qnil
, history
, default_value
,
1025 inherit_input_method
);
1026 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1027 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1031 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1032 doc
: /* Read a string from the terminal, not allowing blanks.
1033 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1034 non-nil, it should be a string, which is used as initial input, with
1035 point positioned at the end, so that SPACE will accept the input.
1036 \(Actually, INITIAL can also be a cons of a string and an integer.
1037 Such values are treated as in `read-from-minibuffer', but are normally
1038 not useful in this function.)
1039 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1040 the current input method and the setting of`enable-multibyte-characters'. */)
1041 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1043 CHECK_STRING (prompt
);
1044 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1045 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1046 !NILP (inherit_input_method
));
1049 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1050 doc
: /* Read the name of a command and return as a symbol.
1051 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1052 if it is a list. */)
1053 (Lisp_Object prompt
, Lisp_Object default_value
)
1055 Lisp_Object name
, default_string
;
1057 if (NILP (default_value
))
1058 default_string
= Qnil
;
1059 else if (SYMBOLP (default_value
))
1060 default_string
= SYMBOL_NAME (default_value
);
1062 default_string
= default_value
;
1064 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1065 Qnil
, Qnil
, default_string
, Qnil
);
1068 return Fintern (name
, Qnil
);
1072 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1073 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1074 Prompt with PROMPT. */)
1075 (Lisp_Object prompt
)
1077 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1082 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1083 doc
: /* Read the name of a user variable and return it as a symbol.
1084 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1086 A user variable is one for which `user-variable-p' returns non-nil. */)
1087 (Lisp_Object prompt
, Lisp_Object default_value
)
1089 Lisp_Object name
, default_string
;
1091 if (NILP (default_value
))
1092 default_string
= Qnil
;
1093 else if (SYMBOLP (default_value
))
1094 default_string
= SYMBOL_NAME (default_value
);
1096 default_string
= default_value
;
1098 name
= Fcompleting_read (prompt
, Vobarray
,
1099 Quser_variable_p
, Qt
,
1100 Qnil
, Qnil
, default_string
, Qnil
);
1103 return Fintern (name
, Qnil
);
1106 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1107 doc
: /* Read the name of a buffer and return as a string.
1109 Optional second arg DEF is value to return if user enters an empty line.
1110 If DEF is a list of default values, return its first element.
1111 Optional third arg REQUIRE-MATCH determines whether non-existing
1112 buffer names are allowed. It has the same meaning as the
1113 REQUIRE-MATCH argument of `completing-read'.
1114 The argument PROMPT should be a string ending with a colon and a space.
1115 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1116 case while reading the buffer name.
1117 If `read-buffer-function' is non-nil, this works by calling it as a
1118 function, instead of the usual behavior. */)
1119 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1121 Lisp_Object args
[4], result
;
1124 int count
= SPECPDL_INDEX ();
1127 def
= BVAR (XBUFFER (def
), name
);
1129 specbind (Qcompletion_ignore_case
,
1130 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1132 if (NILP (Vread_buffer_function
))
1136 /* A default value was provided: we must change PROMPT,
1137 editing the default value in before the colon. To achieve
1138 this, we replace PROMPT with a substring that doesn't
1139 contain the terminal space and colon (if present). They
1140 are then added back using Fformat. */
1142 if (STRINGP (prompt
))
1144 s
= SSDATA (prompt
);
1145 len
= SBYTES (prompt
);
1146 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1148 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1151 prompt
= make_specified_string (s
, -1, len
,
1152 STRING_MULTIBYTE (prompt
));
1155 args
[0] = build_string ("%s (default %s): ");
1157 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1158 prompt
= Fformat (3, args
);
1161 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1162 Qnil
, require_match
, Qnil
,
1163 Qbuffer_name_history
, def
, Qnil
);
1167 args
[0] = Vread_buffer_function
;
1170 args
[3] = require_match
;
1171 result
= Ffuncall (4, args
);
1173 return unbind_to (count
, result
);
1177 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1179 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1182 if (STRING_MULTIBYTE (string
))
1183 return Fstring_make_unibyte (string
);
1185 return Fstring_make_multibyte (string
);
1188 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1189 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1190 Test each possible completion specified by COLLECTION
1191 to see if it begins with STRING. The possible completions may be
1192 strings or symbols. Symbols are converted to strings before testing,
1194 All that match STRING are compared together; the longest initial sequence
1195 common to all these matches is the return value.
1196 If there is no match at all, the return value is nil.
1197 For a unique match which is exact, the return value is t.
1199 If COLLECTION is an alist, the keys (cars of elements) are the
1200 possible completions. If an element is not a cons cell, then the
1201 element itself is the possible completion.
1202 If COLLECTION is a hash-table, all the keys that are strings or symbols
1203 are the possible completions.
1204 If COLLECTION is an obarray, the names of all symbols in the obarray
1205 are the possible completions.
1207 COLLECTION can also be a function to do the completion itself.
1208 It receives three arguments: the values STRING, PREDICATE and nil.
1209 Whatever it returns becomes the value of `try-completion'.
1211 If optional third argument PREDICATE is non-nil,
1212 it is used to test each possible match.
1213 The match is a candidate only if PREDICATE returns non-nil.
1214 The argument given to PREDICATE is the alist element
1215 or the symbol from the obarray. If COLLECTION is a hash-table,
1216 predicate is called with two arguments: the key and the value.
1217 Additionally to this predicate, `completion-regexp-list'
1218 is used to further constrain the set of candidates. */)
1219 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1221 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1222 /* Size in bytes of BESTMATCH. */
1223 int bestmatchsize
= 0;
1224 /* These are in bytes, too. */
1225 int compare
, matchsize
;
1226 enum { function_table
, list_table
, obarray_table
, hash_table
}
1227 type
= (HASH_TABLE_P (collection
) ? hash_table
1228 : VECTORP (collection
) ? obarray_table
1229 : ((NILP (collection
)
1230 || (CONSP (collection
)
1231 && (!SYMBOLP (XCAR (collection
))
1232 || NILP (XCAR (collection
)))))
1233 ? list_table
: function_table
));
1234 EMACS_INT idx
= 0, obsize
= 0;
1237 Lisp_Object bucket
, zero
, end
, tem
;
1238 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1240 CHECK_STRING (string
);
1241 if (type
== function_table
)
1242 return call3 (collection
, string
, predicate
, Qnil
);
1244 bestmatch
= bucket
= Qnil
;
1245 zero
= make_number (0);
1247 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1249 if (type
== obarray_table
)
1251 collection
= check_obarray (collection
);
1252 obsize
= ASIZE (collection
);
1253 bucket
= XVECTOR (collection
)->contents
[idx
];
1258 /* Get the next element of the alist, obarray, or hash-table. */
1259 /* Exit the loop if the elements are all used up. */
1260 /* elt gets the alist element or symbol.
1261 eltstring gets the name to check as a completion. */
1263 if (type
== list_table
)
1268 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1271 else if (type
== obarray_table
)
1273 if (!EQ (bucket
, zero
))
1275 if (!SYMBOLP (bucket
))
1276 error ("Bad data in guts of obarray");
1279 if (XSYMBOL (bucket
)->next
)
1280 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1282 XSETFASTINT (bucket
, 0);
1284 else if (++idx
>= obsize
)
1288 bucket
= XVECTOR (collection
)->contents
[idx
];
1292 else /* if (type == hash_table) */
1294 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1295 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1297 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1300 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1303 /* Is this element a possible completion? */
1305 if (SYMBOLP (eltstring
))
1306 eltstring
= Fsymbol_name (eltstring
);
1308 if (STRINGP (eltstring
)
1309 && SCHARS (string
) <= SCHARS (eltstring
)
1310 && (tem
= Fcompare_strings (eltstring
, zero
,
1311 make_number (SCHARS (string
)),
1313 completion_ignore_case
? Qt
: Qnil
),
1317 Lisp_Object regexps
;
1319 /* Ignore this element if it fails to match all the regexps. */
1321 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1322 regexps
= XCDR (regexps
))
1324 if (bindcount
< 0) {
1325 bindcount
= SPECPDL_INDEX ();
1326 specbind (Qcase_fold_search
,
1327 completion_ignore_case
? Qt
: Qnil
);
1329 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1333 if (CONSP (regexps
))
1337 /* Ignore this element if there is a predicate
1338 and the predicate doesn't like it. */
1340 if (!NILP (predicate
))
1342 if (EQ (predicate
, Qcommandp
))
1343 tem
= Fcommandp (elt
, Qnil
);
1348 unbind_to (bindcount
, Qnil
);
1351 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1352 tem
= (type
== hash_table
1353 ? call2 (predicate
, elt
,
1354 HASH_VALUE (XHASH_TABLE (collection
),
1356 : call1 (predicate
, elt
));
1359 if (NILP (tem
)) continue;
1362 /* Update computation of how much all possible completions match */
1364 if (NILP (bestmatch
))
1367 bestmatch
= eltstring
;
1368 bestmatchsize
= SCHARS (eltstring
);
1372 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1373 tem
= Fcompare_strings (bestmatch
, zero
,
1374 make_number (compare
),
1376 make_number (compare
),
1377 completion_ignore_case
? Qt
: Qnil
);
1379 matchsize
= compare
;
1380 else if (XINT (tem
) < 0)
1381 matchsize
= - XINT (tem
) - 1;
1383 matchsize
= XINT (tem
) - 1;
1385 if (completion_ignore_case
)
1387 /* If this is an exact match except for case,
1388 use it as the best match rather than one that is not an
1389 exact match. This way, we get the case pattern
1390 of the actual match. */
1391 if ((matchsize
== SCHARS (eltstring
)
1392 && matchsize
< SCHARS (bestmatch
))
1394 /* If there is more than one exact match ignoring case,
1395 and one of them is exact including case,
1397 /* If there is no exact match ignoring case,
1398 prefer a match that does not change the case
1400 ((matchsize
== SCHARS (eltstring
))
1402 (matchsize
== SCHARS (bestmatch
))
1403 && (tem
= Fcompare_strings (eltstring
, zero
,
1404 make_number (SCHARS (string
)),
1409 && (tem
= Fcompare_strings (bestmatch
, zero
,
1410 make_number (SCHARS (string
)),
1415 bestmatch
= eltstring
;
1417 if (bestmatchsize
!= SCHARS (eltstring
)
1418 || bestmatchsize
!= matchsize
)
1419 /* Don't count the same string multiple times. */
1421 bestmatchsize
= matchsize
;
1422 if (matchsize
<= SCHARS (string
)
1423 /* If completion-ignore-case is non-nil, don't
1424 short-circuit because we want to find the best
1425 possible match *including* case differences. */
1426 && !completion_ignore_case
1428 /* No need to look any further. */
1434 if (bindcount
>= 0) {
1435 unbind_to (bindcount
, Qnil
);
1439 if (NILP (bestmatch
))
1440 return Qnil
; /* No completions found. */
1441 /* If we are ignoring case, and there is no exact match,
1442 and no additional text was supplied,
1443 don't change the case of what the user typed. */
1444 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1445 && SCHARS (bestmatch
) > bestmatchsize
)
1446 return minibuf_conform_representation (string
, bestmatch
);
1448 /* Return t if the supplied string is an exact match (counting case);
1449 it does not require any change to be made. */
1450 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1453 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1454 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1455 return Fsubstring (bestmatch
, zero
, end
);
1458 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1459 doc
: /* Search for partial matches to STRING in COLLECTION.
1460 Test each of the possible completions specified by COLLECTION
1461 to see if it begins with STRING. The possible completions may be
1462 strings or symbols. Symbols are converted to strings before testing,
1464 The value is a list of all the possible completions that match STRING.
1466 If COLLECTION is an alist, the keys (cars of elements) are the
1467 possible completions. If an element is not a cons cell, then the
1468 element itself is the possible completion.
1469 If COLLECTION is a hash-table, all the keys that are strings or symbols
1470 are the possible completions.
1471 If COLLECTION is an obarray, the names of all symbols in the obarray
1472 are the possible completions.
1474 COLLECTION can also be a function to do the completion itself.
1475 It receives three arguments: the values STRING, PREDICATE and t.
1476 Whatever it returns becomes the value of `all-completions'.
1478 If optional third argument PREDICATE is non-nil,
1479 it is used to test each possible match.
1480 The match is a candidate only if PREDICATE returns non-nil.
1481 The argument given to PREDICATE is the alist element
1482 or the symbol from the obarray. If COLLECTION is a hash-table,
1483 predicate is called with two arguments: the key and the value.
1484 Additionally to this predicate, `completion-regexp-list'
1485 is used to further constrain the set of candidates.
1487 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1488 backward compatibility. If non-nil, strings in COLLECTION that start
1489 with a space are ignored unless STRING itself starts with a space. */)
1490 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1492 Lisp_Object tail
, elt
, eltstring
;
1493 Lisp_Object allmatches
;
1494 int type
= HASH_TABLE_P (collection
) ? 3
1495 : VECTORP (collection
) ? 2
1496 : NILP (collection
) || (CONSP (collection
)
1497 && (!SYMBOLP (XCAR (collection
))
1498 || NILP (XCAR (collection
))));
1499 EMACS_INT idx
= 0, obsize
= 0;
1501 Lisp_Object bucket
, tem
, zero
;
1502 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1504 CHECK_STRING (string
);
1506 return call3 (collection
, string
, predicate
, Qt
);
1507 allmatches
= bucket
= Qnil
;
1508 zero
= make_number (0);
1510 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1514 collection
= check_obarray (collection
);
1515 obsize
= ASIZE (collection
);
1516 bucket
= XVECTOR (collection
)->contents
[idx
];
1521 /* Get the next element of the alist, obarray, or hash-table. */
1522 /* Exit the loop if the elements are all used up. */
1523 /* elt gets the alist element or symbol.
1524 eltstring gets the name to check as a completion. */
1531 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1536 if (!EQ (bucket
, zero
))
1538 if (!SYMBOLP (bucket
))
1539 error ("Bad data in guts of obarray");
1542 if (XSYMBOL (bucket
)->next
)
1543 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1545 XSETFASTINT (bucket
, 0);
1547 else if (++idx
>= obsize
)
1551 bucket
= XVECTOR (collection
)->contents
[idx
];
1555 else /* if (type == 3) */
1557 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1558 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1560 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1563 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1566 /* Is this element a possible completion? */
1568 if (SYMBOLP (eltstring
))
1569 eltstring
= Fsymbol_name (eltstring
);
1571 if (STRINGP (eltstring
)
1572 && SCHARS (string
) <= SCHARS (eltstring
)
1573 /* If HIDE_SPACES, reject alternatives that start with space
1574 unless the input starts with space. */
1575 && (NILP (hide_spaces
)
1576 || (SBYTES (string
) > 0
1577 && SREF (string
, 0) == ' ')
1578 || SREF (eltstring
, 0) != ' ')
1579 && (tem
= Fcompare_strings (eltstring
, zero
,
1580 make_number (SCHARS (string
)),
1582 make_number (SCHARS (string
)),
1583 completion_ignore_case
? Qt
: Qnil
),
1587 Lisp_Object regexps
;
1589 /* Ignore this element if it fails to match all the regexps. */
1591 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1592 regexps
= XCDR (regexps
))
1594 if (bindcount
< 0) {
1595 bindcount
= SPECPDL_INDEX ();
1596 specbind (Qcase_fold_search
,
1597 completion_ignore_case
? Qt
: Qnil
);
1599 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1603 if (CONSP (regexps
))
1607 /* Ignore this element if there is a predicate
1608 and the predicate doesn't like it. */
1610 if (!NILP (predicate
))
1612 if (EQ (predicate
, Qcommandp
))
1613 tem
= Fcommandp (elt
, Qnil
);
1616 if (bindcount
>= 0) {
1617 unbind_to (bindcount
, Qnil
);
1620 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1622 ? call2 (predicate
, elt
,
1623 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1624 : call1 (predicate
, elt
);
1627 if (NILP (tem
)) continue;
1629 /* Ok => put it on the list. */
1630 allmatches
= Fcons (eltstring
, allmatches
);
1634 if (bindcount
>= 0) {
1635 unbind_to (bindcount
, Qnil
);
1639 return Fnreverse (allmatches
);
1642 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1643 doc
: /* Read a string in the minibuffer, with completion.
1644 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1645 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1646 COLLECTION can also be a function to do the completion itself.
1647 PREDICATE limits completion to a subset of COLLECTION.
1648 See `try-completion' and `all-completions' for more details
1649 on completion, COLLECTION, and PREDICATE.
1651 REQUIRE-MATCH can take the following values:
1652 - t means that the user is not allowed to exit unless
1653 the input is (or completes to) an element of COLLECTION or is null.
1654 - nil means that the user can exit with any input.
1655 - `confirm' means that the user can exit with any input, but she needs
1656 to confirm her choice if the input is not an element of COLLECTION.
1657 - `confirm-after-completion' means that the user can exit with any
1658 input, but she needs to confirm her choice if she called
1659 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1660 and the input is not an element of COLLECTION.
1661 - anything else behaves like t except that typing RET does not exit if it
1662 does non-null completion.
1664 If the input is null, `completing-read' returns DEF, or the first element
1665 of the list of default values, or an empty string if DEF is nil,
1666 regardless of the value of REQUIRE-MATCH.
1668 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1669 with point positioned at the end.
1670 If it is (STRING . POSITION), the initial input is STRING, but point
1671 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1672 that this is different from `read-from-minibuffer' and related
1673 functions, which use one-indexing for POSITION.) This feature is
1674 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1675 default value DEF instead. The user can yank the default value into
1676 the minibuffer easily using \\[next-history-element].
1678 HIST, if non-nil, specifies a history list and optionally the initial
1679 position in the list. It can be a symbol, which is the history list
1680 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1681 that case, HISTVAR is the history list variable to use, and HISTPOS
1682 is the initial position (the position in the list used by the
1683 minibuffer history commands). For consistency, you should also
1684 specify that element of the history as the value of
1685 INITIAL-INPUT. (This is the only case in which you should use
1686 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1687 1 at the beginning of the list. The variable `history-length'
1688 controls the maximum length of a history list.
1690 DEF, if non-nil, is the default value or the list of default values.
1692 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1693 the current input method and the setting of `enable-multibyte-characters'.
1695 Completion ignores case if the ambient value of
1696 `completion-ignore-case' is non-nil.
1698 See also `completing-read-function'. */)
1699 (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
)
1701 Lisp_Object args
[9];
1702 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1704 args
[2] = collection
;
1705 args
[3] = predicate
;
1706 args
[4] = require_match
;
1707 args
[5] = initial_input
;
1710 args
[8] = inherit_input_method
;
1711 return Ffuncall (9, args
);
1714 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1716 /* Test whether TXT is an exact completion. */
1717 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1718 doc
: /* Return non-nil if STRING is a valid completion.
1719 Takes the same arguments as `all-completions' and `try-completion'.
1720 If COLLECTION is a function, it is called with three arguments:
1721 the values STRING, PREDICATE and `lambda'. */)
1722 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1724 Lisp_Object regexps
, tail
, tem
= Qnil
;
1727 CHECK_STRING (string
);
1729 if ((CONSP (collection
)
1730 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1731 || NILP (collection
))
1733 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1737 else if (VECTORP (collection
))
1739 /* Bypass intern-soft as that loses for nil. */
1740 tem
= oblookup (collection
,
1746 if (STRING_MULTIBYTE (string
))
1747 string
= Fstring_make_unibyte (string
);
1749 string
= Fstring_make_multibyte (string
);
1751 tem
= oblookup (collection
,
1757 if (completion_ignore_case
&& !SYMBOLP (tem
))
1759 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1761 tail
= XVECTOR (collection
)->contents
[i
];
1765 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1766 Fsymbol_name (tail
),
1767 make_number (0) , Qnil
, Qt
),
1773 if (XSYMBOL (tail
)->next
== 0)
1775 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1783 else if (HASH_TABLE_P (collection
))
1785 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1786 i
= hash_lookup (h
, string
, NULL
);
1788 tem
= HASH_KEY (h
, i
);
1790 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1791 if (!NILP (HASH_HASH (h
, i
))
1792 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1793 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1794 completion_ignore_case
? Qt
: Qnil
),
1797 tem
= HASH_KEY (h
, i
);
1804 return call3 (collection
, string
, predicate
, Qlambda
);
1806 /* Reject this element if it fails to match all the regexps. */
1807 if (CONSP (Vcompletion_regexp_list
))
1809 int count
= SPECPDL_INDEX ();
1810 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1811 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1812 regexps
= XCDR (regexps
))
1814 if (NILP (Fstring_match (XCAR (regexps
),
1815 SYMBOLP (tem
) ? string
: tem
,
1817 return unbind_to (count
, Qnil
);
1819 unbind_to (count
, Qnil
);
1822 /* Finally, check the predicate. */
1823 if (!NILP (predicate
))
1825 return HASH_TABLE_P (collection
)
1826 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1827 : call1 (predicate
, tem
);
1833 static Lisp_Object Qmetadata
;
1834 extern Lisp_Object Qbuffer
;
1836 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1837 doc
: /* Perform completion on buffer names.
1838 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1839 `all-completions', otherwise invoke `test-completion'.
1841 The arguments STRING and PREDICATE are as in `try-completion',
1842 `all-completions', and `test-completion'. */)
1843 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1846 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1847 else if (EQ (flag
, Qt
))
1849 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1850 if (SCHARS (string
) > 0)
1853 { /* Strip out internal buffers. */
1854 Lisp_Object bufs
= res
;
1855 /* First, look for a non-internal buffer in `res'. */
1856 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1859 /* All bufs in `res' are internal, so don't trip them out. */
1862 while (CONSP (XCDR (bufs
)))
1863 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1864 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1870 else if (EQ (flag
, Qlambda
))
1871 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1872 else if (EQ (flag
, Qmetadata
))
1873 return Fcons (Qmetadata
, Fcons (Fcons (Qcategory
, Qbuffer
), Qnil
));
1878 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1880 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1881 doc
: /* Like `assoc' but specifically for strings (and symbols).
1883 This returns the first element of LIST whose car matches the string or
1884 symbol KEY, or nil if no match exists. When performing the
1885 comparison, symbols are first converted to strings, and unibyte
1886 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1889 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1890 single string, rather than a cons cell whose car is a string. */)
1891 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1893 register Lisp_Object tail
;
1896 key
= Fsymbol_name (key
);
1898 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1900 register Lisp_Object elt
, tem
, thiscar
;
1902 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1903 if (SYMBOLP (thiscar
))
1904 thiscar
= Fsymbol_name (thiscar
);
1905 else if (!STRINGP (thiscar
))
1907 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1908 key
, make_number (0), Qnil
,
1918 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1919 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1922 return make_number (minibuf_level
);
1925 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1926 doc
: /* Return the prompt string of the currently-active minibuffer.
1927 If no minibuffer is active, return nil. */)
1930 return Fcopy_sequence (minibuf_prompt
);
1935 init_minibuf_once (void)
1937 Vminibuffer_list
= Qnil
;
1938 staticpro (&Vminibuffer_list
);
1942 syms_of_minibuf (void)
1945 minibuf_prompt
= Qnil
;
1946 staticpro (&minibuf_prompt
);
1948 minibuf_save_list
= Qnil
;
1949 staticpro (&minibuf_save_list
);
1951 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1952 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1953 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1954 Fset (Qminibuffer_default
, Qnil
);
1956 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1957 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1958 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1960 staticpro (&last_minibuf_string
);
1961 last_minibuf_string
= Qnil
;
1963 DEFSYM (Quser_variable_p
, "user-variable-p");
1964 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1965 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1966 Fset (Qbuffer_name_history
, Qnil
);
1968 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1969 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1970 DEFSYM (Qhistory_length
, "history-length");
1971 DEFSYM (Qcurrent_input_method
, "current-input-method");
1972 DEFSYM (Qactivate_input_method
, "activate-input-method");
1973 DEFSYM (Qcase_fold_search
, "case-fold-search");
1974 DEFSYM (Qmetadata
, "metadata");
1976 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1977 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1978 For example, `eval-expression' uses this. */);
1979 Vread_expression_history
= Qnil
;
1981 DEFSYM (Qread_expression_history
, "read-expression-history");
1983 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1984 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1985 The function is called with the arguments passed to `read-buffer'. */);
1986 Vread_buffer_function
= Qnil
;
1988 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1989 read_buffer_completion_ignore_case
,
1990 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
1991 read_buffer_completion_ignore_case
= 0;
1993 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1994 doc
: /* Normal hook run just after entry to minibuffer. */);
1995 Vminibuffer_setup_hook
= Qnil
;
1997 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1998 doc
: /* Normal hook run just after exit from minibuffer. */);
1999 Vminibuffer_exit_hook
= Qnil
;
2001 DEFVAR_LISP ("history-length", Vhistory_length
,
2002 doc
: /* *Maximum length for history lists before truncation takes place.
2003 A number means that length; t means infinite. Truncation takes place
2004 just after a new element is inserted. Setting the `history-length'
2005 property of a history variable overrides this default. */);
2006 XSETFASTINT (Vhistory_length
, 30);
2008 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
2009 doc
: /* *Non-nil means to delete duplicates in history.
2010 If set to t when adding a new history element, all previous identical
2011 elements are deleted from the history list. */);
2012 history_delete_duplicates
= 0;
2014 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
2015 doc
: /* *Non-nil means to add new elements in history.
2016 If set to nil, minibuffer reading functions don't add new elements to the
2017 history list, so it is possible to do this afterwards by calling
2018 `add-to-history' explicitly. */);
2019 Vhistory_add_new_input
= Qt
;
2021 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
2022 doc
: /* Non-nil means don't consider case significant in completion.
2023 For file-name completion, `read-file-name-completion-ignore-case'
2024 controls the behavior, rather than this variable.
2025 For buffer name completion, `read-buffer-completion-ignore-case'
2026 controls the behavior, rather than this variable. */);
2027 completion_ignore_case
= 0;
2029 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
2030 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2031 This variable makes a difference whenever the minibuffer window is active. */);
2032 enable_recursive_minibuffers
= 0;
2034 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2035 doc
: /* Alist or obarray used for completion in the minibuffer.
2036 This becomes the ALIST argument to `try-completion' and `all-completions'.
2037 The value can also be a list of strings or a hash table.
2039 The value may alternatively be a function, which is given three arguments:
2040 STRING, the current buffer contents;
2041 PREDICATE, the predicate for filtering possible matches;
2042 CODE, which says what kind of things to do.
2043 CODE can be nil, t or `lambda':
2044 nil -- return the best completion of STRING, or nil if there is none.
2045 t -- return a list of all possible completions of STRING.
2046 lambda -- return t if STRING is a valid completion as it stands. */);
2047 Vminibuffer_completion_table
= Qnil
;
2049 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2050 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2051 Vminibuffer_completion_predicate
= Qnil
;
2053 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2054 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2055 If nil, confirmation is not required.
2056 If the value is `confirm', the user may exit with an input that is not
2057 a valid completion alternative, but Emacs asks for confirmation.
2058 If the value is `confirm-after-completion', the user may exit with an
2059 input that is not a valid completion alternative, but Emacs asks for
2060 confirmation if the user submitted the input right after any of the
2061 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2062 Vminibuffer_completion_confirm
= Qnil
;
2064 DEFVAR_LISP ("minibuffer-completing-file-name",
2065 Vminibuffer_completing_file_name
,
2066 doc
: /* Non-nil means completing file names. */);
2067 Vminibuffer_completing_file_name
= Qnil
;
2069 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2070 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2071 Vminibuffer_help_form
= Qnil
;
2073 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2074 doc
: /* History list symbol to add minibuffer values to.
2075 Each string of minibuffer input, as it appears on exit from the minibuffer,
2077 (set minibuffer-history-variable
2078 (cons STRING (symbol-value minibuffer-history-variable))) */);
2079 XSETFASTINT (Vminibuffer_history_variable
, 0);
2081 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2082 doc
: /* Current position of redoing in the history list. */);
2083 Vminibuffer_history_position
= Qnil
;
2085 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2086 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2087 Some uses of the echo area also raise that frame (since they use it too). */);
2088 minibuffer_auto_raise
= 0;
2090 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2091 doc
: /* List of regexps that should restrict possible completions.
2092 The basic completion functions only consider a completion acceptable
2093 if it matches all regular expressions in this list, with
2094 `case-fold-search' bound to the value of `completion-ignore-case'.
2095 See Info node `(elisp)Basic Completion', for a description of these
2097 Vcompletion_regexp_list
= Qnil
;
2099 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2100 minibuffer_allow_text_properties
,
2101 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2102 This also affects `read-string', but it does not affect `read-minibuffer',
2103 `read-no-blanks-input', or any of the functions that do minibuffer input
2104 with completion; they always discard text properties. */);
2105 minibuffer_allow_text_properties
= 0;
2107 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2108 doc
: /* Text properties that are added to minibuffer prompts.
2109 These are in addition to the basic `field' property, and stickiness
2111 /* We use `intern' here instead of Qread_only to avoid
2112 initialization-order problems. */
2113 Vminibuffer_prompt_properties
2114 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2116 DEFVAR_LISP ("read-expression-map", Vread_expression_map
,
2117 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2118 Vread_expression_map
= Qnil
;
2120 defsubr (&Sactive_minibuffer_window
);
2121 defsubr (&Sset_minibuffer_window
);
2122 defsubr (&Sread_from_minibuffer
);
2123 defsubr (&Seval_minibuffer
);
2124 defsubr (&Sread_minibuffer
);
2125 defsubr (&Sread_string
);
2126 defsubr (&Sread_command
);
2127 defsubr (&Sread_variable
);
2128 defsubr (&Sinternal_complete_buffer
);
2129 defsubr (&Sread_buffer
);
2130 defsubr (&Sread_no_blanks_input
);
2131 defsubr (&Sminibuffer_depth
);
2132 defsubr (&Sminibuffer_prompt
);
2134 defsubr (&Sminibufferp
);
2135 defsubr (&Sminibuffer_prompt_end
);
2136 defsubr (&Sminibuffer_contents
);
2137 defsubr (&Sminibuffer_contents_no_properties
);
2138 defsubr (&Sminibuffer_completion_contents
);
2140 defsubr (&Stry_completion
);
2141 defsubr (&Sall_completions
);
2142 defsubr (&Stest_completion
);
2143 defsubr (&Sassoc_string
);
2144 defsubr (&Scompleting_read
);