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
) && XSTRING (val
)->size
== 0
240 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
241 pos
= XINT (Fcdr (expr_and_pos
));
242 if (pos
!= XSTRING (val
)->size
)
244 /* Ignore trailing whitespace; any other trailing junk
247 pos
= string_char_to_byte (val
, pos
);
248 for (i
= pos
; i
< STRING_BYTES (XSTRING (val
)); i
++)
250 int c
= XSTRING (val
)->data
[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", XSTRING (prompt
)->data
);
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
);
322 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
323 Sminibuffer_prompt_end
, 0, 0, 0,
324 doc
: /* Return the buffer position of the end of the minibuffer prompt.
325 Return (point-min) if current buffer is not a mini-buffer. */)
328 /* This function is written to be most efficient when there's a prompt. */
329 Lisp_Object beg
= make_number (BEGV
);
330 Lisp_Object end
= Ffield_end (beg
, Qnil
, Qnil
);
332 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
338 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
339 Sminibuffer_contents
, 0, 0, 0,
340 doc
: /* Return the user input in a minibuffer as a string.
341 The current buffer must be a minibuffer. */)
344 int prompt_end
= XINT (Fminibuffer_prompt_end ());
345 return make_buffer_string (prompt_end
, ZV
, 1);
348 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
349 Sminibuffer_contents_no_properties
, 0, 0, 0,
350 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
351 The current buffer must be a minibuffer. */)
354 int prompt_end
= XINT (Fminibuffer_prompt_end ());
355 return make_buffer_string (prompt_end
, ZV
, 0);
358 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
359 Sdelete_minibuffer_contents
, 0, 0, 0,
360 doc
: /* Delete all user input in a minibuffer.
361 The current buffer must be a minibuffer. */)
364 int prompt_end
= XINT (Fminibuffer_prompt_end ());
366 del_range (prompt_end
, ZV
);
371 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
372 (a string), putting point minus BACKUP_N bytes from the end of INITIAL,
373 prompting with PROMPT (a string), using history list HISTVAR
374 with initial position HISTPOS. (BACKUP_N should be <= 0.)
376 Normally return the result as a string (the text that was read),
377 but if EXPFLAG is nonzero, read it and return the object read.
378 If HISTVAR is given, save the value read on that history only if it doesn't
379 match the front of that history list exactly. The value is pushed onto
380 the list as the string that was read.
382 DEFALT specifies te default value for the sake of history commands.
384 If ALLOW_PROPS is nonzero, we do not throw away text properties.
386 if INHERIT_INPUT_METHOD is nonzeor, the minibuffer inherit the
387 current input method. */
390 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
391 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
395 Lisp_Object backup_n
;
401 int inherit_input_method
;
404 int count
= specpdl_ptr
- specpdl
;
405 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
406 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
407 Lisp_Object enable_multibyte
;
408 extern Lisp_Object Qfront_sticky
;
409 extern Lisp_Object Qrear_nonsticky
;
411 specbind (Qminibuffer_default
, defalt
);
413 single_kboard_state ();
414 #ifdef HAVE_X_WINDOWS
415 if (display_hourglass_p
)
420 ambient_dir
= current_buffer
->directory
;
422 enable_multibyte
= Qnil
;
424 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
425 store them away before we can GC. Don't need to protect
426 BACKUP_N because we use the value only if it is an integer. */
427 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
429 if (!STRINGP (prompt
))
430 prompt
= empty_string
;
432 if (!enable_recursive_minibuffers
433 && minibuf_level
> 0)
435 if (EQ (selected_window
, minibuf_window
))
436 error ("Command attempted to use minibuffer while in minibuffer");
438 /* If we're in another window, cancel the minibuffer that's active. */
440 build_string ("Command attempted to use minibuffer while in minibuffer"));
445 val
= read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
,
446 expflag
, histvar
, histpos
, defalt
,
447 allow_props
, inherit_input_method
);
448 return unbind_to (count
, val
);
451 /* Choose the minibuffer window and frame, and take action on them. */
453 choose_minibuf_frame ();
455 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
457 record_unwind_protect (Fset_window_configuration
,
458 Fcurrent_window_configuration (Qnil
));
460 /* If the minibuffer window is on a different frame, save that
461 frame's configuration too. */
462 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
463 if (!EQ (mini_frame
, selected_frame
))
464 record_unwind_protect (Fset_window_configuration
,
465 Fcurrent_window_configuration (mini_frame
));
467 /* If the minibuffer is on an iconified or invisible frame,
468 make it visible now. */
469 Fmake_frame_visible (mini_frame
);
471 if (minibuffer_auto_raise
)
472 Fraise_frame (mini_frame
);
474 /* We have to do this after saving the window configuration
475 since that is what restores the current buffer. */
477 /* Arrange to restore a number of minibuffer-related variables.
478 We could bind each variable separately, but that would use lots of
481 = Fcons (Voverriding_local_map
,
482 Fcons (minibuf_window
, minibuf_save_list
));
484 = Fcons (minibuf_prompt
,
485 Fcons (make_number (minibuf_prompt_width
),
487 Fcons (Vcurrent_prefix_arg
,
488 Fcons (Vminibuffer_history_position
,
489 Fcons (Vminibuffer_history_variable
,
490 minibuf_save_list
))))));
492 record_unwind_protect (read_minibuf_unwind
, Qnil
);
495 /* Now that we can restore all those variables, start changing them. */
497 minibuf_prompt_width
= 0;
498 minibuf_prompt
= Fcopy_sequence (prompt
);
499 Vminibuffer_history_position
= histpos
;
500 Vminibuffer_history_variable
= histvar
;
501 Vhelp_form
= Vminibuffer_help_form
;
503 if (inherit_input_method
)
505 /* `current-input-method' is buffer local. So, remember it in
506 INPUT_METHOD before changing the current buffer. */
507 input_method
= Fsymbol_value (Qcurrent_input_method
);
508 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
511 /* Switch to the minibuffer. */
513 minibuffer
= get_minibuffer (minibuf_level
);
514 Fset_buffer (minibuffer
);
516 /* The current buffer's default directory is usually the right thing
517 for our minibuffer here. However, if you're typing a command at
518 a minibuffer-only frame when minibuf_level is zero, then buf IS
519 the current_buffer, so reset_buffer leaves buf's default
520 directory unchanged. This is a bummer when you've just started
521 up Emacs and buf's default directory is Qnil. Here's a hack; can
522 you think of something better to do? Find another buffer with a
523 better directory, and use that one instead. */
524 if (STRINGP (ambient_dir
))
525 current_buffer
->directory
= ambient_dir
;
528 Lisp_Object buf_list
;
530 for (buf_list
= Vbuffer_alist
;
532 buf_list
= XCDR (buf_list
))
534 Lisp_Object other_buf
;
536 other_buf
= XCDR (XCAR (buf_list
));
537 if (STRINGP (XBUFFER (other_buf
)->directory
))
539 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
545 if (!EQ (mini_frame
, selected_frame
))
546 Fredirect_frame_focus (selected_frame
, mini_frame
);
548 Vminibuf_scroll_window
= selected_window
;
549 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
550 minibuf_selected_window
= selected_window
;
551 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
552 Fselect_window (minibuf_window
);
553 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
555 Fmake_local_variable (Qprint_escape_newlines
);
556 print_escape_newlines
= 1;
558 /* Erase the buffer. */
560 int count1
= BINDING_STACK_SIZE ();
561 specbind (Qinhibit_read_only
, Qt
);
562 specbind (Qinhibit_modification_hooks
, Qt
);
564 unbind_to (count1
, Qnil
);
567 if (!NILP (current_buffer
->enable_multibyte_characters
)
568 && ! STRING_MULTIBYTE (minibuf_prompt
))
569 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
571 /* Insert the prompt, record where it ends. */
572 Finsert (1, &minibuf_prompt
);
575 Fput_text_property (make_number (BEG
), make_number (PT
),
576 Qfront_sticky
, Qt
, Qnil
);
577 Fput_text_property (make_number (BEG
), make_number (PT
),
578 Qrear_nonsticky
, Qt
, Qnil
);
579 Fput_text_property (make_number (BEG
), make_number (PT
),
581 Fadd_text_properties (make_number (BEG
), make_number (PT
),
582 Vminibuffer_prompt_properties
, Qnil
);
585 minibuf_prompt_width
= current_column ();
587 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
588 if (inherit_input_method
)
589 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
591 /* Put in the initial input. */
594 Finsert (1, &initial
);
595 if (INTEGERP (backup_n
))
596 Fforward_char (backup_n
);
599 clear_message (1, 1);
600 current_buffer
->keymap
= map
;
602 /* Turn on an input method stored in INPUT_METHOD if any. */
603 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
604 call1 (Qactivate_input_method
, input_method
);
606 /* Run our hook, but not if it is empty.
607 (run-hooks would do nothing if it is empty,
608 but it's important to save time here in the usual case.) */
609 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
610 && !NILP (Vrun_hooks
))
611 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
613 /* Don't allow the user to undo past this point. */
614 current_buffer
->undo_list
= Qnil
;
618 /* If cursor is on the minibuffer line,
619 show the user we have exited by putting it in column 0. */
620 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
623 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
624 XWINDOW (minibuf_window
)->cursor
.x
= 0;
625 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
626 update_frame (XFRAME (selected_frame
), 1, 1);
627 if (rif
&& rif
->flush_display
)
628 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
631 /* Make minibuffer contents into a string. */
632 Fset_buffer (minibuffer
);
634 val
= Fminibuffer_contents ();
636 val
= Fminibuffer_contents_no_properties ();
638 /* VAL is the string of minibuffer text. */
640 last_minibuf_string
= val
;
642 /* Add the value to the appropriate history list unless it is empty. */
643 if (XSTRING (val
)->size
!= 0
644 && SYMBOLP (Vminibuffer_history_variable
))
646 /* If the caller wanted to save the value read on a history list,
647 then do so if the value is not already the front of the list. */
650 /* If variable is unbound, make it nil. */
651 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
652 Fset (Vminibuffer_history_variable
, Qnil
);
654 histval
= Fsymbol_value (Vminibuffer_history_variable
);
656 /* The value of the history variable must be a cons or nil. Other
657 values are unacceptable. We silently ignore these values. */
660 && NILP (Fequal (last_minibuf_string
, Fcar (histval
)))))
664 histval
= Fcons (last_minibuf_string
, histval
);
665 Fset (Vminibuffer_history_variable
, histval
);
667 /* Truncate if requested. */
668 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
669 if (NILP (length
)) length
= Vhistory_length
;
670 if (INTEGERP (length
))
672 if (XINT (length
) <= 0)
673 Fset (Vminibuffer_history_variable
, Qnil
);
678 temp
= Fnthcdr (Fsub1 (length
), histval
);
679 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
685 /* If Lisp form desired instead of string, parse it. */
687 val
= string_to_object (val
, defalt
);
689 /* The appropriate frame will get selected
690 in set-window-configuration. */
691 RETURN_UNGCPRO (unbind_to (count
, val
));
694 /* Return a buffer to be used as the minibuffer at depth `depth'.
695 depth = 0 is the lowest allowed argument, and that is the value
696 used for nonrecursive minibuffer invocations */
699 get_minibuffer (depth
)
702 Lisp_Object tail
, num
, buf
;
704 extern Lisp_Object
nconc2 ();
706 XSETFASTINT (num
, depth
);
707 tail
= Fnthcdr (num
, Vminibuffer_list
);
710 tail
= Fcons (Qnil
, Qnil
);
711 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
714 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
716 sprintf (name
, " *Minibuf-%d*", depth
);
717 buf
= Fget_buffer_create (build_string (name
));
719 /* Although the buffer's name starts with a space, undo should be
721 Fbuffer_enable_undo (buf
);
727 int count
= specpdl_ptr
- specpdl
;
729 reset_buffer (XBUFFER (buf
));
730 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
732 Fkill_all_local_variables ();
733 unbind_to (count
, Qnil
);
739 /* This function is called on exiting minibuffer, whether normally or
740 not, and it restores the current window, buffer, etc. */
743 read_minibuf_unwind (data
)
746 Lisp_Object old_deactivate_mark
;
749 /* We are exiting the minibuffer one way or the other,
751 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
752 && !NILP (Vrun_hooks
))
753 safe_run_hooks (Qminibuffer_exit_hook
);
755 /* If this was a recursive minibuffer,
756 tie the minibuffer window back to the outer level minibuffer buffer. */
759 window
= minibuf_window
;
760 /* To keep things predictable, in case it matters, let's be in the
761 minibuffer when we reset the relevant variables. */
762 Fset_buffer (XWINDOW (window
)->buffer
);
764 /* Restore prompt, etc, from outer minibuffer level. */
765 minibuf_prompt
= Fcar (minibuf_save_list
);
766 minibuf_save_list
= Fcdr (minibuf_save_list
);
767 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
768 minibuf_save_list
= Fcdr (minibuf_save_list
);
769 Vhelp_form
= Fcar (minibuf_save_list
);
770 minibuf_save_list
= Fcdr (minibuf_save_list
);
771 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
772 minibuf_save_list
= Fcdr (minibuf_save_list
);
773 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
774 minibuf_save_list
= Fcdr (minibuf_save_list
);
775 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
776 minibuf_save_list
= Fcdr (minibuf_save_list
);
777 Voverriding_local_map
= Fcar (minibuf_save_list
);
778 minibuf_save_list
= Fcdr (minibuf_save_list
);
780 temp
= Fcar (minibuf_save_list
);
781 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
782 minibuf_window
= temp
;
784 minibuf_save_list
= Fcdr (minibuf_save_list
);
786 /* Erase the minibuffer we were using at this level. */
788 int count
= specpdl_ptr
- specpdl
;
789 /* Prevent error in erase-buffer. */
790 specbind (Qinhibit_read_only
, Qt
);
791 specbind (Qinhibit_modification_hooks
, Qt
);
792 old_deactivate_mark
= Vdeactivate_mark
;
794 Vdeactivate_mark
= old_deactivate_mark
;
795 unbind_to (count
, Qnil
);
798 /* When we get to the outmost level, make sure we resize the
799 mini-window back to its normal size. */
800 if (minibuf_level
== 0)
801 resize_mini_window (XWINDOW (window
), 0);
803 /* Make sure minibuffer window is erased, not ignored. */
804 windows_or_buffers_changed
++;
805 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
806 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
811 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
812 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
813 If optional second arg INITIAL-CONTENTS is non-nil, it is a string
814 to be inserted into the minibuffer before reading input.
815 If INITIAL-CONTENTS is (STRING . POSITION), the initial input
816 is STRING, but point is placed at position POSITION in the minibuffer.
817 Third arg KEYMAP is a keymap to use whilst reading;
818 if omitted or nil, the default is `minibuffer-local-map'.
819 If fourth arg READ is non-nil, then interpret the result as a Lisp object
820 and return that object:
821 in other words, do `(car (read-from-string INPUT-STRING))'
822 Fifth arg HIST, if non-nil, specifies a history list
823 and optionally the initial position in the list.
824 It can be a symbol, which is the history list variable to use,
825 or it can be a cons cell (HISTVAR . HISTPOS).
826 In that case, HISTVAR is the history list variable to use,
827 and HISTPOS is the initial position (the position in the list
828 which INITIAL-CONTENTS corresponds to).
829 Positions are counted starting from 1 at the beginning of the list.
830 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
831 for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE
832 if the user enters empty input! It returns the empty string.
833 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
834 the current input method and the setting of `enable-multibyte-characters'.
835 If the variable `minibuffer-allow-text-properties' is non-nil,
836 then the string which is returned includes whatever text properties
837 were present in the minibuffer. Otherwise the value has no text properties. */)
838 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
839 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
840 Lisp_Object inherit_input_method
;
843 Lisp_Object histvar
, histpos
, position
, val
;
848 CHECK_STRING (prompt
);
849 if (!NILP (initial_contents
))
851 if (CONSP (initial_contents
))
853 position
= Fcdr (initial_contents
);
854 initial_contents
= Fcar (initial_contents
);
856 CHECK_STRING (initial_contents
);
857 if (!NILP (position
))
859 CHECK_NUMBER (position
);
860 /* Convert to distance from end of input. */
861 if (XINT (position
) < 1)
862 /* A number too small means the beginning of the string. */
863 pos
= - XSTRING (initial_contents
)->size
;
865 pos
= XINT (position
) - 1 - XSTRING (initial_contents
)->size
;
870 keymap
= Vminibuffer_local_map
;
872 keymap
= get_keymap (keymap
, 1, 0);
881 histvar
= Fcar_safe (hist
);
882 histpos
= Fcdr_safe (hist
);
885 histvar
= Qminibuffer_history
;
887 XSETFASTINT (histpos
, 0);
889 GCPRO1 (default_value
);
890 val
= read_minibuf (keymap
, initial_contents
, prompt
,
891 make_number (pos
), !NILP (read
),
892 histvar
, histpos
, default_value
,
893 minibuffer_allow_text_properties
,
894 !NILP (inherit_input_method
));
899 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
900 doc
: /* Return a Lisp object read using the minibuffer.
901 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
902 is a string to insert in the minibuffer before reading. */)
903 (prompt
, initial_contents
)
904 Lisp_Object prompt
, initial_contents
;
906 CHECK_STRING (prompt
);
907 if (!NILP (initial_contents
))
908 CHECK_STRING (initial_contents
);
909 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
910 prompt
, Qnil
, 1, Qminibuffer_history
,
911 make_number (0), Qnil
, 0, 0);
914 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
915 doc
: /* Return value of Lisp expression read using the minibuffer.
916 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
917 is a string to insert in the minibuffer before reading. */)
918 (prompt
, initial_contents
)
919 Lisp_Object prompt
, initial_contents
;
921 return Feval (Fread_minibuffer (prompt
, initial_contents
));
924 /* Functions that use the minibuffer to read various things. */
926 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
927 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
928 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
929 The third arg HISTORY, if non-nil, specifies a history list
930 and optionally the initial position in the list.
931 See `read-from-minibuffer' for details of HISTORY argument.
932 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
933 for history commands, and as the value to return if the user enters
935 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
936 the current input method and the setting of `enable-multibyte-characters'. */)
937 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
938 Lisp_Object prompt
, initial_input
, history
, default_value
;
939 Lisp_Object inherit_input_method
;
942 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
943 Qnil
, history
, default_value
,
944 inherit_input_method
);
945 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (default_value
))
950 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
951 doc
: /* Read a string from the terminal, not allowing blanks.
952 Prompt with PROMPT, and provide INITIAL as an initial value of the input string.
953 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
954 the current input method and the setting of `enable-multibyte-characters'. */)
955 (prompt
, initial
, inherit_input_method
)
956 Lisp_Object prompt
, initial
, inherit_input_method
;
958 CHECK_STRING (prompt
);
959 if (! NILP (initial
))
960 CHECK_STRING (initial
);
962 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
963 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
964 !NILP (inherit_input_method
));
967 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
968 doc
: /* Read the name of a command and return as a symbol.
969 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
970 (prompt
, default_value
)
971 Lisp_Object prompt
, default_value
;
973 Lisp_Object name
, default_string
;
975 if (NILP (default_value
))
976 default_string
= Qnil
;
977 else if (SYMBOLP (default_value
))
978 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
980 default_string
= default_value
;
982 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
983 Qnil
, Qnil
, default_string
, Qnil
);
986 return Fintern (name
, Qnil
);
990 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
991 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
992 Prompt with PROMPT. */)
996 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1001 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1002 doc
: /* Read the name of a user variable and return it as a symbol.
1003 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1004 A user variable is one whose documentation starts with a `*' character. */)
1005 (prompt
, default_value
)
1006 Lisp_Object prompt
, default_value
;
1008 Lisp_Object name
, default_string
;
1010 if (NILP (default_value
))
1011 default_string
= Qnil
;
1012 else if (SYMBOLP (default_value
))
1013 XSETSTRING (default_string
, XSYMBOL (default_value
)->name
);
1015 default_string
= default_value
;
1017 name
= Fcompleting_read (prompt
, Vobarray
,
1018 Quser_variable_p
, Qt
,
1019 Qnil
, Qnil
, default_string
, Qnil
);
1022 return Fintern (name
, Qnil
);
1025 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1026 doc
: /* Read the name of a buffer and return as a string.
1028 Optional second arg DEF is value to return if user enters an empty line.
1029 If optional third arg REQUIRE-MATCH is non-nil,
1030 only existing buffer names are allowed. */)
1031 (prompt
, def
, require_match
)
1032 Lisp_Object prompt
, def
, require_match
;
1034 Lisp_Object args
[4];
1037 def
= XBUFFER (def
)->name
;
1039 if (NILP (Vread_buffer_function
))
1043 args
[0] = build_string ("%s(default %s) ");
1046 prompt
= Fformat (3, args
);
1049 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1050 require_match
, Qnil
, Qbuffer_name_history
,
1055 args
[0] = Vread_buffer_function
;
1058 args
[3] = require_match
;
1059 return Ffuncall(4, args
);
1064 minibuf_conform_representation (string
, basis
)
1065 Lisp_Object string
, basis
;
1067 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1070 if (STRING_MULTIBYTE (string
))
1071 return Fstring_make_unibyte (string
);
1073 return Fstring_make_multibyte (string
);
1076 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1077 doc
: /* Return common substring of all completions of STRING in ALIST.
1078 Each car of each element of ALIST is tested to see if it begins with STRING.
1079 All that match are compared together; the longest initial sequence
1080 common to all matches is returned as a string.
1081 If there is no match at all, nil is returned.
1082 For a unique match which is exact, t is returned.
1084 ALIST can be an obarray instead of an alist.
1085 Then the print names of all symbols in the obarray are the possible matches.
1087 ALIST can also be a function to do the completion itself.
1088 It receives three arguments: the values STRING, PREDICATE and nil.
1089 Whatever it returns becomes the value of `try-completion'.
1091 If optional third argument PREDICATE is non-nil,
1092 it is used to test each possible match.
1093 The match is a candidate only if PREDICATE returns non-nil.
1094 The argument given to PREDICATE is the alist element
1095 or the symbol from the obarray.
1096 Additionally to this predicate, `completion-regexp-list'
1097 is used to further constrain the set of candidates. */)
1098 (string
, alist
, predicate
)
1099 Lisp_Object string
, alist
, predicate
;
1101 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1102 /* Size in bytes of BESTMATCH. */
1103 int bestmatchsize
= 0;
1104 /* These are in bytes, too. */
1105 int compare
, matchsize
;
1106 int list
= NILP (alist
) || (CONSP (alist
)
1107 && (!SYMBOLP (XCAR (alist
))
1108 || NILP (XCAR (alist
))));
1109 int index
= 0, obsize
= 0;
1111 Lisp_Object bucket
, zero
, end
, tem
;
1112 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1114 CHECK_STRING (string
);
1115 if (!list
&& !VECTORP (alist
))
1116 return call3 (alist
, string
, predicate
, Qnil
);
1118 bestmatch
= bucket
= Qnil
;
1120 /* If ALIST is not a list, set TAIL just for gc pro. */
1125 obsize
= XVECTOR (alist
)->size
;
1126 bucket
= XVECTOR (alist
)->contents
[index
];
1131 /* Get the next element of the alist or obarray. */
1132 /* Exit the loop if the elements are all used up. */
1133 /* elt gets the alist element or symbol.
1134 eltstring gets the name to check as a completion. */
1141 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1146 if (XFASTINT (bucket
) != 0)
1149 eltstring
= Fsymbol_name (elt
);
1150 if (XSYMBOL (bucket
)->next
)
1151 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1153 XSETFASTINT (bucket
, 0);
1155 else if (++index
>= obsize
)
1159 bucket
= XVECTOR (alist
)->contents
[index
];
1164 /* Is this element a possible completion? */
1166 if (STRINGP (eltstring
)
1167 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1168 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1169 make_number (XSTRING (string
)->size
),
1170 string
, make_number (0), Qnil
,
1171 completion_ignore_case
?Qt
: Qnil
),
1175 Lisp_Object regexps
;
1177 XSETFASTINT (zero
, 0);
1179 /* Ignore this element if it fails to match all the regexps. */
1180 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1181 regexps
= XCDR (regexps
))
1183 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1187 if (CONSP (regexps
))
1190 /* Ignore this element if there is a predicate
1191 and the predicate doesn't like it. */
1193 if (!NILP (predicate
))
1195 if (EQ (predicate
, Qcommandp
))
1196 tem
= Fcommandp (elt
, Qnil
);
1199 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1200 tem
= call1 (predicate
, elt
);
1203 if (NILP (tem
)) continue;
1206 /* Update computation of how much all possible completions match */
1209 if (NILP (bestmatch
))
1211 bestmatch
= eltstring
;
1212 bestmatchsize
= XSTRING (eltstring
)->size
;
1216 compare
= min (bestmatchsize
, XSTRING (eltstring
)->size
);
1217 tem
= Fcompare_strings (bestmatch
, make_number (0),
1218 make_number (compare
),
1219 eltstring
, make_number (0),
1220 make_number (compare
),
1221 completion_ignore_case
? Qt
: Qnil
);
1223 matchsize
= compare
;
1224 else if (XINT (tem
) < 0)
1225 matchsize
= - XINT (tem
) - 1;
1227 matchsize
= XINT (tem
) - 1;
1230 /* When can this happen ? -stef */
1231 matchsize
= compare
;
1232 if (completion_ignore_case
)
1234 /* If this is an exact match except for case,
1235 use it as the best match rather than one that is not an
1236 exact match. This way, we get the case pattern
1237 of the actual match. */
1238 if ((matchsize
== XSTRING (eltstring
)->size
1239 && matchsize
< XSTRING (bestmatch
)->size
)
1241 /* If there is more than one exact match ignoring case,
1242 and one of them is exact including case,
1244 /* If there is no exact match ignoring case,
1245 prefer a match that does not change the case
1247 ((matchsize
== XSTRING (eltstring
)->size
)
1249 (matchsize
== XSTRING (bestmatch
)->size
)
1250 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1251 make_number (XSTRING (string
)->size
),
1252 string
, make_number (0),
1256 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1257 make_number (XSTRING (string
)->size
),
1258 string
, make_number (0),
1262 bestmatch
= eltstring
;
1264 bestmatchsize
= matchsize
;
1265 if (matchsize
<= XSTRING (string
)->size
1267 /* No need to look any further. */
1273 if (NILP (bestmatch
))
1274 return Qnil
; /* No completions found */
1275 /* If we are ignoring case, and there is no exact match,
1276 and no additional text was supplied,
1277 don't change the case of what the user typed. */
1278 if (completion_ignore_case
&& bestmatchsize
== XSTRING (string
)->size
1279 && XSTRING (bestmatch
)->size
> bestmatchsize
)
1280 return minibuf_conform_representation (string
, bestmatch
);
1282 /* Return t if the supplied string is an exact match (counting case);
1283 it does not require any change to be made. */
1284 if (matchcount
== 1 && bestmatchsize
== XSTRING (string
)->size
1285 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1286 make_number (bestmatchsize
),
1287 string
, make_number (0),
1288 make_number (bestmatchsize
),
1293 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1294 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1295 return Fsubstring (bestmatch
, zero
, end
);
1298 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1299 doc
: /* Search for partial matches to STRING in ALIST.
1300 Each car of each element of ALIST is tested to see if it begins with STRING.
1301 The value is a list of all the strings from ALIST that match.
1303 ALIST can be an obarray instead of an alist.
1304 Then the print names of all symbols in the obarray are the possible matches.
1306 ALIST can also be a function to do the completion itself.
1307 It receives three arguments: the values STRING, PREDICATE and t.
1308 Whatever it returns becomes the value of `all-completions'.
1310 If optional third argument PREDICATE is non-nil,
1311 it is used to test each possible match.
1312 The match is a candidate only if PREDICATE returns non-nil.
1313 The argument given to PREDICATE is the alist element
1314 or the symbol from the obarray.
1315 Additionally to this predicate, `completion-regexp-list'
1316 is used to further constrain the set of candidates.
1318 If the optional fourth argument HIDE-SPACES is non-nil,
1319 strings in ALIST that start with a space
1320 are ignored unless STRING itself starts with a space. */)
1321 (string
, alist
, predicate
, hide_spaces
)
1322 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1324 Lisp_Object tail
, elt
, eltstring
;
1325 Lisp_Object allmatches
;
1326 int list
= NILP (alist
) || (CONSP (alist
)
1327 && (!SYMBOLP (XCAR (alist
))
1328 || NILP (XCAR (alist
))));
1329 int index
= 0, obsize
= 0;
1330 Lisp_Object bucket
, tem
;
1331 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1333 CHECK_STRING (string
);
1334 if (!list
&& !VECTORP (alist
))
1336 return call3 (alist
, string
, predicate
, Qt
);
1338 allmatches
= bucket
= Qnil
;
1340 /* If ALIST is not a list, set TAIL just for gc pro. */
1345 obsize
= XVECTOR (alist
)->size
;
1346 bucket
= XVECTOR (alist
)->contents
[index
];
1351 /* Get the next element of the alist or obarray. */
1352 /* Exit the loop if the elements are all used up. */
1353 /* elt gets the alist element or symbol.
1354 eltstring gets the name to check as a completion. */
1361 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1366 if (XFASTINT (bucket
) != 0)
1369 eltstring
= Fsymbol_name (elt
);
1370 if (XSYMBOL (bucket
)->next
)
1371 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1373 XSETFASTINT (bucket
, 0);
1375 else if (++index
>= obsize
)
1379 bucket
= XVECTOR (alist
)->contents
[index
];
1384 /* Is this element a possible completion? */
1386 if (STRINGP (eltstring
)
1387 && XSTRING (string
)->size
<= XSTRING (eltstring
)->size
1388 /* If HIDE_SPACES, reject alternatives that start with space
1389 unless the input starts with space. */
1390 && ((STRING_BYTES (XSTRING (string
)) > 0
1391 && XSTRING (string
)->data
[0] == ' ')
1392 || XSTRING (eltstring
)->data
[0] != ' '
1393 || NILP (hide_spaces
))
1394 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1395 make_number (XSTRING (string
)->size
),
1396 string
, make_number (0),
1397 make_number (XSTRING (string
)->size
),
1398 completion_ignore_case
? Qt
: Qnil
),
1402 Lisp_Object regexps
;
1404 XSETFASTINT (zero
, 0);
1406 /* Ignore this element if it fails to match all the regexps. */
1407 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1408 regexps
= XCDR (regexps
))
1410 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1414 if (CONSP (regexps
))
1417 /* Ignore this element if there is a predicate
1418 and the predicate doesn't like it. */
1420 if (!NILP (predicate
))
1422 if (EQ (predicate
, Qcommandp
))
1423 tem
= Fcommandp (elt
, Qnil
);
1426 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1427 tem
= call1 (predicate
, elt
);
1430 if (NILP (tem
)) continue;
1432 /* Ok => put it on the list. */
1433 allmatches
= Fcons (eltstring
, allmatches
);
1437 return Fnreverse (allmatches
);
1440 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1441 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1442 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1443 Lisp_Object Vminibuffer_completing_file_name
;
1445 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1446 doc
: /* Read a string in the minibuffer, with completion.
1447 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1448 TABLE is an alist whose elements' cars are strings, or an obarray.
1449 TABLE can also be a function to do the completion itself.
1450 PREDICATE limits completion to a subset of TABLE.
1451 See `try-completion' and `all-completions' for more details
1452 on completion, TABLE, and PREDICATE.
1454 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1455 the input is (or completes to) an element of TABLE or is null.
1456 If it is also not t, typing RET does not exit if it does non-null completion.
1457 If the input is null, `completing-read' returns an empty string,
1458 regardless of the value of REQUIRE-MATCH.
1460 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
1461 If it is (STRING . POSITION), the initial input
1462 is STRING, but point is placed POSITION characters into the string.
1463 This feature is deprecated--it is best to pass nil for INITIAL-INPUT
1464 and supply the default value DEF instead. The user can yank the
1465 default value into the minibuffer easily using \\[next-history-element].
1467 HIST, if non-nil, specifies a history list
1468 and optionally the initial position in the list.
1469 It can be a symbol, which is the history list variable to use,
1470 or it can be a cons cell (HISTVAR . HISTPOS).
1471 In that case, HISTVAR is the history list variable to use,
1472 and HISTPOS is the initial position (the position in the list
1473 which INITIAL-INPUT corresponds to).
1474 Positions are counted starting from 1 at the beginning of the list.
1475 DEF, if non-nil, is the default value.
1477 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1478 the current input method and the setting of `enable-multibyte-characters'.
1480 Completion ignores case if the ambient value of
1481 `completion-ignore-case' is non-nil. */)
1482 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1483 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1484 Lisp_Object hist
, def
, inherit_input_method
;
1486 Lisp_Object val
, histvar
, histpos
, position
;
1489 int count
= specpdl_ptr
- specpdl
;
1490 struct gcpro gcpro1
;
1492 init
= initial_input
;
1495 specbind (Qminibuffer_completion_table
, table
);
1496 specbind (Qminibuffer_completion_predicate
, predicate
);
1497 specbind (Qminibuffer_completion_confirm
,
1498 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1499 last_exact_completion
= Qnil
;
1506 position
= Fcdr (init
);
1509 CHECK_STRING (init
);
1510 if (!NILP (position
))
1512 CHECK_NUMBER (position
);
1513 /* Convert to distance from end of input. */
1514 pos
= XINT (position
) - XSTRING (init
)->size
;
1525 histvar
= Fcar_safe (hist
);
1526 histpos
= Fcdr_safe (hist
);
1529 histvar
= Qminibuffer_history
;
1531 XSETFASTINT (histpos
, 0);
1533 val
= read_minibuf (NILP (require_match
)
1534 ? Vminibuffer_local_completion_map
1535 : Vminibuffer_local_must_match_map
,
1536 init
, prompt
, make_number (pos
), 0,
1537 histvar
, histpos
, def
, 0,
1538 !NILP (inherit_input_method
));
1540 if (STRINGP (val
) && XSTRING (val
)->size
== 0 && ! NILP (def
))
1543 RETURN_UNGCPRO (unbind_to (count
, val
));
1546 Lisp_Object
Fminibuffer_completion_help ();
1547 Lisp_Object
Fassoc_string ();
1549 /* Test whether TXT is an exact completion. */
1550 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1551 doc
: /* Return non-nil if STRING is a valid completion.
1552 Takes the same arguments as `all-completions' and `try-completion'.
1553 If ALIST is a function, it is called with three arguments:
1554 the values STRING, PREDICATE and `lambda'. */)
1555 (string
, alist
, predicate
)
1556 Lisp_Object string
, alist
, predicate
;
1558 Lisp_Object regexps
, tem
= Qnil
;
1560 CHECK_STRING (string
);
1562 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1565 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1571 else if (VECTORP (alist
))
1573 /* Bypass intern-soft as that loses for nil. */
1574 tem
= oblookup (alist
,
1575 XSTRING (string
)->data
,
1576 XSTRING (string
)->size
,
1577 STRING_BYTES (XSTRING (string
)));
1580 if (STRING_MULTIBYTE (string
))
1581 string
= Fstring_make_unibyte (string
);
1583 string
= Fstring_make_multibyte (string
);
1585 tem
= oblookup (Vminibuffer_completion_table
,
1586 XSTRING (string
)->data
,
1587 XSTRING (string
)->size
,
1588 STRING_BYTES (XSTRING (string
)));
1594 return call3 (alist
, string
, predicate
, Qlambda
);
1596 /* Reject this element if it fails to match all the regexps. */
1597 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1598 regexps
= XCDR (regexps
))
1600 if (NILP (Fstring_match (XCAR (regexps
),
1601 SYMBOLP (tem
) ? string
: tem
,
1606 /* Finally, check the predicate. */
1607 if (!NILP (predicate
))
1608 return call1 (predicate
, tem
);
1614 * 0 no possible completion
1615 * 1 was already an exact and unique completion
1616 * 3 was already an exact completion
1617 * 4 completed to an exact completion
1618 * 5 some completion happened
1619 * 6 no completion happened
1624 Lisp_Object completion
, string
, tem
;
1627 struct gcpro gcpro1
, gcpro2
;
1629 completion
= Ftry_completion (Fminibuffer_contents (),
1630 Vminibuffer_completion_table
,
1631 Vminibuffer_completion_predicate
);
1632 last
= last_exact_completion
;
1633 last_exact_completion
= Qnil
;
1635 GCPRO2 (completion
, last
);
1637 if (NILP (completion
))
1640 temp_echo_area_glyphs (" [No match]");
1645 if (EQ (completion
, Qt
)) /* exact and unique match */
1651 string
= Fminibuffer_contents ();
1653 /* COMPLETEDP should be true if some completion was done, which
1654 doesn't include simply changing the case of the entered string.
1655 However, for appearance, the string is rewritten if the case
1657 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1658 completedp
= !EQ (tem
, Qt
);
1660 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1662 /* Rewrite the user's input. */
1664 Fdelete_minibuffer_contents (); /* Some completion happened */
1665 Finsert (1, &completion
);
1668 /* The case of the string changed, but that's all. We're not
1669 sure whether this is a unique completion or not, so try again
1670 using the real case (this shouldn't recurse again, because
1671 the next time try-completion will return either `t' or the
1675 return do_completion ();
1679 /* It did find a match. Do we match some possibility exactly now? */
1680 tem
= Ftest_completion (Fminibuffer_contents (),
1681 Vminibuffer_completion_table
,
1682 Vminibuffer_completion_predicate
);
1685 /* not an exact match */
1689 else if (!NILP (Vcompletion_auto_help
))
1690 Fminibuffer_completion_help ();
1692 temp_echo_area_glyphs (" [Next char not unique]");
1695 else if (completedp
)
1700 /* If the last exact completion and this one were the same,
1701 it means we've already given a "Complete but not unique"
1702 message and the user's hit TAB again, so now we give him help. */
1703 last_exact_completion
= completion
;
1706 tem
= Fminibuffer_contents ();
1707 if (!NILP (Fequal (tem
, last
)))
1708 Fminibuffer_completion_help ();
1714 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1716 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1717 doc
: /* Like `assoc' but specifically for strings.
1718 Unibyte strings are converted to multibyte for comparison.
1719 And case is ignored if CASE-FOLD is non-nil.
1720 As opposed to `assoc', it will also match an entry consisting of a single
1721 string rather than a cons cell whose car is a string. */)
1722 (key
, list
, case_fold
)
1723 register Lisp_Object key
;
1724 Lisp_Object list
, case_fold
;
1726 register Lisp_Object tail
;
1728 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1730 register Lisp_Object elt
, tem
, thiscar
;
1732 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1733 if (!STRINGP (thiscar
))
1735 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1736 key
, make_number (0), Qnil
,
1745 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1746 doc
: /* Complete the minibuffer contents as far as possible.
1747 Return nil if there is no valid completion, else t.
1748 If no characters can be completed, display a list of possible completions.
1749 If you repeat this command after it displayed such a list,
1750 scroll the window of possible completions. */)
1754 Lisp_Object window
, tem
;
1756 /* If the previous command was not this,
1757 mark the completion buffer obsolete. */
1758 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1759 Vminibuf_scroll_window
= Qnil
;
1761 window
= Vminibuf_scroll_window
;
1762 /* If there's a fresh completion window with a live buffer,
1763 and this command is repeated, scroll that window. */
1764 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1765 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1767 struct buffer
*obuf
= current_buffer
;
1769 Fset_buffer (XWINDOW (window
)->buffer
);
1770 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1772 /* If end is in view, scroll up to the beginning. */
1773 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1775 /* Else scroll down one screen. */
1776 Fscroll_other_window (Qnil
);
1778 set_buffer_internal (obuf
);
1782 i
= do_completion ();
1790 Fgoto_char (make_number (ZV
));
1791 temp_echo_area_glyphs (" [Sole completion]");
1796 Fgoto_char (make_number (ZV
));
1797 temp_echo_area_glyphs (" [Complete, but not unique]");
1804 /* Subroutines of Fminibuffer_complete_and_exit. */
1806 /* This one is called by internal_condition_case to do the real work. */
1809 complete_and_exit_1 ()
1811 return make_number (do_completion ());
1814 /* This one is called by internal_condition_case if an error happens.
1815 Pretend the current value is an exact match. */
1818 complete_and_exit_2 (ignore
)
1821 return make_number (1);
1824 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1825 Sminibuffer_complete_and_exit
, 0, 0, "",
1826 doc
: /* If the minibuffer contents is a valid completion then exit.
1827 Otherwise try to complete it. If completion leads to a valid completion,
1828 a repetition of this command will exit. */)
1834 /* Allow user to specify null string */
1835 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
1838 if (!NILP (Ftest_completion (Fminibuffer_contents (),
1839 Vminibuffer_completion_table
,
1840 Vminibuffer_completion_predicate
)))
1843 /* Call do_completion, but ignore errors. */
1844 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
1845 complete_and_exit_2
);
1855 if (!NILP (Vminibuffer_completion_confirm
))
1857 temp_echo_area_glyphs (" [Confirm]");
1867 return Fthrow (Qexit
, Qnil
);
1871 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1873 doc
: /* Complete the minibuffer contents at most a single word.
1874 After one word is completed as much as possible, a space or hyphen
1875 is added, provided that matches some possible completion.
1876 Return nil if there is no valid completion, else t. */)
1879 Lisp_Object completion
, tem
, tem1
;
1880 register int i
, i_byte
;
1881 register unsigned char *completion_string
;
1882 struct gcpro gcpro1
, gcpro2
;
1883 int prompt_end_charpos
;
1885 /* We keep calling Fbuffer_string rather than arrange for GC to
1886 hold onto a pointer to one of the strings thus made. */
1888 completion
= Ftry_completion (Fminibuffer_contents (),
1889 Vminibuffer_completion_table
,
1890 Vminibuffer_completion_predicate
);
1891 if (NILP (completion
))
1894 temp_echo_area_glyphs (" [No match]");
1897 if (EQ (completion
, Qt
))
1900 #if 0 /* How the below code used to look, for reference. */
1901 tem
= Fminibuffer_contents ();
1902 b
= XSTRING (tem
)->data
;
1903 i
= ZV
- 1 - XSTRING (completion
)->size
;
1904 p
= XSTRING (completion
)->data
;
1906 0 <= scmp (b
, p
, ZV
- 1))
1909 /* Set buffer to longest match of buffer tail and completion head. */
1910 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1912 del_range (1, i
+ 1);
1915 #else /* Rewritten code */
1917 int buffer_nchars
, completion_nchars
;
1919 CHECK_STRING (completion
);
1920 tem
= Fminibuffer_contents ();
1921 GCPRO2 (completion
, tem
);
1922 /* If reading a file name,
1923 expand any $ENVVAR refs in the buffer and in TEM. */
1924 if (! NILP (Vminibuffer_completing_file_name
))
1926 Lisp_Object substituted
;
1927 substituted
= Fsubstitute_in_file_name (tem
);
1928 if (! EQ (substituted
, tem
))
1931 Fdelete_minibuffer_contents ();
1932 insert_from_string (tem
, 0, 0, XSTRING (tem
)->size
,
1933 STRING_BYTES (XSTRING (tem
)), 0);
1936 buffer_nchars
= XSTRING (tem
)->size
; /* ie ZV - BEGV */
1937 completion_nchars
= XSTRING (completion
)->size
;
1938 i
= buffer_nchars
- completion_nchars
;
1941 (tem1
= Fcompare_strings (tem
, make_number (0),
1942 make_number (buffer_nchars
),
1943 completion
, make_number (0),
1944 make_number (buffer_nchars
),
1945 completion_ignore_case
? Qt
: Qnil
),
1950 /* Set buffer to longest match of buffer tail and completion head. */
1956 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
1957 completion
, make_number (0),
1958 make_number (buffer_nchars
),
1959 completion_ignore_case
? Qt
: Qnil
);
1966 del_range (1, i
+ 1);
1967 SET_PT_BOTH (ZV
, ZV_BYTE
);
1971 #endif /* Rewritten code */
1973 prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
1976 int prompt_end_bytepos
;
1977 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
1978 i
= ZV
- prompt_end_charpos
;
1979 i_byte
= ZV_BYTE
- prompt_end_bytepos
;
1982 /* If completion finds next char not unique,
1983 consider adding a space or a hyphen. */
1984 if (i
== XSTRING (completion
)->size
)
1986 GCPRO1 (completion
);
1987 tem
= Ftry_completion (concat2 (Fminibuffer_contents (), build_string (" ")),
1988 Vminibuffer_completion_table
,
1989 Vminibuffer_completion_predicate
);
1996 GCPRO1 (completion
);
1998 Ftry_completion (concat2 (Fminibuffer_contents (), build_string ("-")),
1999 Vminibuffer_completion_table
,
2000 Vminibuffer_completion_predicate
);
2008 /* Now find first word-break in the stuff found by completion.
2009 i gets index in string of where to stop completing. */
2012 int bytes
= STRING_BYTES (XSTRING (completion
));
2013 completion_string
= XSTRING (completion
)->data
;
2014 for (; i_byte
< STRING_BYTES (XSTRING (completion
)); i_byte
+= len
, i
++)
2016 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2019 if (SYNTAX (c
) != Sword
)
2028 /* If got no characters, print help for user. */
2030 if (i
== ZV
- prompt_end_charpos
)
2032 if (!NILP (Vcompletion_auto_help
))
2033 Fminibuffer_completion_help ();
2037 /* Otherwise insert in minibuffer the chars we got */
2039 Fdelete_minibuffer_contents ();
2040 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2044 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2046 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2047 Each element may be just a symbol or string
2048 or may be a list of two strings to be printed as if concatenated.
2049 `standard-output' must be a buffer.
2050 The actual completion alternatives, as inserted, are given `mouse-face'
2051 properties of `highlight'.
2052 At the end, this runs the normal hook `completion-setup-hook'.
2053 It can find the completion buffer in `standard-output'. */)
2055 Lisp_Object completions
;
2057 Lisp_Object tail
, elt
;
2060 struct gcpro gcpro1
, gcpro2
;
2061 struct buffer
*old
= current_buffer
;
2064 /* Note that (when it matters) every variable
2065 points to a non-string that is pointed to by COMPLETIONS,
2066 except for ELT. ELT can be pointing to a string
2067 when terpri or Findent_to calls a change hook. */
2069 GCPRO2 (completions
, elt
);
2071 if (BUFFERP (Vstandard_output
))
2072 set_buffer_internal (XBUFFER (Vstandard_output
));
2074 if (NILP (completions
))
2075 write_string ("There are no possible completions of what you have typed.",
2079 write_string ("Possible completions are:", -1);
2080 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2082 Lisp_Object tem
, string
;
2084 Lisp_Object startpos
, endpos
;
2089 /* Compute the length of this element. */
2094 length
= XSTRING (tem
)->size
;
2096 tem
= Fcar (XCDR (elt
));
2098 length
+= XSTRING (tem
)->size
;
2103 length
= XSTRING (elt
)->size
;
2106 /* This does a bad job for narrower than usual windows.
2107 Sadly, the window it will appear in is not known
2108 until after the text has been made. */
2110 if (BUFFERP (Vstandard_output
))
2111 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2113 /* If the previous completion was very wide,
2114 or we have two on this line already,
2115 don't put another on the same line. */
2116 if (column
> 33 || first
2117 /* If this is really wide, don't put it second on a line. */
2118 || (column
> 0 && length
> 45))
2123 /* Otherwise advance to column 35. */
2126 if (BUFFERP (Vstandard_output
))
2128 tem
= Findent_to (make_number (35), make_number (2));
2130 column
= XINT (tem
);
2136 write_string (" ", -1);
2139 while (column
< 35);
2143 if (BUFFERP (Vstandard_output
))
2145 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2146 Fset_text_properties (startpos
, endpos
,
2147 Qnil
, Vstandard_output
);
2150 /* Output this element.
2151 If necessary, convert it to unibyte or to multibyte first. */
2153 string
= Fcar (elt
);
2156 if (NILP (current_buffer
->enable_multibyte_characters
)
2157 && STRING_MULTIBYTE (string
))
2158 string
= Fstring_make_unibyte (string
);
2159 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2160 && !STRING_MULTIBYTE (string
))
2161 string
= Fstring_make_multibyte (string
);
2163 if (BUFFERP (Vstandard_output
))
2165 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2167 Fprinc (string
, Qnil
);
2169 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2171 Fput_text_property (startpos
, endpos
,
2172 Qmouse_face
, intern ("highlight"),
2177 Fprinc (string
, Qnil
);
2180 /* Output the annotation for this element. */
2183 if (BUFFERP (Vstandard_output
))
2185 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2187 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2189 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2191 Fset_text_properties (startpos
, endpos
, Qnil
,
2196 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2201 /* Update COLUMN for what we have output. */
2204 /* If output is to a buffer, recompute COLUMN in a way
2205 that takes account of character widths. */
2206 if (BUFFERP (Vstandard_output
))
2208 tem
= Fcurrent_column ();
2209 column
= XINT (tem
);
2218 if (BUFFERP (Vstandard_output
))
2219 set_buffer_internal (old
);
2221 if (!NILP (Vrun_hooks
))
2222 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2227 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2229 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2232 Lisp_Object completions
;
2234 message ("Making completion list...");
2235 completions
= Fall_completions (Fminibuffer_contents (),
2236 Vminibuffer_completion_table
,
2237 Vminibuffer_completion_predicate
,
2239 clear_message (1, 0);
2241 if (NILP (completions
))
2244 temp_echo_area_glyphs (" [No completions]");
2247 internal_with_output_to_temp_buffer ("*Completions*",
2248 Fdisplay_completion_list
,
2249 Fsort (completions
, Qstring_lessp
));
2253 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2254 doc
: /* Terminate minibuffer input. */)
2257 if (INTEGERP (last_command_char
))
2258 internal_self_insert (XINT (last_command_char
), 0);
2262 return Fthrow (Qexit
, Qnil
);
2265 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2266 doc
: /* Terminate this minibuffer argument. */)
2269 return Fthrow (Qexit
, Qnil
);
2272 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2273 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2276 return make_number (minibuf_level
);
2279 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2280 doc
: /* Return the prompt string of the currently-active minibuffer.
2281 If no minibuffer is active, return nil. */)
2284 return Fcopy_sequence (minibuf_prompt
);
2288 /* Temporarily display the string M at the end of the current
2289 minibuffer contents. This is used to display things like
2290 "[No Match]" when the user requests a completion for a prefix
2291 that has no possible completions, and other quick, unobtrusive
2295 temp_echo_area_glyphs (m
)
2299 int osize_byte
= ZV_BYTE
;
2301 int opoint_byte
= PT_BYTE
;
2302 Lisp_Object oinhibit
;
2303 oinhibit
= Vinhibit_quit
;
2305 /* Clear out any old echo-area message to make way for our new thing. */
2308 SET_PT_BOTH (osize
, osize_byte
);
2310 SET_PT_BOTH (opoint
, opoint_byte
);
2312 Fsit_for (make_number (2), Qnil
, Qnil
);
2313 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2314 SET_PT_BOTH (opoint
, opoint_byte
);
2315 if (!NILP (Vquit_flag
))
2318 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2320 Vinhibit_quit
= oinhibit
;
2323 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2325 doc
: /* Temporarily display STRING at the end of the minibuffer.
2326 The text is displayed for two seconds,
2327 or until the next input event arrives, whichever comes first. */)
2331 temp_echo_area_glyphs (XSTRING (string
)->data
);
2336 init_minibuf_once ()
2338 Vminibuffer_list
= Qnil
;
2339 staticpro (&Vminibuffer_list
);
2346 minibuf_prompt
= Qnil
;
2347 staticpro (&minibuf_prompt
);
2349 minibuf_save_list
= Qnil
;
2350 staticpro (&minibuf_save_list
);
2352 Qread_file_name_internal
= intern ("read-file-name-internal");
2353 staticpro (&Qread_file_name_internal
);
2355 Qminibuffer_default
= intern ("minibuffer-default");
2356 staticpro (&Qminibuffer_default
);
2357 Fset (Qminibuffer_default
, Qnil
);
2359 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2360 staticpro (&Qminibuffer_completion_table
);
2362 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2363 staticpro (&Qminibuffer_completion_confirm
);
2365 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2366 staticpro (&Qminibuffer_completion_predicate
);
2368 staticpro (&last_exact_completion
);
2369 last_exact_completion
= Qnil
;
2371 staticpro (&last_minibuf_string
);
2372 last_minibuf_string
= Qnil
;
2374 Quser_variable_p
= intern ("user-variable-p");
2375 staticpro (&Quser_variable_p
);
2377 Qminibuffer_history
= intern ("minibuffer-history");
2378 staticpro (&Qminibuffer_history
);
2380 Qbuffer_name_history
= intern ("buffer-name-history");
2381 staticpro (&Qbuffer_name_history
);
2382 Fset (Qbuffer_name_history
, Qnil
);
2384 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2385 staticpro (&Qminibuffer_setup_hook
);
2387 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2388 staticpro (&Qminibuffer_exit_hook
);
2390 Qhistory_length
= intern ("history-length");
2391 staticpro (&Qhistory_length
);
2393 Qcurrent_input_method
= intern ("current-input-method");
2394 staticpro (&Qcurrent_input_method
);
2396 Qactivate_input_method
= intern ("activate-input-method");
2397 staticpro (&Qactivate_input_method
);
2399 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2400 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2401 Vread_buffer_function
= Qnil
;
2403 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2404 doc
: /* Normal hook run just after entry to minibuffer. */);
2405 Vminibuffer_setup_hook
= Qnil
;
2407 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2408 doc
: /* Normal hook run just after exit from minibuffer. */);
2409 Vminibuffer_exit_hook
= Qnil
;
2411 DEFVAR_LISP ("history-length", &Vhistory_length
,
2412 doc
: /* *Maximum length for history lists before truncation takes place.
2413 A number means that length; t means infinite. Truncation takes place
2414 just after a new element is inserted. Setting the history-length
2415 property of a history variable overrides this default. */);
2416 XSETFASTINT (Vhistory_length
, 30);
2418 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2419 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2420 Vcompletion_auto_help
= Qt
;
2422 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2423 doc
: /* Non-nil means don't consider case significant in completion. */);
2424 completion_ignore_case
= 0;
2426 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2427 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2428 This variable makes a difference whenever the minibuffer window is active. */);
2429 enable_recursive_minibuffers
= 0;
2431 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2432 doc
: /* Alist or obarray used for completion in the minibuffer.
2433 This becomes the ALIST argument to `try-completion' and `all-completion'.
2435 The value may alternatively be a function, which is given three arguments:
2436 STRING, the current buffer contents;
2437 PREDICATE, the predicate for filtering possible matches;
2438 CODE, which says what kind of things to do.
2439 CODE can be nil, t or `lambda'.
2440 nil means to return the best completion of STRING, or nil if there is none.
2441 t means to return a list of all possible completions of STRING.
2442 `lambda' means to return t if STRING is a valid completion as it stands. */);
2443 Vminibuffer_completion_table
= Qnil
;
2445 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2446 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2447 Vminibuffer_completion_predicate
= Qnil
;
2449 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2450 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2451 Vminibuffer_completion_confirm
= Qnil
;
2453 DEFVAR_LISP ("minibuffer-completing-file-name",
2454 &Vminibuffer_completing_file_name
,
2455 doc
: /* Non-nil means completing file names. */);
2456 Vminibuffer_completing_file_name
= Qnil
;
2458 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2459 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2460 Vminibuffer_help_form
= Qnil
;
2462 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2463 doc
: /* History list symbol to add minibuffer values to.
2464 Each string of minibuffer input, as it appears on exit from the minibuffer,
2466 (set minibuffer-history-variable
2467 (cons STRING (symbol-value minibuffer-history-variable))) */);
2468 XSETFASTINT (Vminibuffer_history_variable
, 0);
2470 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2471 doc
: /* Current position of redoing in the history list. */);
2472 Vminibuffer_history_position
= Qnil
;
2474 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2475 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2476 Some uses of the echo area also raise that frame (since they use it too). */);
2477 minibuffer_auto_raise
= 0;
2479 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2480 doc
: /* List of regexps that should restrict possible completions. */);
2481 Vcompletion_regexp_list
= Qnil
;
2483 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2484 &minibuffer_allow_text_properties
,
2485 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2486 This also affects `read-string', but it does not affect `read-minibuffer',
2487 `read-no-blanks-input', or any of the functions that do minibuffer input
2488 with completion; they always discard text properties. */);
2489 minibuffer_allow_text_properties
= 0;
2491 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2492 doc
: /* Text properties that are added to minibuffer prompts.
2493 These are in addition to the basic `field' property, and stickiness
2495 /* We use `intern' here instead of Qread_only to avoid
2496 initialization-order problems. */
2497 Vminibuffer_prompt_properties
2498 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2500 defsubr (&Sset_minibuffer_window
);
2501 defsubr (&Sread_from_minibuffer
);
2502 defsubr (&Seval_minibuffer
);
2503 defsubr (&Sread_minibuffer
);
2504 defsubr (&Sread_string
);
2505 defsubr (&Sread_command
);
2506 defsubr (&Sread_variable
);
2507 defsubr (&Sread_buffer
);
2508 defsubr (&Sread_no_blanks_input
);
2509 defsubr (&Sminibuffer_depth
);
2510 defsubr (&Sminibuffer_prompt
);
2512 defsubr (&Sminibuffer_prompt_end
);
2513 defsubr (&Sminibuffer_contents
);
2514 defsubr (&Sminibuffer_contents_no_properties
);
2515 defsubr (&Sdelete_minibuffer_contents
);
2517 defsubr (&Stry_completion
);
2518 defsubr (&Sall_completions
);
2519 defsubr (&Stest_completion
);
2520 defsubr (&Sassoc_string
);
2521 defsubr (&Scompleting_read
);
2522 defsubr (&Sminibuffer_complete
);
2523 defsubr (&Sminibuffer_complete_word
);
2524 defsubr (&Sminibuffer_complete_and_exit
);
2525 defsubr (&Sdisplay_completion_list
);
2526 defsubr (&Sminibuffer_completion_help
);
2528 defsubr (&Sself_insert_and_exit
);
2529 defsubr (&Sexit_minibuffer
);
2531 defsubr (&Sminibuffer_message
);
2537 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2538 "abort-recursive-edit");
2539 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2541 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2544 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2546 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2548 initial_define_key (Vminibuffer_local_ns_map
, '?',
2549 "self-insert-and-exit");
2551 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2552 "minibuffer-complete");
2553 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2554 "minibuffer-complete-word");
2555 initial_define_key (Vminibuffer_local_completion_map
, '?',
2556 "minibuffer-completion-help");
2558 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2559 "minibuffer-complete-and-exit");
2560 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2561 "minibuffer-complete-and-exit");