1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2011 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
29 #include "dispextern.h"
34 #include "intervals.h"
36 #include "termhooks.h"
38 /* List of buffers for use as minibuffers.
39 The first element of the list is used for the outermost minibuffer
40 invocation, the next element is used for a recursive minibuffer
41 invocation, etc. The list is extended at the end as deeper
42 minibuffer recursions are encountered. */
44 Lisp_Object Vminibuffer_list
;
46 /* Data to remember during recursive minibuffer invocations. */
48 static Lisp_Object minibuf_save_list
;
50 /* Depth in minibuffer invocations. */
54 /* The maximum length of a minibuffer history. */
56 static Lisp_Object Qhistory_length
;
58 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string
;
62 static Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
64 static Lisp_Object Qread_file_name_internal
;
66 /* Normal hooks for entry to and exit from minibuffer. */
68 static Lisp_Object Qminibuffer_setup_hook
;
69 static Lisp_Object Qminibuffer_exit_hook
;
71 Lisp_Object Qcompletion_ignore_case
;
72 static Lisp_Object Qminibuffer_completion_table
;
73 static Lisp_Object Qminibuffer_completion_predicate
;
74 static Lisp_Object Qminibuffer_completion_confirm
;
75 static Lisp_Object Quser_variable_p
;
77 static Lisp_Object Qminibuffer_default
;
79 static Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
81 static Lisp_Object Qcase_fold_search
;
83 static Lisp_Object Qread_expression_history
;
85 /* Prompt to display in front of the mini-buffer contents. */
87 static Lisp_Object minibuf_prompt
;
89 /* Width of current mini-buffer prompt. Only set after display_line
90 of the line that contains the prompt. */
92 static EMACS_INT minibuf_prompt_width
;
95 /* Put minibuf on currently selected frame's minibuffer.
96 We do this whenever the user starts a new minibuffer
97 or when a minibuffer exits. */
100 choose_minibuf_frame (void)
102 if (FRAMEP (selected_frame
)
103 && FRAME_LIVE_P (XFRAME (selected_frame
))
104 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
106 struct frame
*sf
= XFRAME (selected_frame
);
109 /* I don't think that any frames may validly have a null minibuffer
111 if (NILP (sf
->minibuffer_window
))
114 /* Under X, we come here with minibuf_window being the
115 minibuffer window of the unused termcap window created in
116 init_window_once. That window doesn't have a buffer. */
117 buffer
= XWINDOW (minibuf_window
)->buffer
;
118 if (BUFFERP (buffer
))
119 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
120 minibuf_window
= sf
->minibuffer_window
;
123 /* Make sure no other frame has a minibuffer as its selected window,
124 because the text would not be displayed in it, and that would be
125 confusing. Only allow the selected frame to do this,
126 and that only if the minibuffer is active. */
128 Lisp_Object tail
, frame
;
130 FOR_EACH_FRAME (tail
, frame
)
131 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
132 && !(EQ (frame
, selected_frame
)
133 && minibuf_level
> 0))
134 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
139 choose_minibuf_frame_1 (Lisp_Object ignore
)
141 choose_minibuf_frame ();
145 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
146 Sactive_minibuffer_window
, 0, 0, 0,
147 doc
: /* Return the currently active minibuffer window, or nil if none. */)
150 return minibuf_level
? minibuf_window
: Qnil
;
153 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
154 Sset_minibuffer_window
, 1, 1, 0,
155 doc
: /* Specify which minibuffer window to use for the minibuffer.
156 This affects where the minibuffer is displayed if you put text in it
157 without invoking the usual minibuffer commands. */)
160 CHECK_WINDOW (window
);
161 if (! MINI_WINDOW_P (XWINDOW (window
)))
162 error ("Window is not a minibuffer window");
164 minibuf_window
= window
;
170 /* Actual minibuffer invocation. */
172 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
173 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
174 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
175 Lisp_Object
, Lisp_Object
,
177 Lisp_Object
, Lisp_Object
,
179 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
180 Lisp_Object
, Lisp_Object
,
182 Lisp_Object
, Lisp_Object
,
184 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
187 /* Read a Lisp object from VAL and return it. If VAL is an empty
188 string, and DEFALT is a string, read from DEFALT instead of VAL. */
191 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
193 struct gcpro gcpro1
, gcpro2
;
194 Lisp_Object expr_and_pos
;
197 GCPRO2 (val
, defalt
);
199 if (STRINGP (val
) && SCHARS (val
) == 0)
201 if (STRINGP (defalt
))
203 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
207 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
208 pos
= XINT (Fcdr (expr_and_pos
));
209 if (pos
!= SCHARS (val
))
211 /* Ignore trailing whitespace; any other trailing junk
214 pos
= string_char_to_byte (val
, pos
);
215 for (i
= pos
; i
< SBYTES (val
); i
++)
217 int c
= SREF (val
, i
);
218 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
219 error ("Trailing garbage following expression");
223 val
= Fcar (expr_and_pos
);
224 RETURN_UNGCPRO (val
);
228 /* Like read_minibuf but reading from stdin. This function is called
229 from read_minibuf to do the job if noninteractive. */
232 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
233 Lisp_Object prompt
, Lisp_Object backup_n
,
235 Lisp_Object histvar
, Lisp_Object histpos
,
237 int allow_props
, int inherit_input_method
)
244 fprintf (stdout
, "%s", SDATA (prompt
));
250 line
= (char *) xmalloc (size
);
252 while ((c
= getchar ()) != '\n')
263 if (STRING_BYTES_BOUND
/ 2 < size
)
266 memory_full (SIZE_MAX
);
269 line
= (char *) xrealloc (line
, size
);
277 val
= make_string (line
, len
);
283 error ("Error reading from stdin");
286 /* If Lisp form desired instead of string, parse it. */
288 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
293 DEFUN ("minibufferp", Fminibufferp
,
294 Sminibufferp
, 0, 1, 0,
295 doc
: /* Return t if BUFFER is a minibuffer.
296 No argument or nil as argument means use current buffer as BUFFER.
297 BUFFER can be a buffer or a buffer name. */)
303 buffer
= Fcurrent_buffer ();
304 else if (STRINGP (buffer
))
305 buffer
= Fget_buffer (buffer
);
307 CHECK_BUFFER (buffer
);
309 tem
= Fmemq (buffer
, Vminibuffer_list
);
310 return ! NILP (tem
) ? Qt
: Qnil
;
313 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
314 Sminibuffer_prompt_end
, 0, 0, 0,
315 doc
: /* Return the buffer position of the end of the minibuffer prompt.
316 Return (point-min) if current buffer is not a minibuffer. */)
319 /* This function is written to be most efficient when there's a prompt. */
320 Lisp_Object beg
, end
, tem
;
321 beg
= make_number (BEGV
);
323 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
327 end
= Ffield_end (beg
, Qnil
, Qnil
);
329 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
335 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
336 Sminibuffer_contents
, 0, 0, 0,
337 doc
: /* Return the user input in a minibuffer as a string.
338 If the current buffer is not a minibuffer, return its entire contents. */)
341 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
342 return make_buffer_string (prompt_end
, ZV
, 1);
345 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
346 Sminibuffer_contents_no_properties
, 0, 0, 0,
347 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
348 If the current buffer is not a minibuffer, return its entire contents. */)
351 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
352 return make_buffer_string (prompt_end
, ZV
, 0);
355 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
356 Sminibuffer_completion_contents
, 0, 0, 0,
357 doc
: /* Return the user input in a minibuffer before point as a string.
358 That is what completion commands operate on.
359 If the current buffer is not a minibuffer, return its entire contents. */)
362 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
364 error ("Cannot do completion in the prompt");
365 return make_buffer_string (prompt_end
, PT
, 1);
369 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
370 putting point minus BACKUP_N bytes from the end of INITIAL,
371 prompting with PROMPT (a string), using history list HISTVAR
372 with initial position HISTPOS. INITIAL should be a string or a
373 cons of a string and an integer. BACKUP_N should be <= 0, or
374 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
375 ignored and replaced with an integer that puts point at one-indexed
376 position N in INITIAL, where N is the CDR of INITIAL, or at the
377 beginning of INITIAL if N <= 0.
379 Normally return the result as a string (the text that was read),
380 but if EXPFLAG is nonzero, read it and return the object read.
381 If HISTVAR is given, save the value read on that history only if it doesn't
382 match the front of that history list exactly. The value is pushed onto
383 the list as the string that was read.
385 DEFALT specifies the default value for the sake of history commands.
387 If ALLOW_PROPS is nonzero, we do not throw away text properties.
389 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
390 current input method. */
393 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
394 Lisp_Object backup_n
, int expflag
,
395 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
396 int allow_props
, int inherit_input_method
)
399 int count
= SPECPDL_INDEX ();
400 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
401 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
402 Lisp_Object enable_multibyte
;
403 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
404 /* String to add to the history. */
405 Lisp_Object histstring
;
407 Lisp_Object empty_minibuf
;
408 Lisp_Object dummy
, frame
;
410 specbind (Qminibuffer_default
, defalt
);
412 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
413 in previous recursive minibuffer, but was not set explicitly
414 to t for this invocation, so set it to nil in this minibuffer.
415 Save the old value now, before we change it. */
416 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
417 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
418 Vminibuffer_completing_file_name
= Qnil
;
420 #ifdef HAVE_WINDOW_SYSTEM
421 if (display_hourglass_p
)
429 backup_n
= Fcdr (initial
);
430 initial
= Fcar (initial
);
431 CHECK_STRING (initial
);
432 if (!NILP (backup_n
))
434 CHECK_NUMBER (backup_n
);
435 /* Convert to distance from end of input. */
436 if (XINT (backup_n
) < 1)
437 /* A number too small means the beginning of the string. */
438 pos
= - SCHARS (initial
);
440 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
444 CHECK_STRING (initial
);
447 ambient_dir
= BVAR (current_buffer
, directory
);
449 enable_multibyte
= Qnil
;
451 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
452 store them away before we can GC. Don't need to protect
453 BACKUP_N because we use the value only if it is an integer. */
454 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
456 if (!STRINGP (prompt
))
457 prompt
= empty_unibyte_string
;
459 if (!enable_recursive_minibuffers
460 && minibuf_level
> 0)
462 if (EQ (selected_window
, minibuf_window
))
463 error ("Command attempted to use minibuffer while in minibuffer");
465 /* If we're in another window, cancel the minibuffer that's active. */
467 build_string ("Command attempted to use minibuffer while in minibuffer"));
471 /* In case we are running as a daemon, only do this before
472 detaching from the terminal. */
473 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
474 && NILP (Vexecuting_kbd_macro
))
476 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
478 expflag
, histvar
, histpos
, defalt
,
479 allow_props
, inherit_input_method
);
481 return unbind_to (count
, val
);
484 /* Choose the minibuffer window and frame, and take action on them. */
486 choose_minibuf_frame ();
488 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
490 record_unwind_protect (Fset_window_configuration
,
491 Fcurrent_window_configuration (Qnil
));
493 /* If the minibuffer window is on a different frame, save that
494 frame's configuration too. */
495 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
496 if (!EQ (mini_frame
, selected_frame
))
497 record_unwind_protect (Fset_window_configuration
,
498 Fcurrent_window_configuration (mini_frame
));
500 /* If the minibuffer is on an iconified or invisible frame,
501 make it visible now. */
502 Fmake_frame_visible (mini_frame
);
504 if (minibuffer_auto_raise
)
505 Fraise_frame (mini_frame
);
507 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
509 /* We have to do this after saving the window configuration
510 since that is what restores the current buffer. */
512 /* Arrange to restore a number of minibuffer-related variables.
513 We could bind each variable separately, but that would use lots of
516 = Fcons (Voverriding_local_map
,
517 Fcons (minibuf_window
,
520 = Fcons (minibuf_prompt
,
521 Fcons (make_number (minibuf_prompt_width
),
523 Fcons (Vcurrent_prefix_arg
,
524 Fcons (Vminibuffer_history_position
,
525 Fcons (Vminibuffer_history_variable
,
526 minibuf_save_list
))))));
528 record_unwind_protect (read_minibuf_unwind
, Qnil
);
530 /* We are exiting the minibuffer one way or the other, so run the hook.
531 It should be run before unwinding the minibuf settings. Do it
532 separately from read_minibuf_unwind because we need to make sure that
533 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
534 signals an error. --Stef */
535 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
537 /* Now that we can restore all those variables, start changing them. */
539 minibuf_prompt_width
= 0;
540 minibuf_prompt
= Fcopy_sequence (prompt
);
541 Vminibuffer_history_position
= histpos
;
542 Vminibuffer_history_variable
= histvar
;
543 Vhelp_form
= Vminibuffer_help_form
;
544 /* If this minibuffer is reading a file name, that doesn't mean
545 recursive ones are. But we cannot set it to nil, because
546 completion code still need to know the minibuffer is completing a
547 file name. So use `lambda' as intermediate value meaning
548 "t" in this minibuffer, but "nil" in next minibuffer. */
549 if (!NILP (Vminibuffer_completing_file_name
))
550 Vminibuffer_completing_file_name
= Qlambda
;
552 if (inherit_input_method
)
554 /* `current-input-method' is buffer local. So, remember it in
555 INPUT_METHOD before changing the current buffer. */
556 input_method
= Fsymbol_value (Qcurrent_input_method
);
557 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
560 /* Switch to the minibuffer. */
562 minibuffer
= get_minibuffer (minibuf_level
);
563 Fset_buffer (minibuffer
);
565 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
566 if (inherit_input_method
)
567 BVAR (current_buffer
, enable_multibyte_characters
) = enable_multibyte
;
569 /* The current buffer's default directory is usually the right thing
570 for our minibuffer here. However, if you're typing a command at
571 a minibuffer-only frame when minibuf_level is zero, then buf IS
572 the current_buffer, so reset_buffer leaves buf's default
573 directory unchanged. This is a bummer when you've just started
574 up Emacs and buf's default directory is Qnil. Here's a hack; can
575 you think of something better to do? Find another buffer with a
576 better directory, and use that one instead. */
577 if (STRINGP (ambient_dir
))
578 BVAR (current_buffer
, directory
) = ambient_dir
;
581 Lisp_Object buf_list
;
583 for (buf_list
= Vbuffer_alist
;
585 buf_list
= XCDR (buf_list
))
587 Lisp_Object other_buf
;
589 other_buf
= XCDR (XCAR (buf_list
));
590 if (STRINGP (BVAR (XBUFFER (other_buf
), directory
)))
592 BVAR (current_buffer
, directory
) = BVAR (XBUFFER (other_buf
), directory
);
598 if (!EQ (mini_frame
, selected_frame
))
599 Fredirect_frame_focus (selected_frame
, mini_frame
);
601 Vminibuf_scroll_window
= selected_window
;
602 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
603 minibuf_selected_window
= selected_window
;
605 /* Empty out the minibuffers of all frames other than the one
606 where we are going to display one now.
607 Set them to point to ` *Minibuf-0*', which is always empty. */
608 empty_minibuf
= get_minibuffer (0);
610 FOR_EACH_FRAME (dummy
, frame
)
612 Lisp_Object root_window
= Fframe_root_window (frame
);
613 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
615 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
616 && !NILP (Fwindow_minibuffer_p (mini_window
)))
617 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
620 /* Display this minibuffer in the proper window. */
621 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
622 Fselect_window (minibuf_window
, Qnil
);
623 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
625 Fmake_local_variable (Qprint_escape_newlines
);
626 print_escape_newlines
= 1;
628 /* Erase the buffer. */
630 int count1
= SPECPDL_INDEX ();
631 specbind (Qinhibit_read_only
, Qt
);
632 specbind (Qinhibit_modification_hooks
, Qt
);
635 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
636 && ! STRING_MULTIBYTE (minibuf_prompt
))
637 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
639 /* Insert the prompt, record where it ends. */
640 Finsert (1, &minibuf_prompt
);
643 Fput_text_property (make_number (BEG
), make_number (PT
),
644 Qfront_sticky
, Qt
, Qnil
);
645 Fput_text_property (make_number (BEG
), make_number (PT
),
646 Qrear_nonsticky
, Qt
, Qnil
);
647 Fput_text_property (make_number (BEG
), make_number (PT
),
649 Fadd_text_properties (make_number (BEG
), make_number (PT
),
650 Vminibuffer_prompt_properties
, Qnil
);
652 unbind_to (count1
, Qnil
);
655 minibuf_prompt_width
= current_column ();
657 /* Put in the initial input. */
660 Finsert (1, &initial
);
661 Fforward_char (make_number (pos
));
664 clear_message (1, 1);
665 BVAR (current_buffer
, keymap
) = map
;
667 /* Turn on an input method stored in INPUT_METHOD if any. */
668 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
669 call1 (Qactivate_input_method
, input_method
);
671 Frun_hooks (1, &Qminibuffer_setup_hook
);
673 /* Don't allow the user to undo past this point. */
674 BVAR (current_buffer
, undo_list
) = Qnil
;
678 /* If cursor is on the minibuffer line,
679 show the user we have exited by putting it in column 0. */
680 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
683 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
684 XWINDOW (minibuf_window
)->cursor
.x
= 0;
685 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
686 update_frame (XFRAME (selected_frame
), 1, 1);
688 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
689 struct redisplay_interface
*rif
= FRAME_RIF (f
);
690 if (rif
&& rif
->flush_display
)
691 rif
->flush_display (f
);
695 /* Make minibuffer contents into a string. */
696 Fset_buffer (minibuffer
);
698 val
= Fminibuffer_contents ();
700 val
= Fminibuffer_contents_no_properties ();
702 /* VAL is the string of minibuffer text. */
704 last_minibuf_string
= val
;
706 /* Choose the string to add to the history. */
707 if (SCHARS (val
) != 0)
709 else if (STRINGP (defalt
))
711 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
712 histstring
= XCAR (defalt
);
716 /* Add the value to the appropriate history list, if any. */
717 if (!NILP (Vhistory_add_new_input
)
718 && SYMBOLP (Vminibuffer_history_variable
)
719 && !NILP (histstring
))
721 /* If the caller wanted to save the value read on a history list,
722 then do so if the value is not already the front of the list. */
725 /* If variable is unbound, make it nil. */
727 histval
= find_symbol_value (Vminibuffer_history_variable
);
728 if (EQ (histval
, Qunbound
))
729 Fset (Vminibuffer_history_variable
, Qnil
);
731 /* The value of the history variable must be a cons or nil. Other
732 values are unacceptable. We silently ignore these values. */
736 /* Don't duplicate the most recent entry in the history. */
737 && (NILP (Fequal (histstring
, Fcar (histval
))))))
741 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
742 histval
= Fcons (histstring
, histval
);
743 Fset (Vminibuffer_history_variable
, histval
);
745 /* Truncate if requested. */
746 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
747 if (NILP (length
)) length
= Vhistory_length
;
748 if (INTEGERP (length
))
750 if (XINT (length
) <= 0)
751 Fset (Vminibuffer_history_variable
, Qnil
);
756 temp
= Fnthcdr (Fsub1 (length
), histval
);
757 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
763 /* If Lisp form desired instead of string, parse it. */
765 val
= string_to_object (val
, defalt
);
767 /* The appropriate frame will get selected
768 in set-window-configuration. */
770 return unbind_to (count
, val
);
773 /* Return a buffer to be used as the minibuffer at depth `depth'.
774 depth = 0 is the lowest allowed argument, and that is the value
775 used for nonrecursive minibuffer invocations. */
778 get_minibuffer (int depth
)
780 Lisp_Object tail
, num
, buf
;
783 XSETFASTINT (num
, depth
);
784 tail
= Fnthcdr (num
, Vminibuffer_list
);
787 tail
= Fcons (Qnil
, Qnil
);
788 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
791 if (NILP (buf
) || NILP (BVAR (XBUFFER (buf
), name
)))
793 sprintf (name
, " *Minibuf-%d*", depth
);
794 buf
= Fget_buffer_create (build_string (name
));
796 /* Although the buffer's name starts with a space, undo should be
798 Fbuffer_enable_undo (buf
);
804 int count
= SPECPDL_INDEX ();
805 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
806 have to empty the list, otherwise we end up with overlays that
807 think they belong to this buffer while the buffer doesn't know about
809 delete_all_overlays (XBUFFER (buf
));
810 reset_buffer (XBUFFER (buf
));
811 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
813 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
814 call0 (intern ("minibuffer-inactive-mode"));
816 Fkill_all_local_variables ();
817 unbind_to (count
, Qnil
);
824 run_exit_minibuf_hook (Lisp_Object data
)
826 safe_run_hooks (Qminibuffer_exit_hook
);
830 /* This function is called on exiting minibuffer, whether normally or
831 not, and it restores the current window, buffer, etc. */
834 read_minibuf_unwind (Lisp_Object data
)
836 Lisp_Object old_deactivate_mark
;
839 /* If this was a recursive minibuffer,
840 tie the minibuffer window back to the outer level minibuffer buffer. */
843 window
= minibuf_window
;
844 /* To keep things predictable, in case it matters, let's be in the
845 minibuffer when we reset the relevant variables. */
846 Fset_buffer (XWINDOW (window
)->buffer
);
848 /* Restore prompt, etc, from outer minibuffer level. */
849 minibuf_prompt
= Fcar (minibuf_save_list
);
850 minibuf_save_list
= Fcdr (minibuf_save_list
);
851 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
852 minibuf_save_list
= Fcdr (minibuf_save_list
);
853 Vhelp_form
= Fcar (minibuf_save_list
);
854 minibuf_save_list
= Fcdr (minibuf_save_list
);
855 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
856 minibuf_save_list
= Fcdr (minibuf_save_list
);
857 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
858 minibuf_save_list
= Fcdr (minibuf_save_list
);
859 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
860 minibuf_save_list
= Fcdr (minibuf_save_list
);
861 Voverriding_local_map
= Fcar (minibuf_save_list
);
862 minibuf_save_list
= Fcdr (minibuf_save_list
);
864 temp
= Fcar (minibuf_save_list
);
865 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
866 minibuf_window
= temp
;
868 minibuf_save_list
= Fcdr (minibuf_save_list
);
870 /* Erase the minibuffer we were using at this level. */
872 int count
= SPECPDL_INDEX ();
873 /* Prevent error in erase-buffer. */
874 specbind (Qinhibit_read_only
, Qt
);
875 specbind (Qinhibit_modification_hooks
, Qt
);
876 old_deactivate_mark
= Vdeactivate_mark
;
878 Vdeactivate_mark
= old_deactivate_mark
;
879 unbind_to (count
, Qnil
);
882 /* When we get to the outmost level, make sure we resize the
883 mini-window back to its normal size. */
884 if (minibuf_level
== 0)
885 resize_mini_window (XWINDOW (window
), 0);
887 /* Make sure minibuffer window is erased, not ignored. */
888 windows_or_buffers_changed
++;
889 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
890 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
892 /* In case the previous minibuffer displayed in this miniwindow is
893 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
894 to make sure we don't leave around bindings and stuff which only
895 made sense during the read_minibuf invocation. */
896 call0 (intern ("minibuffer-inactive-mode"));
901 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
902 Sread_from_minibuffer
, 1, 7, 0,
903 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
904 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
905 DEFAULT-VALUE. It normally should be nil in new code, except when
906 HIST is a cons. It is discussed in more detail below.
907 Third arg KEYMAP is a keymap to use whilst reading;
908 if omitted or nil, the default is `minibuffer-local-map'.
909 If fourth arg READ is non-nil, then interpret the result as a Lisp object
910 and return that object:
911 in other words, do `(car (read-from-string INPUT-STRING))'
912 Fifth arg HIST, if non-nil, specifies a history list and optionally
913 the initial position in the list. It can be a symbol, which is the
914 history list variable to use, or it can be a cons cell
915 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
916 to use, and HISTPOS is the initial position for use by the minibuffer
917 history commands. For consistency, you should also specify that
918 element of the history as the value of INITIAL-CONTENTS. Positions
919 are counted starting from 1 at the beginning of the list.
920 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
921 If non-nil, it is available for history commands, and as the value
922 (or the first element of the list of default values) to return
923 if the user enters the empty string. But, unless READ is non-nil,
924 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
925 empty input! It returns the empty string.
926 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
927 the current input method and the setting of `enable-multibyte-characters'.
928 If the variable `minibuffer-allow-text-properties' is non-nil,
929 then the string which is returned includes whatever text properties
930 were present in the minibuffer. Otherwise the value has no text properties.
932 The remainder of this documentation string describes the
933 INITIAL-CONTENTS argument in more detail. It is only relevant when
934 studying existing code, or when HIST is a cons. If non-nil,
935 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
936 reading input. Normally, point is put at the end of that string.
937 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
938 input is STRING, but point is placed at _one-indexed_ position
939 POSITION in the minibuffer. Any integer value less than or equal to
940 one puts point at the beginning of the string. *Note* that this
941 behavior differs from the way such arguments are used in `completing-read'
942 and some related functions, which use zero-indexing for POSITION. */)
943 (Lisp_Object prompt
, Lisp_Object initial_contents
, Lisp_Object keymap
, Lisp_Object read
, Lisp_Object hist
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
945 Lisp_Object histvar
, histpos
, val
;
948 CHECK_STRING (prompt
);
950 keymap
= Vminibuffer_local_map
;
952 keymap
= get_keymap (keymap
, 1, 0);
961 histvar
= Fcar_safe (hist
);
962 histpos
= Fcdr_safe (hist
);
965 histvar
= Qminibuffer_history
;
967 XSETFASTINT (histpos
, 0);
969 GCPRO1 (default_value
);
970 val
= read_minibuf (keymap
, initial_contents
, prompt
,
972 histvar
, histpos
, default_value
,
973 minibuffer_allow_text_properties
,
974 !NILP (inherit_input_method
));
979 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
980 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
981 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
982 is a string to insert in the minibuffer before reading.
983 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
984 Such arguments are used as in `read-from-minibuffer'.) */)
985 (Lisp_Object prompt
, Lisp_Object initial_contents
)
987 CHECK_STRING (prompt
);
988 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
989 prompt
, Qnil
, 1, Qminibuffer_history
,
990 make_number (0), Qnil
, 0, 0);
993 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
994 doc
: /* Return value of Lisp expression read using the minibuffer.
995 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
996 is a string to insert in the minibuffer before reading.
997 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
998 Such arguments are used as in `read-from-minibuffer'.) */)
999 (Lisp_Object prompt
, Lisp_Object initial_contents
)
1001 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1002 prompt
, Qnil
, 1, Qread_expression_history
,
1003 make_number (0), Qnil
, 0, 0),
1007 /* Functions that use the minibuffer to read various things. */
1009 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1010 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1011 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1012 This argument has been superseded by DEFAULT-VALUE and should normally
1013 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1014 documentation string of that function for details.
1015 The third arg HISTORY, if non-nil, specifies a history list
1016 and optionally the initial position in the list.
1017 See `read-from-minibuffer' for details of HISTORY argument.
1018 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1019 If non-nil, it is used for history commands, and as the value (or the first
1020 element of the list of default values) to return if the user enters the
1022 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1023 the current input method and the setting of `enable-multibyte-characters'. */)
1024 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1027 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1028 Qnil
, history
, default_value
,
1029 inherit_input_method
);
1030 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1031 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1035 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1036 doc
: /* Read a string from the terminal, not allowing blanks.
1037 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1038 non-nil, it should be a string, which is used as initial input, with
1039 point positioned at the end, so that SPACE will accept the input.
1040 \(Actually, INITIAL can also be a cons of a string and an integer.
1041 Such values are treated as in `read-from-minibuffer', but are normally
1042 not useful in this function.)
1043 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1044 the current input method and the setting of`enable-multibyte-characters'. */)
1045 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1047 CHECK_STRING (prompt
);
1048 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1049 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1050 !NILP (inherit_input_method
));
1053 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1054 doc
: /* Read the name of a command and return as a symbol.
1055 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1056 if it is a list. */)
1057 (Lisp_Object prompt
, Lisp_Object default_value
)
1059 Lisp_Object name
, default_string
;
1061 if (NILP (default_value
))
1062 default_string
= Qnil
;
1063 else if (SYMBOLP (default_value
))
1064 default_string
= SYMBOL_NAME (default_value
);
1066 default_string
= default_value
;
1068 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1069 Qnil
, Qnil
, default_string
, Qnil
);
1072 return Fintern (name
, Qnil
);
1076 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1077 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1078 Prompt with PROMPT. */)
1079 (Lisp_Object prompt
)
1081 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1086 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1087 doc
: /* Read the name of a user variable and return it as a symbol.
1088 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1090 A user variable is one for which `user-variable-p' returns non-nil. */)
1091 (Lisp_Object prompt
, Lisp_Object default_value
)
1093 Lisp_Object name
, default_string
;
1095 if (NILP (default_value
))
1096 default_string
= Qnil
;
1097 else if (SYMBOLP (default_value
))
1098 default_string
= SYMBOL_NAME (default_value
);
1100 default_string
= default_value
;
1102 name
= Fcompleting_read (prompt
, Vobarray
,
1103 Quser_variable_p
, Qt
,
1104 Qnil
, Qnil
, default_string
, Qnil
);
1107 return Fintern (name
, Qnil
);
1110 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1111 doc
: /* Read the name of a buffer and return as a string.
1113 Optional second arg DEF is value to return if user enters an empty line.
1114 If DEF is a list of default values, return its first element.
1115 Optional third arg REQUIRE-MATCH determines whether non-existing
1116 buffer names are allowed. It has the same meaning as the
1117 REQUIRE-MATCH argument of `completing-read'.
1118 The argument PROMPT should be a string ending with a colon and a space.
1119 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1120 case while reading the buffer name.
1121 If `read-buffer-function' is non-nil, this works by calling it as a
1122 function, instead of the usual behavior. */)
1123 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1125 Lisp_Object args
[4], result
;
1128 int count
= SPECPDL_INDEX ();
1131 def
= BVAR (XBUFFER (def
), name
);
1133 specbind (Qcompletion_ignore_case
,
1134 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1136 if (NILP (Vread_buffer_function
))
1140 /* A default value was provided: we must change PROMPT,
1141 editing the default value in before the colon. To achieve
1142 this, we replace PROMPT with a substring that doesn't
1143 contain the terminal space and colon (if present). They
1144 are then added back using Fformat. */
1146 if (STRINGP (prompt
))
1148 s
= SSDATA (prompt
);
1149 len
= SBYTES (prompt
);
1150 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1152 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1155 prompt
= make_specified_string (s
, -1, len
,
1156 STRING_MULTIBYTE (prompt
));
1159 args
[0] = build_string ("%s (default %s): ");
1161 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1162 prompt
= Fformat (3, args
);
1165 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1166 Qnil
, require_match
, Qnil
,
1167 Qbuffer_name_history
, def
, Qnil
);
1171 args
[0] = Vread_buffer_function
;
1174 args
[3] = require_match
;
1175 result
= Ffuncall (4, args
);
1177 return unbind_to (count
, result
);
1181 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1183 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1186 if (STRING_MULTIBYTE (string
))
1187 return Fstring_make_unibyte (string
);
1189 return Fstring_make_multibyte (string
);
1192 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1193 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1194 Test each possible completion specified by COLLECTION
1195 to see if it begins with STRING. The possible completions may be
1196 strings or symbols. Symbols are converted to strings before testing,
1198 All that match STRING are compared together; the longest initial sequence
1199 common to all these matches is the return value.
1200 If there is no match at all, the return value is nil.
1201 For a unique match which is exact, the return value is t.
1203 If COLLECTION is an alist, the keys (cars of elements) are the
1204 possible completions. If an element is not a cons cell, then the
1205 element itself is the possible completion.
1206 If COLLECTION is a hash-table, all the keys that are strings or symbols
1207 are the possible completions.
1208 If COLLECTION is an obarray, the names of all symbols in the obarray
1209 are the possible completions.
1211 COLLECTION can also be a function to do the completion itself.
1212 It receives three arguments: the values STRING, PREDICATE and nil.
1213 Whatever it returns becomes the value of `try-completion'.
1215 If optional third argument PREDICATE is non-nil,
1216 it is used to test each possible match.
1217 The match is a candidate only if PREDICATE returns non-nil.
1218 The argument given to PREDICATE is the alist element
1219 or the symbol from the obarray. If COLLECTION is a hash-table,
1220 predicate is called with two arguments: the key and the value.
1221 Additionally to this predicate, `completion-regexp-list'
1222 is used to further constrain the set of candidates. */)
1223 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1225 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1226 /* Size in bytes of BESTMATCH. */
1227 int bestmatchsize
= 0;
1228 /* These are in bytes, too. */
1229 int compare
, matchsize
;
1230 enum { function_table
, list_table
, obarray_table
, hash_table
}
1231 type
= (HASH_TABLE_P (collection
) ? hash_table
1232 : VECTORP (collection
) ? obarray_table
1233 : ((NILP (collection
)
1234 || (CONSP (collection
)
1235 && (!SYMBOLP (XCAR (collection
))
1236 || NILP (XCAR (collection
)))))
1237 ? list_table
: function_table
));
1238 EMACS_INT idx
= 0, obsize
= 0;
1241 Lisp_Object bucket
, zero
, end
, tem
;
1242 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1244 CHECK_STRING (string
);
1245 if (type
== function_table
)
1246 return call3 (collection
, string
, predicate
, Qnil
);
1248 bestmatch
= bucket
= Qnil
;
1249 zero
= make_number (0);
1251 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1253 if (type
== obarray_table
)
1255 collection
= check_obarray (collection
);
1256 obsize
= ASIZE (collection
);
1257 bucket
= XVECTOR (collection
)->contents
[idx
];
1262 /* Get the next element of the alist, obarray, or hash-table. */
1263 /* Exit the loop if the elements are all used up. */
1264 /* elt gets the alist element or symbol.
1265 eltstring gets the name to check as a completion. */
1267 if (type
== list_table
)
1272 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1275 else if (type
== obarray_table
)
1277 if (!EQ (bucket
, zero
))
1279 if (!SYMBOLP (bucket
))
1280 error ("Bad data in guts of obarray");
1283 if (XSYMBOL (bucket
)->next
)
1284 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1286 XSETFASTINT (bucket
, 0);
1288 else if (++idx
>= obsize
)
1292 bucket
= XVECTOR (collection
)->contents
[idx
];
1296 else /* if (type == hash_table) */
1298 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1299 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1301 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1304 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1307 /* Is this element a possible completion? */
1309 if (SYMBOLP (eltstring
))
1310 eltstring
= Fsymbol_name (eltstring
);
1312 if (STRINGP (eltstring
)
1313 && SCHARS (string
) <= SCHARS (eltstring
)
1314 && (tem
= Fcompare_strings (eltstring
, zero
,
1315 make_number (SCHARS (string
)),
1317 completion_ignore_case
? Qt
: Qnil
),
1321 Lisp_Object regexps
;
1323 /* Ignore this element if it fails to match all the regexps. */
1325 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1326 regexps
= XCDR (regexps
))
1328 if (bindcount
< 0) {
1329 bindcount
= SPECPDL_INDEX ();
1330 specbind (Qcase_fold_search
,
1331 completion_ignore_case
? Qt
: Qnil
);
1333 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1337 if (CONSP (regexps
))
1341 /* Ignore this element if there is a predicate
1342 and the predicate doesn't like it. */
1344 if (!NILP (predicate
))
1346 if (EQ (predicate
, Qcommandp
))
1347 tem
= Fcommandp (elt
, Qnil
);
1352 unbind_to (bindcount
, Qnil
);
1355 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1356 tem
= (type
== hash_table
1357 ? call2 (predicate
, elt
,
1358 HASH_VALUE (XHASH_TABLE (collection
),
1360 : call1 (predicate
, elt
));
1363 if (NILP (tem
)) continue;
1366 /* Update computation of how much all possible completions match */
1368 if (NILP (bestmatch
))
1371 bestmatch
= eltstring
;
1372 bestmatchsize
= SCHARS (eltstring
);
1376 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1377 tem
= Fcompare_strings (bestmatch
, zero
,
1378 make_number (compare
),
1380 make_number (compare
),
1381 completion_ignore_case
? Qt
: Qnil
);
1383 matchsize
= compare
;
1384 else if (XINT (tem
) < 0)
1385 matchsize
= - XINT (tem
) - 1;
1387 matchsize
= XINT (tem
) - 1;
1389 if (completion_ignore_case
)
1391 /* If this is an exact match except for case,
1392 use it as the best match rather than one that is not an
1393 exact match. This way, we get the case pattern
1394 of the actual match. */
1395 if ((matchsize
== SCHARS (eltstring
)
1396 && matchsize
< SCHARS (bestmatch
))
1398 /* If there is more than one exact match ignoring case,
1399 and one of them is exact including case,
1401 /* If there is no exact match ignoring case,
1402 prefer a match that does not change the case
1404 ((matchsize
== SCHARS (eltstring
))
1406 (matchsize
== SCHARS (bestmatch
))
1407 && (tem
= Fcompare_strings (eltstring
, zero
,
1408 make_number (SCHARS (string
)),
1413 && (tem
= Fcompare_strings (bestmatch
, zero
,
1414 make_number (SCHARS (string
)),
1419 bestmatch
= eltstring
;
1421 if (bestmatchsize
!= SCHARS (eltstring
)
1422 || bestmatchsize
!= matchsize
)
1423 /* Don't count the same string multiple times. */
1425 bestmatchsize
= matchsize
;
1426 if (matchsize
<= SCHARS (string
)
1427 /* If completion-ignore-case is non-nil, don't
1428 short-circuit because we want to find the best
1429 possible match *including* case differences. */
1430 && !completion_ignore_case
1432 /* No need to look any further. */
1438 if (bindcount
>= 0) {
1439 unbind_to (bindcount
, Qnil
);
1443 if (NILP (bestmatch
))
1444 return Qnil
; /* No completions found. */
1445 /* If we are ignoring case, and there is no exact match,
1446 and no additional text was supplied,
1447 don't change the case of what the user typed. */
1448 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1449 && SCHARS (bestmatch
) > bestmatchsize
)
1450 return minibuf_conform_representation (string
, bestmatch
);
1452 /* Return t if the supplied string is an exact match (counting case);
1453 it does not require any change to be made. */
1454 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1457 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1458 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1459 return Fsubstring (bestmatch
, zero
, end
);
1462 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1463 doc
: /* Search for partial matches to STRING in COLLECTION.
1464 Test each of the possible completions specified by COLLECTION
1465 to see if it begins with STRING. The possible completions may be
1466 strings or symbols. Symbols are converted to strings before testing,
1468 The value is a list of all the possible completions that match STRING.
1470 If COLLECTION is an alist, the keys (cars of elements) are the
1471 possible completions. If an element is not a cons cell, then the
1472 element itself is the possible completion.
1473 If COLLECTION is a hash-table, all the keys that are strings or symbols
1474 are the possible completions.
1475 If COLLECTION is an obarray, the names of all symbols in the obarray
1476 are the possible completions.
1478 COLLECTION can also be a function to do the completion itself.
1479 It receives three arguments: the values STRING, PREDICATE and t.
1480 Whatever it returns becomes the value of `all-completions'.
1482 If optional third argument PREDICATE is non-nil,
1483 it is used to test each possible match.
1484 The match is a candidate only if PREDICATE returns non-nil.
1485 The argument given to PREDICATE is the alist element
1486 or the symbol from the obarray. If COLLECTION is a hash-table,
1487 predicate is called with two arguments: the key and the value.
1488 Additionally to this predicate, `completion-regexp-list'
1489 is used to further constrain the set of candidates.
1491 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1492 backward compatibility. If non-nil, strings in COLLECTION that start
1493 with a space are ignored unless STRING itself starts with a space. */)
1494 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1496 Lisp_Object tail
, elt
, eltstring
;
1497 Lisp_Object allmatches
;
1498 int type
= HASH_TABLE_P (collection
) ? 3
1499 : VECTORP (collection
) ? 2
1500 : NILP (collection
) || (CONSP (collection
)
1501 && (!SYMBOLP (XCAR (collection
))
1502 || NILP (XCAR (collection
))));
1503 EMACS_INT idx
= 0, obsize
= 0;
1505 Lisp_Object bucket
, tem
, zero
;
1506 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1508 CHECK_STRING (string
);
1510 return call3 (collection
, string
, predicate
, Qt
);
1511 allmatches
= bucket
= Qnil
;
1512 zero
= make_number (0);
1514 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1518 collection
= check_obarray (collection
);
1519 obsize
= ASIZE (collection
);
1520 bucket
= XVECTOR (collection
)->contents
[idx
];
1525 /* Get the next element of the alist, obarray, or hash-table. */
1526 /* Exit the loop if the elements are all used up. */
1527 /* elt gets the alist element or symbol.
1528 eltstring gets the name to check as a completion. */
1535 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1540 if (!EQ (bucket
, zero
))
1542 if (!SYMBOLP (bucket
))
1543 error ("Bad data in guts of obarray");
1546 if (XSYMBOL (bucket
)->next
)
1547 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1549 XSETFASTINT (bucket
, 0);
1551 else if (++idx
>= obsize
)
1555 bucket
= XVECTOR (collection
)->contents
[idx
];
1559 else /* if (type == 3) */
1561 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1562 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1564 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1567 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1570 /* Is this element a possible completion? */
1572 if (SYMBOLP (eltstring
))
1573 eltstring
= Fsymbol_name (eltstring
);
1575 if (STRINGP (eltstring
)
1576 && SCHARS (string
) <= SCHARS (eltstring
)
1577 /* If HIDE_SPACES, reject alternatives that start with space
1578 unless the input starts with space. */
1579 && (NILP (hide_spaces
)
1580 || (SBYTES (string
) > 0
1581 && SREF (string
, 0) == ' ')
1582 || SREF (eltstring
, 0) != ' ')
1583 && (tem
= Fcompare_strings (eltstring
, zero
,
1584 make_number (SCHARS (string
)),
1586 make_number (SCHARS (string
)),
1587 completion_ignore_case
? Qt
: Qnil
),
1591 Lisp_Object regexps
;
1593 /* Ignore this element if it fails to match all the regexps. */
1595 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1596 regexps
= XCDR (regexps
))
1598 if (bindcount
< 0) {
1599 bindcount
= SPECPDL_INDEX ();
1600 specbind (Qcase_fold_search
,
1601 completion_ignore_case
? Qt
: Qnil
);
1603 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1607 if (CONSP (regexps
))
1611 /* Ignore this element if there is a predicate
1612 and the predicate doesn't like it. */
1614 if (!NILP (predicate
))
1616 if (EQ (predicate
, Qcommandp
))
1617 tem
= Fcommandp (elt
, Qnil
);
1620 if (bindcount
>= 0) {
1621 unbind_to (bindcount
, Qnil
);
1624 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1626 ? call2 (predicate
, elt
,
1627 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1628 : call1 (predicate
, elt
);
1631 if (NILP (tem
)) continue;
1633 /* Ok => put it on the list. */
1634 allmatches
= Fcons (eltstring
, allmatches
);
1638 if (bindcount
>= 0) {
1639 unbind_to (bindcount
, Qnil
);
1643 return Fnreverse (allmatches
);
1646 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1647 doc
: /* Read a string in the minibuffer, with completion.
1648 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1649 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1650 COLLECTION can also be a function to do the completion itself.
1651 PREDICATE limits completion to a subset of COLLECTION.
1652 See `try-completion' and `all-completions' for more details
1653 on completion, COLLECTION, and PREDICATE.
1655 REQUIRE-MATCH can take the following values:
1656 - t means that the user is not allowed to exit unless
1657 the input is (or completes to) an element of COLLECTION or is null.
1658 - nil means that the user can exit with any input.
1659 - `confirm' means that the user can exit with any input, but she needs
1660 to confirm her choice if the input is not an element of COLLECTION.
1661 - `confirm-after-completion' means that the user can exit with any
1662 input, but she needs to confirm her choice if she called
1663 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1664 and the input is not an element of COLLECTION.
1665 - anything else behaves like t except that typing RET does not exit if it
1666 does non-null completion.
1668 If the input is null, `completing-read' returns DEF, or the first element
1669 of the list of default values, or an empty string if DEF is nil,
1670 regardless of the value of REQUIRE-MATCH.
1672 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1673 with point positioned at the end.
1674 If it is (STRING . POSITION), the initial input is STRING, but point
1675 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1676 that this is different from `read-from-minibuffer' and related
1677 functions, which use one-indexing for POSITION.) This feature is
1678 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1679 default value DEF instead. The user can yank the default value into
1680 the minibuffer easily using \\[next-history-element].
1682 HIST, if non-nil, specifies a history list and optionally the initial
1683 position in the list. It can be a symbol, which is the history list
1684 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1685 that case, HISTVAR is the history list variable to use, and HISTPOS
1686 is the initial position (the position in the list used by the
1687 minibuffer history commands). For consistency, you should also
1688 specify that element of the history as the value of
1689 INITIAL-INPUT. (This is the only case in which you should use
1690 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1691 1 at the beginning of the list. The variable `history-length'
1692 controls the maximum length of a history list.
1694 DEF, if non-nil, is the default value or the list of default values.
1696 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1697 the current input method and the setting of `enable-multibyte-characters'.
1699 Completion ignores case if the ambient value of
1700 `completion-ignore-case' is non-nil.
1702 See also `completing-read-function'. */)
1703 (Lisp_Object prompt
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object require_match
, Lisp_Object initial_input
, Lisp_Object hist
, Lisp_Object def
, Lisp_Object inherit_input_method
)
1705 Lisp_Object args
[9];
1706 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1708 args
[2] = collection
;
1709 args
[3] = predicate
;
1710 args
[4] = require_match
;
1711 args
[5] = initial_input
;
1714 args
[8] = inherit_input_method
;
1715 return Ffuncall (9, args
);
1718 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1720 /* Test whether TXT is an exact completion. */
1721 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1722 doc
: /* Return non-nil if STRING is a valid completion.
1723 Takes the same arguments as `all-completions' and `try-completion'.
1724 If COLLECTION is a function, it is called with three arguments:
1725 the values STRING, PREDICATE and `lambda'. */)
1726 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1728 Lisp_Object regexps
, tail
, tem
= Qnil
;
1731 CHECK_STRING (string
);
1733 if ((CONSP (collection
)
1734 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1735 || NILP (collection
))
1737 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1741 else if (VECTORP (collection
))
1743 /* Bypass intern-soft as that loses for nil. */
1744 tem
= oblookup (collection
,
1750 if (STRING_MULTIBYTE (string
))
1751 string
= Fstring_make_unibyte (string
);
1753 string
= Fstring_make_multibyte (string
);
1755 tem
= oblookup (collection
,
1761 if (completion_ignore_case
&& !SYMBOLP (tem
))
1763 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1765 tail
= XVECTOR (collection
)->contents
[i
];
1769 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1770 Fsymbol_name (tail
),
1771 make_number (0) , Qnil
, Qt
),
1777 if (XSYMBOL (tail
)->next
== 0)
1779 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1787 else if (HASH_TABLE_P (collection
))
1789 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1790 i
= hash_lookup (h
, string
, NULL
);
1792 tem
= HASH_KEY (h
, i
);
1794 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1795 if (!NILP (HASH_HASH (h
, i
))
1796 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1797 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1798 completion_ignore_case
? Qt
: Qnil
),
1801 tem
= HASH_KEY (h
, i
);
1808 return call3 (collection
, string
, predicate
, Qlambda
);
1810 /* Reject this element if it fails to match all the regexps. */
1811 if (CONSP (Vcompletion_regexp_list
))
1813 int count
= SPECPDL_INDEX ();
1814 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1815 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1816 regexps
= XCDR (regexps
))
1818 if (NILP (Fstring_match (XCAR (regexps
),
1819 SYMBOLP (tem
) ? string
: tem
,
1821 return unbind_to (count
, Qnil
);
1823 unbind_to (count
, Qnil
);
1826 /* Finally, check the predicate. */
1827 if (!NILP (predicate
))
1829 return HASH_TABLE_P (collection
)
1830 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1831 : call1 (predicate
, tem
);
1837 static Lisp_Object Qmetadata
;
1838 extern Lisp_Object Qbuffer
;
1840 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1841 doc
: /* Perform completion on buffer names.
1842 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1843 `all-completions', otherwise invoke `test-completion'.
1845 The arguments STRING and PREDICATE are as in `try-completion',
1846 `all-completions', and `test-completion'. */)
1847 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1850 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1851 else if (EQ (flag
, Qt
))
1853 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1854 if (SCHARS (string
) > 0)
1857 { /* Strip out internal buffers. */
1858 Lisp_Object bufs
= res
;
1859 /* First, look for a non-internal buffer in `res'. */
1860 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1863 /* All bufs in `res' are internal, so don't trip them out. */
1866 while (CONSP (XCDR (bufs
)))
1867 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1868 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1874 else if (EQ (flag
, Qlambda
))
1875 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1876 else if (EQ (flag
, Qmetadata
))
1877 return Fcons (Qmetadata
, Fcons (Fcons (Qcategory
, Qbuffer
), Qnil
));
1882 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1884 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1885 doc
: /* Like `assoc' but specifically for strings (and symbols).
1887 This returns the first element of LIST whose car matches the string or
1888 symbol KEY, or nil if no match exists. When performing the
1889 comparison, symbols are first converted to strings, and unibyte
1890 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1893 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1894 single string, rather than a cons cell whose car is a string. */)
1895 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1897 register Lisp_Object tail
;
1900 key
= Fsymbol_name (key
);
1902 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1904 register Lisp_Object elt
, tem
, thiscar
;
1906 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1907 if (SYMBOLP (thiscar
))
1908 thiscar
= Fsymbol_name (thiscar
);
1909 else if (!STRINGP (thiscar
))
1911 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1912 key
, make_number (0), Qnil
,
1922 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1923 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1926 return make_number (minibuf_level
);
1929 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1930 doc
: /* Return the prompt string of the currently-active minibuffer.
1931 If no minibuffer is active, return nil. */)
1934 return Fcopy_sequence (minibuf_prompt
);
1939 init_minibuf_once (void)
1941 Vminibuffer_list
= Qnil
;
1942 staticpro (&Vminibuffer_list
);
1946 syms_of_minibuf (void)
1949 minibuf_prompt
= Qnil
;
1950 staticpro (&minibuf_prompt
);
1952 minibuf_save_list
= Qnil
;
1953 staticpro (&minibuf_save_list
);
1955 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1956 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1957 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1958 Fset (Qminibuffer_default
, Qnil
);
1960 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1961 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1962 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1964 staticpro (&last_minibuf_string
);
1965 last_minibuf_string
= Qnil
;
1967 DEFSYM (Quser_variable_p
, "user-variable-p");
1968 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1969 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1970 Fset (Qbuffer_name_history
, Qnil
);
1972 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1973 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1974 DEFSYM (Qhistory_length
, "history-length");
1975 DEFSYM (Qcurrent_input_method
, "current-input-method");
1976 DEFSYM (Qactivate_input_method
, "activate-input-method");
1977 DEFSYM (Qcase_fold_search
, "case-fold-search");
1978 DEFSYM (Qmetadata
, "metadata");
1980 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1981 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1982 For example, `eval-expression' uses this. */);
1983 Vread_expression_history
= Qnil
;
1985 DEFSYM (Qread_expression_history
, "read-expression-history");
1987 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1988 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1989 The function is called with the arguments passed to `read-buffer'. */);
1990 Vread_buffer_function
= Qnil
;
1992 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1993 read_buffer_completion_ignore_case
,
1994 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
1995 read_buffer_completion_ignore_case
= 0;
1997 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1998 doc
: /* Normal hook run just after entry to minibuffer. */);
1999 Vminibuffer_setup_hook
= Qnil
;
2001 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
2002 doc
: /* Normal hook run just after exit from minibuffer. */);
2003 Vminibuffer_exit_hook
= Qnil
;
2005 DEFVAR_LISP ("history-length", Vhistory_length
,
2006 doc
: /* *Maximum length for history lists before truncation takes place.
2007 A number means that length; t means infinite. Truncation takes place
2008 just after a new element is inserted. Setting the `history-length'
2009 property of a history variable overrides this default. */);
2010 XSETFASTINT (Vhistory_length
, 30);
2012 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
2013 doc
: /* *Non-nil means to delete duplicates in history.
2014 If set to t when adding a new history element, all previous identical
2015 elements are deleted from the history list. */);
2016 history_delete_duplicates
= 0;
2018 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
2019 doc
: /* *Non-nil means to add new elements in history.
2020 If set to nil, minibuffer reading functions don't add new elements to the
2021 history list, so it is possible to do this afterwards by calling
2022 `add-to-history' explicitly. */);
2023 Vhistory_add_new_input
= Qt
;
2025 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
2026 doc
: /* Non-nil means don't consider case significant in completion.
2027 For file-name completion, `read-file-name-completion-ignore-case'
2028 controls the behavior, rather than this variable.
2029 For buffer name completion, `read-buffer-completion-ignore-case'
2030 controls the behavior, rather than this variable. */);
2031 completion_ignore_case
= 0;
2033 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
2034 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2035 This variable makes a difference whenever the minibuffer window is active. */);
2036 enable_recursive_minibuffers
= 0;
2038 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2039 doc
: /* Alist or obarray used for completion in the minibuffer.
2040 This becomes the ALIST argument to `try-completion' and `all-completions'.
2041 The value can also be a list of strings or a hash table.
2043 The value may alternatively be a function, which is given three arguments:
2044 STRING, the current buffer contents;
2045 PREDICATE, the predicate for filtering possible matches;
2046 CODE, which says what kind of things to do.
2047 CODE can be nil, t or `lambda':
2048 nil -- return the best completion of STRING, or nil if there is none.
2049 t -- return a list of all possible completions of STRING.
2050 lambda -- return t if STRING is a valid completion as it stands. */);
2051 Vminibuffer_completion_table
= Qnil
;
2053 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2054 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2055 Vminibuffer_completion_predicate
= Qnil
;
2057 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2058 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2059 If nil, confirmation is not required.
2060 If the value is `confirm', the user may exit with an input that is not
2061 a valid completion alternative, but Emacs asks for confirmation.
2062 If the value is `confirm-after-completion', the user may exit with an
2063 input that is not a valid completion alternative, but Emacs asks for
2064 confirmation if the user submitted the input right after any of the
2065 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2066 Vminibuffer_completion_confirm
= Qnil
;
2068 DEFVAR_LISP ("minibuffer-completing-file-name",
2069 Vminibuffer_completing_file_name
,
2070 doc
: /* Non-nil means completing file names. */);
2071 Vminibuffer_completing_file_name
= Qnil
;
2073 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2074 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2075 Vminibuffer_help_form
= Qnil
;
2077 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2078 doc
: /* History list symbol to add minibuffer values to.
2079 Each string of minibuffer input, as it appears on exit from the minibuffer,
2081 (set minibuffer-history-variable
2082 (cons STRING (symbol-value minibuffer-history-variable))) */);
2083 XSETFASTINT (Vminibuffer_history_variable
, 0);
2085 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2086 doc
: /* Current position of redoing in the history list. */);
2087 Vminibuffer_history_position
= Qnil
;
2089 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2090 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2091 Some uses of the echo area also raise that frame (since they use it too). */);
2092 minibuffer_auto_raise
= 0;
2094 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2095 doc
: /* List of regexps that should restrict possible completions.
2096 The basic completion functions only consider a completion acceptable
2097 if it matches all regular expressions in this list, with
2098 `case-fold-search' bound to the value of `completion-ignore-case'.
2099 See Info node `(elisp)Basic Completion', for a description of these
2101 Vcompletion_regexp_list
= Qnil
;
2103 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2104 minibuffer_allow_text_properties
,
2105 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2106 This also affects `read-string', but it does not affect `read-minibuffer',
2107 `read-no-blanks-input', or any of the functions that do minibuffer input
2108 with completion; they always discard text properties. */);
2109 minibuffer_allow_text_properties
= 0;
2111 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2112 doc
: /* Text properties that are added to minibuffer prompts.
2113 These are in addition to the basic `field' property, and stickiness
2115 /* We use `intern' here instead of Qread_only to avoid
2116 initialization-order problems. */
2117 Vminibuffer_prompt_properties
2118 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2120 DEFVAR_LISP ("read-expression-map", Vread_expression_map
,
2121 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2122 Vread_expression_map
= Qnil
;
2124 defsubr (&Sactive_minibuffer_window
);
2125 defsubr (&Sset_minibuffer_window
);
2126 defsubr (&Sread_from_minibuffer
);
2127 defsubr (&Seval_minibuffer
);
2128 defsubr (&Sread_minibuffer
);
2129 defsubr (&Sread_string
);
2130 defsubr (&Sread_command
);
2131 defsubr (&Sread_variable
);
2132 defsubr (&Sinternal_complete_buffer
);
2133 defsubr (&Sread_buffer
);
2134 defsubr (&Sread_no_blanks_input
);
2135 defsubr (&Sminibuffer_depth
);
2136 defsubr (&Sminibuffer_prompt
);
2138 defsubr (&Sminibufferp
);
2139 defsubr (&Sminibuffer_prompt_end
);
2140 defsubr (&Sminibuffer_contents
);
2141 defsubr (&Sminibuffer_contents_no_properties
);
2142 defsubr (&Sminibuffer_completion_contents
);
2144 defsubr (&Stry_completion
);
2145 defsubr (&Sall_completions
);
2146 defsubr (&Stest_completion
);
2147 defsubr (&Sassoc_string
);
2148 defsubr (&Scompleting_read
);