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"
36 #define min(a, b) ((a) < (b) ? (a) : (b))
40 /* List of buffers for use as minibuffers.
41 The first element of the list is used for the outermost minibuffer
42 invocation, the next element is used for a recursive minibuffer
43 invocation, etc. The list is extended at the end as deeper
44 minibuffer recursions are encountered. */
46 Lisp_Object Vminibuffer_list
;
48 /* Data to remember during recursive minibuffer invocations */
50 Lisp_Object minibuf_save_list
;
52 /* Depth in minibuffer invocations. */
56 /* Nonzero means display completion help for invalid input. */
58 Lisp_Object Vcompletion_auto_help
;
60 /* The maximum length of a minibuffer history. */
62 Lisp_Object Qhistory_length
, Vhistory_length
;
64 /* Fread_minibuffer leaves the input here as a string. */
66 Lisp_Object last_minibuf_string
;
68 /* Nonzero means let functions called when within a minibuffer
69 invoke recursive minibuffers (to read arguments, or whatever) */
71 int enable_recursive_minibuffers
;
73 /* Nonzero means don't ignore text properties
74 in Fread_from_minibuffer. */
76 int minibuffer_allow_text_properties
;
78 /* help-form is bound to this while in the minibuffer. */
80 Lisp_Object Vminibuffer_help_form
;
82 /* Variable which is the history list to add minibuffer values to. */
84 Lisp_Object Vminibuffer_history_variable
;
86 /* Current position in the history list (adjusted by M-n and M-p). */
88 Lisp_Object Vminibuffer_history_position
;
90 /* Text properties that are added to minibuffer prompts.
91 These are in addition to the basic `field' property, and stickiness
94 Lisp_Object Vminibuffer_prompt_properties
;
96 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
98 Lisp_Object Qread_file_name_internal
;
100 /* Normal hooks for entry to and exit from minibuffer. */
102 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
103 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
105 /* Function to call to read a buffer name. */
106 Lisp_Object Vread_buffer_function
;
108 /* Nonzero means completion ignores case. */
110 int completion_ignore_case
;
112 /* List of regexps that should restrict possible completions. */
114 Lisp_Object Vcompletion_regexp_list
;
116 /* Nonzero means raise the minibuffer frame when the minibuffer
119 int minibuffer_auto_raise
;
121 /* If last completion attempt reported "Complete but not unique"
122 then this is the string completed then; otherwise this is nil. */
124 static Lisp_Object last_exact_completion
;
126 /* Non-nil means it is the window for C-M-v to scroll
127 when the minibuffer is selected. */
129 extern Lisp_Object Vminibuf_scroll_window
;
131 extern Lisp_Object Voverriding_local_map
;
133 Lisp_Object Quser_variable_p
;
135 Lisp_Object Qminibuffer_default
;
137 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
139 extern Lisp_Object Qmouse_face
;
141 extern Lisp_Object Qfield
;
143 /* Put minibuf on currently selected frame's minibuffer.
144 We do this whenever the user starts a new minibuffer
145 or when a minibuffer exits. */
148 choose_minibuf_frame ()
150 if (FRAMEP (selected_frame
)
151 && FRAME_LIVE_P (XFRAME (selected_frame
))
152 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
154 struct frame
*sf
= XFRAME (selected_frame
);
157 /* I don't think that any frames may validly have a null minibuffer
159 if (NILP (sf
->minibuffer_window
))
162 /* Under X, we come here with minibuf_window being the
163 minibuffer window of the unused termcap window created in
164 init_window_once. That window doesn't have a buffer. */
165 buffer
= XWINDOW (minibuf_window
)->buffer
;
166 if (BUFFERP (buffer
))
167 Fset_window_buffer (sf
->minibuffer_window
, buffer
);
168 minibuf_window
= sf
->minibuffer_window
;
171 /* Make sure no other frame has a minibuffer as its selected window,
172 because the text would not be displayed in it, and that would be
173 confusing. Only allow the selected frame to do this,
174 and that only if the minibuffer is active. */
176 Lisp_Object tail
, frame
;
178 FOR_EACH_FRAME (tail
, frame
)
179 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
180 && !(EQ (frame
, selected_frame
)
181 && minibuf_level
> 0))
182 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
187 choose_minibuf_frame_1 (ignore
)
190 choose_minibuf_frame ();
194 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
195 Sset_minibuffer_window
, 1, 1, 0,
196 "Specify which minibuffer window to use for the minibuffer.\n\
197 This effects where the minibuffer is displayed if you put text in it\n\
198 without invoking the usual minibuffer commands.")
202 CHECK_WINDOW (window
, 1);
203 if (! MINI_WINDOW_P (XWINDOW (window
)))
204 error ("Window is not a minibuffer window");
206 minibuf_window
= window
;
212 /* Actual minibuffer invocation. */
214 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
215 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
216 Lisp_Object
, Lisp_Object
,
218 Lisp_Object
, Lisp_Object
,
220 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
221 Lisp_Object
, Lisp_Object
,
223 Lisp_Object
, Lisp_Object
,
225 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
228 /* Read a Lisp object from VAL and return it. If VAL is an empty
229 string, and DEFALT is a string, read from DEFALT instead of VAL. */
232 string_to_object (val
, defalt
)
233 Lisp_Object val
, defalt
;
235 struct gcpro gcpro1
, gcpro2
;
236 Lisp_Object expr_and_pos
;
239 GCPRO2 (val
, defalt
);
241 if (STRINGP (val
) && XSTRING (val
)->size
== 0
245 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
246 pos
= XINT (Fcdr (expr_and_pos
));
247 if (pos
!= XSTRING (val
)->size
)
249 /* Ignore trailing whitespace; any other trailing junk
252 pos
= string_char_to_byte (val
, pos
);
253 for (i
= pos
; i
< STRING_BYTES (XSTRING (val
)); i
++)
255 int c
= XSTRING (val
)->data
[i
];
256 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
257 error ("Trailing garbage following expression");
261 val
= Fcar (expr_and_pos
);
262 RETURN_UNGCPRO (val
);
266 /* Like read_minibuf but reading from stdin. This function is called
267 from read_minibuf to do the job if noninteractive. */
270 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
271 histvar
, histpos
, defalt
, allow_props
,
272 inherit_input_method
)
276 Lisp_Object backup_n
;
282 int inherit_input_method
;
288 fprintf (stdout
, "%s", XSTRING (prompt
)->data
);
294 line
= (char *) xmalloc (size
* sizeof *line
);
295 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
296 && (len
= strlen (line
),
297 len
== size
- 1 && line
[len
- 1] != '\n'))
300 line
= (char *) xrealloc (line
, size
);
307 if (len
> 0 && line
[len
- 1] == '\n')
310 val
= build_string (line
);
316 error ("Error reading from stdin");
319 /* If Lisp form desired instead of string, parse it. */
321 val
= string_to_object (val
, defalt
);
327 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
328 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
329 prompting with PROMPT (a string), using history list HISTVAR
330 with initial position HISTPOS. (BACKUP_N should be <= 0.)
332 Normally return the result as a string (the text that was read),
333 but if EXPFLAG is nonzero, read it and return the object read.
334 If HISTVAR is given, save the value read on that history only if it doesn't
335 match the front of that history list exactly. The value is pushed onto
336 the list as the string that was read.
338 DEFALT specifies te default value for the sake of history commands.
340 If ALLOW_PROPS is nonzero, we do not throw away text properties.
342 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
343 current input method. */
346 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
347 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
351 Lisp_Object backup_n
;
357 int inherit_input_method
;
360 int count
= specpdl_ptr
- specpdl
;
361 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
362 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
363 Lisp_Object enable_multibyte
;
364 extern Lisp_Object Qread_only
, Qfront_sticky
;
365 extern Lisp_Object Qrear_nonsticky
;
367 specbind (Qminibuffer_default
, defalt
);
369 single_kboard_state ();
370 #ifdef HAVE_X_WINDOWS
371 if (display_hourglass_p
)
376 ambient_dir
= current_buffer
->directory
;
378 enable_multibyte
= Qnil
;
380 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
381 store them away before we can GC. Don't need to protect
382 BACKUP_N because we use the value only if it is an integer. */
383 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
385 if (!STRINGP (prompt
))
386 prompt
= build_string ("");
388 if (!enable_recursive_minibuffers
389 && minibuf_level
> 0)
391 if (EQ (selected_window
, minibuf_window
))
392 error ("Command attempted to use minibuffer while in minibuffer");
394 /* If we're in another window, cancel the minibuffer that's active. */
396 build_string ("Command attempted to use minibuffer while in minibuffer"));
401 val
= read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
,
402 expflag
, histvar
, histpos
, defalt
,
403 allow_props
, inherit_input_method
);
404 return unbind_to (count
, val
);
407 /* Choose the minibuffer window and frame, and take action on them. */
409 choose_minibuf_frame ();
411 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
413 record_unwind_protect (Fset_window_configuration
,
414 Fcurrent_window_configuration (Qnil
));
416 /* If the minibuffer window is on a different frame, save that
417 frame's configuration too. */
418 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
419 if (!EQ (mini_frame
, selected_frame
))
420 record_unwind_protect (Fset_window_configuration
,
421 Fcurrent_window_configuration (mini_frame
));
423 /* If the minibuffer is on an iconified or invisible frame,
424 make it visible now. */
425 Fmake_frame_visible (mini_frame
);
427 if (minibuffer_auto_raise
)
428 Fraise_frame (mini_frame
);
430 /* We have to do this after saving the window configuration
431 since that is what restores the current buffer. */
433 /* Arrange to restore a number of minibuffer-related variables.
434 We could bind each variable separately, but that would use lots of
437 = Fcons (Voverriding_local_map
,
438 Fcons (minibuf_window
, minibuf_save_list
));
440 = Fcons (minibuf_prompt
,
441 Fcons (make_number (minibuf_prompt_width
),
443 Fcons (Vcurrent_prefix_arg
,
444 Fcons (Vminibuffer_history_position
,
445 Fcons (Vminibuffer_history_variable
,
446 minibuf_save_list
))))));
448 record_unwind_protect (read_minibuf_unwind
, Qnil
);
451 /* Now that we can restore all those variables, start changing them. */
453 minibuf_prompt_width
= 0;
454 minibuf_prompt
= Fcopy_sequence (prompt
);
455 Vminibuffer_history_position
= histpos
;
456 Vminibuffer_history_variable
= histvar
;
457 Vhelp_form
= Vminibuffer_help_form
;
459 if (inherit_input_method
)
461 /* `current-input-method' is buffer local. So, remeber it in
462 INPUT_METHOD before changing the current buffer. */
463 input_method
= Fsymbol_value (Qcurrent_input_method
);
464 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
467 /* Switch to the minibuffer. */
469 minibuffer
= get_minibuffer (minibuf_level
);
470 Fset_buffer (minibuffer
);
472 /* The current buffer's default directory is usually the right thing
473 for our minibuffer here. However, if you're typing a command at
474 a minibuffer-only frame when minibuf_level is zero, then buf IS
475 the current_buffer, so reset_buffer leaves buf's default
476 directory unchanged. This is a bummer when you've just started
477 up Emacs and buf's default directory is Qnil. Here's a hack; can
478 you think of something better to do? Find another buffer with a
479 better directory, and use that one instead. */
480 if (STRINGP (ambient_dir
))
481 current_buffer
->directory
= ambient_dir
;
484 Lisp_Object buf_list
;
486 for (buf_list
= Vbuffer_alist
;
488 buf_list
= XCDR (buf_list
))
490 Lisp_Object other_buf
;
492 other_buf
= XCDR (XCAR (buf_list
));
493 if (STRINGP (XBUFFER (other_buf
)->directory
))
495 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
501 if (!EQ (mini_frame
, selected_frame
))
502 Fredirect_frame_focus (selected_frame
, mini_frame
);
504 Vminibuf_scroll_window
= selected_window
;
505 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
506 Fselect_window (minibuf_window
);
507 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
509 Fmake_local_variable (Qprint_escape_newlines
);
510 print_escape_newlines
= 1;
512 /* Erase the buffer. */
514 int count1
= specpdl_ptr
- specpdl
;
515 specbind (Qinhibit_read_only
, Qt
);
517 unbind_to (count1
, Qnil
);
520 if (!NILP (current_buffer
->enable_multibyte_characters
)
521 && ! STRING_MULTIBYTE (minibuf_prompt
))
522 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
524 /* Insert the prompt, record where it ends. */
525 Finsert (1, &minibuf_prompt
);
528 Fput_text_property (make_number (BEG
), make_number (PT
),
529 Qfront_sticky
, Qt
, Qnil
);
530 Fput_text_property (make_number (BEG
), make_number (PT
),
531 Qrear_nonsticky
, Qt
, Qnil
);
532 Fput_text_property (make_number (BEG
), make_number (PT
),
534 Fadd_text_properties (make_number (BEG
), make_number (PT
),
535 Vminibuffer_prompt_properties
, Qnil
);
538 minibuf_prompt_width
= current_column ();
540 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
541 if (inherit_input_method
)
542 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
544 /* Put in the initial input. */
547 Finsert (1, &initial
);
548 if (INTEGERP (backup_n
))
549 Fforward_char (backup_n
);
552 clear_message (1, 1);
553 current_buffer
->keymap
= map
;
555 /* Turn on an input method stored in INPUT_METHOD if any. */
556 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
557 call1 (Qactivate_input_method
, input_method
);
559 /* Run our hook, but not if it is empty.
560 (run-hooks would do nothing if it is empty,
561 but it's important to save time here in the usual case). */
562 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
563 && !NILP (Vrun_hooks
))
564 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
566 /* Don't allow the user to undo past this point. */
567 current_buffer
->undo_list
= Qnil
;
571 /* If cursor is on the minibuffer line,
572 show the user we have exited by putting it in column 0. */
573 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
576 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
577 XWINDOW (minibuf_window
)->cursor
.x
= 0;
578 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
579 update_frame (XFRAME (selected_frame
), 1, 1);
580 if (rif
&& rif
->flush_display
)
581 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
584 /* Make minibuffer contents into a string. */
585 Fset_buffer (minibuffer
);
587 val
= Ffield_string (make_number (ZV
));
589 val
= Ffield_string_no_properties (make_number (ZV
));
591 /* VAL is the string of minibuffer text. */
593 last_minibuf_string
= val
;
595 /* Add the value to the appropriate history list unless it is empty. */
596 if (XSTRING (val
)->size
!= 0
597 && SYMBOLP (Vminibuffer_history_variable
))
599 /* If the caller wanted to save the value read on a history list,
600 then do so if the value is not already the front of the list. */
603 /* If variable is unbound, make it nil. */
604 if (EQ (XSYMBOL (Vminibuffer_history_variable
)->value
, Qunbound
))
605 Fset (Vminibuffer_history_variable
, Qnil
);
607 histval
= Fsymbol_value (Vminibuffer_history_variable
);
609 /* The value of the history variable must be a cons or nil. Other
610 values are unacceptable. We silently ignore these values. */
613 && NILP (Fequal (last_minibuf_string
, Fcar (histval
)))))
617 histval
= Fcons (last_minibuf_string
, histval
);
618 Fset (Vminibuffer_history_variable
, histval
);
620 /* Truncate if requested. */
621 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
622 if (NILP (length
)) length
= Vhistory_length
;
623 if (INTEGERP (length
))
625 if (XINT (length
) <= 0)
626 Fset (Vminibuffer_history_variable
, Qnil
);
631 temp
= Fnthcdr (Fsub1 (length
), histval
);
632 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
638 /* If Lisp form desired instead of string, parse it. */
640 val
= string_to_object (val
, defalt
);
642 /* The appropriate frame will get selected
643 in set-window-configuration. */
644 RETURN_UNGCPRO (unbind_to (count
, val
));
647 /* Return a buffer to be used as the minibuffer at depth `depth'.
648 depth = 0 is the lowest allowed argument, and that is the value
649 used for nonrecursive minibuffer invocations */
652 get_minibuffer (depth
)
655 Lisp_Object tail
, num
, buf
;
657 extern Lisp_Object
nconc2 ();
659 XSETFASTINT (num
, depth
);
660 tail
= Fnthcdr (num
, Vminibuffer_list
);
663 tail
= Fcons (Qnil
, Qnil
);
664 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
667 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
669 sprintf (name
, " *Minibuf-%d*", depth
);
670 buf
= Fget_buffer_create (build_string (name
));
672 /* Although the buffer's name starts with a space, undo should be
674 Fbuffer_enable_undo (buf
);
680 int count
= specpdl_ptr
- specpdl
;
682 reset_buffer (XBUFFER (buf
));
683 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
685 Fkill_all_local_variables ();
686 unbind_to (count
, Qnil
);
692 /* This function is called on exiting minibuffer, whether normally or
693 not, and it restores the current window, buffer, etc. */
696 read_minibuf_unwind (data
)
699 Lisp_Object old_deactivate_mark
;
702 /* We are exiting the minibuffer one way or the other,
704 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
705 && !NILP (Vrun_hooks
))
706 safe_run_hooks (Qminibuffer_exit_hook
);
708 /* If this was a recursive minibuffer,
709 tie the minibuffer window back to the outer level minibuffer buffer. */
712 window
= minibuf_window
;
713 /* To keep things predictable, in case it matters, let's be in the
714 minibuffer when we reset the relevant variables. */
715 Fset_buffer (XWINDOW (window
)->buffer
);
717 /* Restore prompt, etc, from outer minibuffer level. */
718 minibuf_prompt
= Fcar (minibuf_save_list
);
719 minibuf_save_list
= Fcdr (minibuf_save_list
);
720 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
721 minibuf_save_list
= Fcdr (minibuf_save_list
);
722 Vhelp_form
= Fcar (minibuf_save_list
);
723 minibuf_save_list
= Fcdr (minibuf_save_list
);
724 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
725 minibuf_save_list
= Fcdr (minibuf_save_list
);
726 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
727 minibuf_save_list
= Fcdr (minibuf_save_list
);
728 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
729 minibuf_save_list
= Fcdr (minibuf_save_list
);
730 Voverriding_local_map
= Fcar (minibuf_save_list
);
731 minibuf_save_list
= Fcdr (minibuf_save_list
);
733 temp
= Fcar (minibuf_save_list
);
734 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
735 minibuf_window
= temp
;
737 minibuf_save_list
= Fcdr (minibuf_save_list
);
739 /* Erase the minibuffer we were using at this level. */
741 int count
= specpdl_ptr
- specpdl
;
742 /* Prevent error in erase-buffer. */
743 specbind (Qinhibit_read_only
, Qt
);
744 old_deactivate_mark
= Vdeactivate_mark
;
746 Vdeactivate_mark
= old_deactivate_mark
;
747 unbind_to (count
, Qnil
);
750 /* When we get to the outmost level, make sure we resize the
751 mini-window back to its normal size. */
752 if (minibuf_level
== 0)
753 resize_mini_window (XWINDOW (window
), 0);
755 /* Make sure minibuffer window is erased, not ignored. */
756 windows_or_buffers_changed
++;
757 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
758 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
763 /* This comment supplies the doc string for read-from-minibuffer,
764 for make-docfile to see. We cannot put this in the real DEFUN
765 due to limits in the Unix cpp.
767 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
768 "Read a string from the minibuffer, prompting with string PROMPT.\n\
769 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
770 to be inserted into the minibuffer before reading input.\n\
771 If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
772 is STRING, but point is placed at position POSITION in the minibuffer.\n\
773 Third arg KEYMAP is a keymap to use whilst reading;\n\
774 if omitted or nil, the default is `minibuffer-local-map'.\n\
775 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
776 and return that object:\n\
777 in other words, do `(car (read-from-string INPUT-STRING))'\n\
778 Fifth arg HIST, if non-nil, specifies a history list\n\
779 and optionally the initial position in the list.\n\
780 It can be a symbol, which is the history list variable to use,\n\
781 or it can be a cons cell (HISTVAR . HISTPOS).\n\
782 In that case, HISTVAR is the history list variable to use,\n\
783 and HISTPOS is the initial position (the position in the list\n\
784 which INITIAL-CONTENTS corresponds to).\n\
785 Positions are counted starting from 1 at the beginning of the list.\n\
786 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available\n\
787 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE\n\
788 if the user enters empty input! It returns the empty string.\n\
789 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
790 the current input method and the setting of enable-multibyte-characters.\n\
791 If the variable `minibuffer-allow-text-properties' is non-nil,\n\
792 then the string which is returned includes whatever text properties\n\
793 were present in the minibuffer. Otherwise the value has no text properties.")
794 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
797 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
798 0 /* See immediately above */)
799 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
800 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
801 Lisp_Object inherit_input_method
;
804 Lisp_Object histvar
, histpos
, position
, val
;
809 CHECK_STRING (prompt
, 0);
810 if (!NILP (initial_contents
))
812 if (CONSP (initial_contents
))
814 position
= Fcdr (initial_contents
);
815 initial_contents
= Fcar (initial_contents
);
817 CHECK_STRING (initial_contents
, 1);
818 if (!NILP (position
))
820 CHECK_NUMBER (position
, 0);
821 /* Convert to distance from end of input. */
822 if (XINT (position
) < 1)
823 /* A number too small means the beginning of the string. */
824 pos
= - XSTRING (initial_contents
)->size
;
826 pos
= XINT (position
) - 1 - XSTRING (initial_contents
)->size
;
831 keymap
= Vminibuffer_local_map
;
833 keymap
= get_keymap (keymap
, 1, 0);
842 histvar
= Fcar_safe (hist
);
843 histpos
= Fcdr_safe (hist
);
846 histvar
= Qminibuffer_history
;
848 XSETFASTINT (histpos
, 0);
850 GCPRO1 (default_value
);
851 val
= read_minibuf (keymap
, initial_contents
, prompt
,
852 make_number (pos
), !NILP (read
),
853 histvar
, histpos
, default_value
,
854 minibuffer_allow_text_properties
,
855 !NILP (inherit_input_method
));
860 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
861 "Return a Lisp object read using the minibuffer.\n\
862 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
863 is a string to insert in the minibuffer before reading.")
864 (prompt
, initial_contents
)
865 Lisp_Object prompt
, initial_contents
;
867 CHECK_STRING (prompt
, 0);
868 if (!NILP (initial_contents
))
869 CHECK_STRING (initial_contents
, 1);
870 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
871 prompt
, Qnil
, 1, Qminibuffer_history
,
872 make_number (0), Qnil
, 0, 0);
875 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
876 "Return value of Lisp expression read using the minibuffer.\n\
877 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
878 is a string to insert in the minibuffer before reading.")
879 (prompt
, initial_contents
)
880 Lisp_Object prompt
, initial_contents
;
882 return Feval (Fread_minibuffer (prompt
, initial_contents
));
885 /* Functions that use the minibuffer to read various things. */
887 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
888 "Read a string from the minibuffer, prompting with string PROMPT.\n\
889 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.\n\
890 The third arg HISTORY, if non-nil, specifies a history list\n\
891 and optionally the initial position in the list.\n\
892 See `read-from-minibuffer' for details of HISTORY argument.\n\
893 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used\n\
894 for history commands, and as the value to return if the user enters\n\
896 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
897 the current input method and the setting of enable-multibyte-characters.")
898 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
899 Lisp_Object prompt
, initial_input
, history
, default_value
;
900 Lisp_Object inherit_input_method
;
903 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
904 Qnil
, history
, default_value
,
905 inherit_input_method
);
906 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (default_value
))
911 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
912 "Read a string from the terminal, not allowing blanks.\n\
913 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.\n\
914 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits\n\
915 the current input method and the setting of enable-multibyte-characters.")
916 (prompt
, initial
, inherit_input_method
)
917 Lisp_Object prompt
, initial
, inherit_input_method
;
919 CHECK_STRING (prompt
, 0);
920 if (! NILP (initial
))
921 CHECK_STRING (initial
, 1);
923 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
924 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
925 !NILP (inherit_input_method
));
928 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
929 "Read the name of a command and return as a symbol.\n\
930 Prompts with PROMPT. By default, return DEFAULT-VALUE.")
931 (prompt
, default_value
)
932 Lisp_Object prompt
, default_value
;
934 Lisp_Object name
, default_string
;
936 if (NILP (default_value
))
937 default_string
= Qnil
;
938 else if (SYMBOLP (default_value
))
939 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
941 default_string
= default_value
;
943 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
944 Qnil
, Qnil
, default_string
, Qnil
);
947 return Fintern (name
, Qnil
);
951 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
952 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
953 Prompts with PROMPT.")
957 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
962 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
963 "Read the name of a user variable and return it as a symbol.\n\
964 Prompts with PROMPT. By default, return DEFAULT-VALUE.\n\
965 A user variable is one whose documentation starts with a `*' character.")
966 (prompt
, default_value
)
967 Lisp_Object prompt
, default_value
;
969 Lisp_Object name
, default_string
;
971 if (NILP (default_value
))
972 default_string
= Qnil
;
973 else if (SYMBOLP (default_value
))
974 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
976 default_string
= default_value
;
978 name
= Fcompleting_read (prompt
, Vobarray
,
979 Quser_variable_p
, Qt
,
980 Qnil
, Qnil
, default_string
, Qnil
);
983 return Fintern (name
, Qnil
);
986 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
987 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
988 Prompts with PROMPT.\n\
989 Optional second arg DEF is value to return if user enters an empty line.\n\
990 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
991 (prompt
, def
, require_match
)
992 Lisp_Object prompt
, def
, require_match
;
997 def
= XBUFFER (def
)->name
;
999 if (NILP (Vread_buffer_function
))
1003 args
[0] = build_string ("%s(default %s) ");
1006 prompt
= Fformat (3, args
);
1009 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1010 require_match
, Qnil
, Qbuffer_name_history
,
1015 args
[0] = Vread_buffer_function
;
1018 args
[3] = require_match
;
1019 return Ffuncall(4, args
);
1024 minibuf_conform_representation (string
, basis
)
1025 Lisp_Object string
, basis
;
1027 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1030 if (STRING_MULTIBYTE (string
))
1031 return Fstring_make_unibyte (string
);
1033 return Fstring_make_multibyte (string
);
1036 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1037 "Return common substring of all completions of STRING in ALIST.\n\
1038 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1039 All that match are compared together; the longest initial sequence\n\
1040 common to all matches is returned as a string.\n\
1041 If there is no match at all, nil is returned.\n\
1042 For a unique match which is exact, t is returned.\n\
1044 ALIST can be an obarray instead of an alist.\n\
1045 Then the print names of all symbols in the obarray are the possible matches.\n\
1047 ALIST can also be a function to do the completion itself.\n\
1048 It receives three arguments: the values STRING, PREDICATE and nil.\n\
1049 Whatever it returns becomes the value of `try-completion'.\n\
1051 If optional third argument PREDICATE is non-nil,\n\
1052 it is used to test each possible match.\n\
1053 The match is a candidate only if PREDICATE returns non-nil.\n\
1054 The argument given to PREDICATE is the alist element\n\
1055 or the symbol from the obarray.\n\
1056 Additionally to this predicate, `completion-regexp-list'\n\
1057 is used to further constrain the set of candidates.")
1058 (string
, alist
, predicate
)
1059 Lisp_Object string
, alist
, predicate
;
1061 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1062 /* Size in bytes of BESTMATCH. */
1063 int bestmatchsize
= 0;
1064 /* These are in bytes, too. */
1065 int compare
, matchsize
;
1066 int list
= CONSP (alist
) || NILP (alist
);
1067 int index
= 0, obsize
= 0;
1069 Lisp_Object bucket
, zero
, end
, tem
;
1070 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1072 CHECK_STRING (string
, 0);
1073 if (!list
&& !VECTORP (alist
))
1074 return call3 (alist
, string
, predicate
, Qnil
);
1076 bestmatch
= bucket
= Qnil
;
1078 /* If ALIST is not a list, set TAIL just for gc pro. */
1083 obsize
= XVECTOR (alist
)->size
;
1084 bucket
= XVECTOR (alist
)->contents
[index
];
1089 /* Get the next element of the alist or obarray. */
1090 /* Exit the loop if the elements are all used up. */
1091 /* elt gets the alist element or symbol.
1092 eltstring gets the name to check as a completion. */
1099 eltstring
= Fcar (elt
);
1104 if (XFASTINT (bucket
) != 0)
1107 eltstring
= Fsymbol_name (elt
);
1108 if (XSYMBOL (bucket
)->next
)
1109 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1111 XSETFASTINT (bucket
, 0);
1113 else if (++index
>= obsize
)
1117 bucket
= XVECTOR (alist
)->contents
[index
];
1122 /* Is this element a possible completion? */
1124 if (STRINGP (eltstring
)
1125 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1126 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1127 make_number (XSTRING (string
)->size
),
1128 string
, make_number (0), Qnil
,
1129 completion_ignore_case
?Qt
: Qnil
),
1133 Lisp_Object regexps
;
1135 XSETFASTINT (zero
, 0);
1137 /* Ignore this element if it fails to match all the regexps. */
1138 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1139 regexps
= XCDR (regexps
))
1141 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1145 if (CONSP (regexps
))
1148 /* Ignore this element if there is a predicate
1149 and the predicate doesn't like it. */
1151 if (!NILP (predicate
))
1153 if (EQ (predicate
, Qcommandp
))
1154 tem
= Fcommandp (elt
);
1157 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1158 tem
= call1 (predicate
, elt
);
1161 if (NILP (tem
)) continue;
1164 /* Update computation of how much all possible completions match */
1167 if (NILP (bestmatch
))
1169 bestmatch
= eltstring
;
1170 bestmatchsize
= XSTRING (eltstring
)->size
;
1174 compare
= min (bestmatchsize
, XSTRING (eltstring
)->size
);
1175 tem
= Fcompare_strings (bestmatch
, make_number (0),
1176 make_number (compare
),
1177 eltstring
, make_number (0),
1178 make_number (compare
),
1179 completion_ignore_case
? Qt
: Qnil
);
1181 matchsize
= compare
;
1182 else if (XINT (tem
) < 0)
1183 matchsize
= - XINT (tem
) - 1;
1185 matchsize
= XINT (tem
) - 1;
1188 matchsize
= compare
;
1189 if (completion_ignore_case
)
1191 /* If this is an exact match except for case,
1192 use it as the best match rather than one that is not an
1193 exact match. This way, we get the case pattern
1194 of the actual match. */
1195 if ((matchsize
== XSTRING (eltstring
)->size
1196 && matchsize
< XSTRING (bestmatch
)->size
)
1198 /* If there is more than one exact match ignoring case,
1199 and one of them is exact including case,
1201 /* If there is no exact match ignoring case,
1202 prefer a match that does not change the case
1204 ((matchsize
== XSTRING (eltstring
)->size
)
1206 (matchsize
== XSTRING (bestmatch
)->size
)
1207 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1208 make_number (XSTRING (string
)->size
),
1209 string
, make_number (0),
1213 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1214 make_number (XSTRING (string
)->size
),
1215 string
, make_number (0),
1219 bestmatch
= eltstring
;
1221 bestmatchsize
= matchsize
;
1226 if (NILP (bestmatch
))
1227 return Qnil
; /* No completions found */
1228 /* If we are ignoring case, and there is no exact match,
1229 and no additional text was supplied,
1230 don't change the case of what the user typed. */
1231 if (completion_ignore_case
&& bestmatchsize
== XSTRING (string
)->size
1232 && XSTRING (bestmatch
)->size
> bestmatchsize
)
1233 return minibuf_conform_representation (string
, bestmatch
);
1235 /* Return t if the supplied string is an exact match (counting case);
1236 it does not require any change to be made. */
1237 if (matchcount
== 1 && bestmatchsize
== XSTRING (string
)->size
1238 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1239 make_number (bestmatchsize
),
1240 string
, make_number (0),
1241 make_number (bestmatchsize
),
1246 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1247 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1248 return Fsubstring (bestmatch
, zero
, end
);
1251 /* Compare exactly LEN chars of strings at S1 and S2,
1252 ignoring case if appropriate.
1253 Return -1 if strings match,
1254 else number of chars that match at the beginning. */
1258 register unsigned char *s1
, *s2
;
1261 register int l
= len
;
1263 if (completion_ignore_case
)
1265 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
1270 while (l
&& *s1
++ == *s2
++)
1277 int match
= len
- l
;
1279 /* Now *--S1 is the unmatching byte. If it is in the middle of
1280 multi-byte form, we must say that the multi-byte character
1281 there doesn't match. */
1282 while (match
&& *--s1
>= 0xA0) match
--;
1287 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1288 "Search for partial matches to STRING in ALIST.\n\
1289 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
1290 The value is a list of all the strings from ALIST that match.\n\
1292 ALIST can be an obarray instead of an alist.\n\
1293 Then the print names of all symbols in the obarray are the possible matches.\n\
1295 ALIST can also be a function to do the completion itself.\n\
1296 It receives three arguments: the values STRING, PREDICATE and t.\n\
1297 Whatever it returns becomes the value of `all-completions'.\n\
1299 If optional third argument PREDICATE is non-nil,\n\
1300 it is used to test each possible match.\n\
1301 The match is a candidate only if PREDICATE returns non-nil.\n\
1302 The argument given to PREDICATE is the alist element\n\
1303 or the symbol from the obarray.\n\
1304 Additionally to this predicate, `completion-regexp-list'\n\
1305 is used to further constrain the set of candidates.\n\
1307 If the optional fourth argument HIDE-SPACES is non-nil,\n\
1308 strings in ALIST that start with a space\n\
1309 are ignored unless STRING itself starts with a space.")
1310 (string
, alist
, predicate
, hide_spaces
)
1311 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1313 Lisp_Object tail
, elt
, eltstring
;
1314 Lisp_Object allmatches
;
1315 int list
= CONSP (alist
) || NILP (alist
);
1316 int index
= 0, obsize
= 0;
1317 Lisp_Object bucket
, tem
;
1318 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1320 CHECK_STRING (string
, 0);
1321 if (!list
&& !VECTORP (alist
))
1323 return call3 (alist
, string
, predicate
, Qt
);
1325 allmatches
= bucket
= Qnil
;
1327 /* If ALIST is not a list, set TAIL just for gc pro. */
1332 obsize
= XVECTOR (alist
)->size
;
1333 bucket
= XVECTOR (alist
)->contents
[index
];
1338 /* Get the next element of the alist or obarray. */
1339 /* Exit the loop if the elements are all used up. */
1340 /* elt gets the alist element or symbol.
1341 eltstring gets the name to check as a completion. */
1348 eltstring
= Fcar (elt
);
1353 if (XFASTINT (bucket
) != 0)
1356 eltstring
= Fsymbol_name (elt
);
1357 if (XSYMBOL (bucket
)->next
)
1358 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1360 XSETFASTINT (bucket
, 0);
1362 else if (++index
>= obsize
)
1366 bucket
= XVECTOR (alist
)->contents
[index
];
1371 /* Is this element a possible completion? */
1373 if (STRINGP (eltstring
)
1374 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1375 /* If HIDE_SPACES, reject alternatives that start with space
1376 unless the input starts with space. */
1377 && ((STRING_BYTES (XSTRING (string
)) > 0
1378 && XSTRING (string
)->data
[0] == ' ')
1379 || XSTRING (eltstring
)->data
[0] != ' '
1380 || NILP (hide_spaces
))
1381 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1382 make_number (XSTRING (string
)->size
),
1383 string
, make_number (0),
1384 make_number (XSTRING (string
)->size
),
1385 completion_ignore_case
? Qt
: Qnil
),
1389 Lisp_Object regexps
;
1391 XSETFASTINT (zero
, 0);
1393 /* Ignore this element if it fails to match all the regexps. */
1394 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1395 regexps
= XCDR (regexps
))
1397 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1401 if (CONSP (regexps
))
1404 /* Ignore this element if there is a predicate
1405 and the predicate doesn't like it. */
1407 if (!NILP (predicate
))
1409 if (EQ (predicate
, Qcommandp
))
1410 tem
= Fcommandp (elt
);
1413 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1414 tem
= call1 (predicate
, elt
);
1417 if (NILP (tem
)) continue;
1419 /* Ok => put it on the list. */
1420 allmatches
= Fcons (eltstring
, allmatches
);
1424 return Fnreverse (allmatches
);
1427 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1428 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1429 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1430 Lisp_Object Vminibuffer_completing_file_name
;
1432 /* This comment supplies the doc string for completing-read,
1433 for make-docfile to see. We cannot put this in the real DEFUN
1434 due to limits in the Unix cpp.
1436 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1437 "Read a string in the minibuffer, with completion.\n\
1438 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
1439 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
1440 TABLE can also be a function to do the completion itself.\n\
1441 PREDICATE limits completion to a subset of TABLE.\n\
1442 See `try-completion' and `all-completions' for more details\n\
1443 on completion, TABLE, and PREDICATE.\n\
1445 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
1446 the input is (or completes to) an element of TABLE or is null.\n\
1447 If it is also not t, Return does not exit if it does non-null completion.\n\
1448 If the input is null, `completing-read' returns an empty string,\n\
1449 regardless of the value of REQUIRE-MATCH.\n\
1451 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
1452 If it is (STRING . POSITION), the initial input\n\
1453 is STRING, but point is placed POSITION characters into the string.\n\
1454 HIST, if non-nil, specifies a history list\n\
1455 and optionally the initial position in the list.\n\
1456 It can be a symbol, which is the history list variable to use,\n\
1457 or it can be a cons cell (HISTVAR . HISTPOS).\n\
1458 In that case, HISTVAR is the history list variable to use,\n\
1459 and HISTPOS is the initial position (the position in the list\n\
1460 which INITIAL-INPUT corresponds to).\n\
1461 Positions are counted starting from 1 at the beginning of the list.\n\
1462 DEF, if non-nil, is the default value.\n\
1464 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits\n\
1465 the current input method and the setting of enable-multibyte-characters.\n\
1467 Completion ignores case if the ambient value of\n\
1468 `completion-ignore-case' is non-nil."
1470 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1471 0 /* See immediately above */)
1472 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1473 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1474 Lisp_Object hist
, def
, inherit_input_method
;
1476 Lisp_Object val
, histvar
, histpos
, position
;
1479 int count
= specpdl_ptr
- specpdl
;
1480 struct gcpro gcpro1
;
1482 init
= initial_input
;
1485 specbind (Qminibuffer_completion_table
, table
);
1486 specbind (Qminibuffer_completion_predicate
, predicate
);
1487 specbind (Qminibuffer_completion_confirm
,
1488 EQ (require_match
, Qt
) ? Qnil
: Qt
);
1489 last_exact_completion
= Qnil
;
1496 position
= Fcdr (init
);
1499 CHECK_STRING (init
, 0);
1500 if (!NILP (position
))
1502 CHECK_NUMBER (position
, 0);
1503 /* Convert to distance from end of input. */
1504 pos
= XINT (position
) - XSTRING (init
)->size
;
1515 histvar
= Fcar_safe (hist
);
1516 histpos
= Fcdr_safe (hist
);
1519 histvar
= Qminibuffer_history
;
1521 XSETFASTINT (histpos
, 0);
1523 val
= read_minibuf (NILP (require_match
)
1524 ? Vminibuffer_local_completion_map
1525 : Vminibuffer_local_must_match_map
,
1526 init
, prompt
, make_number (pos
), 0,
1527 histvar
, histpos
, def
, 0,
1528 !NILP (inherit_input_method
));
1530 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (def
))
1533 RETURN_UNGCPRO (unbind_to (count
, val
));
1536 Lisp_Object
Fminibuffer_completion_help ();
1537 Lisp_Object
assoc_for_completion ();
1539 /* Test whether TXT is an exact completion. */
1541 test_completion (txt
)
1546 if (CONSP (Vminibuffer_completion_table
)
1547 || NILP (Vminibuffer_completion_table
))
1548 return assoc_for_completion (txt
, Vminibuffer_completion_table
);
1549 else if (VECTORP (Vminibuffer_completion_table
))
1551 /* Bypass intern-soft as that loses for nil */
1552 tem
= oblookup (Vminibuffer_completion_table
,
1553 XSTRING (txt
)->data
,
1554 XSTRING (txt
)->size
,
1555 STRING_BYTES (XSTRING (txt
)));
1558 if (STRING_MULTIBYTE (txt
))
1559 txt
= Fstring_make_unibyte (txt
);
1561 txt
= Fstring_make_multibyte (txt
);
1563 tem
= oblookup (Vminibuffer_completion_table
,
1564 XSTRING (txt
)->data
,
1565 XSTRING (txt
)->size
,
1566 STRING_BYTES (XSTRING (txt
)));
1570 if (!NILP (Vminibuffer_completion_predicate
))
1571 return call1 (Vminibuffer_completion_predicate
, tem
);
1576 return call3 (Vminibuffer_completion_table
, txt
,
1577 Vminibuffer_completion_predicate
, Qlambda
);
1581 * 0 no possible completion
1582 * 1 was already an exact and unique completion
1583 * 3 was already an exact completion
1584 * 4 completed to an exact completion
1585 * 5 some completion happened
1586 * 6 no completion happened
1591 Lisp_Object completion
, string
, tem
;
1594 struct gcpro gcpro1
, gcpro2
;
1596 completion
= Ftry_completion (Ffield_string (make_number (ZV
)),
1597 Vminibuffer_completion_table
,
1598 Vminibuffer_completion_predicate
);
1599 last
= last_exact_completion
;
1600 last_exact_completion
= Qnil
;
1602 GCPRO2 (completion
, last
);
1604 if (NILP (completion
))
1607 temp_echo_area_glyphs (" [No match]");
1612 if (EQ (completion
, Qt
)) /* exact and unique match */
1618 string
= Ffield_string (make_number (ZV
));
1620 /* COMPLETEDP should be true if some completion was done, which
1621 doesn't include simply changing the case of the entered string.
1622 However, for appearance, the string is rewritten if the case
1624 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1625 completedp
= !EQ (tem
, Qt
);
1627 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1629 /* Rewrite the user's input. */
1631 Fdelete_field (make_number (ZV
)); /* Some completion happened */
1632 Finsert (1, &completion
);
1635 /* The case of the string changed, but that's all. We're not
1636 sure whether this is a unique completion or not, so try again
1637 using the real case (this shouldn't recurse again, because
1638 the next time try-completion will return either `t' or the
1642 return do_completion ();
1646 /* It did find a match. Do we match some possibility exactly now? */
1647 tem
= test_completion (Ffield_string (make_number (ZV
)));
1650 /* not an exact match */
1654 else if (!NILP (Vcompletion_auto_help
))
1655 Fminibuffer_completion_help ();
1657 temp_echo_area_glyphs (" [Next char not unique]");
1660 else if (completedp
)
1665 /* If the last exact completion and this one were the same,
1666 it means we've already given a "Complete but not unique"
1667 message and the user's hit TAB again, so now we give him help. */
1668 last_exact_completion
= completion
;
1671 tem
= Ffield_string (make_number (ZV
));
1672 if (!NILP (Fequal (tem
, last
)))
1673 Fminibuffer_completion_help ();
1679 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1682 assoc_for_completion (key
, list
)
1683 register Lisp_Object key
;
1686 register Lisp_Object tail
;
1688 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1690 register Lisp_Object elt
, tem
, thiscar
;
1692 if (!CONSP (elt
)) continue;
1693 thiscar
= Fcar (elt
);
1694 if (!STRINGP (thiscar
))
1696 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1697 key
, make_number (0), Qnil
,
1698 completion_ignore_case
? Qt
: Qnil
);
1706 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1707 "Complete the minibuffer contents as far as possible.\n\
1708 Return nil if there is no valid completion, else t.\n\
1709 If no characters can be completed, display a list of possible completions.\n\
1710 If you repeat this command after it displayed such a list,\n\
1711 scroll the window of possible completions.")
1715 Lisp_Object window
, tem
;
1717 /* If the previous command was not this,
1718 mark the completion buffer obsolete. */
1719 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1720 Vminibuf_scroll_window
= Qnil
;
1722 window
= Vminibuf_scroll_window
;
1723 /* If there's a fresh completion window with a live buffer,
1724 and this command is repeated, scroll that window. */
1725 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1726 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1728 struct buffer
*obuf
= current_buffer
;
1730 Fset_buffer (XWINDOW (window
)->buffer
);
1731 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1733 /* If end is in view, scroll up to the beginning. */
1734 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1736 /* Else scroll down one screen. */
1737 Fscroll_other_window (Qnil
);
1739 set_buffer_internal (obuf
);
1743 i
= do_completion ();
1751 Fgoto_char (make_number (ZV
));
1752 temp_echo_area_glyphs (" [Sole completion]");
1757 Fgoto_char (make_number (ZV
));
1758 temp_echo_area_glyphs (" [Complete, but not unique]");
1765 /* Subroutines of Fminibuffer_complete_and_exit. */
1767 /* This one is called by internal_condition_case to do the real work. */
1770 complete_and_exit_1 ()
1772 return make_number (do_completion ());
1775 /* This one is called by internal_condition_case if an error happens.
1776 Pretend the current value is an exact match. */
1779 complete_and_exit_2 (ignore
)
1782 return make_number (1);
1785 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1786 Sminibuffer_complete_and_exit
, 0, 0, "",
1787 "If the minibuffer contents is a valid completion then exit.\n\
1788 Otherwise try to complete it. If completion leads to a valid completion,\n\
1789 a repetition of this command will exit.")
1795 /* Allow user to specify null string */
1796 if (XINT (Ffield_beginning (make_number (ZV
), Qnil
)) == ZV
)
1799 if (!NILP (test_completion (Ffield_string (make_number (ZV
)))))
1802 /* Call do_completion, but ignore errors. */
1803 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
1804 complete_and_exit_2
);
1814 if (!NILP (Vminibuffer_completion_confirm
))
1816 temp_echo_area_glyphs (" [Confirm]");
1826 return Fthrow (Qexit
, Qnil
);
1830 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1832 "Complete the minibuffer contents at most a single word.\n\
1833 After one word is completed as much as possible, a space or hyphen\n\
1834 is added, provided that matches some possible completion.\n\
1835 Return nil if there is no valid completion, else t.")
1838 Lisp_Object completion
, tem
, tem1
;
1839 register int i
, i_byte
;
1840 register unsigned char *completion_string
;
1841 struct gcpro gcpro1
, gcpro2
;
1842 int prompt_end_charpos
;
1844 /* We keep calling Fbuffer_string rather than arrange for GC to
1845 hold onto a pointer to one of the strings thus made. */
1847 completion
= Ftry_completion (Ffield_string (make_number (ZV
)),
1848 Vminibuffer_completion_table
,
1849 Vminibuffer_completion_predicate
);
1850 if (NILP (completion
))
1853 temp_echo_area_glyphs (" [No match]");
1856 if (EQ (completion
, Qt
))
1859 #if 0 /* How the below code used to look, for reference. */
1860 tem
= Ffield_string (make_number (ZV
));
1861 b
= XSTRING (tem
)->data
;
1862 i
= ZV
- 1 - XSTRING (completion
)->size
;
1863 p
= XSTRING (completion
)->data
;
1865 0 <= scmp (b
, p
, ZV
- 1))
1868 /* Set buffer to longest match of buffer tail and completion head. */
1869 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1871 del_range (1, i
+ 1);
1874 #else /* Rewritten code */
1876 int buffer_nchars
, completion_nchars
;
1878 CHECK_STRING (completion
, 0);
1879 tem
= Ffield_string (make_number (ZV
));
1880 GCPRO2 (completion
, tem
);
1881 /* If reading a file name,
1882 expand any $ENVVAR refs in the buffer and in TEM. */
1883 if (! NILP (Vminibuffer_completing_file_name
))
1885 Lisp_Object substituted
;
1886 substituted
= Fsubstitute_in_file_name (tem
);
1887 if (! EQ (substituted
, tem
))
1890 Fdelete_field (make_number (ZV
));
1891 insert_from_string (tem
, 0, 0, XSTRING (tem
)->size
,
1892 STRING_BYTES (XSTRING (tem
)), 0);
1895 buffer_nchars
= XSTRING (tem
)->size
; /* ie ZV - BEGV */
1896 completion_nchars
= XSTRING (completion
)->size
;
1897 i
= buffer_nchars
- completion_nchars
;
1900 (tem1
= Fcompare_strings (tem
, make_number (0),
1901 make_number (buffer_nchars
),
1902 completion
, make_number (0),
1903 make_number (buffer_nchars
),
1904 completion_ignore_case
? Qt
: Qnil
),
1909 /* Set buffer to longest match of buffer tail and completion head. */
1915 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
1916 completion
, make_number (0),
1917 make_number (buffer_nchars
),
1918 completion_ignore_case
? Qt
: Qnil
);
1925 del_range (1, i
+ 1);
1926 SET_PT_BOTH (ZV
, ZV_BYTE
);
1930 #endif /* Rewritten code */
1932 prompt_end_charpos
= XINT (Ffield_beginning (make_number (ZV
), Qnil
));
1935 int prompt_end_bytepos
;
1936 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
1937 i
= ZV
- prompt_end_charpos
;
1938 i_byte
= ZV_BYTE
- prompt_end_bytepos
;
1941 /* If completion finds next char not unique,
1942 consider adding a space or a hyphen. */
1943 if (i
== XSTRING (completion
)->size
)
1945 GCPRO1 (completion
);
1946 tem
= Ftry_completion (concat2 (Ffield_string (make_number (ZV
)), build_string (" ")),
1947 Vminibuffer_completion_table
,
1948 Vminibuffer_completion_predicate
);
1955 GCPRO1 (completion
);
1957 Ftry_completion (concat2 (Ffield_string (make_number (ZV
)), build_string ("-")),
1958 Vminibuffer_completion_table
,
1959 Vminibuffer_completion_predicate
);
1967 /* Now find first word-break in the stuff found by completion.
1968 i gets index in string of where to stop completing. */
1971 int bytes
= STRING_BYTES (XSTRING (completion
));
1972 completion_string
= XSTRING (completion
)->data
;
1973 for (; i_byte
< STRING_BYTES (XSTRING (completion
)); i_byte
+= len
, i
++)
1975 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
1978 if (SYNTAX (c
) != Sword
)
1987 /* If got no characters, print help for user. */
1989 if (i
== ZV
- prompt_end_charpos
)
1991 if (!NILP (Vcompletion_auto_help
))
1992 Fminibuffer_completion_help ();
1996 /* Otherwise insert in minibuffer the chars we got */
1998 Fdelete_field (make_number (ZV
));
1999 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2003 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2005 "Display the list of completions, COMPLETIONS, using `standard-output'.\n\
2006 Each element may be just a symbol or string\n\
2007 or may be a list of two strings to be printed as if concatenated.\n\
2008 `standard-output' must be a buffer.\n\
2009 The actual completion alternatives, as inserted, are given `mouse-face'\n\
2010 properties of `highlight'.\n\
2011 At the end, this runs the normal hook `completion-setup-hook'.\n\
2012 It can find the completion buffer in `standard-output'.")
2014 Lisp_Object completions
;
2016 Lisp_Object tail
, elt
;
2019 struct gcpro gcpro1
, gcpro2
;
2020 struct buffer
*old
= current_buffer
;
2023 /* Note that (when it matters) every variable
2024 points to a non-string that is pointed to by COMPLETIONS,
2025 except for ELT. ELT can be pointing to a string
2026 when terpri or Findent_to calls a change hook. */
2028 GCPRO2 (completions
, elt
);
2030 if (BUFFERP (Vstandard_output
))
2031 set_buffer_internal (XBUFFER (Vstandard_output
));
2033 if (NILP (completions
))
2034 write_string ("There are no possible completions of what you have typed.",
2038 write_string ("Possible completions are:", -1);
2039 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2041 Lisp_Object tem
, string
;
2043 Lisp_Object startpos
, endpos
;
2048 /* Compute the length of this element. */
2052 CHECK_STRING (tem
, 0);
2053 length
= XSTRING (tem
)->size
;
2055 tem
= Fcar (XCDR (elt
));
2056 CHECK_STRING (tem
, 0);
2057 length
+= XSTRING (tem
)->size
;
2061 CHECK_STRING (elt
, 0);
2062 length
= XSTRING (elt
)->size
;
2065 /* This does a bad job for narrower than usual windows.
2066 Sadly, the window it will appear in is not known
2067 until after the text has been made. */
2069 if (BUFFERP (Vstandard_output
))
2070 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2072 /* If the previous completion was very wide,
2073 or we have two on this line already,
2074 don't put another on the same line. */
2075 if (column
> 33 || first
2076 /* If this is really wide, don't put it second on a line. */
2077 || (column
> 0 && length
> 45))
2082 /* Otherwise advance to column 35. */
2085 if (BUFFERP (Vstandard_output
))
2087 tem
= Findent_to (make_number (35), make_number (2));
2089 column
= XINT (tem
);
2095 write_string (" ", -1);
2098 while (column
< 35);
2102 if (BUFFERP (Vstandard_output
))
2104 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2105 Fset_text_properties (startpos
, endpos
,
2106 Qnil
, Vstandard_output
);
2109 /* Output this element.
2110 If necessary, convert it to unibyte or to multibyte first. */
2112 string
= Fcar (elt
);
2115 if (NILP (current_buffer
->enable_multibyte_characters
)
2116 && STRING_MULTIBYTE (string
))
2117 string
= Fstring_make_unibyte (string
);
2118 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2119 && !STRING_MULTIBYTE (string
))
2120 string
= Fstring_make_multibyte (string
);
2122 if (BUFFERP (Vstandard_output
))
2124 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2126 Fprinc (string
, Qnil
);
2128 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2130 Fput_text_property (startpos
, endpos
,
2131 Qmouse_face
, intern ("highlight"),
2136 Fprinc (string
, Qnil
);
2139 /* Output the annotation for this element. */
2142 if (BUFFERP (Vstandard_output
))
2144 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2146 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2148 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2150 Fset_text_properties (startpos
, endpos
, Qnil
,
2155 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2160 /* Update COLUMN for what we have output. */
2163 /* If output is to a buffer, recompute COLUMN in a way
2164 that takes account of character widths. */
2165 if (BUFFERP (Vstandard_output
))
2167 tem
= Fcurrent_column ();
2168 column
= XINT (tem
);
2177 if (BUFFERP (Vstandard_output
))
2178 set_buffer_internal (old
);
2180 if (!NILP (Vrun_hooks
))
2181 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2186 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2188 "Display a list of possible completions of the current minibuffer contents.")
2191 Lisp_Object completions
;
2193 message ("Making completion list...");
2194 completions
= Fall_completions (Ffield_string (make_number (ZV
)),
2195 Vminibuffer_completion_table
,
2196 Vminibuffer_completion_predicate
,
2198 clear_message (1, 0);
2200 if (NILP (completions
))
2203 temp_echo_area_glyphs (" [No completions]");
2206 internal_with_output_to_temp_buffer ("*Completions*",
2207 Fdisplay_completion_list
,
2208 Fsort (completions
, Qstring_lessp
));
2212 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2213 "Terminate minibuffer input.")
2216 if (INTEGERP (last_command_char
))
2217 internal_self_insert (XINT (last_command_char
), 0);
2221 return Fthrow (Qexit
, Qnil
);
2224 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2225 "Terminate this minibuffer argument.")
2228 return Fthrow (Qexit
, Qnil
);
2231 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2232 "Return current depth of activations of minibuffer, a nonnegative integer.")
2235 return make_number (minibuf_level
);
2238 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2239 "Return the prompt string of the currently-active minibuffer.\n\
2240 If no minibuffer is active, return nil.")
2243 return Fcopy_sequence (minibuf_prompt
);
2247 /* Temporarily display the string M at the end of the current
2248 minibuffer contents. This is used to display things like
2249 "[No Match]" when the user requests a completion for a prefix
2250 that has no possible completions, and other quick, unobtrusive
2254 temp_echo_area_glyphs (m
)
2258 int osize_byte
= ZV_BYTE
;
2260 int opoint_byte
= PT_BYTE
;
2261 Lisp_Object oinhibit
;
2262 oinhibit
= Vinhibit_quit
;
2264 /* Clear out any old echo-area message to make way for our new thing. */
2267 SET_PT_BOTH (osize
, osize_byte
);
2269 SET_PT_BOTH (opoint
, opoint_byte
);
2271 Fsit_for (make_number (2), Qnil
, Qnil
);
2272 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2273 SET_PT_BOTH (opoint
, opoint_byte
);
2274 if (!NILP (Vquit_flag
))
2277 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2279 Vinhibit_quit
= oinhibit
;
2282 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2284 "Temporarily display STRING at the end of the minibuffer.\n\
2285 The text is displayed for two seconds,\n\
2286 or until the next input event arrives, whichever comes first.")
2290 temp_echo_area_glyphs (XSTRING (string
)->data
);
2295 init_minibuf_once ()
2297 Vminibuffer_list
= Qnil
;
2298 staticpro (&Vminibuffer_list
);
2305 minibuf_prompt
= Qnil
;
2306 staticpro (&minibuf_prompt
);
2308 minibuf_save_list
= Qnil
;
2309 staticpro (&minibuf_save_list
);
2311 Qread_file_name_internal
= intern ("read-file-name-internal");
2312 staticpro (&Qread_file_name_internal
);
2314 Qminibuffer_default
= intern ("minibuffer-default");
2315 staticpro (&Qminibuffer_default
);
2316 Fset (Qminibuffer_default
, Qnil
);
2318 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2319 staticpro (&Qminibuffer_completion_table
);
2321 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2322 staticpro (&Qminibuffer_completion_confirm
);
2324 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2325 staticpro (&Qminibuffer_completion_predicate
);
2327 staticpro (&last_exact_completion
);
2328 last_exact_completion
= Qnil
;
2330 staticpro (&last_minibuf_string
);
2331 last_minibuf_string
= Qnil
;
2333 Quser_variable_p
= intern ("user-variable-p");
2334 staticpro (&Quser_variable_p
);
2336 Qminibuffer_history
= intern ("minibuffer-history");
2337 staticpro (&Qminibuffer_history
);
2339 Qbuffer_name_history
= intern ("buffer-name-history");
2340 staticpro (&Qbuffer_name_history
);
2341 Fset (Qbuffer_name_history
, Qnil
);
2343 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2344 staticpro (&Qminibuffer_setup_hook
);
2346 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2347 staticpro (&Qminibuffer_exit_hook
);
2349 Qhistory_length
= intern ("history-length");
2350 staticpro (&Qhistory_length
);
2352 Qcurrent_input_method
= intern ("current-input-method");
2353 staticpro (&Qcurrent_input_method
);
2355 Qactivate_input_method
= intern ("activate-input-method");
2356 staticpro (&Qactivate_input_method
);
2358 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2359 "If this is non-nil, `read-buffer' does its work by calling this function.");
2360 Vread_buffer_function
= Qnil
;
2362 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2363 "Normal hook run just after entry to minibuffer.");
2364 Vminibuffer_setup_hook
= Qnil
;
2366 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2367 "Normal hook run just after exit from minibuffer.");
2368 Vminibuffer_exit_hook
= Qnil
;
2370 DEFVAR_LISP ("history-length", &Vhistory_length
,
2371 "*Maximum length for history lists before truncation takes place.\n\
2372 A number means that length; t means infinite. Truncation takes place\n\
2373 just after a new element is inserted. Setting the history-length\n\
2374 property of a history variable overrides this default.");
2375 XSETFASTINT (Vhistory_length
, 30);
2377 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2378 "*Non-nil means automatically provide help for invalid completion input.");
2379 Vcompletion_auto_help
= Qt
;
2381 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2382 "Non-nil means don't consider case significant in completion.");
2383 completion_ignore_case
= 0;
2385 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2386 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
2387 This variable makes a difference whenever the minibuffer window is active.");
2388 enable_recursive_minibuffers
= 0;
2390 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2391 "Alist or obarray used for completion in the minibuffer.\n\
2392 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
2394 The value may alternatively be a function, which is given three arguments:\n\
2395 STRING, the current buffer contents;\n\
2396 PREDICATE, the predicate for filtering possible matches;\n\
2397 CODE, which says what kind of things to do.\n\
2398 CODE can be nil, t or `lambda'.\n\
2399 nil means to return the best completion of STRING, or nil if there is none.\n\
2400 t means to return a list of all possible completions of STRING.\n\
2401 `lambda' means to return t if STRING is a valid completion as it stands.");
2402 Vminibuffer_completion_table
= Qnil
;
2404 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2405 "Within call to `completing-read', this holds the PREDICATE argument.");
2406 Vminibuffer_completion_predicate
= Qnil
;
2408 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2409 "Non-nil => demand confirmation of completion before exiting minibuffer.");
2410 Vminibuffer_completion_confirm
= Qnil
;
2412 DEFVAR_LISP ("minibuffer-completing-file-name",
2413 &Vminibuffer_completing_file_name
,
2414 "Non-nil means completing file names.");
2415 Vminibuffer_completing_file_name
= Qnil
;
2417 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2418 "Value that `help-form' takes on inside the minibuffer.");
2419 Vminibuffer_help_form
= Qnil
;
2421 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2422 "History list symbol to add minibuffer values to.\n\
2423 Each string of minibuffer input, as it appears on exit from the minibuffer,\n\
2425 (set minibuffer-history-variable\n\
2426 (cons STRING (symbol-value minibuffer-history-variable)))");
2427 XSETFASTINT (Vminibuffer_history_variable
, 0);
2429 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2430 "Current position of redoing in the history list.");
2431 Vminibuffer_history_position
= Qnil
;
2433 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2434 "*Non-nil means entering the minibuffer raises the minibuffer's frame.\n\
2435 Some uses of the echo area also raise that frame (since they use it too).");
2436 minibuffer_auto_raise
= 0;
2438 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2439 "List of regexps that should restrict possible completions.");
2440 Vcompletion_regexp_list
= Qnil
;
2442 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2443 &minibuffer_allow_text_properties
,
2444 "Non-nil means `read-from-minibuffer' should not discard text properties.\n\
2445 This also affects `read-string', but it does not affect `read-minibuffer',\n\
2446 `read-no-blanks-input', or any of the functions that do minibuffer input\n\
2447 with completion; they always discard text properties.");
2448 minibuffer_allow_text_properties
= 0;
2450 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2451 "Text properties that are added to minibuffer prompts.\n\
2452 These are in addition to the basic `field' property, and stickiness\n\
2454 /* We use `intern' here instead of Qread_only to avoid
2455 initialization-order problems. */
2456 Vminibuffer_prompt_properties
2457 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2459 defsubr (&Sset_minibuffer_window
);
2460 defsubr (&Sread_from_minibuffer
);
2461 defsubr (&Seval_minibuffer
);
2462 defsubr (&Sread_minibuffer
);
2463 defsubr (&Sread_string
);
2464 defsubr (&Sread_command
);
2465 defsubr (&Sread_variable
);
2466 defsubr (&Sread_buffer
);
2467 defsubr (&Sread_no_blanks_input
);
2468 defsubr (&Sminibuffer_depth
);
2469 defsubr (&Sminibuffer_prompt
);
2471 defsubr (&Stry_completion
);
2472 defsubr (&Sall_completions
);
2473 defsubr (&Scompleting_read
);
2474 defsubr (&Sminibuffer_complete
);
2475 defsubr (&Sminibuffer_complete_word
);
2476 defsubr (&Sminibuffer_complete_and_exit
);
2477 defsubr (&Sdisplay_completion_list
);
2478 defsubr (&Sminibuffer_completion_help
);
2480 defsubr (&Sself_insert_and_exit
);
2481 defsubr (&Sexit_minibuffer
);
2483 defsubr (&Sminibuffer_message
);
2489 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2490 "abort-recursive-edit");
2491 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2493 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2496 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('g'),
2497 "abort-recursive-edit");
2498 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('m'),
2500 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('j'),
2503 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2505 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2507 initial_define_key (Vminibuffer_local_ns_map
, '?',
2508 "self-insert-and-exit");
2510 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('g'),
2511 "abort-recursive-edit");
2512 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('m'),
2514 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('j'),
2517 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2518 "minibuffer-complete");
2519 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2520 "minibuffer-complete-word");
2521 initial_define_key (Vminibuffer_local_completion_map
, '?',
2522 "minibuffer-completion-help");
2524 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('g'),
2525 "abort-recursive-edit");
2526 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2527 "minibuffer-complete-and-exit");
2528 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2529 "minibuffer-complete-and-exit");
2530 initial_define_key (Vminibuffer_local_must_match_map
, '\t',
2531 "minibuffer-complete");
2532 initial_define_key (Vminibuffer_local_must_match_map
, ' ',
2533 "minibuffer-complete-word");
2534 initial_define_key (Vminibuffer_local_must_match_map
, '?',
2535 "minibuffer-completion-help");