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. */
29 #include "dispextern.h"
34 #include "intervals.h"
39 /* List of buffers for use as minibuffers.
40 The first element of the list is used for the outermost minibuffer
41 invocation, the next element is used for a recursive minibuffer
42 invocation, etc. The list is extended at the end as deeper
43 minibuffer recursions are encountered. */
45 Lisp_Object Vminibuffer_list
;
47 /* Data to remember during recursive minibuffer invocations */
49 Lisp_Object minibuf_save_list
;
51 /* Depth in minibuffer invocations. */
55 /* Nonzero means display completion help for invalid input. */
57 Lisp_Object Vcompletion_auto_help
;
59 /* The maximum length of a minibuffer history. */
61 Lisp_Object Qhistory_length
, Vhistory_length
;
63 /* Fread_minibuffer leaves the input here as a string. */
65 Lisp_Object last_minibuf_string
;
67 /* Nonzero means let functions called when within a minibuffer
68 invoke recursive minibuffers (to read arguments, or whatever) */
70 int enable_recursive_minibuffers
;
72 /* Nonzero means don't ignore text properties
73 in Fread_from_minibuffer. */
75 int minibuffer_allow_text_properties
;
77 /* help-form is bound to this while in the minibuffer. */
79 Lisp_Object Vminibuffer_help_form
;
81 /* Variable which is the history list to add minibuffer values to. */
83 Lisp_Object Vminibuffer_history_variable
;
85 /* Current position in the history list (adjusted by M-n and M-p). */
87 Lisp_Object Vminibuffer_history_position
;
89 /* Text properties that are added to minibuffer prompts.
90 These are in addition to the basic `field' property, and stickiness
93 Lisp_Object Vminibuffer_prompt_properties
;
95 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
97 Lisp_Object Qread_file_name_internal
;
99 /* Normal hooks for entry to and exit from minibuffer. */
101 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
102 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
104 /* Function to call to read a buffer name. */
105 Lisp_Object Vread_buffer_function
;
107 /* Nonzero means completion ignores case. */
109 int completion_ignore_case
;
111 /* List of regexps that should restrict possible completions. */
113 Lisp_Object Vcompletion_regexp_list
;
115 /* Nonzero means raise the minibuffer frame when the minibuffer
118 int minibuffer_auto_raise
;
120 /* If last completion attempt reported "Complete but not unique"
121 then this is the string completed then; otherwise this is nil. */
123 static Lisp_Object last_exact_completion
;
125 /* Non-nil means it is the window for C-M-v to scroll
126 when the minibuffer is selected. */
128 extern Lisp_Object Vminibuf_scroll_window
;
130 extern Lisp_Object Voverriding_local_map
;
132 Lisp_Object Quser_variable_p
;
134 Lisp_Object Qminibuffer_default
;
136 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
138 extern Lisp_Object Qmouse_face
;
140 extern Lisp_Object Qfield
;
142 /* Put minibuf on currently selected frame's minibuffer.
143 We do this whenever the user starts a new minibuffer
144 or when a minibuffer exits. */
147 choose_minibuf_frame ()
149 if (FRAMEP (selected_frame
)
150 && FRAME_LIVE_P (XFRAME (selected_frame
))
151 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
153 struct frame
*sf
= XFRAME (selected_frame
);
156 /* I don't think that any frames may validly have a null minibuffer
158 if (NILP (sf
->minibuffer_window
))
161 /* Under X, we come here with minibuf_window being the
162 minibuffer window of the unused termcap window created in
163 init_window_once. That window doesn't have a buffer. */
164 buffer
= XWINDOW (minibuf_window
)->buffer
;
165 if (BUFFERP (buffer
))
166 Fset_window_buffer (sf
->minibuffer_window
, buffer
);
167 minibuf_window
= sf
->minibuffer_window
;
170 /* Make sure no other frame has a minibuffer as its selected window,
171 because the text would not be displayed in it, and that would be
172 confusing. Only allow the selected frame to do this,
173 and that only if the minibuffer is active. */
175 Lisp_Object tail
, frame
;
177 FOR_EACH_FRAME (tail
, frame
)
178 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
179 && !(EQ (frame
, selected_frame
)
180 && minibuf_level
> 0))
181 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
186 choose_minibuf_frame_1 (ignore
)
189 choose_minibuf_frame ();
193 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
194 Sset_minibuffer_window
, 1, 1, 0,
195 "Specify which minibuffer window to use for the minibuffer.\n\
196 This effects where the minibuffer is displayed if you put text in it\n\
197 without invoking the usual minibuffer commands.")
201 CHECK_WINDOW (window
, 1);
202 if (! MINI_WINDOW_P (XWINDOW (window
)))
203 error ("Window is not a minibuffer window");
205 minibuf_window
= window
;
211 /* Actual minibuffer invocation. */
213 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
214 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
215 Lisp_Object
, Lisp_Object
,
217 Lisp_Object
, Lisp_Object
,
219 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
220 Lisp_Object
, Lisp_Object
,
222 Lisp_Object
, Lisp_Object
,
224 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
227 /* Read a Lisp object from VAL and return it. If VAL is an empty
228 string, and DEFALT is a string, read from DEFALT instead of VAL. */
231 string_to_object (val
, defalt
)
232 Lisp_Object val
, defalt
;
234 struct gcpro gcpro1
, gcpro2
;
235 Lisp_Object expr_and_pos
;
238 GCPRO2 (val
, defalt
);
240 if (STRINGP (val
) && XSTRING (val
)->size
== 0
244 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
245 pos
= XINT (Fcdr (expr_and_pos
));
246 if (pos
!= XSTRING (val
)->size
)
248 /* Ignore trailing whitespace; any other trailing junk
251 pos
= string_char_to_byte (val
, pos
);
252 for (i
= pos
; i
< STRING_BYTES (XSTRING (val
)); i
++)
254 int c
= XSTRING (val
)->data
[i
];
255 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
256 error ("Trailing garbage following expression");
260 val
= Fcar (expr_and_pos
);
261 RETURN_UNGCPRO (val
);
265 /* Like read_minibuf but reading from stdin. This function is called
266 from read_minibuf to do the job if noninteractive. */
269 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
270 histvar
, histpos
, defalt
, allow_props
,
271 inherit_input_method
)
275 Lisp_Object backup_n
;
281 int inherit_input_method
;
287 fprintf (stdout
, "%s", XSTRING (prompt
)->data
);
293 line
= (char *) xmalloc (size
* sizeof *line
);
294 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
295 && (len
= strlen (line
),
296 len
== size
- 1 && line
[len
- 1] != '\n'))
299 line
= (char *) xrealloc (line
, size
);
306 if (len
> 0 && line
[len
- 1] == '\n')
309 val
= build_string (line
);
315 error ("Error reading from stdin");
318 /* If Lisp form desired instead of string, parse it. */
320 val
= string_to_object (val
, defalt
);
326 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
327 Sminibuffer_prompt_end
, 0, 0, 0,
328 "Return the buffer position of the end of the minibuffer prompt.\n\
329 Return (point-min) if current buffer is not a mini-buffer.")
332 /* This function is written to be most efficient when there's a prompt. */
333 Lisp_Object beg
= make_number (BEGV
);
334 Lisp_Object end
= Ffield_end (beg
, Qnil
);
336 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
342 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
343 Sminibuffer_contents
, 0, 0, 0,
344 "Return the user input in a minbuffer as a string.\n\
345 The current buffer must be a minibuffer.")
348 int prompt_end
= XINT (Fminibuffer_prompt_end ());
349 return make_buffer_string (prompt_end
, ZV
, 1);
352 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
353 Sminibuffer_contents_no_properties
, 0, 0, 0,
354 "Return the user input in a minbuffer as a string, without text-properties.\n\
355 The current buffer must be a minibuffer.")
358 int prompt_end
= XINT (Fminibuffer_prompt_end ());
359 return make_buffer_string (prompt_end
, ZV
, 0);
362 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
363 Sdelete_minibuffer_contents
, 0, 0, 0,
364 "Delete all user input in a minibuffer.\n\
365 The current buffer must be a minibuffer.")
368 int prompt_end
= XINT (Fminibuffer_prompt_end ());
370 del_range (prompt_end
, ZV
);
375 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
376 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
377 prompting with PROMPT (a string), using history list HISTVAR
378 with initial position HISTPOS. (BACKUP_N should be <= 0.)
380 Normally return the result as a string (the text that was read),
381 but if EXPFLAG is nonzero, read it and return the object read.
382 If HISTVAR is given, save the value read on that history only if it doesn't
383 match the front of that history list exactly. The value is pushed onto
384 the list as the string that was read.
386 DEFALT specifies te default value for the sake of history commands.
388 If ALLOW_PROPS is nonzero, we do not throw away text properties.
390 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
391 current input method. */
394 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
395 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
399 Lisp_Object backup_n
;
405 int inherit_input_method
;
408 int count
= specpdl_ptr
- specpdl
;
409 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
410 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
411 Lisp_Object enable_multibyte
;
412 extern Lisp_Object Qread_only
, Qfront_sticky
;
413 extern Lisp_Object Qrear_nonsticky
;
415 specbind (Qminibuffer_default
, defalt
);
417 single_kboard_state ();
418 #ifdef HAVE_X_WINDOWS
419 if (display_hourglass_p
)
424 ambient_dir
= current_buffer
->directory
;
426 enable_multibyte
= Qnil
;
428 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
429 store them away before we can GC. Don't need to protect
430 BACKUP_N because we use the value only if it is an integer. */
431 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
433 if (!STRINGP (prompt
))
434 prompt
= build_string ("");
436 if (!enable_recursive_minibuffers
437 && minibuf_level
> 0)
439 if (EQ (selected_window
, minibuf_window
))
440 error ("Command attempted to use minibuffer while in minibuffer");
442 /* If we're in another window, cancel the minibuffer that's active. */
444 build_string ("Command attempted to use minibuffer while in minibuffer"));
449 val
= read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
,
450 expflag
, histvar
, histpos
, defalt
,
451 allow_props
, inherit_input_method
);
452 return unbind_to (count
, val
);
455 /* Choose the minibuffer window and frame, and take action on them. */
457 choose_minibuf_frame ();
459 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
461 record_unwind_protect (Fset_window_configuration
,
462 Fcurrent_window_configuration (Qnil
));
464 /* If the minibuffer window is on a different frame, save that
465 frame's configuration too. */
466 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
467 if (!EQ (mini_frame
, selected_frame
))
468 record_unwind_protect (Fset_window_configuration
,
469 Fcurrent_window_configuration (mini_frame
));
471 /* If the minibuffer is on an iconified or invisible frame,
472 make it visible now. */
473 Fmake_frame_visible (mini_frame
);
475 if (minibuffer_auto_raise
)
476 Fraise_frame (mini_frame
);
478 /* We have to do this after saving the window configuration
479 since that is what restores the current buffer. */
481 /* Arrange to restore a number of minibuffer-related variables.
482 We could bind each variable separately, but that would use lots of
485 = Fcons (Voverriding_local_map
,
486 Fcons (minibuf_window
, minibuf_save_list
));
488 = Fcons (minibuf_prompt
,
489 Fcons (make_number (minibuf_prompt_width
),
491 Fcons (Vcurrent_prefix_arg
,
492 Fcons (Vminibuffer_history_position
,
493 Fcons (Vminibuffer_history_variable
,
494 minibuf_save_list
))))));
496 record_unwind_protect (read_minibuf_unwind
, Qnil
);
499 /* Now that we can restore all those variables, start changing them. */
501 minibuf_prompt_width
= 0;
502 minibuf_prompt
= Fcopy_sequence (prompt
);
503 Vminibuffer_history_position
= histpos
;
504 Vminibuffer_history_variable
= histvar
;
505 Vhelp_form
= Vminibuffer_help_form
;
507 if (inherit_input_method
)
509 /* `current-input-method' is buffer local. So, remeber it in
510 INPUT_METHOD before changing the current buffer. */
511 input_method
= Fsymbol_value (Qcurrent_input_method
);
512 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
515 /* Switch to the minibuffer. */
517 minibuffer
= get_minibuffer (minibuf_level
);
518 Fset_buffer (minibuffer
);
520 /* The current buffer's default directory is usually the right thing
521 for our minibuffer here. However, if you're typing a command at
522 a minibuffer-only frame when minibuf_level is zero, then buf IS
523 the current_buffer, so reset_buffer leaves buf's default
524 directory unchanged. This is a bummer when you've just started
525 up Emacs and buf's default directory is Qnil. Here's a hack; can
526 you think of something better to do? Find another buffer with a
527 better directory, and use that one instead. */
528 if (STRINGP (ambient_dir
))
529 current_buffer
->directory
= ambient_dir
;
532 Lisp_Object buf_list
;
534 for (buf_list
= Vbuffer_alist
;
536 buf_list
= XCDR (buf_list
))
538 Lisp_Object other_buf
;
540 other_buf
= XCDR (XCAR (buf_list
));
541 if (STRINGP (XBUFFER (other_buf
)->directory
))
543 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
549 if (!EQ (mini_frame
, selected_frame
))
550 Fredirect_frame_focus (selected_frame
, mini_frame
);
552 Vminibuf_scroll_window
= selected_window
;
553 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
554 Fselect_window (minibuf_window
);
555 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
557 Fmake_local_variable (Qprint_escape_newlines
);
558 print_escape_newlines
= 1;
560 /* Erase the buffer. */
562 int count1
= BINDING_STACK_SIZE ();
563 specbind (Qinhibit_read_only
, Qt
);
564 specbind (Qinhibit_modification_hooks
, Qt
);
566 unbind_to (count1
, Qnil
);
569 if (!NILP (current_buffer
->enable_multibyte_characters
)
570 && ! STRING_MULTIBYTE (minibuf_prompt
))
571 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
573 /* Insert the prompt, record where it ends. */
574 Finsert (1, &minibuf_prompt
);
577 Fput_text_property (make_number (BEG
), make_number (PT
),
578 Qfront_sticky
, Qt
, Qnil
);
579 Fput_text_property (make_number (BEG
), make_number (PT
),
580 Qrear_nonsticky
, Qt
, Qnil
);
581 Fput_text_property (make_number (BEG
), make_number (PT
),
583 Fadd_text_properties (make_number (BEG
), make_number (PT
),
584 Vminibuffer_prompt_properties
, Qnil
);
587 minibuf_prompt_width
= current_column ();
589 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
590 if (inherit_input_method
)
591 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
593 /* Put in the initial input. */
596 Finsert (1, &initial
);
597 if (INTEGERP (backup_n
))
598 Fforward_char (backup_n
);
601 clear_message (1, 1);
602 current_buffer
->keymap
= map
;
604 /* Turn on an input method stored in INPUT_METHOD if any. */
605 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
606 call1 (Qactivate_input_method
, input_method
);
608 /* Run our hook, but not if it is empty.
609 (run-hooks would do nothing if it is empty,
610 but it's important to save time here in the usual case). */
611 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
612 && !NILP (Vrun_hooks
))
613 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
615 /* Don't allow the user to undo past this point. */
616 current_buffer
->undo_list
= Qnil
;
620 /* If cursor is on the minibuffer line,
621 show the user we have exited by putting it in column 0. */
622 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
625 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
626 XWINDOW (minibuf_window
)->cursor
.x
= 0;
627 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
628 update_frame (XFRAME (selected_frame
), 1, 1);
629 if (rif
&& rif
->flush_display
)
630 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
633 /* Make minibuffer contents into a string. */
634 Fset_buffer (minibuffer
);
636 val
= Fminibuffer_contents ();
638 val
= Fminibuffer_contents_no_properties ();
640 /* VAL is the string of minibuffer text. */
642 last_minibuf_string
= val
;
644 /* Add the value to the appropriate history list unless it is empty. */
645 if (XSTRING (val
)->size
!= 0
646 && SYMBOLP (Vminibuffer_history_variable
))
648 /* If the caller wanted to save the value read on a history list,
649 then do so if the value is not already the front of the list. */
652 /* If variable is unbound, make it nil. */
653 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
654 Fset (Vminibuffer_history_variable
, Qnil
);
656 histval
= Fsymbol_value (Vminibuffer_history_variable
);
658 /* The value of the history variable must be a cons or nil. Other
659 values are unacceptable. We silently ignore these values. */
662 && NILP (Fequal (last_minibuf_string
, Fcar (histval
)))))
666 histval
= Fcons (last_minibuf_string
, histval
);
667 Fset (Vminibuffer_history_variable
, histval
);
669 /* Truncate if requested. */
670 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
671 if (NILP (length
)) length
= Vhistory_length
;
672 if (INTEGERP (length
))
674 if (XINT (length
) <= 0)
675 Fset (Vminibuffer_history_variable
, Qnil
);
680 temp
= Fnthcdr (Fsub1 (length
), histval
);
681 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
687 /* If Lisp form desired instead of string, parse it. */
689 val
= string_to_object (val
, defalt
);
691 /* The appropriate frame will get selected
692 in set-window-configuration. */
693 RETURN_UNGCPRO (unbind_to (count
, val
));
696 /* Return a buffer to be used as the minibuffer at depth `depth'.
697 depth = 0 is the lowest allowed argument, and that is the value
698 used for nonrecursive minibuffer invocations */
701 get_minibuffer (depth
)
704 Lisp_Object tail
, num
, buf
;
706 extern Lisp_Object
nconc2 ();
708 XSETFASTINT (num
, depth
);
709 tail
= Fnthcdr (num
, Vminibuffer_list
);
712 tail
= Fcons (Qnil
, Qnil
);
713 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
716 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
718 sprintf (name
, " *Minibuf-%d*", depth
);
719 buf
= Fget_buffer_create (build_string (name
));
721 /* Although the buffer's name starts with a space, undo should be
723 Fbuffer_enable_undo (buf
);
729 int count
= specpdl_ptr
- specpdl
;
731 reset_buffer (XBUFFER (buf
));
732 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
734 Fkill_all_local_variables ();
735 unbind_to (count
, Qnil
);
741 /* This function is called on exiting minibuffer, whether normally or
742 not, and it restores the current window, buffer, etc. */
745 read_minibuf_unwind (data
)
748 Lisp_Object old_deactivate_mark
;
751 /* We are exiting the minibuffer one way or the other,
753 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
754 && !NILP (Vrun_hooks
))
755 safe_run_hooks (Qminibuffer_exit_hook
);
757 /* If this was a recursive minibuffer,
758 tie the minibuffer window back to the outer level minibuffer buffer. */
761 window
= minibuf_window
;
762 /* To keep things predictable, in case it matters, let's be in the
763 minibuffer when we reset the relevant variables. */
764 Fset_buffer (XWINDOW (window
)->buffer
);
766 /* Restore prompt, etc, from outer minibuffer level. */
767 minibuf_prompt
= Fcar (minibuf_save_list
);
768 minibuf_save_list
= Fcdr (minibuf_save_list
);
769 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
770 minibuf_save_list
= Fcdr (minibuf_save_list
);
771 Vhelp_form
= Fcar (minibuf_save_list
);
772 minibuf_save_list
= Fcdr (minibuf_save_list
);
773 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
774 minibuf_save_list
= Fcdr (minibuf_save_list
);
775 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
776 minibuf_save_list
= Fcdr (minibuf_save_list
);
777 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
778 minibuf_save_list
= Fcdr (minibuf_save_list
);
779 Voverriding_local_map
= Fcar (minibuf_save_list
);
780 minibuf_save_list
= Fcdr (minibuf_save_list
);
782 temp
= Fcar (minibuf_save_list
);
783 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
784 minibuf_window
= temp
;
786 minibuf_save_list
= Fcdr (minibuf_save_list
);
788 /* Erase the minibuffer we were using at this level. */
790 int count
= specpdl_ptr
- specpdl
;
791 /* Prevent error in erase-buffer. */
792 specbind (Qinhibit_read_only
, Qt
);
793 specbind (Qinhibit_modification_hooks
, Qt
);
794 old_deactivate_mark
= Vdeactivate_mark
;
796 Vdeactivate_mark
= old_deactivate_mark
;
797 unbind_to (count
, Qnil
);
800 /* When we get to the outmost level, make sure we resize the
801 mini-window back to its normal size. */
802 if (minibuf_level
== 0)
803 resize_mini_window (XWINDOW (window
), 0);
805 /* Make sure minibuffer window is erased, not ignored. */
806 windows_or_buffers_changed
++;
807 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
808 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
813 /* This comment supplies the doc string for read-from-minibuffer,
814 for make-docfile to see. We cannot put this in the real DEFUN
815 due to limits in the Unix cpp.
817 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
818 "Read a string from the minibuffer, prompting with string PROMPT.\n\
819 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
820 to be inserted into the minibuffer before reading input.\n\
821 If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
822 is STRING, but point is placed at position POSITION in the minibuffer.\n\
823 Third arg KEYMAP is a keymap to use whilst reading;\n\
824 if omitted or nil, the default is `minibuffer-local-map'.\n\
825 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
826 and return that object:\n\
827 in other words, do `(car (read-from-string INPUT-STRING))'\n\
828 Fifth arg HIST, if non-nil, specifies a history list\n\
829 and optionally the initial position in the list.\n\
830 It can be a symbol, which is the history list variable to use,\n\
831 or it can be a cons cell (HISTVAR . HISTPOS).\n\
832 In that case, HISTVAR is the history list variable to use,\n\
833 and HISTPOS is the initial position (the position in the list\n\
834 which INITIAL-CONTENTS corresponds to).\n\
835 Positions are counted starting from 1 at the beginning of the list.\n\
836 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available\n\
837 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE\n\
838 if the user enters empty input! It returns the empty string.\n\
839 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
840 the current input method and the setting of enable-multibyte-characters.\n\
841 If the variable `minibuffer-allow-text-properties' is non-nil,\n\
842 then the string which is returned includes whatever text properties\n\
843 were present in the minibuffer. Otherwise the value has no text properties.")
844 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
847 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
848 0 /* See immediately above */)
849 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
850 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
851 Lisp_Object inherit_input_method
;
854 Lisp_Object histvar
, histpos
, position
, val
;
859 CHECK_STRING (prompt
, 0);
860 if (!NILP (initial_contents
))
862 if (CONSP (initial_contents
))
864 position
= Fcdr (initial_contents
);
865 initial_contents
= Fcar (initial_contents
);
867 CHECK_STRING (initial_contents
, 1);
868 if (!NILP (position
))
870 CHECK_NUMBER (position
, 0);
871 /* Convert to distance from end of input. */
872 if (XINT (position
) < 1)
873 /* A number too small means the beginning of the string. */
874 pos
= - XSTRING (initial_contents
)->size
;
876 pos
= XINT (position
) - 1 - XSTRING (initial_contents
)->size
;
881 keymap
= Vminibuffer_local_map
;
883 keymap
= get_keymap (keymap
, 1, 0);
892 histvar
= Fcar_safe (hist
);
893 histpos
= Fcdr_safe (hist
);
896 histvar
= Qminibuffer_history
;
898 XSETFASTINT (histpos
, 0);
900 GCPRO1 (default_value
);
901 val
= read_minibuf (keymap
, initial_contents
, prompt
,
902 make_number (pos
), !NILP (read
),
903 histvar
, histpos
, default_value
,
904 minibuffer_allow_text_properties
,
905 !NILP (inherit_input_method
));
910 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
911 "Return a Lisp object read using the minibuffer.\n\
912 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
913 is a string to insert in the minibuffer before reading.")
914 (prompt
, initial_contents
)
915 Lisp_Object prompt
, initial_contents
;
917 CHECK_STRING (prompt
, 0);
918 if (!NILP (initial_contents
))
919 CHECK_STRING (initial_contents
, 1);
920 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
921 prompt
, Qnil
, 1, Qminibuffer_history
,
922 make_number (0), Qnil
, 0, 0);
925 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
926 "Return value of Lisp expression read using the minibuffer.\n\
927 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
928 is a string to insert in the minibuffer before reading.")
929 (prompt
, initial_contents
)
930 Lisp_Object prompt
, initial_contents
;
932 return Feval (Fread_minibuffer (prompt
, initial_contents
));
935 /* Functions that use the minibuffer to read various things. */
937 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
938 "Read a string from the minibuffer, prompting with string PROMPT.\n\
939 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.\n\
940 The third arg HISTORY, if non-nil, specifies a history list\n\
941 and optionally the initial position in the list.\n\
942 See `read-from-minibuffer' for details of HISTORY argument.\n\
943 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used\n\
944 for history commands, and as the value to return if the user enters\n\
946 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
947 the current input method and the setting of enable-multibyte-characters.")
948 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
949 Lisp_Object prompt
, initial_input
, history
, default_value
;
950 Lisp_Object inherit_input_method
;
953 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
954 Qnil
, history
, default_value
,
955 inherit_input_method
);
956 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (default_value
))
961 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
962 "Read a string from the terminal, not allowing blanks.\n\
963 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.\n\
964 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
965 the current input method and the setting of enable-multibyte-characters.")
966 (prompt
, initial
, inherit_input_method
)
967 Lisp_Object prompt
, initial
, inherit_input_method
;
969 CHECK_STRING (prompt
, 0);
970 if (! NILP (initial
))
971 CHECK_STRING (initial
, 1);
973 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
974 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
975 !NILP (inherit_input_method
));
978 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
979 "Read the name of a command and return as a symbol.\n\
980 Prompts with PROMPT. By default, return DEFAULT-VALUE.")
981 (prompt
, default_value
)
982 Lisp_Object prompt
, default_value
;
984 Lisp_Object name
, default_string
;
986 if (NILP (default_value
))
987 default_string
= Qnil
;
988 else if (SYMBOLP (default_value
))
989 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
991 default_string
= default_value
;
993 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
994 Qnil
, Qnil
, default_string
, Qnil
);
997 return Fintern (name
, Qnil
);
1001 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1002 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
1003 Prompts with PROMPT.")
1007 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1012 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1013 "Read the name of a user variable and return it as a symbol.\n\
1014 Prompts with PROMPT. By default, return DEFAULT-VALUE.\n\
1015 A user variable is one whose documentation starts with a `*' character.")
1016 (prompt
, default_value
)
1017 Lisp_Object prompt
, default_value
;
1019 Lisp_Object name
, default_string
;
1021 if (NILP (default_value
))
1022 default_string
= Qnil
;
1023 else if (SYMBOLP (default_value
))
1024 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
1026 default_string
= default_value
;
1028 name
= Fcompleting_read (prompt
, Vobarray
,
1029 Quser_variable_p
, Qt
,
1030 Qnil
, Qnil
, default_string
, Qnil
);
1033 return Fintern (name
, Qnil
);
1036 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1037 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
1038 Prompts with PROMPT.\n\
1039 Optional second arg DEF is value to return if user enters an empty line.\n\
1040 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
1041 (prompt
, def
, require_match
)
1042 Lisp_Object prompt
, def
, require_match
;
1044 Lisp_Object args
[4];
1047 def
= XBUFFER (def
)->name
;
1049 if (NILP (Vread_buffer_function
))
1053 args
[0] = build_string ("%s(default %s) ");
1056 prompt
= Fformat (3, args
);
1059 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1060 require_match
, Qnil
, Qbuffer_name_history
,
1065 args
[0] = Vread_buffer_function
;
1068 args
[3] = require_match
;
1069 return Ffuncall(4, args
);
1074 minibuf_conform_representation (string
, basis
)
1075 Lisp_Object string
, basis
;
1077 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1080 if (STRING_MULTIBYTE (string
))
1081 return Fstring_make_unibyte (string
);
1083 return Fstring_make_multibyte (string
);
1086 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1087 "Return common substring of all completions of STRING in ALIST.\n\
1088 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1089 All that match are compared together; the longest initial sequence\n\
1090 common to all matches is returned as a string.\n\
1091 If there is no match at all, nil is returned.\n\
1092 For a unique match which is exact, t is returned.\n\
1094 ALIST can be an obarray instead of an alist.\n\
1095 Then the print names of all symbols in the obarray are the possible matches.\n\
1097 ALIST can also be a function to do the completion itself.\n\
1098 It receives three arguments: the values STRING, PREDICATE and nil.\n\
1099 Whatever it returns becomes the value of `try-completion'.\n\
1101 If optional third argument PREDICATE is non-nil,\n\
1102 it is used to test each possible match.\n\
1103 The match is a candidate only if PREDICATE returns non-nil.\n\
1104 The argument given to PREDICATE is the alist element\n\
1105 or the symbol from the obarray.\n\
1106 Additionally to this predicate, `completion-regexp-list'\n\
1107 is used to further constrain the set of candidates.")
1108 (string
, alist
, predicate
)
1109 Lisp_Object string
, alist
, predicate
;
1111 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1112 /* Size in bytes of BESTMATCH. */
1113 int bestmatchsize
= 0;
1114 /* These are in bytes, too. */
1115 int compare
, matchsize
;
1116 int list
= CONSP (alist
) || NILP (alist
);
1117 int index
= 0, obsize
= 0;
1119 Lisp_Object bucket
, zero
, end
, tem
;
1120 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1122 CHECK_STRING (string
, 0);
1123 if (!list
&& !VECTORP (alist
))
1124 return call3 (alist
, string
, predicate
, Qnil
);
1126 bestmatch
= bucket
= Qnil
;
1128 /* If ALIST is not a list, set TAIL just for gc pro. */
1133 obsize
= XVECTOR (alist
)->size
;
1134 bucket
= XVECTOR (alist
)->contents
[index
];
1139 /* Get the next element of the alist or obarray. */
1140 /* Exit the loop if the elements are all used up. */
1141 /* elt gets the alist element or symbol.
1142 eltstring gets the name to check as a completion. */
1149 eltstring
= Fcar (elt
);
1154 if (XFASTINT (bucket
) != 0)
1157 eltstring
= Fsymbol_name (elt
);
1158 if (XSYMBOL (bucket
)->next
)
1159 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1161 XSETFASTINT (bucket
, 0);
1163 else if (++index
>= obsize
)
1167 bucket
= XVECTOR (alist
)->contents
[index
];
1172 /* Is this element a possible completion? */
1174 if (STRINGP (eltstring
)
1175 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1176 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1177 make_number (XSTRING (string
)->size
),
1178 string
, make_number (0), Qnil
,
1179 completion_ignore_case
?Qt
: Qnil
),
1183 Lisp_Object regexps
;
1185 XSETFASTINT (zero
, 0);
1187 /* Ignore this element if it fails to match all the regexps. */
1188 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1189 regexps
= XCDR (regexps
))
1191 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1195 if (CONSP (regexps
))
1198 /* Ignore this element if there is a predicate
1199 and the predicate doesn't like it. */
1201 if (!NILP (predicate
))
1203 if (EQ (predicate
, Qcommandp
))
1204 tem
= Fcommandp (elt
);
1207 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1208 tem
= call1 (predicate
, elt
);
1211 if (NILP (tem
)) continue;
1214 /* Update computation of how much all possible completions match */
1217 if (NILP (bestmatch
))
1219 bestmatch
= eltstring
;
1220 bestmatchsize
= XSTRING (eltstring
)->size
;
1224 compare
= min (bestmatchsize
, XSTRING (eltstring
)->size
);
1225 tem
= Fcompare_strings (bestmatch
, make_number (0),
1226 make_number (compare
),
1227 eltstring
, make_number (0),
1228 make_number (compare
),
1229 completion_ignore_case
? Qt
: Qnil
);
1231 matchsize
= compare
;
1232 else if (XINT (tem
) < 0)
1233 matchsize
= - XINT (tem
) - 1;
1235 matchsize
= XINT (tem
) - 1;
1238 matchsize
= compare
;
1239 if (completion_ignore_case
)
1241 /* If this is an exact match except for case,
1242 use it as the best match rather than one that is not an
1243 exact match. This way, we get the case pattern
1244 of the actual match. */
1245 if ((matchsize
== XSTRING (eltstring
)->size
1246 && matchsize
< XSTRING (bestmatch
)->size
)
1248 /* If there is more than one exact match ignoring case,
1249 and one of them is exact including case,
1251 /* If there is no exact match ignoring case,
1252 prefer a match that does not change the case
1254 ((matchsize
== XSTRING (eltstring
)->size
)
1256 (matchsize
== XSTRING (bestmatch
)->size
)
1257 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1258 make_number (XSTRING (string
)->size
),
1259 string
, make_number (0),
1263 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1264 make_number (XSTRING (string
)->size
),
1265 string
, make_number (0),
1269 bestmatch
= eltstring
;
1271 bestmatchsize
= matchsize
;
1276 if (NILP (bestmatch
))
1277 return Qnil
; /* No completions found */
1278 /* If we are ignoring case, and there is no exact match,
1279 and no additional text was supplied,
1280 don't change the case of what the user typed. */
1281 if (completion_ignore_case
&& bestmatchsize
== XSTRING (string
)->size
1282 && XSTRING (bestmatch
)->size
> bestmatchsize
)
1283 return minibuf_conform_representation (string
, bestmatch
);
1285 /* Return t if the supplied string is an exact match (counting case);
1286 it does not require any change to be made. */
1287 if (matchcount
== 1 && bestmatchsize
== XSTRING (string
)->size
1288 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1289 make_number (bestmatchsize
),
1290 string
, make_number (0),
1291 make_number (bestmatchsize
),
1296 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1297 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1298 return Fsubstring (bestmatch
, zero
, end
);
1301 /* Compare exactly LEN chars of strings at S1 and S2,
1302 ignoring case if appropriate.
1303 Return -1 if strings match,
1304 else number of chars that match at the beginning. */
1308 register unsigned char *s1
, *s2
;
1311 register int l
= len
;
1313 if (completion_ignore_case
)
1315 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
1320 while (l
&& *s1
++ == *s2
++)
1327 int match
= len
- l
;
1329 /* Now *--S1 is the unmatching byte. If it is in the middle of
1330 multi-byte form, we must say that the multi-byte character
1331 there doesn't match. */
1332 while (match
&& *--s1
>= 0xA0) match
--;
1337 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1338 "Search for partial matches to STRING in ALIST.\n\
1339 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1340 The value is a list of all the strings from ALIST that match.\n\
1342 ALIST can be an obarray instead of an alist.\n\
1343 Then the print names of all symbols in the obarray are the possible matches.\n\
1345 ALIST can also be a function to do the completion itself.\n\
1346 It receives three arguments: the values STRING, PREDICATE and t.\n\
1347 Whatever it returns becomes the value of `all-completions'.\n\
1349 If optional third argument PREDICATE is non-nil,\n\
1350 it is used to test each possible match.\n\
1351 The match is a candidate only if PREDICATE returns non-nil.\n\
1352 The argument given to PREDICATE is the alist element\n\
1353 or the symbol from the obarray.\n\
1354 Additionally to this predicate, `completion-regexp-list'\n\
1355 is used to further constrain the set of candidates.\n\
1357 If the optional fourth argument HIDE-SPACES is non-nil,\n\
1358 strings in ALIST that start with a space\n\
1359 are ignored unless STRING itself starts with a space.")
1360 (string
, alist
, predicate
, hide_spaces
)
1361 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1363 Lisp_Object tail
, elt
, eltstring
;
1364 Lisp_Object allmatches
;
1365 int list
= CONSP (alist
) || NILP (alist
);
1366 int index
= 0, obsize
= 0;
1367 Lisp_Object bucket
, tem
;
1368 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1370 CHECK_STRING (string
, 0);
1371 if (!list
&& !VECTORP (alist
))
1373 return call3 (alist
, string
, predicate
, Qt
);
1375 allmatches
= bucket
= Qnil
;
1377 /* If ALIST is not a list, set TAIL just for gc pro. */
1382 obsize
= XVECTOR (alist
)->size
;
1383 bucket
= XVECTOR (alist
)->contents
[index
];
1388 /* Get the next element of the alist or obarray. */
1389 /* Exit the loop if the elements are all used up. */
1390 /* elt gets the alist element or symbol.
1391 eltstring gets the name to check as a completion. */
1398 eltstring
= Fcar (elt
);
1403 if (XFASTINT (bucket
) != 0)
1406 eltstring
= Fsymbol_name (elt
);
1407 if (XSYMBOL (bucket
)->next
)
1408 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1410 XSETFASTINT (bucket
, 0);
1412 else if (++index
>= obsize
)
1416 bucket
= XVECTOR (alist
)->contents
[index
];
1421 /* Is this element a possible completion? */
1423 if (STRINGP (eltstring
)
1424 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1425 /* If HIDE_SPACES, reject alternatives that start with space
1426 unless the input starts with space. */
1427 && ((STRING_BYTES (XSTRING (string
)) > 0
1428 && XSTRING (string
)->data
[0] == ' ')
1429 || XSTRING (eltstring
)->data
[0] != ' '
1430 || NILP (hide_spaces
))
1431 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1432 make_number (XSTRING (string
)->size
),
1433 string
, make_number (0),
1434 make_number (XSTRING (string
)->size
),
1435 completion_ignore_case
? Qt
: Qnil
),
1439 Lisp_Object regexps
;
1441 XSETFASTINT (zero
, 0);
1443 /* Ignore this element if it fails to match all the regexps. */
1444 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1445 regexps
= XCDR (regexps
))
1447 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1451 if (CONSP (regexps
))
1454 /* Ignore this element if there is a predicate
1455 and the predicate doesn't like it. */
1457 if (!NILP (predicate
))
1459 if (EQ (predicate
, Qcommandp
))
1460 tem
= Fcommandp (elt
);
1463 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1464 tem
= call1 (predicate
, elt
);
1467 if (NILP (tem
)) continue;
1469 /* Ok => put it on the list. */
1470 allmatches
= Fcons (eltstring
, allmatches
);
1474 return Fnreverse (allmatches
);
1477 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1478 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1479 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1480 Lisp_Object Vminibuffer_completing_file_name
;
1482 /* This comment supplies the doc string for completing-read,
1483 for make-docfile to see. We cannot put this in the real DEFUN
1484 due to limits in the Unix cpp.
1486 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1487 "Read a string in the minibuffer, with completion.\n\
1488 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
1489 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
1490 TABLE can also be a function to do the completion itself.\n\
1491 PREDICATE limits completion to a subset of TABLE.\n\
1492 See `try-completion' and `all-completions' for more details\n\
1493 on completion, TABLE, and PREDICATE.\n\
1495 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
1496 the input is (or completes to) an element of TABLE or is null.\n\
1497 If it is also not t, Return does not exit if it does non-null completion.\n\
1498 If the input is null, `completing-read' returns an empty string,\n\
1499 regardless of the value of REQUIRE-MATCH.\n\
1501 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
1502 If it is (STRING . POSITION), the initial input\n\
1503 is STRING, but point is placed POSITION characters into the string.\n\
1504 This feature is deprecated--it is best to pass nil for INITIAL.\n\
1505 HIST, if non-nil, specifies a history list\n\
1506 and optionally the initial position in the list.\n\
1507 It can be a symbol, which is the history list variable to use,\n\
1508 or it can be a cons cell (HISTVAR . HISTPOS).\n\
1509 In that case, HISTVAR is the history list variable to use,\n\
1510 and HISTPOS is the initial position (the position in the list\n\
1511 which INITIAL-INPUT corresponds to).\n\
1512 Positions are counted starting from 1 at the beginning of the list.\n\
1513 DEF, if non-nil, is the default value.\n\
1515 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits\n\
1516 the current input method and the setting of enable-multibyte-characters.\n\
1518 Completion ignores case if the ambient value of\n\
1519 `completion-ignore-case' is non-nil."
1521 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1522 0 /* See immediately above */)
1523 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1524 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1525 Lisp_Object hist
, def
, inherit_input_method
;
1527 Lisp_Object val
, histvar
, histpos
, position
;
1530 int count
= specpdl_ptr
- specpdl
;
1531 struct gcpro gcpro1
;
1533 init
= initial_input
;
1536 specbind (Qminibuffer_completion_table
, table
);
1537 specbind (Qminibuffer_completion_predicate
, predicate
);
1538 specbind (Qminibuffer_completion_confirm
,
1539 EQ (require_match
, Qt
) ? Qnil
: Qt
);
1540 last_exact_completion
= Qnil
;
1547 position
= Fcdr (init
);
1550 CHECK_STRING (init
, 0);
1551 if (!NILP (position
))
1553 CHECK_NUMBER (position
, 0);
1554 /* Convert to distance from end of input. */
1555 pos
= XINT (position
) - XSTRING (init
)->size
;
1566 histvar
= Fcar_safe (hist
);
1567 histpos
= Fcdr_safe (hist
);
1570 histvar
= Qminibuffer_history
;
1572 XSETFASTINT (histpos
, 0);
1574 val
= read_minibuf (NILP (require_match
)
1575 ? Vminibuffer_local_completion_map
1576 : Vminibuffer_local_must_match_map
,
1577 init
, prompt
, make_number (pos
), 0,
1578 histvar
, histpos
, def
, 0,
1579 !NILP (inherit_input_method
));
1581 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (def
))
1584 RETURN_UNGCPRO (unbind_to (count
, val
));
1587 Lisp_Object
Fminibuffer_completion_help ();
1588 Lisp_Object
assoc_for_completion ();
1590 /* Test whether TXT is an exact completion. */
1592 test_completion (txt
)
1597 if (CONSP (Vminibuffer_completion_table
)
1598 || NILP (Vminibuffer_completion_table
))
1599 return assoc_for_completion (txt
, Vminibuffer_completion_table
);
1600 else if (VECTORP (Vminibuffer_completion_table
))
1602 /* Bypass intern-soft as that loses for nil */
1603 tem
= oblookup (Vminibuffer_completion_table
,
1604 XSTRING (txt
)->data
,
1605 XSTRING (txt
)->size
,
1606 STRING_BYTES (XSTRING (txt
)));
1609 if (STRING_MULTIBYTE (txt
))
1610 txt
= Fstring_make_unibyte (txt
);
1612 txt
= Fstring_make_multibyte (txt
);
1614 tem
= oblookup (Vminibuffer_completion_table
,
1615 XSTRING (txt
)->data
,
1616 XSTRING (txt
)->size
,
1617 STRING_BYTES (XSTRING (txt
)));
1621 if (!NILP (Vminibuffer_completion_predicate
))
1622 return call1 (Vminibuffer_completion_predicate
, tem
);
1627 return call3 (Vminibuffer_completion_table
, txt
,
1628 Vminibuffer_completion_predicate
, Qlambda
);
1632 * 0 no possible completion
1633 * 1 was already an exact and unique completion
1634 * 3 was already an exact completion
1635 * 4 completed to an exact completion
1636 * 5 some completion happened
1637 * 6 no completion happened
1642 Lisp_Object completion
, string
, tem
;
1645 struct gcpro gcpro1
, gcpro2
;
1647 completion
= Ftry_completion (Fminibuffer_contents (),
1648 Vminibuffer_completion_table
,
1649 Vminibuffer_completion_predicate
);
1650 last
= last_exact_completion
;
1651 last_exact_completion
= Qnil
;
1653 GCPRO2 (completion
, last
);
1655 if (NILP (completion
))
1658 temp_echo_area_glyphs (" [No match]");
1663 if (EQ (completion
, Qt
)) /* exact and unique match */
1669 string
= Fminibuffer_contents ();
1671 /* COMPLETEDP should be true if some completion was done, which
1672 doesn't include simply changing the case of the entered string.
1673 However, for appearance, the string is rewritten if the case
1675 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1676 completedp
= !EQ (tem
, Qt
);
1678 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1680 /* Rewrite the user's input. */
1682 Fdelete_minibuffer_contents (); /* Some completion happened */
1683 Finsert (1, &completion
);
1686 /* The case of the string changed, but that's all. We're not
1687 sure whether this is a unique completion or not, so try again
1688 using the real case (this shouldn't recurse again, because
1689 the next time try-completion will return either `t' or the
1693 return do_completion ();
1697 /* It did find a match. Do we match some possibility exactly now? */
1698 tem
= test_completion (Fminibuffer_contents ());
1701 /* not an exact match */
1705 else if (!NILP (Vcompletion_auto_help
))
1706 Fminibuffer_completion_help ();
1708 temp_echo_area_glyphs (" [Next char not unique]");
1711 else if (completedp
)
1716 /* If the last exact completion and this one were the same,
1717 it means we've already given a "Complete but not unique"
1718 message and the user's hit TAB again, so now we give him help. */
1719 last_exact_completion
= completion
;
1722 tem
= Fminibuffer_contents ();
1723 if (!NILP (Fequal (tem
, last
)))
1724 Fminibuffer_completion_help ();
1730 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1733 assoc_for_completion (key
, list
)
1734 register Lisp_Object key
;
1737 register Lisp_Object tail
;
1739 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1741 register Lisp_Object elt
, tem
, thiscar
;
1743 if (!CONSP (elt
)) continue;
1744 thiscar
= Fcar (elt
);
1745 if (!STRINGP (thiscar
))
1747 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1748 key
, make_number (0), Qnil
,
1749 completion_ignore_case
? Qt
: Qnil
);
1757 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1758 "Complete the minibuffer contents as far as possible.\n\
1759 Return nil if there is no valid completion, else t.\n\
1760 If no characters can be completed, display a list of possible completions.\n\
1761 If you repeat this command after it displayed such a list,\n\
1762 scroll the window of possible completions.")
1766 Lisp_Object window
, tem
;
1768 /* If the previous command was not this,
1769 mark the completion buffer obsolete. */
1770 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1771 Vminibuf_scroll_window
= Qnil
;
1773 window
= Vminibuf_scroll_window
;
1774 /* If there's a fresh completion window with a live buffer,
1775 and this command is repeated, scroll that window. */
1776 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1777 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1779 struct buffer
*obuf
= current_buffer
;
1781 Fset_buffer (XWINDOW (window
)->buffer
);
1782 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1784 /* If end is in view, scroll up to the beginning. */
1785 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1787 /* Else scroll down one screen. */
1788 Fscroll_other_window (Qnil
);
1790 set_buffer_internal (obuf
);
1794 i
= do_completion ();
1802 Fgoto_char (make_number (ZV
));
1803 temp_echo_area_glyphs (" [Sole completion]");
1808 Fgoto_char (make_number (ZV
));
1809 temp_echo_area_glyphs (" [Complete, but not unique]");
1816 /* Subroutines of Fminibuffer_complete_and_exit. */
1818 /* This one is called by internal_condition_case to do the real work. */
1821 complete_and_exit_1 ()
1823 return make_number (do_completion ());
1826 /* This one is called by internal_condition_case if an error happens.
1827 Pretend the current value is an exact match. */
1830 complete_and_exit_2 (ignore
)
1833 return make_number (1);
1836 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1837 Sminibuffer_complete_and_exit
, 0, 0, "",
1838 "If the minibuffer contents is a valid completion then exit.\n\
1839 Otherwise try to complete it. If completion leads to a valid completion,\n\
1840 a repetition of this command will exit.")
1846 /* Allow user to specify null string */
1847 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
1850 if (!NILP (test_completion (Fminibuffer_contents ())))
1853 /* Call do_completion, but ignore errors. */
1854 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
1855 complete_and_exit_2
);
1865 if (!NILP (Vminibuffer_completion_confirm
))
1867 temp_echo_area_glyphs (" [Confirm]");
1877 return Fthrow (Qexit
, Qnil
);
1881 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1883 "Complete the minibuffer contents at most a single word.\n\
1884 After one word is completed as much as possible, a space or hyphen\n\
1885 is added, provided that matches some possible completion.\n\
1886 Return nil if there is no valid completion, else t.")
1889 Lisp_Object completion
, tem
, tem1
;
1890 register int i
, i_byte
;
1891 register unsigned char *completion_string
;
1892 struct gcpro gcpro1
, gcpro2
;
1893 int prompt_end_charpos
;
1895 /* We keep calling Fbuffer_string rather than arrange for GC to
1896 hold onto a pointer to one of the strings thus made. */
1898 completion
= Ftry_completion (Fminibuffer_contents (),
1899 Vminibuffer_completion_table
,
1900 Vminibuffer_completion_predicate
);
1901 if (NILP (completion
))
1904 temp_echo_area_glyphs (" [No match]");
1907 if (EQ (completion
, Qt
))
1910 #if 0 /* How the below code used to look, for reference. */
1911 tem
= Fminibuffer_contents ();
1912 b
= XSTRING (tem
)->data
;
1913 i
= ZV
- 1 - XSTRING (completion
)->size
;
1914 p
= XSTRING (completion
)->data
;
1916 0 <= scmp (b
, p
, ZV
- 1))
1919 /* Set buffer to longest match of buffer tail and completion head. */
1920 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1922 del_range (1, i
+ 1);
1925 #else /* Rewritten code */
1927 int buffer_nchars
, completion_nchars
;
1929 CHECK_STRING (completion
, 0);
1930 tem
= Fminibuffer_contents ();
1931 GCPRO2 (completion
, tem
);
1932 /* If reading a file name,
1933 expand any $ENVVAR refs in the buffer and in TEM. */
1934 if (! NILP (Vminibuffer_completing_file_name
))
1936 Lisp_Object substituted
;
1937 substituted
= Fsubstitute_in_file_name (tem
);
1938 if (! EQ (substituted
, tem
))
1941 Fdelete_minibuffer_contents ();
1942 insert_from_string (tem
, 0, 0, XSTRING (tem
)->size
,
1943 STRING_BYTES (XSTRING (tem
)), 0);
1946 buffer_nchars
= XSTRING (tem
)->size
; /* ie ZV - BEGV */
1947 completion_nchars
= XSTRING (completion
)->size
;
1948 i
= buffer_nchars
- completion_nchars
;
1951 (tem1
= Fcompare_strings (tem
, make_number (0),
1952 make_number (buffer_nchars
),
1953 completion
, make_number (0),
1954 make_number (buffer_nchars
),
1955 completion_ignore_case
? Qt
: Qnil
),
1960 /* Set buffer to longest match of buffer tail and completion head. */
1966 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
1967 completion
, make_number (0),
1968 make_number (buffer_nchars
),
1969 completion_ignore_case
? Qt
: Qnil
);
1976 del_range (1, i
+ 1);
1977 SET_PT_BOTH (ZV
, ZV_BYTE
);
1981 #endif /* Rewritten code */
1983 prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
1986 int prompt_end_bytepos
;
1987 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
1988 i
= ZV
- prompt_end_charpos
;
1989 i_byte
= ZV_BYTE
- prompt_end_bytepos
;
1992 /* If completion finds next char not unique,
1993 consider adding a space or a hyphen. */
1994 if (i
== XSTRING (completion
)->size
)
1996 GCPRO1 (completion
);
1997 tem
= Ftry_completion (concat2 (Fminibuffer_contents (), build_string (" ")),
1998 Vminibuffer_completion_table
,
1999 Vminibuffer_completion_predicate
);
2006 GCPRO1 (completion
);
2008 Ftry_completion (concat2 (Fminibuffer_contents (), build_string ("-")),
2009 Vminibuffer_completion_table
,
2010 Vminibuffer_completion_predicate
);
2018 /* Now find first word-break in the stuff found by completion.
2019 i gets index in string of where to stop completing. */
2022 int bytes
= STRING_BYTES (XSTRING (completion
));
2023 completion_string
= XSTRING (completion
)->data
;
2024 for (; i_byte
< STRING_BYTES (XSTRING (completion
)); i_byte
+= len
, i
++)
2026 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2029 if (SYNTAX (c
) != Sword
)
2038 /* If got no characters, print help for user. */
2040 if (i
== ZV
- prompt_end_charpos
)
2042 if (!NILP (Vcompletion_auto_help
))
2043 Fminibuffer_completion_help ();
2047 /* Otherwise insert in minibuffer the chars we got */
2049 Fdelete_minibuffer_contents ();
2050 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2054 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2056 "Display the list of completions, COMPLETIONS, using `standard-output'.\n\
2057 Each element may be just a symbol or string\n\
2058 or may be a list of two strings to be printed as if concatenated.\n\
2059 `standard-output' must be a buffer.\n\
2060 The actual completion alternatives, as inserted, are given `mouse-face'\n\
2061 properties of `highlight'.\n\
2062 At the end, this runs the normal hook `completion-setup-hook'.\n\
2063 It can find the completion buffer in `standard-output'.")
2065 Lisp_Object completions
;
2067 Lisp_Object tail
, elt
;
2070 struct gcpro gcpro1
, gcpro2
;
2071 struct buffer
*old
= current_buffer
;
2074 /* Note that (when it matters) every variable
2075 points to a non-string that is pointed to by COMPLETIONS,
2076 except for ELT. ELT can be pointing to a string
2077 when terpri or Findent_to calls a change hook. */
2079 GCPRO2 (completions
, elt
);
2081 if (BUFFERP (Vstandard_output
))
2082 set_buffer_internal (XBUFFER (Vstandard_output
));
2084 if (NILP (completions
))
2085 write_string ("There are no possible completions of what you have typed.",
2089 write_string ("Possible completions are:", -1);
2090 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2092 Lisp_Object tem
, string
;
2094 Lisp_Object startpos
, endpos
;
2099 /* Compute the length of this element. */
2103 CHECK_STRING (tem
, 0);
2104 length
= XSTRING (tem
)->size
;
2106 tem
= Fcar (XCDR (elt
));
2107 CHECK_STRING (tem
, 0);
2108 length
+= XSTRING (tem
)->size
;
2112 CHECK_STRING (elt
, 0);
2113 length
= XSTRING (elt
)->size
;
2116 /* This does a bad job for narrower than usual windows.
2117 Sadly, the window it will appear in is not known
2118 until after the text has been made. */
2120 if (BUFFERP (Vstandard_output
))
2121 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2123 /* If the previous completion was very wide,
2124 or we have two on this line already,
2125 don't put another on the same line. */
2126 if (column
> 33 || first
2127 /* If this is really wide, don't put it second on a line. */
2128 || (column
> 0 && length
> 45))
2133 /* Otherwise advance to column 35. */
2136 if (BUFFERP (Vstandard_output
))
2138 tem
= Findent_to (make_number (35), make_number (2));
2140 column
= XINT (tem
);
2146 write_string (" ", -1);
2149 while (column
< 35);
2153 if (BUFFERP (Vstandard_output
))
2155 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2156 Fset_text_properties (startpos
, endpos
,
2157 Qnil
, Vstandard_output
);
2160 /* Output this element.
2161 If necessary, convert it to unibyte or to multibyte first. */
2163 string
= Fcar (elt
);
2166 if (NILP (current_buffer
->enable_multibyte_characters
)
2167 && STRING_MULTIBYTE (string
))
2168 string
= Fstring_make_unibyte (string
);
2169 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2170 && !STRING_MULTIBYTE (string
))
2171 string
= Fstring_make_multibyte (string
);
2173 if (BUFFERP (Vstandard_output
))
2175 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2177 Fprinc (string
, Qnil
);
2179 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2181 Fput_text_property (startpos
, endpos
,
2182 Qmouse_face
, intern ("highlight"),
2187 Fprinc (string
, Qnil
);
2190 /* Output the annotation for this element. */
2193 if (BUFFERP (Vstandard_output
))
2195 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2197 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2199 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2201 Fset_text_properties (startpos
, endpos
, Qnil
,
2206 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2211 /* Update COLUMN for what we have output. */
2214 /* If output is to a buffer, recompute COLUMN in a way
2215 that takes account of character widths. */
2216 if (BUFFERP (Vstandard_output
))
2218 tem
= Fcurrent_column ();
2219 column
= XINT (tem
);
2228 if (BUFFERP (Vstandard_output
))
2229 set_buffer_internal (old
);
2231 if (!NILP (Vrun_hooks
))
2232 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2237 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2239 "Display a list of possible completions of the current minibuffer contents.")
2242 Lisp_Object completions
;
2244 message ("Making completion list...");
2245 completions
= Fall_completions (Fminibuffer_contents (),
2246 Vminibuffer_completion_table
,
2247 Vminibuffer_completion_predicate
,
2249 clear_message (1, 0);
2251 if (NILP (completions
))
2254 temp_echo_area_glyphs (" [No completions]");
2257 internal_with_output_to_temp_buffer ("*Completions*",
2258 Fdisplay_completion_list
,
2259 Fsort (completions
, Qstring_lessp
));
2263 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2264 "Terminate minibuffer input.")
2267 if (INTEGERP (last_command_char
))
2268 internal_self_insert (XINT (last_command_char
), 0);
2272 return Fthrow (Qexit
, Qnil
);
2275 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2276 "Terminate this minibuffer argument.")
2279 return Fthrow (Qexit
, Qnil
);
2282 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2283 "Return current depth of activations of minibuffer, a nonnegative integer.")
2286 return make_number (minibuf_level
);
2289 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2290 "Return the prompt string of the currently-active minibuffer.\n\
2291 If no minibuffer is active, return nil.")
2294 return Fcopy_sequence (minibuf_prompt
);
2298 /* Temporarily display the string M at the end of the current
2299 minibuffer contents. This is used to display things like
2300 "[No Match]" when the user requests a completion for a prefix
2301 that has no possible completions, and other quick, unobtrusive
2305 temp_echo_area_glyphs (m
)
2309 int osize_byte
= ZV_BYTE
;
2311 int opoint_byte
= PT_BYTE
;
2312 Lisp_Object oinhibit
;
2313 oinhibit
= Vinhibit_quit
;
2315 /* Clear out any old echo-area message to make way for our new thing. */
2318 SET_PT_BOTH (osize
, osize_byte
);
2320 SET_PT_BOTH (opoint
, opoint_byte
);
2322 Fsit_for (make_number (2), Qnil
, Qnil
);
2323 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2324 SET_PT_BOTH (opoint
, opoint_byte
);
2325 if (!NILP (Vquit_flag
))
2328 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2330 Vinhibit_quit
= oinhibit
;
2333 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2335 "Temporarily display STRING at the end of the minibuffer.\n\
2336 The text is displayed for two seconds,\n\
2337 or until the next input event arrives, whichever comes first.")
2341 temp_echo_area_glyphs (XSTRING (string
)->data
);
2346 init_minibuf_once ()
2348 Vminibuffer_list
= Qnil
;
2349 staticpro (&Vminibuffer_list
);
2356 minibuf_prompt
= Qnil
;
2357 staticpro (&minibuf_prompt
);
2359 minibuf_save_list
= Qnil
;
2360 staticpro (&minibuf_save_list
);
2362 Qread_file_name_internal
= intern ("read-file-name-internal");
2363 staticpro (&Qread_file_name_internal
);
2365 Qminibuffer_default
= intern ("minibuffer-default");
2366 staticpro (&Qminibuffer_default
);
2367 Fset (Qminibuffer_default
, Qnil
);
2369 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2370 staticpro (&Qminibuffer_completion_table
);
2372 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2373 staticpro (&Qminibuffer_completion_confirm
);
2375 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2376 staticpro (&Qminibuffer_completion_predicate
);
2378 staticpro (&last_exact_completion
);
2379 last_exact_completion
= Qnil
;
2381 staticpro (&last_minibuf_string
);
2382 last_minibuf_string
= Qnil
;
2384 Quser_variable_p
= intern ("user-variable-p");
2385 staticpro (&Quser_variable_p
);
2387 Qminibuffer_history
= intern ("minibuffer-history");
2388 staticpro (&Qminibuffer_history
);
2390 Qbuffer_name_history
= intern ("buffer-name-history");
2391 staticpro (&Qbuffer_name_history
);
2392 Fset (Qbuffer_name_history
, Qnil
);
2394 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2395 staticpro (&Qminibuffer_setup_hook
);
2397 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2398 staticpro (&Qminibuffer_exit_hook
);
2400 Qhistory_length
= intern ("history-length");
2401 staticpro (&Qhistory_length
);
2403 Qcurrent_input_method
= intern ("current-input-method");
2404 staticpro (&Qcurrent_input_method
);
2406 Qactivate_input_method
= intern ("activate-input-method");
2407 staticpro (&Qactivate_input_method
);
2409 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2410 "If this is non-nil, `read-buffer' does its work by calling this function.");
2411 Vread_buffer_function
= Qnil
;
2413 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2414 "Normal hook run just after entry to minibuffer.");
2415 Vminibuffer_setup_hook
= Qnil
;
2417 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2418 "Normal hook run just after exit from minibuffer.");
2419 Vminibuffer_exit_hook
= Qnil
;
2421 DEFVAR_LISP ("history-length", &Vhistory_length
,
2422 "*Maximum length for history lists before truncation takes place.\n\
2423 A number means that length; t means infinite. Truncation takes place\n\
2424 just after a new element is inserted. Setting the history-length\n\
2425 property of a history variable overrides this default.");
2426 XSETFASTINT (Vhistory_length
, 30);
2428 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2429 "*Non-nil means automatically provide help for invalid completion input.");
2430 Vcompletion_auto_help
= Qt
;
2432 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2433 "Non-nil means don't consider case significant in completion.");
2434 completion_ignore_case
= 0;
2436 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2437 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
2438 This variable makes a difference whenever the minibuffer window is active.");
2439 enable_recursive_minibuffers
= 0;
2441 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2442 "Alist or obarray used for completion in the minibuffer.\n\
2443 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
2445 The value may alternatively be a function, which is given three arguments:\n\
2446 STRING, the current buffer contents;\n\
2447 PREDICATE, the predicate for filtering possible matches;\n\
2448 CODE, which says what kind of things to do.\n\
2449 CODE can be nil, t or `lambda'.\n\
2450 nil means to return the best completion of STRING, or nil if there is none.\n\
2451 t means to return a list of all possible completions of STRING.\n\
2452 `lambda' means to return t if STRING is a valid completion as it stands.");
2453 Vminibuffer_completion_table
= Qnil
;
2455 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2456 "Within call to `completing-read', this holds the PREDICATE argument.");
2457 Vminibuffer_completion_predicate
= Qnil
;
2459 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2460 "Non-nil => demand confirmation of completion before exiting minibuffer.");
2461 Vminibuffer_completion_confirm
= Qnil
;
2463 DEFVAR_LISP ("minibuffer-completing-file-name",
2464 &Vminibuffer_completing_file_name
,
2465 "Non-nil means completing file names.");
2466 Vminibuffer_completing_file_name
= Qnil
;
2468 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2469 "Value that `help-form' takes on inside the minibuffer.");
2470 Vminibuffer_help_form
= Qnil
;
2472 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2473 "History list symbol to add minibuffer values to.\n\
2474 Each string of minibuffer input, as it appears on exit from the minibuffer,\n\
2476 (set minibuffer-history-variable\n\
2477 (cons STRING (symbol-value minibuffer-history-variable)))");
2478 XSETFASTINT (Vminibuffer_history_variable
, 0);
2480 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2481 "Current position of redoing in the history list.");
2482 Vminibuffer_history_position
= Qnil
;
2484 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2485 "*Non-nil means entering the minibuffer raises the minibuffer's frame.\n\
2486 Some uses of the echo area also raise that frame (since they use it too).");
2487 minibuffer_auto_raise
= 0;
2489 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2490 "List of regexps that should restrict possible completions.");
2491 Vcompletion_regexp_list
= Qnil
;
2493 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2494 &minibuffer_allow_text_properties
,
2495 "Non-nil means `read-from-minibuffer' should not discard text properties.\n\
2496 This also affects `read-string', but it does not affect `read-minibuffer',\n\
2497 `read-no-blanks-input', or any of the functions that do minibuffer input\n\
2498 with completion; they always discard text properties.");
2499 minibuffer_allow_text_properties
= 0;
2501 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2502 "Text properties that are added to minibuffer prompts.\n\
2503 These are in addition to the basic `field' property, and stickiness\n\
2505 /* We use `intern' here instead of Qread_only to avoid
2506 initialization-order problems. */
2507 Vminibuffer_prompt_properties
2508 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2510 defsubr (&Sset_minibuffer_window
);
2511 defsubr (&Sread_from_minibuffer
);
2512 defsubr (&Seval_minibuffer
);
2513 defsubr (&Sread_minibuffer
);
2514 defsubr (&Sread_string
);
2515 defsubr (&Sread_command
);
2516 defsubr (&Sread_variable
);
2517 defsubr (&Sread_buffer
);
2518 defsubr (&Sread_no_blanks_input
);
2519 defsubr (&Sminibuffer_depth
);
2520 defsubr (&Sminibuffer_prompt
);
2522 defsubr (&Sminibuffer_prompt_end
);
2523 defsubr (&Sminibuffer_contents
);
2524 defsubr (&Sminibuffer_contents_no_properties
);
2525 defsubr (&Sdelete_minibuffer_contents
);
2527 defsubr (&Stry_completion
);
2528 defsubr (&Sall_completions
);
2529 defsubr (&Scompleting_read
);
2530 defsubr (&Sminibuffer_complete
);
2531 defsubr (&Sminibuffer_complete_word
);
2532 defsubr (&Sminibuffer_complete_and_exit
);
2533 defsubr (&Sdisplay_completion_list
);
2534 defsubr (&Sminibuffer_completion_help
);
2536 defsubr (&Sself_insert_and_exit
);
2537 defsubr (&Sexit_minibuffer
);
2539 defsubr (&Sminibuffer_message
);
2545 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2546 "abort-recursive-edit");
2547 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2549 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2552 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('g'),
2553 "abort-recursive-edit");
2554 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('m'),
2556 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('j'),
2559 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2561 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2563 initial_define_key (Vminibuffer_local_ns_map
, '?',
2564 "self-insert-and-exit");
2566 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('g'),
2567 "abort-recursive-edit");
2568 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('m'),
2570 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('j'),
2573 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2574 "minibuffer-complete");
2575 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2576 "minibuffer-complete-word");
2577 initial_define_key (Vminibuffer_local_completion_map
, '?',
2578 "minibuffer-completion-help");
2580 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('g'),
2581 "abort-recursive-edit");
2582 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2583 "minibuffer-complete-and-exit");
2584 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2585 "minibuffer-complete-and-exit");
2586 initial_define_key (Vminibuffer_local_must_match_map
, '\t',
2587 "minibuffer-complete");
2588 initial_define_key (Vminibuffer_local_must_match_map
, ' ',
2589 "minibuffer-complete-word");
2590 initial_define_key (Vminibuffer_local_must_match_map
, '?',
2591 "minibuffer-completion-help");