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 extern Lisp_Object Voverriding_local_map
;
128 Lisp_Object Quser_variable_p
;
130 Lisp_Object Qminibuffer_default
;
132 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
134 extern Lisp_Object Qmouse_face
;
136 extern Lisp_Object Qfield
;
138 /* Put minibuf on currently selected frame's minibuffer.
139 We do this whenever the user starts a new minibuffer
140 or when a minibuffer exits. */
143 choose_minibuf_frame ()
145 if (FRAMEP (selected_frame
)
146 && FRAME_LIVE_P (XFRAME (selected_frame
))
147 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
149 struct frame
*sf
= XFRAME (selected_frame
);
152 /* I don't think that any frames may validly have a null minibuffer
154 if (NILP (sf
->minibuffer_window
))
157 /* Under X, we come here with minibuf_window being the
158 minibuffer window of the unused termcap window created in
159 init_window_once. That window doesn't have a buffer. */
160 buffer
= XWINDOW (minibuf_window
)->buffer
;
161 if (BUFFERP (buffer
))
162 Fset_window_buffer (sf
->minibuffer_window
, buffer
);
163 minibuf_window
= sf
->minibuffer_window
;
166 /* Make sure no other frame has a minibuffer as its selected window,
167 because the text would not be displayed in it, and that would be
168 confusing. Only allow the selected frame to do this,
169 and that only if the minibuffer is active. */
171 Lisp_Object tail
, frame
;
173 FOR_EACH_FRAME (tail
, frame
)
174 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
175 && !(EQ (frame
, selected_frame
)
176 && minibuf_level
> 0))
177 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
182 choose_minibuf_frame_1 (ignore
)
185 choose_minibuf_frame ();
189 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
190 Sset_minibuffer_window
, 1, 1, 0,
191 doc
: /* Specify which minibuffer window to use for the minibuffer.
192 This effects where the minibuffer is displayed if you put text in it
193 without invoking the usual minibuffer commands. */)
197 CHECK_WINDOW (window
);
198 if (! MINI_WINDOW_P (XWINDOW (window
)))
199 error ("Window is not a minibuffer window");
201 minibuf_window
= window
;
207 /* Actual minibuffer invocation. */
209 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
210 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
211 Lisp_Object
, Lisp_Object
,
213 Lisp_Object
, Lisp_Object
,
215 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
216 Lisp_Object
, Lisp_Object
,
218 Lisp_Object
, Lisp_Object
,
220 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
223 /* Read a Lisp object from VAL and return it. If VAL is an empty
224 string, and DEFALT is a string, read from DEFALT instead of VAL. */
227 string_to_object (val
, defalt
)
228 Lisp_Object val
, defalt
;
230 struct gcpro gcpro1
, gcpro2
;
231 Lisp_Object expr_and_pos
;
234 GCPRO2 (val
, defalt
);
236 if (STRINGP (val
) && SCHARS (val
) == 0
240 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
241 pos
= XINT (Fcdr (expr_and_pos
));
242 if (pos
!= SCHARS (val
))
244 /* Ignore trailing whitespace; any other trailing junk
247 pos
= string_char_to_byte (val
, pos
);
248 for (i
= pos
; i
< SBYTES (val
); i
++)
250 int c
= SREF (val
, i
);
251 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
252 error ("Trailing garbage following expression");
256 val
= Fcar (expr_and_pos
);
257 RETURN_UNGCPRO (val
);
261 /* Like read_minibuf but reading from stdin. This function is called
262 from read_minibuf to do the job if noninteractive. */
265 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
266 histvar
, histpos
, defalt
, allow_props
,
267 inherit_input_method
)
271 Lisp_Object backup_n
;
277 int inherit_input_method
;
283 fprintf (stdout
, "%s", SDATA (prompt
));
289 line
= (char *) xmalloc (size
* sizeof *line
);
290 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
291 && (len
= strlen (line
),
292 len
== size
- 1 && line
[len
- 1] != '\n'))
295 line
= (char *) xrealloc (line
, size
);
302 if (len
> 0 && line
[len
- 1] == '\n')
305 val
= build_string (line
);
311 error ("Error reading from stdin");
314 /* If Lisp form desired instead of string, parse it. */
316 val
= string_to_object (val
, defalt
);
321 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
322 Sminibuffer_prompt_end
, 0, 0, 0,
323 doc
: /* Return the buffer position of the end of the minibuffer prompt.
324 Return (point-min) if current buffer is not a mini-buffer. */)
327 /* This function is written to be most efficient when there's a prompt. */
328 Lisp_Object beg
= make_number (BEGV
);
329 Lisp_Object end
= Ffield_end (beg
, Qnil
, Qnil
);
331 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
337 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
338 Sminibuffer_contents
, 0, 0, 0,
339 doc
: /* Return the user input in a minibuffer as a string.
340 The current buffer must be a minibuffer. */)
343 int prompt_end
= XINT (Fminibuffer_prompt_end ());
344 return make_buffer_string (prompt_end
, ZV
, 1);
347 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
348 Sminibuffer_contents_no_properties
, 0, 0, 0,
349 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
350 The current buffer must be a minibuffer. */)
353 int prompt_end
= XINT (Fminibuffer_prompt_end ());
354 return make_buffer_string (prompt_end
, ZV
, 0);
357 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
358 Sdelete_minibuffer_contents
, 0, 0, 0,
359 doc
: /* Delete all user input in a minibuffer.
360 The current buffer must be a minibuffer. */)
363 int prompt_end
= XINT (Fminibuffer_prompt_end ());
365 del_range (prompt_end
, ZV
);
369 /* Get the text in the minibuffer before point.
370 That is what completion commands operate on. */
373 minibuffer_completion_contents ()
375 int prompt_end
= XINT (Fminibuffer_prompt_end ());
376 return make_buffer_string (prompt_end
, PT
, 1);
379 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
380 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
381 prompting with PROMPT (a string), using history list HISTVAR
382 with initial position HISTPOS. (BACKUP_N should be <= 0.)
384 Normally return the result as a string (the text that was read),
385 but if EXPFLAG is nonzero, read it and return the object read.
386 If HISTVAR is given, save the value read on that history only if it doesn't
387 match the front of that history list exactly. The value is pushed onto
388 the list as the string that was read.
390 DEFALT specifies te default value for the sake of history commands.
392 If ALLOW_PROPS is nonzero, we do not throw away text properties.
394 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
395 current input method. */
398 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
399 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
403 Lisp_Object backup_n
;
409 int inherit_input_method
;
412 int count
= SPECPDL_INDEX ();
413 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
414 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
415 Lisp_Object enable_multibyte
;
416 extern Lisp_Object Qfront_sticky
;
417 extern Lisp_Object Qrear_nonsticky
;
419 specbind (Qminibuffer_default
, defalt
);
421 single_kboard_state ();
422 #ifdef HAVE_X_WINDOWS
423 if (display_hourglass_p
)
428 ambient_dir
= current_buffer
->directory
;
430 enable_multibyte
= Qnil
;
432 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
433 store them away before we can GC. Don't need to protect
434 BACKUP_N because we use the value only if it is an integer. */
435 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
437 if (!STRINGP (prompt
))
438 prompt
= empty_string
;
440 if (!enable_recursive_minibuffers
441 && minibuf_level
> 0)
443 if (EQ (selected_window
, minibuf_window
))
444 error ("Command attempted to use minibuffer while in minibuffer");
446 /* If we're in another window, cancel the minibuffer that's active. */
448 build_string ("Command attempted to use minibuffer while in minibuffer"));
453 val
= read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
,
454 expflag
, histvar
, histpos
, defalt
,
455 allow_props
, inherit_input_method
);
456 return unbind_to (count
, val
);
459 /* Choose the minibuffer window and frame, and take action on them. */
461 choose_minibuf_frame ();
463 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
465 record_unwind_protect (Fset_window_configuration
,
466 Fcurrent_window_configuration (Qnil
));
468 /* If the minibuffer window is on a different frame, save that
469 frame's configuration too. */
470 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
471 if (!EQ (mini_frame
, selected_frame
))
472 record_unwind_protect (Fset_window_configuration
,
473 Fcurrent_window_configuration (mini_frame
));
475 /* If the minibuffer is on an iconified or invisible frame,
476 make it visible now. */
477 Fmake_frame_visible (mini_frame
);
479 if (minibuffer_auto_raise
)
480 Fraise_frame (mini_frame
);
482 /* We have to do this after saving the window configuration
483 since that is what restores the current buffer. */
485 /* Arrange to restore a number of minibuffer-related variables.
486 We could bind each variable separately, but that would use lots of
489 = Fcons (Voverriding_local_map
,
490 Fcons (minibuf_window
, minibuf_save_list
));
492 = Fcons (minibuf_prompt
,
493 Fcons (make_number (minibuf_prompt_width
),
495 Fcons (Vcurrent_prefix_arg
,
496 Fcons (Vminibuffer_history_position
,
497 Fcons (Vminibuffer_history_variable
,
498 minibuf_save_list
))))));
500 record_unwind_protect (read_minibuf_unwind
, Qnil
);
503 /* Now that we can restore all those variables, start changing them. */
505 minibuf_prompt_width
= 0;
506 minibuf_prompt
= Fcopy_sequence (prompt
);
507 Vminibuffer_history_position
= histpos
;
508 Vminibuffer_history_variable
= histvar
;
509 Vhelp_form
= Vminibuffer_help_form
;
511 if (inherit_input_method
)
513 /* `current-input-method' is buffer local. So, remember it in
514 INPUT_METHOD before changing the current buffer. */
515 input_method
= Fsymbol_value (Qcurrent_input_method
);
516 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
519 /* Switch to the minibuffer. */
521 minibuffer
= get_minibuffer (minibuf_level
);
522 Fset_buffer (minibuffer
);
524 /* The current buffer's default directory is usually the right thing
525 for our minibuffer here. However, if you're typing a command at
526 a minibuffer-only frame when minibuf_level is zero, then buf IS
527 the current_buffer, so reset_buffer leaves buf's default
528 directory unchanged. This is a bummer when you've just started
529 up Emacs and buf's default directory is Qnil. Here's a hack; can
530 you think of something better to do? Find another buffer with a
531 better directory, and use that one instead. */
532 if (STRINGP (ambient_dir
))
533 current_buffer
->directory
= ambient_dir
;
536 Lisp_Object buf_list
;
538 for (buf_list
= Vbuffer_alist
;
540 buf_list
= XCDR (buf_list
))
542 Lisp_Object other_buf
;
544 other_buf
= XCDR (XCAR (buf_list
));
545 if (STRINGP (XBUFFER (other_buf
)->directory
))
547 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
553 if (!EQ (mini_frame
, selected_frame
))
554 Fredirect_frame_focus (selected_frame
, mini_frame
);
556 Vminibuf_scroll_window
= selected_window
;
557 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
558 minibuf_selected_window
= selected_window
;
559 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
560 Fselect_window (minibuf_window
);
561 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
563 Fmake_local_variable (Qprint_escape_newlines
);
564 print_escape_newlines
= 1;
566 /* Erase the buffer. */
568 int count1
= SPECPDL_INDEX ();
569 specbind (Qinhibit_read_only
, Qt
);
570 specbind (Qinhibit_modification_hooks
, Qt
);
572 unbind_to (count1
, Qnil
);
575 if (!NILP (current_buffer
->enable_multibyte_characters
)
576 && ! STRING_MULTIBYTE (minibuf_prompt
))
577 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
579 /* Insert the prompt, record where it ends. */
580 Finsert (1, &minibuf_prompt
);
583 Fput_text_property (make_number (BEG
), make_number (PT
),
584 Qfront_sticky
, Qt
, Qnil
);
585 Fput_text_property (make_number (BEG
), make_number (PT
),
586 Qrear_nonsticky
, Qt
, Qnil
);
587 Fput_text_property (make_number (BEG
), make_number (PT
),
589 Fadd_text_properties (make_number (BEG
), make_number (PT
),
590 Vminibuffer_prompt_properties
, Qnil
);
593 minibuf_prompt_width
= (int) current_column (); /* iftc */
595 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
596 if (inherit_input_method
)
597 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
599 /* Put in the initial input. */
602 Finsert (1, &initial
);
603 if (INTEGERP (backup_n
))
604 Fforward_char (backup_n
);
607 clear_message (1, 1);
608 current_buffer
->keymap
= map
;
610 /* Turn on an input method stored in INPUT_METHOD if any. */
611 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
612 call1 (Qactivate_input_method
, input_method
);
614 /* Run our hook, but not if it is empty.
615 (run-hooks would do nothing if it is empty,
616 but it's important to save time here in the usual case.) */
617 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
618 && !NILP (Vrun_hooks
))
619 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
621 /* Don't allow the user to undo past this point. */
622 current_buffer
->undo_list
= Qnil
;
626 /* If cursor is on the minibuffer line,
627 show the user we have exited by putting it in column 0. */
628 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
631 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
632 XWINDOW (minibuf_window
)->cursor
.x
= 0;
633 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
634 update_frame (XFRAME (selected_frame
), 1, 1);
635 if (rif
&& rif
->flush_display
)
636 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
639 /* Make minibuffer contents into a string. */
640 Fset_buffer (minibuffer
);
642 val
= Fminibuffer_contents ();
644 val
= Fminibuffer_contents_no_properties ();
646 /* VAL is the string of minibuffer text. */
648 last_minibuf_string
= val
;
650 /* Add the value to the appropriate history list unless it is empty. */
651 if (SCHARS (val
) != 0
652 && SYMBOLP (Vminibuffer_history_variable
))
654 /* If the caller wanted to save the value read on a history list,
655 then do so if the value is not already the front of the list. */
658 /* If variable is unbound, make it nil. */
659 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
660 Fset (Vminibuffer_history_variable
, Qnil
);
662 histval
= Fsymbol_value (Vminibuffer_history_variable
);
664 /* The value of the history variable must be a cons or nil. Other
665 values are unacceptable. We silently ignore these values. */
668 && NILP (Fequal (last_minibuf_string
, Fcar (histval
)))))
672 histval
= Fcons (last_minibuf_string
, histval
);
673 Fset (Vminibuffer_history_variable
, histval
);
675 /* Truncate if requested. */
676 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
677 if (NILP (length
)) length
= Vhistory_length
;
678 if (INTEGERP (length
))
680 if (XINT (length
) <= 0)
681 Fset (Vminibuffer_history_variable
, Qnil
);
686 temp
= Fnthcdr (Fsub1 (length
), histval
);
687 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
693 /* If Lisp form desired instead of string, parse it. */
695 val
= string_to_object (val
, defalt
);
697 /* The appropriate frame will get selected
698 in set-window-configuration. */
699 RETURN_UNGCPRO (unbind_to (count
, val
));
702 /* Return a buffer to be used as the minibuffer at depth `depth'.
703 depth = 0 is the lowest allowed argument, and that is the value
704 used for nonrecursive minibuffer invocations */
707 get_minibuffer (depth
)
710 Lisp_Object tail
, num
, buf
;
712 extern Lisp_Object
nconc2 ();
714 XSETFASTINT (num
, depth
);
715 tail
= Fnthcdr (num
, Vminibuffer_list
);
718 tail
= Fcons (Qnil
, Qnil
);
719 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
722 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
724 sprintf (name
, " *Minibuf-%d*", depth
);
725 buf
= Fget_buffer_create (build_string (name
));
727 /* Although the buffer's name starts with a space, undo should be
729 Fbuffer_enable_undo (buf
);
735 int count
= SPECPDL_INDEX ();
737 reset_buffer (XBUFFER (buf
));
738 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
740 Fkill_all_local_variables ();
741 unbind_to (count
, Qnil
);
747 /* This function is called on exiting minibuffer, whether normally or
748 not, and it restores the current window, buffer, etc. */
751 read_minibuf_unwind (data
)
754 Lisp_Object old_deactivate_mark
;
757 /* We are exiting the minibuffer one way or the other,
759 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
760 && !NILP (Vrun_hooks
))
761 safe_run_hooks (Qminibuffer_exit_hook
);
763 /* If this was a recursive minibuffer,
764 tie the minibuffer window back to the outer level minibuffer buffer. */
767 window
= minibuf_window
;
768 /* To keep things predictable, in case it matters, let's be in the
769 minibuffer when we reset the relevant variables. */
770 Fset_buffer (XWINDOW (window
)->buffer
);
772 /* Restore prompt, etc, from outer minibuffer level. */
773 minibuf_prompt
= Fcar (minibuf_save_list
);
774 minibuf_save_list
= Fcdr (minibuf_save_list
);
775 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
776 minibuf_save_list
= Fcdr (minibuf_save_list
);
777 Vhelp_form
= Fcar (minibuf_save_list
);
778 minibuf_save_list
= Fcdr (minibuf_save_list
);
779 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
780 minibuf_save_list
= Fcdr (minibuf_save_list
);
781 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
782 minibuf_save_list
= Fcdr (minibuf_save_list
);
783 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
784 minibuf_save_list
= Fcdr (minibuf_save_list
);
785 Voverriding_local_map
= Fcar (minibuf_save_list
);
786 minibuf_save_list
= Fcdr (minibuf_save_list
);
788 temp
= Fcar (minibuf_save_list
);
789 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
790 minibuf_window
= temp
;
792 minibuf_save_list
= Fcdr (minibuf_save_list
);
794 /* Erase the minibuffer we were using at this level. */
796 int count
= SPECPDL_INDEX ();
797 /* Prevent error in erase-buffer. */
798 specbind (Qinhibit_read_only
, Qt
);
799 specbind (Qinhibit_modification_hooks
, Qt
);
800 old_deactivate_mark
= Vdeactivate_mark
;
802 Vdeactivate_mark
= old_deactivate_mark
;
803 unbind_to (count
, Qnil
);
806 /* When we get to the outmost level, make sure we resize the
807 mini-window back to its normal size. */
808 if (minibuf_level
== 0)
809 resize_mini_window (XWINDOW (window
), 0);
811 /* Make sure minibuffer window is erased, not ignored. */
812 windows_or_buffers_changed
++;
813 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
814 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
819 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
820 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
821 If optional second arg INITIAL-CONTENTS is non-nil, it is a string
822 to be inserted into the minibuffer before reading input.
823 If INITIAL-CONTENTS is (STRING . POSITION), the initial input
824 is STRING, but point is placed at position POSITION in the minibuffer.
825 Third arg KEYMAP is a keymap to use whilst reading;
826 if omitted or nil, the default is `minibuffer-local-map'.
827 If fourth arg READ is non-nil, then interpret the result as a Lisp object
828 and return that object:
829 in other words, do `(car (read-from-string INPUT-STRING))'
830 Fifth arg HIST, if non-nil, specifies a history list
831 and optionally the initial position in the list.
832 It can be a symbol, which is the history list variable to use,
833 or it can be a cons cell (HISTVAR . HISTPOS).
834 In that case, HISTVAR is the history list variable to use,
835 and HISTPOS is the initial position (the position in the list
836 which INITIAL-CONTENTS corresponds to).
837 Positions are counted starting from 1 at the beginning of the list.
838 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
839 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE
840 if the user enters empty input! It returns the empty string.
841 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
842 the current input method and the setting of `enable-multibyte-characters'.
843 If the variable `minibuffer-allow-text-properties' is non-nil,
844 then the string which is returned includes whatever text properties
845 were present in the minibuffer. Otherwise the value has no text properties. */)
846 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
847 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
848 Lisp_Object inherit_input_method
;
851 Lisp_Object histvar
, histpos
, position
, val
;
856 CHECK_STRING (prompt
);
857 if (!NILP (initial_contents
))
859 if (CONSP (initial_contents
))
861 position
= Fcdr (initial_contents
);
862 initial_contents
= Fcar (initial_contents
);
864 CHECK_STRING (initial_contents
);
865 if (!NILP (position
))
867 CHECK_NUMBER (position
);
868 /* Convert to distance from end of input. */
869 if (XINT (position
) < 1)
870 /* A number too small means the beginning of the string. */
871 pos
= - SCHARS (initial_contents
);
873 pos
= XINT (position
) - 1 - SCHARS (initial_contents
);
878 keymap
= Vminibuffer_local_map
;
880 keymap
= get_keymap (keymap
, 1, 0);
889 histvar
= Fcar_safe (hist
);
890 histpos
= Fcdr_safe (hist
);
893 histvar
= Qminibuffer_history
;
895 XSETFASTINT (histpos
, 0);
897 GCPRO1 (default_value
);
898 val
= read_minibuf (keymap
, initial_contents
, prompt
,
899 make_number (pos
), !NILP (read
),
900 histvar
, histpos
, default_value
,
901 minibuffer_allow_text_properties
,
902 !NILP (inherit_input_method
));
907 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
908 doc
: /* Return a Lisp object read using the minibuffer.
909 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
910 is a string to insert in the minibuffer before reading. */)
911 (prompt
, initial_contents
)
912 Lisp_Object prompt
, initial_contents
;
914 CHECK_STRING (prompt
);
915 if (!NILP (initial_contents
))
916 CHECK_STRING (initial_contents
);
917 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
918 prompt
, Qnil
, 1, Qminibuffer_history
,
919 make_number (0), Qnil
, 0, 0);
922 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
923 doc
: /* Return value of Lisp expression read using the minibuffer.
924 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
925 is a string to insert in the minibuffer before reading. */)
926 (prompt
, initial_contents
)
927 Lisp_Object prompt
, initial_contents
;
929 return Feval (Fread_minibuffer (prompt
, initial_contents
));
932 /* Functions that use the minibuffer to read various things. */
934 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
935 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
936 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
937 The third arg HISTORY, if non-nil, specifies a history list
938 and optionally the initial position in the list.
939 See `read-from-minibuffer' for details of HISTORY argument.
940 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
941 for history commands, and as the value to return if the user enters
943 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
944 the current input method and the setting of `enable-multibyte-characters'. */)
945 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
946 Lisp_Object prompt
, initial_input
, history
, default_value
;
947 Lisp_Object inherit_input_method
;
950 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
951 Qnil
, history
, default_value
,
952 inherit_input_method
);
953 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
958 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
959 doc
: /* Read a string from the terminal, not allowing blanks.
960 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.
961 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
962 the current input method and the setting of `enable-multibyte-characters'. */)
963 (prompt
, initial
, inherit_input_method
)
964 Lisp_Object prompt
, initial
, inherit_input_method
;
966 CHECK_STRING (prompt
);
967 if (! NILP (initial
))
968 CHECK_STRING (initial
);
970 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
971 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
972 !NILP (inherit_input_method
));
975 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
976 doc
: /* Read the name of a command and return as a symbol.
977 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
978 (prompt
, default_value
)
979 Lisp_Object prompt
, default_value
;
981 Lisp_Object name
, default_string
;
983 if (NILP (default_value
))
984 default_string
= Qnil
;
985 else if (SYMBOLP (default_value
))
986 default_string
= SYMBOL_NAME (default_value
);
988 default_string
= default_value
;
990 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
991 Qnil
, Qnil
, default_string
, Qnil
);
994 return Fintern (name
, Qnil
);
998 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
999 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1000 Prompt with PROMPT. */)
1004 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1009 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1010 doc
: /* Read the name of a user variable and return it as a symbol.
1011 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1012 A user variable is one whose documentation starts with a `*' character. */)
1013 (prompt
, default_value
)
1014 Lisp_Object prompt
, default_value
;
1016 Lisp_Object name
, default_string
;
1018 if (NILP (default_value
))
1019 default_string
= Qnil
;
1020 else if (SYMBOLP (default_value
))
1021 default_string
= SYMBOL_NAME (default_value
);
1023 default_string
= default_value
;
1025 name
= Fcompleting_read (prompt
, Vobarray
,
1026 Quser_variable_p
, Qt
,
1027 Qnil
, Qnil
, default_string
, Qnil
);
1030 return Fintern (name
, Qnil
);
1033 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1034 doc
: /* Read the name of a buffer and return as a string.
1036 Optional second arg DEF is value to return if user enters an empty line.
1037 If optional third arg REQUIRE-MATCH is non-nil,
1038 only existing buffer names are allowed. */)
1039 (prompt
, def
, require_match
)
1040 Lisp_Object prompt
, def
, require_match
;
1042 Lisp_Object args
[4];
1045 def
= XBUFFER (def
)->name
;
1047 if (NILP (Vread_buffer_function
))
1051 args
[0] = build_string ("%s(default %s) ");
1054 prompt
= Fformat (3, args
);
1057 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1058 require_match
, Qnil
, Qbuffer_name_history
,
1063 args
[0] = Vread_buffer_function
;
1066 args
[3] = require_match
;
1067 return Ffuncall(4, args
);
1072 minibuf_conform_representation (string
, basis
)
1073 Lisp_Object string
, basis
;
1075 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1078 if (STRING_MULTIBYTE (string
))
1079 return Fstring_make_unibyte (string
);
1081 return Fstring_make_multibyte (string
);
1084 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1085 doc
: /* Return common substring of all completions of STRING in ALIST.
1086 Each car of each element of ALIST is tested to see if it begins with STRING.
1087 All that match are compared together; the longest initial sequence
1088 common to all matches is returned as a string.
1089 If there is no match at all, nil is returned.
1090 For a unique match which is exact, t is returned.
1092 If ALIST is a hash-table, all the string keys are the possible matches.
1093 If ALIST is an obarray, the names of all symbols in the obarray
1094 are the possible matches.
1096 ALIST can also be a function to do the completion itself.
1097 It receives three arguments: the values STRING, PREDICATE and nil.
1098 Whatever it returns becomes the value of `try-completion'.
1100 If optional third argument PREDICATE is non-nil,
1101 it is used to test each possible match.
1102 The match is a candidate only if PREDICATE returns non-nil.
1103 The argument given to PREDICATE is the alist element
1104 or the symbol from the obarray. If ALIST is a hash-table,
1105 predicate is called with two arguments: the key and the value.
1106 Additionally to this predicate, `completion-regexp-list'
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 type
= HASH_TABLE_P (alist
) ? 3
1117 : VECTORP (alist
) ? 2
1118 : NILP (alist
) || (CONSP (alist
)
1119 && (!SYMBOLP (XCAR (alist
))
1120 || NILP (XCAR (alist
))));
1121 int index
= 0, obsize
= 0;
1123 Lisp_Object bucket
, zero
, end
, tem
;
1124 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1126 CHECK_STRING (string
);
1128 return call3 (alist
, string
, predicate
, Qnil
);
1130 bestmatch
= bucket
= Qnil
;
1132 /* If ALIST is not a list, set TAIL just for gc pro. */
1136 obsize
= XVECTOR (alist
)->size
;
1137 bucket
= XVECTOR (alist
)->contents
[index
];
1142 /* Get the next element of the alist, obarray, or hash-table. */
1143 /* Exit the loop if the elements are all used up. */
1144 /* elt gets the alist element or symbol.
1145 eltstring gets the name to check as a completion. */
1152 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1157 if (XFASTINT (bucket
) != 0)
1160 eltstring
= Fsymbol_name (elt
);
1161 if (XSYMBOL (bucket
)->next
)
1162 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1164 XSETFASTINT (bucket
, 0);
1166 else if (++index
>= obsize
)
1170 bucket
= XVECTOR (alist
)->contents
[index
];
1174 else /* if (type == 3) */
1176 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1177 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1179 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1182 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1185 /* Is this element a possible completion? */
1187 if (STRINGP (eltstring
)
1188 && SCHARS (string
) <= SCHARS (eltstring
)
1189 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1190 make_number (SCHARS (string
)),
1191 string
, make_number (0), Qnil
,
1192 completion_ignore_case
?Qt
: Qnil
),
1196 Lisp_Object regexps
;
1198 XSETFASTINT (zero
, 0);
1200 /* Ignore this element if it fails to match all the regexps. */
1201 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1202 regexps
= XCDR (regexps
))
1204 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1208 if (CONSP (regexps
))
1211 /* Ignore this element if there is a predicate
1212 and the predicate doesn't like it. */
1214 if (!NILP (predicate
))
1216 if (EQ (predicate
, Qcommandp
))
1217 tem
= Fcommandp (elt
, Qnil
);
1220 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1222 ? call2 (predicate
, elt
,
1223 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1224 : call1 (predicate
, elt
);
1227 if (NILP (tem
)) continue;
1230 /* Update computation of how much all possible completions match */
1232 if (NILP (bestmatch
))
1235 bestmatch
= eltstring
;
1236 bestmatchsize
= SCHARS (eltstring
);
1240 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1241 tem
= Fcompare_strings (bestmatch
, make_number (0),
1242 make_number (compare
),
1243 eltstring
, make_number (0),
1244 make_number (compare
),
1245 completion_ignore_case
? Qt
: Qnil
);
1247 matchsize
= compare
;
1248 else if (XINT (tem
) < 0)
1249 matchsize
= - XINT (tem
) - 1;
1251 matchsize
= XINT (tem
) - 1;
1254 /* When can this happen ? -stef */
1255 matchsize
= compare
;
1256 if (completion_ignore_case
)
1258 /* If this is an exact match except for case,
1259 use it as the best match rather than one that is not an
1260 exact match. This way, we get the case pattern
1261 of the actual match. */
1262 if ((matchsize
== SCHARS (eltstring
)
1263 && matchsize
< SCHARS (bestmatch
))
1265 /* If there is more than one exact match ignoring case,
1266 and one of them is exact including case,
1268 /* If there is no exact match ignoring case,
1269 prefer a match that does not change the case
1271 ((matchsize
== SCHARS (eltstring
))
1273 (matchsize
== SCHARS (bestmatch
))
1274 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1275 make_number (SCHARS (string
)),
1276 string
, make_number (0),
1280 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1281 make_number (SCHARS (string
)),
1282 string
, make_number (0),
1286 bestmatch
= eltstring
;
1288 if (bestmatchsize
!= SCHARS (eltstring
)
1289 || bestmatchsize
!= matchsize
)
1290 /* Don't count the same string multiple times. */
1292 bestmatchsize
= matchsize
;
1293 if (matchsize
<= SCHARS (string
)
1295 /* No need to look any further. */
1301 if (NILP (bestmatch
))
1302 return Qnil
; /* No completions found */
1303 /* If we are ignoring case, and there is no exact match,
1304 and no additional text was supplied,
1305 don't change the case of what the user typed. */
1306 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1307 && SCHARS (bestmatch
) > bestmatchsize
)
1308 return minibuf_conform_representation (string
, bestmatch
);
1310 /* Return t if the supplied string is an exact match (counting case);
1311 it does not require any change to be made. */
1312 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1313 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1314 make_number (bestmatchsize
),
1315 string
, make_number (0),
1316 make_number (bestmatchsize
),
1321 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1322 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1323 return Fsubstring (bestmatch
, zero
, end
);
1326 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1327 doc
: /* Search for partial matches to STRING in ALIST.
1328 Each car of each element of ALIST is tested to see if it begins with STRING.
1329 The value is a list of all the strings from ALIST that match.
1331 If ALIST is a hash-table, all the string keys are the possible matches.
1332 If ALIST is an obarray, the names of all symbols in the obarray
1333 are the possible matches.
1335 ALIST can also be a function to do the completion itself.
1336 It receives three arguments: the values STRING, PREDICATE and t.
1337 Whatever it returns becomes the value of `all-completions'.
1339 If optional third argument PREDICATE is non-nil,
1340 it is used to test each possible match.
1341 The match is a candidate only if PREDICATE returns non-nil.
1342 The argument given to PREDICATE is the alist element
1343 or the symbol from the obarray. If ALIST is a hash-table,
1344 predicate is called with two arguments: the key and the value.
1345 Additionally to this predicate, `completion-regexp-list'
1346 is used to further constrain the set of candidates.
1348 If the optional fourth argument HIDE-SPACES is non-nil,
1349 strings in ALIST that start with a space
1350 are ignored unless STRING itself starts with a space. */)
1351 (string
, alist
, predicate
, hide_spaces
)
1352 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1354 Lisp_Object tail
, elt
, eltstring
;
1355 Lisp_Object allmatches
;
1356 int type
= HASH_TABLE_P (alist
) ? 3
1357 : VECTORP (alist
) ? 2
1358 : NILP (alist
) || (CONSP (alist
)
1359 && (!SYMBOLP (XCAR (alist
))
1360 || NILP (XCAR (alist
))));
1361 int index
= 0, obsize
= 0;
1362 Lisp_Object bucket
, tem
;
1363 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1365 CHECK_STRING (string
);
1367 return call3 (alist
, string
, predicate
, Qt
);
1368 allmatches
= bucket
= Qnil
;
1370 /* 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, obarray, or hash-table. */
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
= CONSP (elt
) ? XCAR (elt
) : 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
];
1412 else /* if (type == 3) */
1414 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1415 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1417 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1420 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1423 /* Is this element a possible completion? */
1425 if (STRINGP (eltstring
)
1426 && SCHARS (string
) <= SCHARS (eltstring
)
1427 /* If HIDE_SPACES, reject alternatives that start with space
1428 unless the input starts with space. */
1429 && ((SBYTES (string
) > 0
1430 && SREF (string
, 0) == ' ')
1431 || SREF (eltstring
, 0) != ' '
1432 || NILP (hide_spaces
))
1433 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1434 make_number (SCHARS (string
)),
1435 string
, make_number (0),
1436 make_number (SCHARS (string
)),
1437 completion_ignore_case
? Qt
: Qnil
),
1441 Lisp_Object regexps
;
1443 XSETFASTINT (zero
, 0);
1445 /* Ignore this element if it fails to match all the regexps. */
1446 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1447 regexps
= XCDR (regexps
))
1449 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1453 if (CONSP (regexps
))
1456 /* Ignore this element if there is a predicate
1457 and the predicate doesn't like it. */
1459 if (!NILP (predicate
))
1461 if (EQ (predicate
, Qcommandp
))
1462 tem
= Fcommandp (elt
, Qnil
);
1465 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1467 ? call2 (predicate
, elt
,
1468 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1469 : call1 (predicate
, elt
);
1472 if (NILP (tem
)) continue;
1474 /* Ok => put it on the list. */
1475 allmatches
= Fcons (eltstring
, allmatches
);
1479 return Fnreverse (allmatches
);
1482 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1483 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1484 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1485 Lisp_Object Vminibuffer_completing_file_name
;
1487 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1488 doc
: /* Read a string in the minibuffer, with completion.
1489 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1490 TABLE is an alist whose elements' cars are strings, or an obarray.
1491 TABLE can also be a function to do the completion itself.
1492 PREDICATE limits completion to a subset of TABLE.
1493 See `try-completion' and `all-completions' for more details
1494 on completion, TABLE, and PREDICATE.
1496 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1497 the input is (or completes to) an element of TABLE or is null.
1498 If it is also not t, typing RET does not exit if it does non-null completion.
1499 If the input is null, `completing-read' returns an empty string,
1500 regardless of the value of REQUIRE-MATCH.
1502 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1503 If it is (STRING . POSITION), the initial input
1504 is STRING, but point is placed POSITION characters into the string.
1505 This feature is deprecated--it is best to pass nil for INITIAL-INPUT
1506 and supply the default value DEF instead. The user can yank the
1507 default value into the minibuffer easily using \\[next-history-element].
1509 HIST, if non-nil, specifies a history list
1510 and optionally the initial position in the list.
1511 It can be a symbol, which is the history list variable to use,
1512 or it can be a cons cell (HISTVAR . HISTPOS).
1513 In that case, HISTVAR is the history list variable to use,
1514 and HISTPOS is the initial position (the position in the list
1515 which INITIAL-INPUT corresponds to).
1516 Positions are counted starting from 1 at the beginning of the list.
1517 DEF, if non-nil, is the default value.
1519 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1520 the current input method and the setting of `enable-multibyte-characters'.
1522 Completion ignores case if the ambient value of
1523 `completion-ignore-case' is non-nil. */)
1524 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1525 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1526 Lisp_Object hist
, def
, inherit_input_method
;
1528 Lisp_Object val
, histvar
, histpos
, position
;
1531 int count
= SPECPDL_INDEX ();
1532 struct gcpro gcpro1
;
1534 init
= initial_input
;
1537 specbind (Qminibuffer_completion_table
, table
);
1538 specbind (Qminibuffer_completion_predicate
, predicate
);
1539 specbind (Qminibuffer_completion_confirm
,
1540 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1541 last_exact_completion
= Qnil
;
1548 position
= Fcdr (init
);
1551 CHECK_STRING (init
);
1552 if (!NILP (position
))
1554 CHECK_NUMBER (position
);
1555 /* Convert to distance from end of input. */
1556 pos
= XINT (position
) - SCHARS (init
);
1567 histvar
= Fcar_safe (hist
);
1568 histpos
= Fcdr_safe (hist
);
1571 histvar
= Qminibuffer_history
;
1573 XSETFASTINT (histpos
, 0);
1575 val
= read_minibuf (NILP (require_match
)
1576 ? Vminibuffer_local_completion_map
1577 : Vminibuffer_local_must_match_map
,
1578 init
, prompt
, make_number (pos
), 0,
1579 histvar
, histpos
, def
, 0,
1580 !NILP (inherit_input_method
));
1582 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1585 RETURN_UNGCPRO (unbind_to (count
, val
));
1588 Lisp_Object
Fminibuffer_completion_help ();
1589 Lisp_Object
Fassoc_string ();
1591 /* Test whether TXT is an exact completion. */
1592 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1593 doc
: /* Return non-nil if STRING is a valid completion.
1594 Takes the same arguments as `all-completions' and `try-completion'.
1595 If ALIST is a function, it is called with three arguments:
1596 the values STRING, PREDICATE and `lambda'. */)
1597 (string
, alist
, predicate
)
1598 Lisp_Object string
, alist
, predicate
;
1600 Lisp_Object regexps
, tem
= Qnil
;
1603 CHECK_STRING (string
);
1605 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1608 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1612 else if (VECTORP (alist
))
1614 /* Bypass intern-soft as that loses for nil. */
1615 tem
= oblookup (alist
,
1621 if (STRING_MULTIBYTE (string
))
1622 string
= Fstring_make_unibyte (string
);
1624 string
= Fstring_make_multibyte (string
);
1626 tem
= oblookup (Vminibuffer_completion_table
,
1634 else if (HASH_TABLE_P (alist
))
1636 i
= hash_lookup (XHASH_TABLE (alist
), string
, NULL
);
1638 tem
= HASH_KEY (XHASH_TABLE (alist
), i
);
1643 return call3 (alist
, string
, predicate
, Qlambda
);
1645 /* Reject this element if it fails to match all the regexps. */
1646 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1647 regexps
= XCDR (regexps
))
1649 if (NILP (Fstring_match (XCAR (regexps
),
1650 SYMBOLP (tem
) ? string
: tem
,
1655 /* Finally, check the predicate. */
1656 if (!NILP (predicate
))
1657 return HASH_TABLE_P (alist
)
1658 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1659 : call1 (predicate
, tem
);
1665 * 0 no possible completion
1666 * 1 was already an exact and unique completion
1667 * 3 was already an exact completion
1668 * 4 completed to an exact completion
1669 * 5 some completion happened
1670 * 6 no completion happened
1675 Lisp_Object completion
, string
, tem
;
1678 struct gcpro gcpro1
, gcpro2
;
1680 completion
= Ftry_completion (minibuffer_completion_contents (),
1681 Vminibuffer_completion_table
,
1682 Vminibuffer_completion_predicate
);
1683 last
= last_exact_completion
;
1684 last_exact_completion
= Qnil
;
1686 GCPRO2 (completion
, last
);
1688 if (NILP (completion
))
1691 temp_echo_area_glyphs (" [No match]");
1696 if (EQ (completion
, Qt
)) /* exact and unique match */
1702 string
= minibuffer_completion_contents ();
1704 /* COMPLETEDP should be true if some completion was done, which
1705 doesn't include simply changing the case of the entered string.
1706 However, for appearance, the string is rewritten if the case
1708 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1709 completedp
= !EQ (tem
, Qt
);
1711 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1713 /* Rewrite the user's input. */
1715 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1716 /* Some completion happened */
1718 if (! NILP (Vminibuffer_completing_file_name
)
1719 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1721 && FETCH_CHAR (PT_BYTE
) == '/')
1723 del_range (prompt_end
, PT
+ 1);
1726 del_range (prompt_end
, PT
);
1728 Finsert (1, &completion
);
1731 /* The case of the string changed, but that's all. We're not
1732 sure whether this is a unique completion or not, so try again
1733 using the real case (this shouldn't recurse again, because
1734 the next time try-completion will return either `t' or the
1738 return do_completion ();
1742 /* It did find a match. Do we match some possibility exactly now? */
1743 tem
= Ftest_completion (Fminibuffer_contents (),
1744 Vminibuffer_completion_table
,
1745 Vminibuffer_completion_predicate
);
1748 /* not an exact match */
1752 else if (!NILP (Vcompletion_auto_help
))
1753 Fminibuffer_completion_help ();
1755 temp_echo_area_glyphs (" [Next char not unique]");
1758 else if (completedp
)
1763 /* If the last exact completion and this one were the same,
1764 it means we've already given a "Complete but not unique"
1765 message and the user's hit TAB again, so now we give him help. */
1766 last_exact_completion
= completion
;
1769 tem
= minibuffer_completion_contents ();
1770 if (!NILP (Fequal (tem
, last
)))
1771 Fminibuffer_completion_help ();
1777 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1779 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1780 doc
: /* Like `assoc' but specifically for strings.
1781 Unibyte strings are converted to multibyte for comparison.
1782 And case is ignored if CASE-FOLD is non-nil.
1783 As opposed to `assoc', it will also match an entry consisting of a single
1784 string rather than a cons cell whose car is a string. */)
1785 (key
, list
, case_fold
)
1786 register Lisp_Object key
;
1787 Lisp_Object list
, case_fold
;
1789 register Lisp_Object tail
;
1791 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1793 register Lisp_Object elt
, tem
, thiscar
;
1795 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1796 if (!STRINGP (thiscar
))
1798 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1799 key
, make_number (0), Qnil
,
1808 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1809 doc
: /* Complete the minibuffer contents as far as possible.
1810 Return nil if there is no valid completion, else t.
1811 If no characters can be completed, display a list of possible completions.
1812 If you repeat this command after it displayed such a list,
1813 scroll the window of possible completions. */)
1817 Lisp_Object window
, tem
;
1819 /* If the previous command was not this,
1820 mark the completion buffer obsolete. */
1821 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1822 Vminibuf_scroll_window
= Qnil
;
1824 window
= Vminibuf_scroll_window
;
1825 /* If there's a fresh completion window with a live buffer,
1826 and this command is repeated, scroll that window. */
1827 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1828 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1830 struct buffer
*obuf
= current_buffer
;
1832 Fset_buffer (XWINDOW (window
)->buffer
);
1833 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1835 /* If end is in view, scroll up to the beginning. */
1836 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1838 /* Else scroll down one screen. */
1839 Fscroll_other_window (Qnil
);
1841 set_buffer_internal (obuf
);
1845 i
= do_completion ();
1853 Fgoto_char (make_number (ZV
));
1854 temp_echo_area_glyphs (" [Sole completion]");
1859 Fgoto_char (make_number (ZV
));
1860 temp_echo_area_glyphs (" [Complete, but not unique]");
1867 /* Subroutines of Fminibuffer_complete_and_exit. */
1869 /* This one is called by internal_condition_case to do the real work. */
1872 complete_and_exit_1 ()
1874 return make_number (do_completion ());
1877 /* This one is called by internal_condition_case if an error happens.
1878 Pretend the current value is an exact match. */
1881 complete_and_exit_2 (ignore
)
1884 return make_number (1);
1887 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1888 Sminibuffer_complete_and_exit
, 0, 0, "",
1889 doc
: /* If the minibuffer contents is a valid completion then exit.
1890 Otherwise try to complete it. If completion leads to a valid completion,
1891 a repetition of this command will exit. */)
1897 /* Allow user to specify null string */
1898 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
1901 if (!NILP (Ftest_completion (Fminibuffer_contents (),
1902 Vminibuffer_completion_table
,
1903 Vminibuffer_completion_predicate
)))
1906 /* Call do_completion, but ignore errors. */
1908 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
1909 complete_and_exit_2
);
1919 if (!NILP (Vminibuffer_completion_confirm
))
1921 temp_echo_area_glyphs (" [Confirm]");
1931 return Fthrow (Qexit
, Qnil
);
1935 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1937 doc
: /* Complete the minibuffer contents at most a single word.
1938 After one word is completed as much as possible, a space or hyphen
1939 is added, provided that matches some possible completion.
1940 Return nil if there is no valid completion, else t. */)
1943 Lisp_Object completion
, tem
, tem1
;
1944 register int i
, i_byte
;
1945 register const unsigned char *completion_string
;
1946 struct gcpro gcpro1
, gcpro2
;
1947 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
1949 /* We keep calling Fbuffer_string rather than arrange for GC to
1950 hold onto a pointer to one of the strings thus made. */
1952 completion
= Ftry_completion (minibuffer_completion_contents (),
1953 Vminibuffer_completion_table
,
1954 Vminibuffer_completion_predicate
);
1955 if (NILP (completion
))
1958 temp_echo_area_glyphs (" [No match]");
1961 if (EQ (completion
, Qt
))
1964 #if 0 /* How the below code used to look, for reference. */
1965 tem
= Fminibuffer_contents ();
1967 i
= ZV
- 1 - SCHARS (completion
);
1968 p
= SDATA (completion
);
1970 0 <= scmp (b
, p
, ZV
- 1))
1973 /* Set buffer to longest match of buffer tail and completion head. */
1974 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1976 del_range (1, i
+ 1);
1979 #else /* Rewritten code */
1981 int buffer_nchars
, completion_nchars
;
1983 CHECK_STRING (completion
);
1984 tem
= minibuffer_completion_contents ();
1985 GCPRO2 (completion
, tem
);
1986 /* If reading a file name,
1987 expand any $ENVVAR refs in the buffer and in TEM. */
1988 if (! NILP (Vminibuffer_completing_file_name
))
1990 Lisp_Object substituted
;
1991 substituted
= Fsubstitute_in_file_name (tem
);
1992 if (! EQ (substituted
, tem
))
1995 del_range (prompt_end_charpos
, PT
);
1999 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2000 completion_nchars
= SCHARS (completion
);
2001 i
= buffer_nchars
- completion_nchars
;
2004 (tem1
= Fcompare_strings (tem
, make_number (0),
2005 make_number (buffer_nchars
),
2006 completion
, make_number (0),
2007 make_number (buffer_nchars
),
2008 completion_ignore_case
? Qt
: Qnil
),
2013 /* Make buffer (before point) contain the longest match
2014 of TEM's tail and COMPLETION's head. */
2020 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2021 completion
, make_number (0),
2022 make_number (buffer_nchars
),
2023 completion_ignore_case
? Qt
: Qnil
);
2030 del_range (1, i
+ 1);
2034 #endif /* Rewritten code */
2037 int prompt_end_bytepos
;
2038 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2039 i
= PT
- prompt_end_charpos
;
2040 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2043 /* If completion finds next char not unique,
2044 consider adding a space or a hyphen. */
2045 if (i
== SCHARS (completion
))
2047 GCPRO1 (completion
);
2048 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2049 build_string (" ")),
2050 Vminibuffer_completion_table
,
2051 Vminibuffer_completion_predicate
);
2058 GCPRO1 (completion
);
2060 Ftry_completion (concat2 (minibuffer_completion_contents (),
2061 build_string ("-")),
2062 Vminibuffer_completion_table
,
2063 Vminibuffer_completion_predicate
);
2071 /* Now find first word-break in the stuff found by completion.
2072 i gets index in string of where to stop completing. */
2075 int bytes
= SBYTES (completion
);
2076 completion_string
= SDATA (completion
);
2077 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2079 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2082 if (SYNTAX (c
) != Sword
)
2091 /* If got no characters, print help for user. */
2093 if (i
== PT
- prompt_end_charpos
)
2095 if (!NILP (Vcompletion_auto_help
))
2096 Fminibuffer_completion_help ();
2100 /* Otherwise insert in minibuffer the chars we got */
2102 if (! NILP (Vminibuffer_completing_file_name
)
2103 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2105 && FETCH_CHAR (PT_BYTE
) == '/')
2107 del_range (prompt_end_charpos
, PT
+ 1);
2110 del_range (prompt_end_charpos
, PT
);
2112 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2116 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2118 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2119 Each element may be just a symbol or string
2120 or may be a list of two strings to be printed as if concatenated.
2121 `standard-output' must be a buffer.
2122 The actual completion alternatives, as inserted, are given `mouse-face'
2123 properties of `highlight'.
2124 At the end, this runs the normal hook `completion-setup-hook'.
2125 It can find the completion buffer in `standard-output'. */)
2127 Lisp_Object completions
;
2129 Lisp_Object tail
, elt
;
2132 struct gcpro gcpro1
, gcpro2
;
2133 struct buffer
*old
= current_buffer
;
2136 /* Note that (when it matters) every variable
2137 points to a non-string that is pointed to by COMPLETIONS,
2138 except for ELT. ELT can be pointing to a string
2139 when terpri or Findent_to calls a change hook. */
2141 GCPRO2 (completions
, elt
);
2143 if (BUFFERP (Vstandard_output
))
2144 set_buffer_internal (XBUFFER (Vstandard_output
));
2146 if (NILP (completions
))
2147 write_string ("There are no possible completions of what you have typed.",
2151 write_string ("Possible completions are:", -1);
2152 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2154 Lisp_Object tem
, string
;
2156 Lisp_Object startpos
, endpos
;
2161 /* Compute the length of this element. */
2166 length
= SCHARS (tem
);
2168 tem
= Fcar (XCDR (elt
));
2170 length
+= SCHARS (tem
);
2175 length
= SCHARS (elt
);
2178 /* This does a bad job for narrower than usual windows.
2179 Sadly, the window it will appear in is not known
2180 until after the text has been made. */
2182 if (BUFFERP (Vstandard_output
))
2183 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2185 /* If the previous completion was very wide,
2186 or we have two on this line already,
2187 don't put another on the same line. */
2188 if (column
> 33 || first
2189 /* If this is really wide, don't put it second on a line. */
2190 || (column
> 0 && length
> 45))
2195 /* Otherwise advance to column 35. */
2198 if (BUFFERP (Vstandard_output
))
2200 tem
= Findent_to (make_number (35), make_number (2));
2202 column
= XINT (tem
);
2208 write_string (" ", -1);
2211 while (column
< 35);
2215 if (BUFFERP (Vstandard_output
))
2217 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2218 Fset_text_properties (startpos
, endpos
,
2219 Qnil
, Vstandard_output
);
2222 /* Output this element.
2223 If necessary, convert it to unibyte or to multibyte first. */
2225 string
= Fcar (elt
);
2228 if (NILP (current_buffer
->enable_multibyte_characters
)
2229 && STRING_MULTIBYTE (string
))
2230 string
= Fstring_make_unibyte (string
);
2231 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2232 && !STRING_MULTIBYTE (string
))
2233 string
= Fstring_make_multibyte (string
);
2235 if (BUFFERP (Vstandard_output
))
2237 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2239 Fprinc (string
, Qnil
);
2241 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2243 Fput_text_property (startpos
, endpos
,
2244 Qmouse_face
, intern ("highlight"),
2249 Fprinc (string
, Qnil
);
2252 /* Output the annotation for this element. */
2255 if (BUFFERP (Vstandard_output
))
2257 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2259 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2261 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2263 Fset_text_properties (startpos
, endpos
, Qnil
,
2268 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2273 /* Update COLUMN for what we have output. */
2276 /* If output is to a buffer, recompute COLUMN in a way
2277 that takes account of character widths. */
2278 if (BUFFERP (Vstandard_output
))
2280 tem
= Fcurrent_column ();
2281 column
= XINT (tem
);
2290 if (BUFFERP (Vstandard_output
))
2291 set_buffer_internal (old
);
2293 if (!NILP (Vrun_hooks
))
2294 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2299 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2301 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2304 Lisp_Object completions
;
2306 message ("Making completion list...");
2307 completions
= Fall_completions (minibuffer_completion_contents (),
2308 Vminibuffer_completion_table
,
2309 Vminibuffer_completion_predicate
,
2311 clear_message (1, 0);
2313 if (NILP (completions
))
2316 temp_echo_area_glyphs (" [No completions]");
2319 internal_with_output_to_temp_buffer ("*Completions*",
2320 Fdisplay_completion_list
,
2321 Fsort (completions
, Qstring_lessp
));
2325 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2326 doc
: /* Terminate minibuffer input. */)
2329 if (INTEGERP (last_command_char
))
2330 internal_self_insert (XINT (last_command_char
), 0);
2334 return Fthrow (Qexit
, Qnil
);
2337 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2338 doc
: /* Terminate this minibuffer argument. */)
2341 return Fthrow (Qexit
, Qnil
);
2344 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2345 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2348 return make_number (minibuf_level
);
2351 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2352 doc
: /* Return the prompt string of the currently-active minibuffer.
2353 If no minibuffer is active, return nil. */)
2356 return Fcopy_sequence (minibuf_prompt
);
2360 /* Temporarily display the string M at the end of the current
2361 minibuffer contents. This is used to display things like
2362 "[No Match]" when the user requests a completion for a prefix
2363 that has no possible completions, and other quick, unobtrusive
2367 temp_echo_area_glyphs (m
)
2371 int osize_byte
= ZV_BYTE
;
2373 int opoint_byte
= PT_BYTE
;
2374 Lisp_Object oinhibit
;
2375 oinhibit
= Vinhibit_quit
;
2377 /* Clear out any old echo-area message to make way for our new thing. */
2380 SET_PT_BOTH (osize
, osize_byte
);
2382 SET_PT_BOTH (opoint
, opoint_byte
);
2384 Fsit_for (make_number (2), Qnil
, Qnil
);
2385 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2386 SET_PT_BOTH (opoint
, opoint_byte
);
2387 if (!NILP (Vquit_flag
))
2390 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2392 Vinhibit_quit
= oinhibit
;
2395 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2397 doc
: /* Temporarily display STRING at the end of the minibuffer.
2398 The text is displayed for two seconds,
2399 or until the next input event arrives, whichever comes first. */)
2403 temp_echo_area_glyphs (SDATA (string
));
2408 init_minibuf_once ()
2410 Vminibuffer_list
= Qnil
;
2411 staticpro (&Vminibuffer_list
);
2418 minibuf_prompt
= Qnil
;
2419 staticpro (&minibuf_prompt
);
2421 minibuf_save_list
= Qnil
;
2422 staticpro (&minibuf_save_list
);
2424 Qread_file_name_internal
= intern ("read-file-name-internal");
2425 staticpro (&Qread_file_name_internal
);
2427 Qminibuffer_default
= intern ("minibuffer-default");
2428 staticpro (&Qminibuffer_default
);
2429 Fset (Qminibuffer_default
, Qnil
);
2431 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2432 staticpro (&Qminibuffer_completion_table
);
2434 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2435 staticpro (&Qminibuffer_completion_confirm
);
2437 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2438 staticpro (&Qminibuffer_completion_predicate
);
2440 staticpro (&last_exact_completion
);
2441 last_exact_completion
= Qnil
;
2443 staticpro (&last_minibuf_string
);
2444 last_minibuf_string
= Qnil
;
2446 Quser_variable_p
= intern ("user-variable-p");
2447 staticpro (&Quser_variable_p
);
2449 Qminibuffer_history
= intern ("minibuffer-history");
2450 staticpro (&Qminibuffer_history
);
2452 Qbuffer_name_history
= intern ("buffer-name-history");
2453 staticpro (&Qbuffer_name_history
);
2454 Fset (Qbuffer_name_history
, Qnil
);
2456 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2457 staticpro (&Qminibuffer_setup_hook
);
2459 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2460 staticpro (&Qminibuffer_exit_hook
);
2462 Qhistory_length
= intern ("history-length");
2463 staticpro (&Qhistory_length
);
2465 Qcurrent_input_method
= intern ("current-input-method");
2466 staticpro (&Qcurrent_input_method
);
2468 Qactivate_input_method
= intern ("activate-input-method");
2469 staticpro (&Qactivate_input_method
);
2471 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2472 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2473 Vread_buffer_function
= Qnil
;
2475 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2476 doc
: /* Normal hook run just after entry to minibuffer. */);
2477 Vminibuffer_setup_hook
= Qnil
;
2479 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2480 doc
: /* Normal hook run just after exit from minibuffer. */);
2481 Vminibuffer_exit_hook
= Qnil
;
2483 DEFVAR_LISP ("history-length", &Vhistory_length
,
2484 doc
: /* *Maximum length for history lists before truncation takes place.
2485 A number means that length; t means infinite. Truncation takes place
2486 just after a new element is inserted. Setting the history-length
2487 property of a history variable overrides this default. */);
2488 XSETFASTINT (Vhistory_length
, 30);
2490 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2491 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2492 Vcompletion_auto_help
= Qt
;
2494 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2495 doc
: /* Non-nil means don't consider case significant in completion. */);
2496 completion_ignore_case
= 0;
2498 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2499 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2500 This variable makes a difference whenever the minibuffer window is active. */);
2501 enable_recursive_minibuffers
= 0;
2503 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2504 doc
: /* Alist or obarray used for completion in the minibuffer.
2505 This becomes the ALIST argument to `try-completion' and `all-completion'.
2507 The value may alternatively be a function, which is given three arguments:
2508 STRING, the current buffer contents;
2509 PREDICATE, the predicate for filtering possible matches;
2510 CODE, which says what kind of things to do.
2511 CODE can be nil, t or `lambda'.
2512 nil means to return the best completion of STRING, or nil if there is none.
2513 t means to return a list of all possible completions of STRING.
2514 `lambda' means to return t if STRING is a valid completion as it stands. */);
2515 Vminibuffer_completion_table
= Qnil
;
2517 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2518 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2519 Vminibuffer_completion_predicate
= Qnil
;
2521 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2522 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2523 Vminibuffer_completion_confirm
= Qnil
;
2525 DEFVAR_LISP ("minibuffer-completing-file-name",
2526 &Vminibuffer_completing_file_name
,
2527 doc
: /* Non-nil means completing file names. */);
2528 Vminibuffer_completing_file_name
= Qnil
;
2530 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2531 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2532 Vminibuffer_help_form
= Qnil
;
2534 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2535 doc
: /* History list symbol to add minibuffer values to.
2536 Each string of minibuffer input, as it appears on exit from the minibuffer,
2538 (set minibuffer-history-variable
2539 (cons STRING (symbol-value minibuffer-history-variable))) */);
2540 XSETFASTINT (Vminibuffer_history_variable
, 0);
2542 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2543 doc
: /* Current position of redoing in the history list. */);
2544 Vminibuffer_history_position
= Qnil
;
2546 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2547 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2548 Some uses of the echo area also raise that frame (since they use it too). */);
2549 minibuffer_auto_raise
= 0;
2551 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2552 doc
: /* List of regexps that should restrict possible completions. */);
2553 Vcompletion_regexp_list
= Qnil
;
2555 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2556 &minibuffer_allow_text_properties
,
2557 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2558 This also affects `read-string', but it does not affect `read-minibuffer',
2559 `read-no-blanks-input', or any of the functions that do minibuffer input
2560 with completion; they always discard text properties. */);
2561 minibuffer_allow_text_properties
= 0;
2563 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2564 doc
: /* Text properties that are added to minibuffer prompts.
2565 These are in addition to the basic `field' property, and stickiness
2567 /* We use `intern' here instead of Qread_only to avoid
2568 initialization-order problems. */
2569 Vminibuffer_prompt_properties
2570 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2572 defsubr (&Sset_minibuffer_window
);
2573 defsubr (&Sread_from_minibuffer
);
2574 defsubr (&Seval_minibuffer
);
2575 defsubr (&Sread_minibuffer
);
2576 defsubr (&Sread_string
);
2577 defsubr (&Sread_command
);
2578 defsubr (&Sread_variable
);
2579 defsubr (&Sread_buffer
);
2580 defsubr (&Sread_no_blanks_input
);
2581 defsubr (&Sminibuffer_depth
);
2582 defsubr (&Sminibuffer_prompt
);
2584 defsubr (&Sminibuffer_prompt_end
);
2585 defsubr (&Sminibuffer_contents
);
2586 defsubr (&Sminibuffer_contents_no_properties
);
2587 defsubr (&Sdelete_minibuffer_contents
);
2589 defsubr (&Stry_completion
);
2590 defsubr (&Sall_completions
);
2591 defsubr (&Stest_completion
);
2592 defsubr (&Sassoc_string
);
2593 defsubr (&Scompleting_read
);
2594 defsubr (&Sminibuffer_complete
);
2595 defsubr (&Sminibuffer_complete_word
);
2596 defsubr (&Sminibuffer_complete_and_exit
);
2597 defsubr (&Sdisplay_completion_list
);
2598 defsubr (&Sminibuffer_completion_help
);
2600 defsubr (&Sself_insert_and_exit
);
2601 defsubr (&Sexit_minibuffer
);
2603 defsubr (&Sminibuffer_message
);
2609 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2610 "abort-recursive-edit");
2611 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2613 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2616 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2618 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2620 initial_define_key (Vminibuffer_local_ns_map
, '?',
2621 "self-insert-and-exit");
2623 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2624 "minibuffer-complete");
2625 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2626 "minibuffer-complete-word");
2627 initial_define_key (Vminibuffer_local_completion_map
, '?',
2628 "minibuffer-completion-help");
2630 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2631 "minibuffer-complete-and-exit");
2632 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2633 "minibuffer-complete-and-exit");