1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 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 2, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "dispextern.h"
35 #include "intervals.h"
40 /* List of buffers for use as minibuffers.
41 The first element of the list is used for the outermost minibuffer
42 invocation, the next element is used for a recursive minibuffer
43 invocation, etc. The list is extended at the end as deeper
44 minibuffer recursions are encountered. */
46 Lisp_Object Vminibuffer_list
;
48 /* Data to remember during recursive minibuffer invocations */
50 Lisp_Object minibuf_save_list
;
52 /* Depth in minibuffer invocations. */
56 /* Nonzero means display completion help for invalid input. */
58 Lisp_Object Vcompletion_auto_help
;
60 /* The maximum length of a minibuffer history. */
62 Lisp_Object Qhistory_length
, Vhistory_length
;
64 /* Fread_minibuffer leaves the input here as a string. */
66 Lisp_Object last_minibuf_string
;
68 /* Nonzero means let functions called when within a minibuffer
69 invoke recursive minibuffers (to read arguments, or whatever) */
71 int enable_recursive_minibuffers
;
73 /* Nonzero means don't ignore text properties
74 in Fread_from_minibuffer. */
76 int minibuffer_allow_text_properties
;
78 /* help-form is bound to this while in the minibuffer. */
80 Lisp_Object Vminibuffer_help_form
;
82 /* Variable which is the history list to add minibuffer values to. */
84 Lisp_Object Vminibuffer_history_variable
;
86 /* Current position in the history list (adjusted by M-n and M-p). */
88 Lisp_Object Vminibuffer_history_position
;
90 /* Text properties that are added to minibuffer prompts.
91 These are in addition to the basic `field' property, and stickiness
94 Lisp_Object Vminibuffer_prompt_properties
;
96 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
98 Lisp_Object Qread_file_name_internal
;
100 /* Normal hooks for entry to and exit from minibuffer. */
102 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
103 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
105 /* Function to call to read a buffer name. */
106 Lisp_Object Vread_buffer_function
;
108 /* Nonzero means completion ignores case. */
110 int completion_ignore_case
;
112 /* List of regexps that should restrict possible completions. */
114 Lisp_Object Vcompletion_regexp_list
;
116 /* Nonzero means raise the minibuffer frame when the minibuffer
119 int minibuffer_auto_raise
;
121 /* If last completion attempt reported "Complete but not unique"
122 then this is the string completed then; otherwise this is nil. */
124 static Lisp_Object last_exact_completion
;
126 /* Non-nil means it is the window for C-M-v to scroll
127 when the minibuffer is selected. */
129 extern Lisp_Object Vminibuf_scroll_window
;
131 extern Lisp_Object Voverriding_local_map
;
133 Lisp_Object Quser_variable_p
;
135 Lisp_Object Qminibuffer_default
;
137 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
139 extern Lisp_Object Qmouse_face
;
141 extern Lisp_Object Qfield
;
143 /* Put minibuf on currently selected frame's minibuffer.
144 We do this whenever the user starts a new minibuffer
145 or when a minibuffer exits. */
148 choose_minibuf_frame ()
150 if (FRAMEP (selected_frame
)
151 && FRAME_LIVE_P (XFRAME (selected_frame
))
152 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
154 struct frame
*sf
= XFRAME (selected_frame
);
157 /* I don't think that any frames may validly have a null minibuffer
159 if (NILP (sf
->minibuffer_window
))
162 /* Under X, we come here with minibuf_window being the
163 minibuffer window of the unused termcap window created in
164 init_window_once. That window doesn't have a buffer. */
165 buffer
= XWINDOW (minibuf_window
)->buffer
;
166 if (BUFFERP (buffer
))
167 Fset_window_buffer (sf
->minibuffer_window
, buffer
);
168 minibuf_window
= sf
->minibuffer_window
;
171 /* Make sure no other frame has a minibuffer as its selected window,
172 because the text would not be displayed in it, and that would be
173 confusing. Only allow the selected frame to do this,
174 and that only if the minibuffer is active. */
176 Lisp_Object tail
, frame
;
178 FOR_EACH_FRAME (tail
, frame
)
179 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
180 && !(EQ (frame
, selected_frame
)
181 && minibuf_level
> 0))
182 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
187 choose_minibuf_frame_1 (ignore
)
190 choose_minibuf_frame ();
194 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
195 Sset_minibuffer_window
, 1, 1, 0,
196 doc
: /* Specify which minibuffer window to use for the minibuffer.
197 This effects where the minibuffer is displayed if you put text in it
198 without invoking the usual minibuffer commands. */)
202 CHECK_WINDOW (window
);
203 if (! MINI_WINDOW_P (XWINDOW (window
)))
204 error ("Window is not a minibuffer window");
206 minibuf_window
= window
;
212 /* Actual minibuffer invocation. */
214 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
215 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
216 Lisp_Object
, Lisp_Object
,
218 Lisp_Object
, Lisp_Object
,
220 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
221 Lisp_Object
, Lisp_Object
,
223 Lisp_Object
, Lisp_Object
,
225 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
228 /* Read a Lisp object from VAL and return it. If VAL is an empty
229 string, and DEFALT is a string, read from DEFALT instead of VAL. */
232 string_to_object (val
, defalt
)
233 Lisp_Object val
, defalt
;
235 struct gcpro gcpro1
, gcpro2
;
236 Lisp_Object expr_and_pos
;
239 GCPRO2 (val
, defalt
);
241 if (STRINGP (val
) && XSTRING (val
)->size
== 0
245 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
246 pos
= XINT (Fcdr (expr_and_pos
));
247 if (pos
!= XSTRING (val
)->size
)
249 /* Ignore trailing whitespace; any other trailing junk
252 pos
= string_char_to_byte (val
, pos
);
253 for (i
= pos
; i
< STRING_BYTES (XSTRING (val
)); i
++)
255 int c
= XSTRING (val
)->data
[i
];
256 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
257 error ("Trailing garbage following expression");
261 val
= Fcar (expr_and_pos
);
262 RETURN_UNGCPRO (val
);
266 /* Like read_minibuf but reading from stdin. This function is called
267 from read_minibuf to do the job if noninteractive. */
270 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
271 histvar
, histpos
, defalt
, allow_props
,
272 inherit_input_method
)
276 Lisp_Object backup_n
;
282 int inherit_input_method
;
288 fprintf (stdout
, "%s", XSTRING (prompt
)->data
);
294 line
= (char *) xmalloc (size
* sizeof *line
);
295 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
296 && (len
= strlen (line
),
297 len
== size
- 1 && line
[len
- 1] != '\n'))
300 line
= (char *) xrealloc (line
, size
);
307 if (len
> 0 && line
[len
- 1] == '\n')
310 val
= build_string (line
);
316 error ("Error reading from stdin");
319 /* If Lisp form desired instead of string, parse it. */
321 val
= string_to_object (val
, defalt
);
327 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
328 Sminibuffer_prompt_end
, 0, 0, 0,
329 doc
: /* Return the buffer position of the end of the minibuffer prompt.
330 Return (point-min) if current buffer is not a mini-buffer. */)
333 /* This function is written to be most efficient when there's a prompt. */
334 Lisp_Object beg
= make_number (BEGV
);
335 Lisp_Object end
= Ffield_end (beg
, Qnil
, Qnil
);
337 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
343 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
344 Sminibuffer_contents
, 0, 0, 0,
345 doc
: /* Return the user input in a minbuffer as a string.
346 The current buffer must be a minibuffer. */)
349 int prompt_end
= XINT (Fminibuffer_prompt_end ());
350 return make_buffer_string (prompt_end
, ZV
, 1);
353 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
354 Sminibuffer_contents_no_properties
, 0, 0, 0,
355 doc
: /* Return the user input in a minbuffer as a string, without text-properties.
356 The current buffer must be a minibuffer. */)
359 int prompt_end
= XINT (Fminibuffer_prompt_end ());
360 return make_buffer_string (prompt_end
, ZV
, 0);
363 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
364 Sdelete_minibuffer_contents
, 0, 0, 0,
365 doc
: /* Delete all user input in a minibuffer.
366 The current buffer must be a minibuffer. */)
369 int prompt_end
= XINT (Fminibuffer_prompt_end ());
371 del_range (prompt_end
, ZV
);
376 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
377 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
378 prompting with PROMPT (a string), using history list HISTVAR
379 with initial position HISTPOS. (BACKUP_N should be <= 0.)
381 Normally return the result as a string (the text that was read),
382 but if EXPFLAG is nonzero, read it and return the object read.
383 If HISTVAR is given, save the value read on that history only if it doesn't
384 match the front of that history list exactly. The value is pushed onto
385 the list as the string that was read.
387 DEFALT specifies te default value for the sake of history commands.
389 If ALLOW_PROPS is nonzero, we do not throw away text properties.
391 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
392 current input method. */
395 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
396 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
400 Lisp_Object backup_n
;
406 int inherit_input_method
;
409 int count
= specpdl_ptr
- specpdl
;
410 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
411 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
412 Lisp_Object enable_multibyte
;
413 extern Lisp_Object Qfront_sticky
;
414 extern Lisp_Object Qrear_nonsticky
;
416 specbind (Qminibuffer_default
, defalt
);
418 single_kboard_state ();
419 #ifdef HAVE_X_WINDOWS
420 if (display_hourglass_p
)
425 ambient_dir
= current_buffer
->directory
;
427 enable_multibyte
= Qnil
;
429 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
430 store them away before we can GC. Don't need to protect
431 BACKUP_N because we use the value only if it is an integer. */
432 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
434 if (!STRINGP (prompt
))
435 prompt
= build_string ("");
437 if (!enable_recursive_minibuffers
438 && minibuf_level
> 0)
440 if (EQ (selected_window
, minibuf_window
))
441 error ("Command attempted to use minibuffer while in minibuffer");
443 /* If we're in another window, cancel the minibuffer that's active. */
445 build_string ("Command attempted to use minibuffer while in minibuffer"));
450 val
= read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
,
451 expflag
, histvar
, histpos
, defalt
,
452 allow_props
, inherit_input_method
);
453 return unbind_to (count
, val
);
456 /* Choose the minibuffer window and frame, and take action on them. */
458 choose_minibuf_frame ();
460 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
462 record_unwind_protect (Fset_window_configuration
,
463 Fcurrent_window_configuration (Qnil
));
465 /* If the minibuffer window is on a different frame, save that
466 frame's configuration too. */
467 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
468 if (!EQ (mini_frame
, selected_frame
))
469 record_unwind_protect (Fset_window_configuration
,
470 Fcurrent_window_configuration (mini_frame
));
472 /* If the minibuffer is on an iconified or invisible frame,
473 make it visible now. */
474 Fmake_frame_visible (mini_frame
);
476 if (minibuffer_auto_raise
)
477 Fraise_frame (mini_frame
);
479 /* We have to do this after saving the window configuration
480 since that is what restores the current buffer. */
482 /* Arrange to restore a number of minibuffer-related variables.
483 We could bind each variable separately, but that would use lots of
486 = Fcons (Voverriding_local_map
,
487 Fcons (minibuf_window
, minibuf_save_list
));
489 = Fcons (minibuf_prompt
,
490 Fcons (make_number (minibuf_prompt_width
),
492 Fcons (Vcurrent_prefix_arg
,
493 Fcons (Vminibuffer_history_position
,
494 Fcons (Vminibuffer_history_variable
,
495 minibuf_save_list
))))));
497 record_unwind_protect (read_minibuf_unwind
, Qnil
);
500 /* Now that we can restore all those variables, start changing them. */
502 minibuf_prompt_width
= 0;
503 minibuf_prompt
= Fcopy_sequence (prompt
);
504 Vminibuffer_history_position
= histpos
;
505 Vminibuffer_history_variable
= histvar
;
506 Vhelp_form
= Vminibuffer_help_form
;
508 if (inherit_input_method
)
510 /* `current-input-method' is buffer local. So, remeber it in
511 INPUT_METHOD before changing the current buffer. */
512 input_method
= Fsymbol_value (Qcurrent_input_method
);
513 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
516 /* Switch to the minibuffer. */
518 minibuffer
= get_minibuffer (minibuf_level
);
519 Fset_buffer (minibuffer
);
521 /* The current buffer's default directory is usually the right thing
522 for our minibuffer here. However, if you're typing a command at
523 a minibuffer-only frame when minibuf_level is zero, then buf IS
524 the current_buffer, so reset_buffer leaves buf's default
525 directory unchanged. This is a bummer when you've just started
526 up Emacs and buf's default directory is Qnil. Here's a hack; can
527 you think of something better to do? Find another buffer with a
528 better directory, and use that one instead. */
529 if (STRINGP (ambient_dir
))
530 current_buffer
->directory
= ambient_dir
;
533 Lisp_Object buf_list
;
535 for (buf_list
= Vbuffer_alist
;
537 buf_list
= XCDR (buf_list
))
539 Lisp_Object other_buf
;
541 other_buf
= XCDR (XCAR (buf_list
));
542 if (STRINGP (XBUFFER (other_buf
)->directory
))
544 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
550 if (!EQ (mini_frame
, selected_frame
))
551 Fredirect_frame_focus (selected_frame
, mini_frame
);
553 Vminibuf_scroll_window
= selected_window
;
554 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
555 Fselect_window (minibuf_window
);
556 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
558 Fmake_local_variable (Qprint_escape_newlines
);
559 print_escape_newlines
= 1;
561 /* Erase the buffer. */
563 int count1
= BINDING_STACK_SIZE ();
564 specbind (Qinhibit_read_only
, Qt
);
565 specbind (Qinhibit_modification_hooks
, Qt
);
567 unbind_to (count1
, Qnil
);
570 if (!NILP (current_buffer
->enable_multibyte_characters
)
571 && ! STRING_MULTIBYTE (minibuf_prompt
))
572 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
574 /* Insert the prompt, record where it ends. */
575 Finsert (1, &minibuf_prompt
);
578 Fput_text_property (make_number (BEG
), make_number (PT
),
579 Qfront_sticky
, Qt
, Qnil
);
580 Fput_text_property (make_number (BEG
), make_number (PT
),
581 Qrear_nonsticky
, Qt
, Qnil
);
582 Fput_text_property (make_number (BEG
), make_number (PT
),
584 Fadd_text_properties (make_number (BEG
), make_number (PT
),
585 Vminibuffer_prompt_properties
, Qnil
);
588 minibuf_prompt_width
= current_column ();
590 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
591 if (inherit_input_method
)
592 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
594 /* Put in the initial input. */
597 Finsert (1, &initial
);
598 if (INTEGERP (backup_n
))
599 Fforward_char (backup_n
);
602 clear_message (1, 1);
603 current_buffer
->keymap
= map
;
605 /* Turn on an input method stored in INPUT_METHOD if any. */
606 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
607 call1 (Qactivate_input_method
, input_method
);
609 /* Run our hook, but not if it is empty.
610 (run-hooks would do nothing if it is empty,
611 but it's important to save time here in the usual case). */
612 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
613 && !NILP (Vrun_hooks
))
614 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
616 /* Don't allow the user to undo past this point. */
617 current_buffer
->undo_list
= Qnil
;
621 /* If cursor is on the minibuffer line,
622 show the user we have exited by putting it in column 0. */
623 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
626 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
627 XWINDOW (minibuf_window
)->cursor
.x
= 0;
628 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
629 update_frame (XFRAME (selected_frame
), 1, 1);
630 if (rif
&& rif
->flush_display
)
631 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
634 /* Make minibuffer contents into a string. */
635 Fset_buffer (minibuffer
);
637 val
= Fminibuffer_contents ();
639 val
= Fminibuffer_contents_no_properties ();
641 /* VAL is the string of minibuffer text. */
643 last_minibuf_string
= val
;
645 /* Add the value to the appropriate history list unless it is empty. */
646 if (XSTRING (val
)->size
!= 0
647 && SYMBOLP (Vminibuffer_history_variable
))
649 /* If the caller wanted to save the value read on a history list,
650 then do so if the value is not already the front of the list. */
653 /* If variable is unbound, make it nil. */
654 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
655 Fset (Vminibuffer_history_variable
, Qnil
);
657 histval
= Fsymbol_value (Vminibuffer_history_variable
);
659 /* The value of the history variable must be a cons or nil. Other
660 values are unacceptable. We silently ignore these values. */
663 && NILP (Fequal (last_minibuf_string
, Fcar (histval
)))))
667 histval
= Fcons (last_minibuf_string
, histval
);
668 Fset (Vminibuffer_history_variable
, histval
);
670 /* Truncate if requested. */
671 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
672 if (NILP (length
)) length
= Vhistory_length
;
673 if (INTEGERP (length
))
675 if (XINT (length
) <= 0)
676 Fset (Vminibuffer_history_variable
, Qnil
);
681 temp
= Fnthcdr (Fsub1 (length
), histval
);
682 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
688 /* If Lisp form desired instead of string, parse it. */
690 val
= string_to_object (val
, defalt
);
692 /* The appropriate frame will get selected
693 in set-window-configuration. */
694 RETURN_UNGCPRO (unbind_to (count
, val
));
697 /* Return a buffer to be used as the minibuffer at depth `depth'.
698 depth = 0 is the lowest allowed argument, and that is the value
699 used for nonrecursive minibuffer invocations */
702 get_minibuffer (depth
)
705 Lisp_Object tail
, num
, buf
;
707 extern Lisp_Object
nconc2 ();
709 XSETFASTINT (num
, depth
);
710 tail
= Fnthcdr (num
, Vminibuffer_list
);
713 tail
= Fcons (Qnil
, Qnil
);
714 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
717 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
719 sprintf (name
, " *Minibuf-%d*", depth
);
720 buf
= Fget_buffer_create (build_string (name
));
722 /* Although the buffer's name starts with a space, undo should be
724 Fbuffer_enable_undo (buf
);
730 int count
= specpdl_ptr
- specpdl
;
732 reset_buffer (XBUFFER (buf
));
733 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
735 Fkill_all_local_variables ();
736 unbind_to (count
, Qnil
);
742 /* This function is called on exiting minibuffer, whether normally or
743 not, and it restores the current window, buffer, etc. */
746 read_minibuf_unwind (data
)
749 Lisp_Object old_deactivate_mark
;
752 /* We are exiting the minibuffer one way or the other,
754 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
755 && !NILP (Vrun_hooks
))
756 safe_run_hooks (Qminibuffer_exit_hook
);
758 /* If this was a recursive minibuffer,
759 tie the minibuffer window back to the outer level minibuffer buffer. */
762 window
= minibuf_window
;
763 /* To keep things predictable, in case it matters, let's be in the
764 minibuffer when we reset the relevant variables. */
765 Fset_buffer (XWINDOW (window
)->buffer
);
767 /* Restore prompt, etc, from outer minibuffer level. */
768 minibuf_prompt
= Fcar (minibuf_save_list
);
769 minibuf_save_list
= Fcdr (minibuf_save_list
);
770 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
771 minibuf_save_list
= Fcdr (minibuf_save_list
);
772 Vhelp_form
= Fcar (minibuf_save_list
);
773 minibuf_save_list
= Fcdr (minibuf_save_list
);
774 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
775 minibuf_save_list
= Fcdr (minibuf_save_list
);
776 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
777 minibuf_save_list
= Fcdr (minibuf_save_list
);
778 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
779 minibuf_save_list
= Fcdr (minibuf_save_list
);
780 Voverriding_local_map
= Fcar (minibuf_save_list
);
781 minibuf_save_list
= Fcdr (minibuf_save_list
);
783 temp
= Fcar (minibuf_save_list
);
784 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
785 minibuf_window
= temp
;
787 minibuf_save_list
= Fcdr (minibuf_save_list
);
789 /* Erase the minibuffer we were using at this level. */
791 int count
= specpdl_ptr
- specpdl
;
792 /* Prevent error in erase-buffer. */
793 specbind (Qinhibit_read_only
, Qt
);
794 specbind (Qinhibit_modification_hooks
, Qt
);
795 old_deactivate_mark
= Vdeactivate_mark
;
797 Vdeactivate_mark
= old_deactivate_mark
;
798 unbind_to (count
, Qnil
);
801 /* When we get to the outmost level, make sure we resize the
802 mini-window back to its normal size. */
803 if (minibuf_level
== 0)
804 resize_mini_window (XWINDOW (window
), 0);
806 /* Make sure minibuffer window is erased, not ignored. */
807 windows_or_buffers_changed
++;
808 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
809 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
814 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
815 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
816 If optional second arg INITIAL-CONTENTS is non-nil, it is a string
817 to be inserted into the minibuffer before reading input.
818 If INITIAL-CONTENTS is (STRING . POSITION), the initial input
819 is STRING, but point is placed at position POSITION in the minibuffer.
820 Third arg KEYMAP is a keymap to use whilst reading;
821 if omitted or nil, the default is `minibuffer-local-map'.
822 If fourth arg READ is non-nil, then interpret the result as a lisp object
823 and return that object:
824 in other words, do `(car (read-from-string INPUT-STRING))'
825 Fifth arg HIST, if non-nil, specifies a history list
826 and optionally the initial position in the list.
827 It can be a symbol, which is the history list variable to use,
828 or it can be a cons cell (HISTVAR . HISTPOS).
829 In that case, HISTVAR is the history list variable to use,
830 and HISTPOS is the initial position (the position in the list
831 which INITIAL-CONTENTS corresponds to).
832 Positions are counted starting from 1 at the beginning of the list.
833 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
834 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE
835 if the user enters empty input! It returns the empty string.
836 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
837 the current input method and the setting of enable-multibyte-characters.
838 If the variable `minibuffer-allow-text-properties' is non-nil,
839 then the string which is returned includes whatever text properties
840 were present in the minibuffer. Otherwise the value has no text properties. */)
841 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
842 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
843 Lisp_Object inherit_input_method
;
846 Lisp_Object histvar
, histpos
, position
, val
;
851 CHECK_STRING (prompt
);
852 if (!NILP (initial_contents
))
854 if (CONSP (initial_contents
))
856 position
= Fcdr (initial_contents
);
857 initial_contents
= Fcar (initial_contents
);
859 CHECK_STRING (initial_contents
);
860 if (!NILP (position
))
862 CHECK_NUMBER (position
);
863 /* Convert to distance from end of input. */
864 if (XINT (position
) < 1)
865 /* A number too small means the beginning of the string. */
866 pos
= - XSTRING (initial_contents
)->size
;
868 pos
= XINT (position
) - 1 - XSTRING (initial_contents
)->size
;
873 keymap
= Vminibuffer_local_map
;
875 keymap
= get_keymap (keymap
, 1, 0);
884 histvar
= Fcar_safe (hist
);
885 histpos
= Fcdr_safe (hist
);
888 histvar
= Qminibuffer_history
;
890 XSETFASTINT (histpos
, 0);
892 GCPRO1 (default_value
);
893 val
= read_minibuf (keymap
, initial_contents
, prompt
,
894 make_number (pos
), !NILP (read
),
895 histvar
, histpos
, default_value
,
896 minibuffer_allow_text_properties
,
897 !NILP (inherit_input_method
));
902 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
903 doc
: /* Return a Lisp object read using the minibuffer.
904 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
905 is a string to insert in the minibuffer before reading. */)
906 (prompt
, initial_contents
)
907 Lisp_Object prompt
, initial_contents
;
909 CHECK_STRING (prompt
);
910 if (!NILP (initial_contents
))
911 CHECK_STRING (initial_contents
);
912 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
913 prompt
, Qnil
, 1, Qminibuffer_history
,
914 make_number (0), Qnil
, 0, 0);
917 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
918 doc
: /* Return value of Lisp expression read using the minibuffer.
919 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
920 is a string to insert in the minibuffer before reading. */)
921 (prompt
, initial_contents
)
922 Lisp_Object prompt
, initial_contents
;
924 return Feval (Fread_minibuffer (prompt
, initial_contents
));
927 /* Functions that use the minibuffer to read various things. */
929 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
930 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
931 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
932 The third arg HISTORY, if non-nil, specifies a history list
933 and optionally the initial position in the list.
934 See `read-from-minibuffer' for details of HISTORY argument.
935 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
936 for history commands, and as the value to return if the user enters
938 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
939 the current input method and the setting of enable-multibyte-characters. */)
940 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
941 Lisp_Object prompt
, initial_input
, history
, default_value
;
942 Lisp_Object inherit_input_method
;
945 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
946 Qnil
, history
, default_value
,
947 inherit_input_method
);
948 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (default_value
))
953 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
954 doc
: /* Read a string from the terminal, not allowing blanks.
955 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.
956 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
957 the current input method and the setting of enable-multibyte-characters. */)
958 (prompt
, initial
, inherit_input_method
)
959 Lisp_Object prompt
, initial
, inherit_input_method
;
961 CHECK_STRING (prompt
);
962 if (! NILP (initial
))
963 CHECK_STRING (initial
);
965 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
966 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
967 !NILP (inherit_input_method
));
970 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
971 doc
: /* Read the name of a command and return as a symbol.
972 Prompts with PROMPT. By default, return DEFAULT-VALUE. */)
973 (prompt
, default_value
)
974 Lisp_Object prompt
, default_value
;
976 Lisp_Object name
, default_string
;
978 if (NILP (default_value
))
979 default_string
= Qnil
;
980 else if (SYMBOLP (default_value
))
981 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
983 default_string
= default_value
;
985 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
986 Qnil
, Qnil
, default_string
, Qnil
);
989 return Fintern (name
, Qnil
);
993 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
994 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
995 Prompts with PROMPT. */)
999 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1004 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1005 doc
: /* Read the name of a user variable and return it as a symbol.
1006 Prompts with PROMPT. By default, return DEFAULT-VALUE.
1007 A user variable is one whose documentation starts with a `*' character. */)
1008 (prompt
, default_value
)
1009 Lisp_Object prompt
, default_value
;
1011 Lisp_Object name
, default_string
;
1013 if (NILP (default_value
))
1014 default_string
= Qnil
;
1015 else if (SYMBOLP (default_value
))
1016 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
1018 default_string
= default_value
;
1020 name
= Fcompleting_read (prompt
, Vobarray
,
1021 Quser_variable_p
, Qt
,
1022 Qnil
, Qnil
, default_string
, Qnil
);
1025 return Fintern (name
, Qnil
);
1028 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1029 doc
: /* One arg PROMPT, a string. Read the name of a buffer and return as a string.
1030 Prompts with PROMPT.
1031 Optional second arg DEF is value to return if user enters an empty line.
1032 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed. */)
1033 (prompt
, def
, require_match
)
1034 Lisp_Object prompt
, def
, require_match
;
1036 Lisp_Object args
[4];
1039 def
= XBUFFER (def
)->name
;
1041 if (NILP (Vread_buffer_function
))
1045 args
[0] = build_string ("%s(default %s) ");
1048 prompt
= Fformat (3, args
);
1051 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1052 require_match
, Qnil
, Qbuffer_name_history
,
1057 args
[0] = Vread_buffer_function
;
1060 args
[3] = require_match
;
1061 return Ffuncall(4, args
);
1066 minibuf_conform_representation (string
, basis
)
1067 Lisp_Object string
, basis
;
1069 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1072 if (STRING_MULTIBYTE (string
))
1073 return Fstring_make_unibyte (string
);
1075 return Fstring_make_multibyte (string
);
1078 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1079 doc
: /* Return common substring of all completions of STRING in ALIST.
1080 Each car of each element of ALIST is tested to see if it begins with STRING.
1081 All that match are compared together; the longest initial sequence
1082 common to all matches is returned as a string.
1083 If there is no match at all, nil is returned.
1084 For a unique match which is exact, t is returned.
1086 ALIST can be an obarray instead of an alist.
1087 Then the print names of all symbols in the obarray are the possible matches.
1089 ALIST can also be a function to do the completion itself.
1090 It receives three arguments: the values STRING, PREDICATE and nil.
1091 Whatever it returns becomes the value of `try-completion'.
1093 If optional third argument PREDICATE is non-nil,
1094 it is used to test each possible match.
1095 The match is a candidate only if PREDICATE returns non-nil.
1096 The argument given to PREDICATE is the alist element
1097 or the symbol from the obarray.
1098 Additionally to this predicate, `completion-regexp-list'
1099 is used to further constrain the set of candidates. */)
1100 (string
, alist
, predicate
)
1101 Lisp_Object string
, alist
, predicate
;
1103 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1104 /* Size in bytes of BESTMATCH. */
1105 int bestmatchsize
= 0;
1106 /* These are in bytes, too. */
1107 int compare
, matchsize
;
1108 int list
= CONSP (alist
) || NILP (alist
);
1109 int index
= 0, obsize
= 0;
1111 Lisp_Object bucket
, zero
, end
, tem
;
1112 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1114 CHECK_STRING (string
);
1115 if (!list
&& !VECTORP (alist
))
1116 return call3 (alist
, string
, predicate
, Qnil
);
1118 bestmatch
= bucket
= Qnil
;
1120 /* If ALIST is not a list, set TAIL just for gc pro. */
1125 obsize
= XVECTOR (alist
)->size
;
1126 bucket
= XVECTOR (alist
)->contents
[index
];
1131 /* Get the next element of the alist or obarray. */
1132 /* Exit the loop if the elements are all used up. */
1133 /* elt gets the alist element or symbol.
1134 eltstring gets the name to check as a completion. */
1141 eltstring
= Fcar (elt
);
1146 if (XFASTINT (bucket
) != 0)
1149 eltstring
= Fsymbol_name (elt
);
1150 if (XSYMBOL (bucket
)->next
)
1151 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1153 XSETFASTINT (bucket
, 0);
1155 else if (++index
>= obsize
)
1159 bucket
= XVECTOR (alist
)->contents
[index
];
1164 /* Is this element a possible completion? */
1166 if (STRINGP (eltstring
)
1167 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1168 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1169 make_number (XSTRING (string
)->size
),
1170 string
, make_number (0), Qnil
,
1171 completion_ignore_case
?Qt
: Qnil
),
1175 Lisp_Object regexps
;
1177 XSETFASTINT (zero
, 0);
1179 /* Ignore this element if it fails to match all the regexps. */
1180 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1181 regexps
= XCDR (regexps
))
1183 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1187 if (CONSP (regexps
))
1190 /* Ignore this element if there is a predicate
1191 and the predicate doesn't like it. */
1193 if (!NILP (predicate
))
1195 if (EQ (predicate
, Qcommandp
))
1196 tem
= Fcommandp (elt
);
1199 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1200 tem
= call1 (predicate
, elt
);
1203 if (NILP (tem
)) continue;
1206 /* Update computation of how much all possible completions match */
1209 if (NILP (bestmatch
))
1211 bestmatch
= eltstring
;
1212 bestmatchsize
= XSTRING (eltstring
)->size
;
1216 compare
= min (bestmatchsize
, XSTRING (eltstring
)->size
);
1217 tem
= Fcompare_strings (bestmatch
, make_number (0),
1218 make_number (compare
),
1219 eltstring
, make_number (0),
1220 make_number (compare
),
1221 completion_ignore_case
? Qt
: Qnil
);
1223 matchsize
= compare
;
1224 else if (XINT (tem
) < 0)
1225 matchsize
= - XINT (tem
) - 1;
1227 matchsize
= XINT (tem
) - 1;
1230 matchsize
= compare
;
1231 if (completion_ignore_case
)
1233 /* If this is an exact match except for case,
1234 use it as the best match rather than one that is not an
1235 exact match. This way, we get the case pattern
1236 of the actual match. */
1237 if ((matchsize
== XSTRING (eltstring
)->size
1238 && matchsize
< XSTRING (bestmatch
)->size
)
1240 /* If there is more than one exact match ignoring case,
1241 and one of them is exact including case,
1243 /* If there is no exact match ignoring case,
1244 prefer a match that does not change the case
1246 ((matchsize
== XSTRING (eltstring
)->size
)
1248 (matchsize
== XSTRING (bestmatch
)->size
)
1249 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1250 make_number (XSTRING (string
)->size
),
1251 string
, make_number (0),
1255 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1256 make_number (XSTRING (string
)->size
),
1257 string
, make_number (0),
1261 bestmatch
= eltstring
;
1263 bestmatchsize
= matchsize
;
1268 if (NILP (bestmatch
))
1269 return Qnil
; /* No completions found */
1270 /* If we are ignoring case, and there is no exact match,
1271 and no additional text was supplied,
1272 don't change the case of what the user typed. */
1273 if (completion_ignore_case
&& bestmatchsize
== XSTRING (string
)->size
1274 && XSTRING (bestmatch
)->size
> bestmatchsize
)
1275 return minibuf_conform_representation (string
, bestmatch
);
1277 /* Return t if the supplied string is an exact match (counting case);
1278 it does not require any change to be made. */
1279 if (matchcount
== 1 && bestmatchsize
== XSTRING (string
)->size
1280 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1281 make_number (bestmatchsize
),
1282 string
, make_number (0),
1283 make_number (bestmatchsize
),
1288 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1289 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1290 return Fsubstring (bestmatch
, zero
, end
);
1293 /* Compare exactly LEN chars of strings at S1 and S2,
1294 ignoring case if appropriate.
1295 Return -1 if strings match,
1296 else number of chars that match at the beginning. */
1300 register unsigned char *s1
, *s2
;
1303 register int l
= len
;
1305 if (completion_ignore_case
)
1307 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
1312 while (l
&& *s1
++ == *s2
++)
1319 int match
= len
- l
;
1321 /* Now *--S1 is the unmatching byte. If it is in the middle of
1322 multi-byte form, we must say that the multi-byte character
1323 there doesn't match. */
1324 while (match
&& *--s1
>= 0xA0) match
--;
1329 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1330 doc
: /* Search for partial matches to STRING in ALIST.
1331 Each car of each element of ALIST is tested to see if it begins with STRING.
1332 The value is a list of all the strings from ALIST that match.
1334 ALIST can be an obarray instead of an alist.
1335 Then the print names of all symbols in the obarray are the possible matches.
1337 ALIST can also be a function to do the completion itself.
1338 It receives three arguments: the values STRING, PREDICATE and t.
1339 Whatever it returns becomes the value of `all-completions'.
1341 If optional third argument PREDICATE is non-nil,
1342 it is used to test each possible match.
1343 The match is a candidate only if PREDICATE returns non-nil.
1344 The argument given to PREDICATE is the alist element
1345 or the symbol from the obarray.
1346 Additionally to this predicate, `completion-regexp-list'
1347 is used to further constrain the set of candidates.
1349 If the optional fourth argument HIDE-SPACES is non-nil,
1350 strings in ALIST that start with a space
1351 are ignored unless STRING itself starts with a space. */)
1352 (string
, alist
, predicate
, hide_spaces
)
1353 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1355 Lisp_Object tail
, elt
, eltstring
;
1356 Lisp_Object allmatches
;
1357 int list
= CONSP (alist
) || NILP (alist
);
1358 int index
= 0, obsize
= 0;
1359 Lisp_Object bucket
, tem
;
1360 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1362 CHECK_STRING (string
);
1363 if (!list
&& !VECTORP (alist
))
1365 return call3 (alist
, string
, predicate
, Qt
);
1367 allmatches
= bucket
= Qnil
;
1369 /* If ALIST is not a list, set TAIL just for gc pro. */
1374 obsize
= XVECTOR (alist
)->size
;
1375 bucket
= XVECTOR (alist
)->contents
[index
];
1380 /* Get the next element of the alist or obarray. */
1381 /* Exit the loop if the elements are all used up. */
1382 /* elt gets the alist element or symbol.
1383 eltstring gets the name to check as a completion. */
1390 eltstring
= Fcar (elt
);
1395 if (XFASTINT (bucket
) != 0)
1398 eltstring
= Fsymbol_name (elt
);
1399 if (XSYMBOL (bucket
)->next
)
1400 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1402 XSETFASTINT (bucket
, 0);
1404 else if (++index
>= obsize
)
1408 bucket
= XVECTOR (alist
)->contents
[index
];
1413 /* Is this element a possible completion? */
1415 if (STRINGP (eltstring
)
1416 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1417 /* If HIDE_SPACES, reject alternatives that start with space
1418 unless the input starts with space. */
1419 && ((STRING_BYTES (XSTRING (string
)) > 0
1420 && XSTRING (string
)->data
[0] == ' ')
1421 || XSTRING (eltstring
)->data
[0] != ' '
1422 || NILP (hide_spaces
))
1423 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1424 make_number (XSTRING (string
)->size
),
1425 string
, make_number (0),
1426 make_number (XSTRING (string
)->size
),
1427 completion_ignore_case
? Qt
: Qnil
),
1431 Lisp_Object regexps
;
1433 XSETFASTINT (zero
, 0);
1435 /* Ignore this element if it fails to match all the regexps. */
1436 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1437 regexps
= XCDR (regexps
))
1439 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1443 if (CONSP (regexps
))
1446 /* Ignore this element if there is a predicate
1447 and the predicate doesn't like it. */
1449 if (!NILP (predicate
))
1451 if (EQ (predicate
, Qcommandp
))
1452 tem
= Fcommandp (elt
);
1455 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1456 tem
= call1 (predicate
, elt
);
1459 if (NILP (tem
)) continue;
1461 /* Ok => put it on the list. */
1462 allmatches
= Fcons (eltstring
, allmatches
);
1466 return Fnreverse (allmatches
);
1469 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1470 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1471 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1472 Lisp_Object Vminibuffer_completing_file_name
;
1474 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1475 doc
: /* Read a string in the minibuffer, with completion.
1476 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1477 TABLE is an alist whose elements' cars are strings, or an obarray.
1478 TABLE can also be a function to do the completion itself.
1479 PREDICATE limits completion to a subset of TABLE.
1480 See `try-completion' and `all-completions' for more details
1481 on completion, TABLE, and PREDICATE.
1483 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1484 the input is (or completes to) an element of TABLE or is null.
1485 If it is also not t, Return does not exit if it does non-null completion.
1486 If the input is null, `completing-read' returns an empty string,
1487 regardless of the value of REQUIRE-MATCH.
1489 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1490 If it is (STRING . POSITION), the initial input
1491 is STRING, but point is placed POSITION characters into the string.
1492 This feature is deprecated--it is best to pass nil for INITIAL.
1493 HIST, if non-nil, specifies a history list
1494 and optionally the initial position in the list.
1495 It can be a symbol, which is the history list variable to use,
1496 or it can be a cons cell (HISTVAR . HISTPOS).
1497 In that case, HISTVAR is the history list variable to use,
1498 and HISTPOS is the initial position (the position in the list
1499 which INITIAL-INPUT corresponds to).
1500 Positions are counted starting from 1 at the beginning of the list.
1501 DEF, if non-nil, is the default value.
1503 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1504 the current input method and the setting of enable-multibyte-characters.
1506 Completion ignores case if the ambient value of
1507 `completion-ignore-case' is non-nil. */)
1508 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1509 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1510 Lisp_Object hist
, def
, inherit_input_method
;
1512 Lisp_Object val
, histvar
, histpos
, position
;
1515 int count
= specpdl_ptr
- specpdl
;
1516 struct gcpro gcpro1
;
1518 init
= initial_input
;
1521 specbind (Qminibuffer_completion_table
, table
);
1522 specbind (Qminibuffer_completion_predicate
, predicate
);
1523 specbind (Qminibuffer_completion_confirm
,
1524 EQ (require_match
, Qt
) ? Qnil
: Qt
);
1525 last_exact_completion
= Qnil
;
1532 position
= Fcdr (init
);
1535 CHECK_STRING (init
);
1536 if (!NILP (position
))
1538 CHECK_NUMBER (position
);
1539 /* Convert to distance from end of input. */
1540 pos
= XINT (position
) - XSTRING (init
)->size
;
1551 histvar
= Fcar_safe (hist
);
1552 histpos
= Fcdr_safe (hist
);
1555 histvar
= Qminibuffer_history
;
1557 XSETFASTINT (histpos
, 0);
1559 val
= read_minibuf (NILP (require_match
)
1560 ? Vminibuffer_local_completion_map
1561 : Vminibuffer_local_must_match_map
,
1562 init
, prompt
, make_number (pos
), 0,
1563 histvar
, histpos
, def
, 0,
1564 !NILP (inherit_input_method
));
1566 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (def
))
1569 RETURN_UNGCPRO (unbind_to (count
, val
));
1572 Lisp_Object
Fminibuffer_completion_help ();
1573 Lisp_Object
assoc_for_completion ();
1575 /* Test whether TXT is an exact completion. */
1577 test_completion (txt
)
1582 if (CONSP (Vminibuffer_completion_table
)
1583 || NILP (Vminibuffer_completion_table
))
1584 return assoc_for_completion (txt
, Vminibuffer_completion_table
);
1585 else if (VECTORP (Vminibuffer_completion_table
))
1587 /* Bypass intern-soft as that loses for nil */
1588 tem
= oblookup (Vminibuffer_completion_table
,
1589 XSTRING (txt
)->data
,
1590 XSTRING (txt
)->size
,
1591 STRING_BYTES (XSTRING (txt
)));
1594 if (STRING_MULTIBYTE (txt
))
1595 txt
= Fstring_make_unibyte (txt
);
1597 txt
= Fstring_make_multibyte (txt
);
1599 tem
= oblookup (Vminibuffer_completion_table
,
1600 XSTRING (txt
)->data
,
1601 XSTRING (txt
)->size
,
1602 STRING_BYTES (XSTRING (txt
)));
1606 if (!NILP (Vminibuffer_completion_predicate
))
1607 return call1 (Vminibuffer_completion_predicate
, tem
);
1612 return call3 (Vminibuffer_completion_table
, txt
,
1613 Vminibuffer_completion_predicate
, Qlambda
);
1617 * 0 no possible completion
1618 * 1 was already an exact and unique completion
1619 * 3 was already an exact completion
1620 * 4 completed to an exact completion
1621 * 5 some completion happened
1622 * 6 no completion happened
1627 Lisp_Object completion
, string
, tem
;
1630 struct gcpro gcpro1
, gcpro2
;
1632 completion
= Ftry_completion (Fminibuffer_contents (),
1633 Vminibuffer_completion_table
,
1634 Vminibuffer_completion_predicate
);
1635 last
= last_exact_completion
;
1636 last_exact_completion
= Qnil
;
1638 GCPRO2 (completion
, last
);
1640 if (NILP (completion
))
1643 temp_echo_area_glyphs (" [No match]");
1648 if (EQ (completion
, Qt
)) /* exact and unique match */
1654 string
= Fminibuffer_contents ();
1656 /* COMPLETEDP should be true if some completion was done, which
1657 doesn't include simply changing the case of the entered string.
1658 However, for appearance, the string is rewritten if the case
1660 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1661 completedp
= !EQ (tem
, Qt
);
1663 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1665 /* Rewrite the user's input. */
1667 Fdelete_minibuffer_contents (); /* Some completion happened */
1668 Finsert (1, &completion
);
1671 /* The case of the string changed, but that's all. We're not
1672 sure whether this is a unique completion or not, so try again
1673 using the real case (this shouldn't recurse again, because
1674 the next time try-completion will return either `t' or the
1678 return do_completion ();
1682 /* It did find a match. Do we match some possibility exactly now? */
1683 tem
= test_completion (Fminibuffer_contents ());
1686 /* not an exact match */
1690 else if (!NILP (Vcompletion_auto_help
))
1691 Fminibuffer_completion_help ();
1693 temp_echo_area_glyphs (" [Next char not unique]");
1696 else if (completedp
)
1701 /* If the last exact completion and this one were the same,
1702 it means we've already given a "Complete but not unique"
1703 message and the user's hit TAB again, so now we give him help. */
1704 last_exact_completion
= completion
;
1707 tem
= Fminibuffer_contents ();
1708 if (!NILP (Fequal (tem
, last
)))
1709 Fminibuffer_completion_help ();
1715 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1718 assoc_for_completion (key
, list
)
1719 register Lisp_Object key
;
1722 register Lisp_Object tail
;
1724 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1726 register Lisp_Object elt
, tem
, thiscar
;
1728 if (!CONSP (elt
)) continue;
1729 thiscar
= Fcar (elt
);
1730 if (!STRINGP (thiscar
))
1732 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1733 key
, make_number (0), Qnil
,
1734 completion_ignore_case
? Qt
: Qnil
);
1742 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1743 doc
: /* Complete the minibuffer contents as far as possible.
1744 Return nil if there is no valid completion, else t.
1745 If no characters can be completed, display a list of possible completions.
1746 If you repeat this command after it displayed such a list,
1747 scroll the window of possible completions. */)
1751 Lisp_Object window
, tem
;
1753 /* If the previous command was not this,
1754 mark the completion buffer obsolete. */
1755 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1756 Vminibuf_scroll_window
= Qnil
;
1758 window
= Vminibuf_scroll_window
;
1759 /* If there's a fresh completion window with a live buffer,
1760 and this command is repeated, scroll that window. */
1761 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1762 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1764 struct buffer
*obuf
= current_buffer
;
1766 Fset_buffer (XWINDOW (window
)->buffer
);
1767 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1769 /* If end is in view, scroll up to the beginning. */
1770 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1772 /* Else scroll down one screen. */
1773 Fscroll_other_window (Qnil
);
1775 set_buffer_internal (obuf
);
1779 i
= do_completion ();
1787 Fgoto_char (make_number (ZV
));
1788 temp_echo_area_glyphs (" [Sole completion]");
1793 Fgoto_char (make_number (ZV
));
1794 temp_echo_area_glyphs (" [Complete, but not unique]");
1801 /* Subroutines of Fminibuffer_complete_and_exit. */
1803 /* This one is called by internal_condition_case to do the real work. */
1806 complete_and_exit_1 ()
1808 return make_number (do_completion ());
1811 /* This one is called by internal_condition_case if an error happens.
1812 Pretend the current value is an exact match. */
1815 complete_and_exit_2 (ignore
)
1818 return make_number (1);
1821 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1822 Sminibuffer_complete_and_exit
, 0, 0, "",
1823 doc
: /* If the minibuffer contents is a valid completion then exit.
1824 Otherwise try to complete it. If completion leads to a valid completion,
1825 a repetition of this command will exit. */)
1831 /* Allow user to specify null string */
1832 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
1835 if (!NILP (test_completion (Fminibuffer_contents ())))
1838 /* Call do_completion, but ignore errors. */
1839 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
1840 complete_and_exit_2
);
1850 if (!NILP (Vminibuffer_completion_confirm
))
1852 temp_echo_area_glyphs (" [Confirm]");
1862 return Fthrow (Qexit
, Qnil
);
1866 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1868 doc
: /* Complete the minibuffer contents at most a single word.
1869 After one word is completed as much as possible, a space or hyphen
1870 is added, provided that matches some possible completion.
1871 Return nil if there is no valid completion, else t. */)
1874 Lisp_Object completion
, tem
, tem1
;
1875 register int i
, i_byte
;
1876 register unsigned char *completion_string
;
1877 struct gcpro gcpro1
, gcpro2
;
1878 int prompt_end_charpos
;
1880 /* We keep calling Fbuffer_string rather than arrange for GC to
1881 hold onto a pointer to one of the strings thus made. */
1883 completion
= Ftry_completion (Fminibuffer_contents (),
1884 Vminibuffer_completion_table
,
1885 Vminibuffer_completion_predicate
);
1886 if (NILP (completion
))
1889 temp_echo_area_glyphs (" [No match]");
1892 if (EQ (completion
, Qt
))
1895 #if 0 /* How the below code used to look, for reference. */
1896 tem
= Fminibuffer_contents ();
1897 b
= XSTRING (tem
)->data
;
1898 i
= ZV
- 1 - XSTRING (completion
)->size
;
1899 p
= XSTRING (completion
)->data
;
1901 0 <= scmp (b
, p
, ZV
- 1))
1904 /* Set buffer to longest match of buffer tail and completion head. */
1905 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1907 del_range (1, i
+ 1);
1910 #else /* Rewritten code */
1912 int buffer_nchars
, completion_nchars
;
1914 CHECK_STRING (completion
);
1915 tem
= Fminibuffer_contents ();
1916 GCPRO2 (completion
, tem
);
1917 /* If reading a file name,
1918 expand any $ENVVAR refs in the buffer and in TEM. */
1919 if (! NILP (Vminibuffer_completing_file_name
))
1921 Lisp_Object substituted
;
1922 substituted
= Fsubstitute_in_file_name (tem
);
1923 if (! EQ (substituted
, tem
))
1926 Fdelete_minibuffer_contents ();
1927 insert_from_string (tem
, 0, 0, XSTRING (tem
)->size
,
1928 STRING_BYTES (XSTRING (tem
)), 0);
1931 buffer_nchars
= XSTRING (tem
)->size
; /* ie ZV - BEGV */
1932 completion_nchars
= XSTRING (completion
)->size
;
1933 i
= buffer_nchars
- completion_nchars
;
1936 (tem1
= Fcompare_strings (tem
, make_number (0),
1937 make_number (buffer_nchars
),
1938 completion
, make_number (0),
1939 make_number (buffer_nchars
),
1940 completion_ignore_case
? Qt
: Qnil
),
1945 /* Set buffer to longest match of buffer tail and completion head. */
1951 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
1952 completion
, make_number (0),
1953 make_number (buffer_nchars
),
1954 completion_ignore_case
? Qt
: Qnil
);
1961 del_range (1, i
+ 1);
1962 SET_PT_BOTH (ZV
, ZV_BYTE
);
1966 #endif /* Rewritten code */
1968 prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
1971 int prompt_end_bytepos
;
1972 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
1973 i
= ZV
- prompt_end_charpos
;
1974 i_byte
= ZV_BYTE
- prompt_end_bytepos
;
1977 /* If completion finds next char not unique,
1978 consider adding a space or a hyphen. */
1979 if (i
== XSTRING (completion
)->size
)
1981 GCPRO1 (completion
);
1982 tem
= Ftry_completion (concat2 (Fminibuffer_contents (), build_string (" ")),
1983 Vminibuffer_completion_table
,
1984 Vminibuffer_completion_predicate
);
1991 GCPRO1 (completion
);
1993 Ftry_completion (concat2 (Fminibuffer_contents (), build_string ("-")),
1994 Vminibuffer_completion_table
,
1995 Vminibuffer_completion_predicate
);
2003 /* Now find first word-break in the stuff found by completion.
2004 i gets index in string of where to stop completing. */
2007 int bytes
= STRING_BYTES (XSTRING (completion
));
2008 completion_string
= XSTRING (completion
)->data
;
2009 for (; i_byte
< STRING_BYTES (XSTRING (completion
)); i_byte
+= len
, i
++)
2011 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2014 if (SYNTAX (c
) != Sword
)
2023 /* If got no characters, print help for user. */
2025 if (i
== ZV
- prompt_end_charpos
)
2027 if (!NILP (Vcompletion_auto_help
))
2028 Fminibuffer_completion_help ();
2032 /* Otherwise insert in minibuffer the chars we got */
2034 Fdelete_minibuffer_contents ();
2035 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2039 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2041 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2042 Each element may be just a symbol or string
2043 or may be a list of two strings to be printed as if concatenated.
2044 `standard-output' must be a buffer.
2045 The actual completion alternatives, as inserted, are given `mouse-face'
2046 properties of `highlight'.
2047 At the end, this runs the normal hook `completion-setup-hook'.
2048 It can find the completion buffer in `standard-output'. */)
2050 Lisp_Object completions
;
2052 Lisp_Object tail
, elt
;
2055 struct gcpro gcpro1
, gcpro2
;
2056 struct buffer
*old
= current_buffer
;
2059 /* Note that (when it matters) every variable
2060 points to a non-string that is pointed to by COMPLETIONS,
2061 except for ELT. ELT can be pointing to a string
2062 when terpri or Findent_to calls a change hook. */
2064 GCPRO2 (completions
, elt
);
2066 if (BUFFERP (Vstandard_output
))
2067 set_buffer_internal (XBUFFER (Vstandard_output
));
2069 if (NILP (completions
))
2070 write_string ("There are no possible completions of what you have typed.",
2074 write_string ("Possible completions are:", -1);
2075 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2077 Lisp_Object tem
, string
;
2079 Lisp_Object startpos
, endpos
;
2084 /* Compute the length of this element. */
2089 length
= XSTRING (tem
)->size
;
2091 tem
= Fcar (XCDR (elt
));
2093 length
+= XSTRING (tem
)->size
;
2098 length
= XSTRING (elt
)->size
;
2101 /* This does a bad job for narrower than usual windows.
2102 Sadly, the window it will appear in is not known
2103 until after the text has been made. */
2105 if (BUFFERP (Vstandard_output
))
2106 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2108 /* If the previous completion was very wide,
2109 or we have two on this line already,
2110 don't put another on the same line. */
2111 if (column
> 33 || first
2112 /* If this is really wide, don't put it second on a line. */
2113 || (column
> 0 && length
> 45))
2118 /* Otherwise advance to column 35. */
2121 if (BUFFERP (Vstandard_output
))
2123 tem
= Findent_to (make_number (35), make_number (2));
2125 column
= XINT (tem
);
2131 write_string (" ", -1);
2134 while (column
< 35);
2138 if (BUFFERP (Vstandard_output
))
2140 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2141 Fset_text_properties (startpos
, endpos
,
2142 Qnil
, Vstandard_output
);
2145 /* Output this element.
2146 If necessary, convert it to unibyte or to multibyte first. */
2148 string
= Fcar (elt
);
2151 if (NILP (current_buffer
->enable_multibyte_characters
)
2152 && STRING_MULTIBYTE (string
))
2153 string
= Fstring_make_unibyte (string
);
2154 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2155 && !STRING_MULTIBYTE (string
))
2156 string
= Fstring_make_multibyte (string
);
2158 if (BUFFERP (Vstandard_output
))
2160 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2162 Fprinc (string
, Qnil
);
2164 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2166 Fput_text_property (startpos
, endpos
,
2167 Qmouse_face
, intern ("highlight"),
2172 Fprinc (string
, Qnil
);
2175 /* Output the annotation for this element. */
2178 if (BUFFERP (Vstandard_output
))
2180 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2182 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2184 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2186 Fset_text_properties (startpos
, endpos
, Qnil
,
2191 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2196 /* Update COLUMN for what we have output. */
2199 /* If output is to a buffer, recompute COLUMN in a way
2200 that takes account of character widths. */
2201 if (BUFFERP (Vstandard_output
))
2203 tem
= Fcurrent_column ();
2204 column
= XINT (tem
);
2213 if (BUFFERP (Vstandard_output
))
2214 set_buffer_internal (old
);
2216 if (!NILP (Vrun_hooks
))
2217 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2222 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2224 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2227 Lisp_Object completions
;
2229 message ("Making completion list...");
2230 completions
= Fall_completions (Fminibuffer_contents (),
2231 Vminibuffer_completion_table
,
2232 Vminibuffer_completion_predicate
,
2234 clear_message (1, 0);
2236 if (NILP (completions
))
2239 temp_echo_area_glyphs (" [No completions]");
2242 internal_with_output_to_temp_buffer ("*Completions*",
2243 Fdisplay_completion_list
,
2244 Fsort (completions
, Qstring_lessp
));
2248 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2249 doc
: /* Terminate minibuffer input. */)
2252 if (INTEGERP (last_command_char
))
2253 internal_self_insert (XINT (last_command_char
), 0);
2257 return Fthrow (Qexit
, Qnil
);
2260 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2261 doc
: /* Terminate this minibuffer argument. */)
2264 return Fthrow (Qexit
, Qnil
);
2267 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2268 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2271 return make_number (minibuf_level
);
2274 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2275 doc
: /* Return the prompt string of the currently-active minibuffer.
2276 If no minibuffer is active, return nil. */)
2279 return Fcopy_sequence (minibuf_prompt
);
2283 /* Temporarily display the string M at the end of the current
2284 minibuffer contents. This is used to display things like
2285 "[No Match]" when the user requests a completion for a prefix
2286 that has no possible completions, and other quick, unobtrusive
2290 temp_echo_area_glyphs (m
)
2294 int osize_byte
= ZV_BYTE
;
2296 int opoint_byte
= PT_BYTE
;
2297 Lisp_Object oinhibit
;
2298 oinhibit
= Vinhibit_quit
;
2300 /* Clear out any old echo-area message to make way for our new thing. */
2303 SET_PT_BOTH (osize
, osize_byte
);
2305 SET_PT_BOTH (opoint
, opoint_byte
);
2307 Fsit_for (make_number (2), Qnil
, Qnil
);
2308 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2309 SET_PT_BOTH (opoint
, opoint_byte
);
2310 if (!NILP (Vquit_flag
))
2313 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2315 Vinhibit_quit
= oinhibit
;
2318 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2320 doc
: /* Temporarily display STRING at the end of the minibuffer.
2321 The text is displayed for two seconds,
2322 or until the next input event arrives, whichever comes first. */)
2326 temp_echo_area_glyphs (XSTRING (string
)->data
);
2331 init_minibuf_once ()
2333 Vminibuffer_list
= Qnil
;
2334 staticpro (&Vminibuffer_list
);
2341 minibuf_prompt
= Qnil
;
2342 staticpro (&minibuf_prompt
);
2344 minibuf_save_list
= Qnil
;
2345 staticpro (&minibuf_save_list
);
2347 Qread_file_name_internal
= intern ("read-file-name-internal");
2348 staticpro (&Qread_file_name_internal
);
2350 Qminibuffer_default
= intern ("minibuffer-default");
2351 staticpro (&Qminibuffer_default
);
2352 Fset (Qminibuffer_default
, Qnil
);
2354 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2355 staticpro (&Qminibuffer_completion_table
);
2357 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2358 staticpro (&Qminibuffer_completion_confirm
);
2360 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2361 staticpro (&Qminibuffer_completion_predicate
);
2363 staticpro (&last_exact_completion
);
2364 last_exact_completion
= Qnil
;
2366 staticpro (&last_minibuf_string
);
2367 last_minibuf_string
= Qnil
;
2369 Quser_variable_p
= intern ("user-variable-p");
2370 staticpro (&Quser_variable_p
);
2372 Qminibuffer_history
= intern ("minibuffer-history");
2373 staticpro (&Qminibuffer_history
);
2375 Qbuffer_name_history
= intern ("buffer-name-history");
2376 staticpro (&Qbuffer_name_history
);
2377 Fset (Qbuffer_name_history
, Qnil
);
2379 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2380 staticpro (&Qminibuffer_setup_hook
);
2382 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2383 staticpro (&Qminibuffer_exit_hook
);
2385 Qhistory_length
= intern ("history-length");
2386 staticpro (&Qhistory_length
);
2388 Qcurrent_input_method
= intern ("current-input-method");
2389 staticpro (&Qcurrent_input_method
);
2391 Qactivate_input_method
= intern ("activate-input-method");
2392 staticpro (&Qactivate_input_method
);
2394 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2395 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2396 Vread_buffer_function
= Qnil
;
2398 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2399 doc
: /* Normal hook run just after entry to minibuffer. */);
2400 Vminibuffer_setup_hook
= Qnil
;
2402 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2403 doc
: /* Normal hook run just after exit from minibuffer. */);
2404 Vminibuffer_exit_hook
= Qnil
;
2406 DEFVAR_LISP ("history-length", &Vhistory_length
,
2407 doc
: /* *Maximum length for history lists before truncation takes place.
2408 A number means that length; t means infinite. Truncation takes place
2409 just after a new element is inserted. Setting the history-length
2410 property of a history variable overrides this default. */);
2411 XSETFASTINT (Vhistory_length
, 30);
2413 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2414 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2415 Vcompletion_auto_help
= Qt
;
2417 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2418 doc
: /* Non-nil means don't consider case significant in completion. */);
2419 completion_ignore_case
= 0;
2421 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2422 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2423 This variable makes a difference whenever the minibuffer window is active. */);
2424 enable_recursive_minibuffers
= 0;
2426 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2427 doc
: /* Alist or obarray used for completion in the minibuffer.
2428 This becomes the ALIST argument to `try-completion' and `all-completion'.
2430 The value may alternatively be a function, which is given three arguments:
2431 STRING, the current buffer contents;
2432 PREDICATE, the predicate for filtering possible matches;
2433 CODE, which says what kind of things to do.
2434 CODE can be nil, t or `lambda'.
2435 nil means to return the best completion of STRING, or nil if there is none.
2436 t means to return a list of all possible completions of STRING.
2437 `lambda' means to return t if STRING is a valid completion as it stands. */);
2438 Vminibuffer_completion_table
= Qnil
;
2440 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2441 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2442 Vminibuffer_completion_predicate
= Qnil
;
2444 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2445 doc
: /* Non-nil => demand confirmation of completion before exiting minibuffer. */);
2446 Vminibuffer_completion_confirm
= Qnil
;
2448 DEFVAR_LISP ("minibuffer-completing-file-name",
2449 &Vminibuffer_completing_file_name
,
2450 doc
: /* Non-nil means completing file names. */);
2451 Vminibuffer_completing_file_name
= Qnil
;
2453 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2454 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2455 Vminibuffer_help_form
= Qnil
;
2457 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2458 doc
: /* History list symbol to add minibuffer values to.
2459 Each string of minibuffer input, as it appears on exit from the minibuffer,
2461 (set minibuffer-history-variable
2462 (cons STRING (symbol-value minibuffer-history-variable))) */);
2463 XSETFASTINT (Vminibuffer_history_variable
, 0);
2465 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2466 doc
: /* Current position of redoing in the history list. */);
2467 Vminibuffer_history_position
= Qnil
;
2469 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2470 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2471 Some uses of the echo area also raise that frame (since they use it too). */);
2472 minibuffer_auto_raise
= 0;
2474 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2475 doc
: /* List of regexps that should restrict possible completions. */);
2476 Vcompletion_regexp_list
= Qnil
;
2478 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2479 &minibuffer_allow_text_properties
,
2480 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2481 This also affects `read-string', but it does not affect `read-minibuffer',
2482 `read-no-blanks-input', or any of the functions that do minibuffer input
2483 with completion; they always discard text properties. */);
2484 minibuffer_allow_text_properties
= 0;
2486 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2487 doc
: /* Text properties that are added to minibuffer prompts.
2488 These are in addition to the basic `field' property, and stickiness
2490 /* We use `intern' here instead of Qread_only to avoid
2491 initialization-order problems. */
2492 Vminibuffer_prompt_properties
2493 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2495 defsubr (&Sset_minibuffer_window
);
2496 defsubr (&Sread_from_minibuffer
);
2497 defsubr (&Seval_minibuffer
);
2498 defsubr (&Sread_minibuffer
);
2499 defsubr (&Sread_string
);
2500 defsubr (&Sread_command
);
2501 defsubr (&Sread_variable
);
2502 defsubr (&Sread_buffer
);
2503 defsubr (&Sread_no_blanks_input
);
2504 defsubr (&Sminibuffer_depth
);
2505 defsubr (&Sminibuffer_prompt
);
2507 defsubr (&Sminibuffer_prompt_end
);
2508 defsubr (&Sminibuffer_contents
);
2509 defsubr (&Sminibuffer_contents_no_properties
);
2510 defsubr (&Sdelete_minibuffer_contents
);
2512 defsubr (&Stry_completion
);
2513 defsubr (&Sall_completions
);
2514 defsubr (&Scompleting_read
);
2515 defsubr (&Sminibuffer_complete
);
2516 defsubr (&Sminibuffer_complete_word
);
2517 defsubr (&Sminibuffer_complete_and_exit
);
2518 defsubr (&Sdisplay_completion_list
);
2519 defsubr (&Sminibuffer_completion_help
);
2521 defsubr (&Sself_insert_and_exit
);
2522 defsubr (&Sexit_minibuffer
);
2524 defsubr (&Sminibuffer_message
);
2530 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2531 "abort-recursive-edit");
2532 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2534 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2537 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2539 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2541 initial_define_key (Vminibuffer_local_ns_map
, '?',
2542 "self-insert-and-exit");
2544 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2545 "minibuffer-complete");
2546 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2547 "minibuffer-complete-word");
2548 initial_define_key (Vminibuffer_local_completion_map
, '?',
2549 "minibuffer-completion-help");
2551 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2552 "minibuffer-complete-and-exit");
2553 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2554 "minibuffer-complete-and-exit");