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/>. */
28 #include "character.h"
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 Qcompleting_read_default
;
76 static Lisp_Object Quser_variable_p
;
78 static Lisp_Object Qminibuffer_default
;
80 static Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
82 static Lisp_Object Qcase_fold_search
;
84 static Lisp_Object Qread_expression_history
;
86 /* Prompt to display in front of the mini-buffer contents. */
88 static Lisp_Object minibuf_prompt
;
90 /* Width of current mini-buffer prompt. Only set after display_line
91 of the line that contains the prompt. */
93 static EMACS_INT minibuf_prompt_width
;
96 /* Put minibuf on currently selected frame's minibuffer.
97 We do this whenever the user starts a new minibuffer
98 or when a minibuffer exits. */
101 choose_minibuf_frame (void)
103 if (FRAMEP (selected_frame
)
104 && FRAME_LIVE_P (XFRAME (selected_frame
))
105 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
107 struct frame
*sf
= XFRAME (selected_frame
);
110 /* I don't think that any frames may validly have a null minibuffer
112 if (NILP (sf
->minibuffer_window
))
115 /* Under X, we come here with minibuf_window being the
116 minibuffer window of the unused termcap window created in
117 init_window_once. That window doesn't have a buffer. */
118 buffer
= XWINDOW (minibuf_window
)->buffer
;
119 if (BUFFERP (buffer
))
120 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
121 minibuf_window
= sf
->minibuffer_window
;
124 /* Make sure no other frame has a minibuffer as its selected window,
125 because the text would not be displayed in it, and that would be
126 confusing. Only allow the selected frame to do this,
127 and that only if the minibuffer is active. */
129 Lisp_Object tail
, frame
;
131 FOR_EACH_FRAME (tail
, frame
)
132 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
133 && !(EQ (frame
, selected_frame
)
134 && minibuf_level
> 0))
135 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
140 choose_minibuf_frame_1 (Lisp_Object ignore
)
142 choose_minibuf_frame ();
146 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
147 Sactive_minibuffer_window
, 0, 0, 0,
148 doc
: /* Return the currently active minibuffer window, or nil if none. */)
151 return minibuf_level
? minibuf_window
: Qnil
;
154 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
155 Sset_minibuffer_window
, 1, 1, 0,
156 doc
: /* Specify which minibuffer window to use for the minibuffer.
157 This affects where the minibuffer is displayed if you put text in it
158 without invoking the usual minibuffer commands. */)
161 CHECK_WINDOW (window
);
162 if (! MINI_WINDOW_P (XWINDOW (window
)))
163 error ("Window is not a minibuffer window");
165 minibuf_window
= window
;
171 /* Actual minibuffer invocation. */
173 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
174 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
175 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
176 Lisp_Object
, Lisp_Object
,
178 Lisp_Object
, Lisp_Object
,
180 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
181 Lisp_Object
, Lisp_Object
,
183 Lisp_Object
, Lisp_Object
,
185 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
188 /* Read a Lisp object from VAL and return it. If VAL is an empty
189 string, and DEFALT is a string, read from DEFALT instead of VAL. */
192 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
194 struct gcpro gcpro1
, gcpro2
;
195 Lisp_Object expr_and_pos
;
198 GCPRO2 (val
, defalt
);
200 if (STRINGP (val
) && SCHARS (val
) == 0)
202 if (STRINGP (defalt
))
204 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
208 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
209 pos
= XINT (Fcdr (expr_and_pos
));
210 if (pos
!= SCHARS (val
))
212 /* Ignore trailing whitespace; any other trailing junk
215 pos
= string_char_to_byte (val
, pos
);
216 for (i
= pos
; i
< SBYTES (val
); i
++)
218 int c
= SREF (val
, i
);
219 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
220 error ("Trailing garbage following expression");
224 val
= Fcar (expr_and_pos
);
225 RETURN_UNGCPRO (val
);
229 /* Like read_minibuf but reading from stdin. This function is called
230 from read_minibuf to do the job if noninteractive. */
233 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
234 Lisp_Object prompt
, Lisp_Object backup_n
,
236 Lisp_Object histvar
, Lisp_Object histpos
,
238 int allow_props
, int inherit_input_method
)
244 fprintf (stdout
, "%s", SDATA (prompt
));
250 line
= (char *) xmalloc (size
* sizeof *line
);
251 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
252 && (len
= strlen (line
),
253 len
== size
- 1 && line
[len
- 1] != '\n'))
255 if ((size_t) -1 / 2 < size
)
256 memory_full (SIZE_MAX
);
258 line
= (char *) xrealloc (line
, size
);
265 if (len
> 0 && line
[len
- 1] == '\n')
268 val
= build_string (line
);
274 error ("Error reading from stdin");
277 /* If Lisp form desired instead of string, parse it. */
279 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
284 DEFUN ("minibufferp", Fminibufferp
,
285 Sminibufferp
, 0, 1, 0,
286 doc
: /* Return t if BUFFER is a minibuffer.
287 No argument or nil as argument means use current buffer as BUFFER.
288 BUFFER can be a buffer or a buffer name. */)
294 buffer
= Fcurrent_buffer ();
295 else if (STRINGP (buffer
))
296 buffer
= Fget_buffer (buffer
);
298 CHECK_BUFFER (buffer
);
300 tem
= Fmemq (buffer
, Vminibuffer_list
);
301 return ! NILP (tem
) ? Qt
: Qnil
;
304 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
305 Sminibuffer_prompt_end
, 0, 0, 0,
306 doc
: /* Return the buffer position of the end of the minibuffer prompt.
307 Return (point-min) if current buffer is not a minibuffer. */)
310 /* This function is written to be most efficient when there's a prompt. */
311 Lisp_Object beg
, end
, tem
;
312 beg
= make_number (BEGV
);
314 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
318 end
= Ffield_end (beg
, Qnil
, Qnil
);
320 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
326 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
327 Sminibuffer_contents
, 0, 0, 0,
328 doc
: /* Return the user input in a minibuffer as a string.
329 If the current buffer is not a minibuffer, return its entire contents. */)
332 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
333 return make_buffer_string (prompt_end
, ZV
, 1);
336 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
337 Sminibuffer_contents_no_properties
, 0, 0, 0,
338 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
339 If the current buffer is not a minibuffer, return its entire contents. */)
342 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
343 return make_buffer_string (prompt_end
, ZV
, 0);
346 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
347 Sminibuffer_completion_contents
, 0, 0, 0,
348 doc
: /* Return the user input in a minibuffer before point as a string.
349 That is what completion commands operate on.
350 If the current buffer is not a minibuffer, return its entire contents. */)
353 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
355 error ("Cannot do completion in the prompt");
356 return make_buffer_string (prompt_end
, PT
, 1);
360 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
361 putting point minus BACKUP_N bytes from the end of INITIAL,
362 prompting with PROMPT (a string), using history list HISTVAR
363 with initial position HISTPOS. INITIAL should be a string or a
364 cons of a string and an integer. BACKUP_N should be <= 0, or
365 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
366 ignored and replaced with an integer that puts point at one-indexed
367 position N in INITIAL, where N is the CDR of INITIAL, or at the
368 beginning of INITIAL if N <= 0.
370 Normally return the result as a string (the text that was read),
371 but if EXPFLAG is nonzero, read it and return the object read.
372 If HISTVAR is given, save the value read on that history only if it doesn't
373 match the front of that history list exactly. The value is pushed onto
374 the list as the string that was read.
376 DEFALT specifies the default value for the sake of history commands.
378 If ALLOW_PROPS is nonzero, we do not throw away text properties.
380 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
381 current input method. */
384 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
385 Lisp_Object backup_n
, int expflag
,
386 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
387 int allow_props
, int inherit_input_method
)
390 int count
= SPECPDL_INDEX ();
391 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
392 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
393 Lisp_Object enable_multibyte
;
394 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
395 /* String to add to the history. */
396 Lisp_Object histstring
;
398 Lisp_Object empty_minibuf
;
399 Lisp_Object dummy
, frame
;
401 specbind (Qminibuffer_default
, defalt
);
403 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
404 in previous recursive minibuffer, but was not set explicitly
405 to t for this invocation, so set it to nil in this minibuffer.
406 Save the old value now, before we change it. */
407 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
408 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
409 Vminibuffer_completing_file_name
= Qnil
;
411 #ifdef HAVE_WINDOW_SYSTEM
412 if (display_hourglass_p
)
420 backup_n
= Fcdr (initial
);
421 initial
= Fcar (initial
);
422 CHECK_STRING (initial
);
423 if (!NILP (backup_n
))
425 CHECK_NUMBER (backup_n
);
426 /* Convert to distance from end of input. */
427 if (XINT (backup_n
) < 1)
428 /* A number too small means the beginning of the string. */
429 pos
= - SCHARS (initial
);
431 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
435 CHECK_STRING (initial
);
438 ambient_dir
= BVAR (current_buffer
, directory
);
440 enable_multibyte
= Qnil
;
442 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
443 store them away before we can GC. Don't need to protect
444 BACKUP_N because we use the value only if it is an integer. */
445 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
447 if (!STRINGP (prompt
))
448 prompt
= empty_unibyte_string
;
450 if (!enable_recursive_minibuffers
451 && minibuf_level
> 0)
453 if (EQ (selected_window
, minibuf_window
))
454 error ("Command attempted to use minibuffer while in minibuffer");
456 /* If we're in another window, cancel the minibuffer that's active. */
458 build_string ("Command attempted to use minibuffer while in minibuffer"));
462 /* In case we are running as a daemon, only do this before
463 detaching from the terminal. */
464 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
465 && NILP (Vexecuting_kbd_macro
))
467 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
469 expflag
, histvar
, histpos
, defalt
,
470 allow_props
, inherit_input_method
);
472 return unbind_to (count
, val
);
475 /* Choose the minibuffer window and frame, and take action on them. */
477 choose_minibuf_frame ();
479 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
481 record_unwind_protect (Fset_window_configuration
,
482 Fcurrent_window_configuration (Qnil
));
484 /* If the minibuffer window is on a different frame, save that
485 frame's configuration too. */
486 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
487 if (!EQ (mini_frame
, selected_frame
))
488 record_unwind_protect (Fset_window_configuration
,
489 Fcurrent_window_configuration (mini_frame
));
491 /* If the minibuffer is on an iconified or invisible frame,
492 make it visible now. */
493 Fmake_frame_visible (mini_frame
);
495 if (minibuffer_auto_raise
)
496 Fraise_frame (mini_frame
);
498 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
500 /* We have to do this after saving the window configuration
501 since that is what restores the current buffer. */
503 /* Arrange to restore a number of minibuffer-related variables.
504 We could bind each variable separately, but that would use lots of
507 = Fcons (Voverriding_local_map
,
508 Fcons (minibuf_window
,
511 = Fcons (minibuf_prompt
,
512 Fcons (make_number (minibuf_prompt_width
),
514 Fcons (Vcurrent_prefix_arg
,
515 Fcons (Vminibuffer_history_position
,
516 Fcons (Vminibuffer_history_variable
,
517 minibuf_save_list
))))));
519 record_unwind_protect (read_minibuf_unwind
, Qnil
);
521 /* We are exiting the minibuffer one way or the other, so run the hook.
522 It should be run before unwinding the minibuf settings. Do it
523 separately from read_minibuf_unwind because we need to make sure that
524 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
525 signals an error. --Stef */
526 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
528 /* Now that we can restore all those variables, start changing them. */
530 minibuf_prompt_width
= 0;
531 minibuf_prompt
= Fcopy_sequence (prompt
);
532 Vminibuffer_history_position
= histpos
;
533 Vminibuffer_history_variable
= histvar
;
534 Vhelp_form
= Vminibuffer_help_form
;
535 /* If this minibuffer is reading a file name, that doesn't mean
536 recursive ones are. But we cannot set it to nil, because
537 completion code still need to know the minibuffer is completing a
538 file name. So use `lambda' as intermediate value meaning
539 "t" in this minibuffer, but "nil" in next minibuffer. */
540 if (!NILP (Vminibuffer_completing_file_name
))
541 Vminibuffer_completing_file_name
= Qlambda
;
543 if (inherit_input_method
)
545 /* `current-input-method' is buffer local. So, remember it in
546 INPUT_METHOD before changing the current buffer. */
547 input_method
= Fsymbol_value (Qcurrent_input_method
);
548 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
551 /* Switch to the minibuffer. */
553 minibuffer
= get_minibuffer (minibuf_level
);
554 Fset_buffer (minibuffer
);
556 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
557 if (inherit_input_method
)
558 BVAR (current_buffer
, enable_multibyte_characters
) = enable_multibyte
;
560 /* The current buffer's default directory is usually the right thing
561 for our minibuffer here. However, if you're typing a command at
562 a minibuffer-only frame when minibuf_level is zero, then buf IS
563 the current_buffer, so reset_buffer leaves buf's default
564 directory unchanged. This is a bummer when you've just started
565 up Emacs and buf's default directory is Qnil. Here's a hack; can
566 you think of something better to do? Find another buffer with a
567 better directory, and use that one instead. */
568 if (STRINGP (ambient_dir
))
569 BVAR (current_buffer
, directory
) = ambient_dir
;
572 Lisp_Object buf_list
;
574 for (buf_list
= Vbuffer_alist
;
576 buf_list
= XCDR (buf_list
))
578 Lisp_Object other_buf
;
580 other_buf
= XCDR (XCAR (buf_list
));
581 if (STRINGP (BVAR (XBUFFER (other_buf
), directory
)))
583 BVAR (current_buffer
, directory
) = BVAR (XBUFFER (other_buf
), directory
);
589 if (!EQ (mini_frame
, selected_frame
))
590 Fredirect_frame_focus (selected_frame
, mini_frame
);
592 Vminibuf_scroll_window
= selected_window
;
593 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
594 minibuf_selected_window
= selected_window
;
596 /* Empty out the minibuffers of all frames other than the one
597 where we are going to display one now.
598 Set them to point to ` *Minibuf-0*', which is always empty. */
599 empty_minibuf
= get_minibuffer (0);
601 FOR_EACH_FRAME (dummy
, frame
)
603 Lisp_Object root_window
= Fframe_root_window (frame
);
604 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
606 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
607 && !NILP (Fwindow_minibuffer_p (mini_window
)))
608 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
611 /* Display this minibuffer in the proper window. */
612 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
613 Fselect_window (minibuf_window
, Qnil
);
614 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
616 Fmake_local_variable (Qprint_escape_newlines
);
617 print_escape_newlines
= 1;
619 /* Erase the buffer. */
621 int count1
= SPECPDL_INDEX ();
622 specbind (Qinhibit_read_only
, Qt
);
623 specbind (Qinhibit_modification_hooks
, Qt
);
626 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
627 && ! STRING_MULTIBYTE (minibuf_prompt
))
628 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
630 /* Insert the prompt, record where it ends. */
631 Finsert (1, &minibuf_prompt
);
634 Fput_text_property (make_number (BEG
), make_number (PT
),
635 Qfront_sticky
, Qt
, Qnil
);
636 Fput_text_property (make_number (BEG
), make_number (PT
),
637 Qrear_nonsticky
, Qt
, Qnil
);
638 Fput_text_property (make_number (BEG
), make_number (PT
),
640 Fadd_text_properties (make_number (BEG
), make_number (PT
),
641 Vminibuffer_prompt_properties
, Qnil
);
643 unbind_to (count1
, Qnil
);
646 minibuf_prompt_width
= current_column ();
648 /* Put in the initial input. */
651 Finsert (1, &initial
);
652 Fforward_char (make_number (pos
));
655 clear_message (1, 1);
656 BVAR (current_buffer
, keymap
) = map
;
658 /* Turn on an input method stored in INPUT_METHOD if any. */
659 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
660 call1 (Qactivate_input_method
, input_method
);
662 Frun_hooks (1, &Qminibuffer_setup_hook
);
664 /* Don't allow the user to undo past this point. */
665 BVAR (current_buffer
, undo_list
) = Qnil
;
669 /* If cursor is on the minibuffer line,
670 show the user we have exited by putting it in column 0. */
671 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
674 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
675 XWINDOW (minibuf_window
)->cursor
.x
= 0;
676 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
677 update_frame (XFRAME (selected_frame
), 1, 1);
679 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
680 struct redisplay_interface
*rif
= FRAME_RIF (f
);
681 if (rif
&& rif
->flush_display
)
682 rif
->flush_display (f
);
686 /* Make minibuffer contents into a string. */
687 Fset_buffer (minibuffer
);
689 val
= Fminibuffer_contents ();
691 val
= Fminibuffer_contents_no_properties ();
693 /* VAL is the string of minibuffer text. */
695 last_minibuf_string
= val
;
697 /* Choose the string to add to the history. */
698 if (SCHARS (val
) != 0)
700 else if (STRINGP (defalt
))
702 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
703 histstring
= XCAR (defalt
);
707 /* Add the value to the appropriate history list, if any. */
708 if (!NILP (Vhistory_add_new_input
)
709 && SYMBOLP (Vminibuffer_history_variable
)
710 && !NILP (histstring
))
712 /* If the caller wanted to save the value read on a history list,
713 then do so if the value is not already the front of the list. */
716 /* If variable is unbound, make it nil. */
718 histval
= find_symbol_value (Vminibuffer_history_variable
);
719 if (EQ (histval
, Qunbound
))
720 Fset (Vminibuffer_history_variable
, Qnil
);
722 /* The value of the history variable must be a cons or nil. Other
723 values are unacceptable. We silently ignore these values. */
727 /* Don't duplicate the most recent entry in the history. */
728 && (NILP (Fequal (histstring
, Fcar (histval
))))))
732 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
733 histval
= Fcons (histstring
, histval
);
734 Fset (Vminibuffer_history_variable
, histval
);
736 /* Truncate if requested. */
737 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
738 if (NILP (length
)) length
= Vhistory_length
;
739 if (INTEGERP (length
))
741 if (XINT (length
) <= 0)
742 Fset (Vminibuffer_history_variable
, Qnil
);
747 temp
= Fnthcdr (Fsub1 (length
), histval
);
748 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
754 /* If Lisp form desired instead of string, parse it. */
756 val
= string_to_object (val
, defalt
);
758 /* The appropriate frame will get selected
759 in set-window-configuration. */
761 return unbind_to (count
, val
);
764 /* Return a buffer to be used as the minibuffer at depth `depth'.
765 depth = 0 is the lowest allowed argument, and that is the value
766 used for nonrecursive minibuffer invocations. */
769 get_minibuffer (int depth
)
771 Lisp_Object tail
, num
, buf
;
774 XSETFASTINT (num
, depth
);
775 tail
= Fnthcdr (num
, Vminibuffer_list
);
778 tail
= Fcons (Qnil
, Qnil
);
779 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
782 if (NILP (buf
) || NILP (BVAR (XBUFFER (buf
), name
)))
784 sprintf (name
, " *Minibuf-%d*", depth
);
785 buf
= Fget_buffer_create (build_string (name
));
787 /* Although the buffer's name starts with a space, undo should be
789 Fbuffer_enable_undo (buf
);
795 int count
= SPECPDL_INDEX ();
796 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
797 have to empty the list, otherwise we end up with overlays that
798 think they belong to this buffer while the buffer doesn't know about
800 delete_all_overlays (XBUFFER (buf
));
801 reset_buffer (XBUFFER (buf
));
802 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
804 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
805 call0 (intern ("minibuffer-inactive-mode"));
807 Fkill_all_local_variables ();
808 unbind_to (count
, Qnil
);
815 run_exit_minibuf_hook (Lisp_Object data
)
817 safe_run_hooks (Qminibuffer_exit_hook
);
821 /* This function is called on exiting minibuffer, whether normally or
822 not, and it restores the current window, buffer, etc. */
825 read_minibuf_unwind (Lisp_Object data
)
827 Lisp_Object old_deactivate_mark
;
830 /* If this was a recursive minibuffer,
831 tie the minibuffer window back to the outer level minibuffer buffer. */
834 window
= minibuf_window
;
835 /* To keep things predictable, in case it matters, let's be in the
836 minibuffer when we reset the relevant variables. */
837 Fset_buffer (XWINDOW (window
)->buffer
);
839 /* Restore prompt, etc, from outer minibuffer level. */
840 minibuf_prompt
= Fcar (minibuf_save_list
);
841 minibuf_save_list
= Fcdr (minibuf_save_list
);
842 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
843 minibuf_save_list
= Fcdr (minibuf_save_list
);
844 Vhelp_form
= Fcar (minibuf_save_list
);
845 minibuf_save_list
= Fcdr (minibuf_save_list
);
846 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
847 minibuf_save_list
= Fcdr (minibuf_save_list
);
848 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
849 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
851 minibuf_save_list
= Fcdr (minibuf_save_list
);
852 Voverriding_local_map
= Fcar (minibuf_save_list
);
853 minibuf_save_list
= Fcdr (minibuf_save_list
);
855 temp
= Fcar (minibuf_save_list
);
856 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
857 minibuf_window
= temp
;
859 minibuf_save_list
= Fcdr (minibuf_save_list
);
861 /* Erase the minibuffer we were using at this level. */
863 int count
= SPECPDL_INDEX ();
864 /* Prevent error in erase-buffer. */
865 specbind (Qinhibit_read_only
, Qt
);
866 specbind (Qinhibit_modification_hooks
, Qt
);
867 old_deactivate_mark
= Vdeactivate_mark
;
869 Vdeactivate_mark
= old_deactivate_mark
;
870 unbind_to (count
, Qnil
);
873 /* When we get to the outmost level, make sure we resize the
874 mini-window back to its normal size. */
875 if (minibuf_level
== 0)
876 resize_mini_window (XWINDOW (window
), 0);
878 /* Make sure minibuffer window is erased, not ignored. */
879 windows_or_buffers_changed
++;
880 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
881 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
883 /* In case the previous minibuffer displayed in this miniwindow is
884 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
885 to make sure we don't leave around bindings and stuff which only
886 made sense during the read_minibuf invocation. */
887 call0 (intern ("minibuffer-inactive-mode"));
892 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
893 Sread_from_minibuffer
, 1, 7, 0,
894 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
895 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
896 DEFAULT-VALUE. It normally should be nil in new code, except when
897 HIST is a cons. It is discussed in more detail below.
898 Third arg KEYMAP is a keymap to use whilst reading;
899 if omitted or nil, the default is `minibuffer-local-map'.
900 If fourth arg READ is non-nil, then interpret the result as a Lisp object
901 and return that object:
902 in other words, do `(car (read-from-string INPUT-STRING))'
903 Fifth arg HIST, if non-nil, specifies a history list and optionally
904 the initial position in the list. It can be a symbol, which is the
905 history list variable to use, or it can be a cons cell
906 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
907 to use, and HISTPOS is the initial position for use by the minibuffer
908 history commands. For consistency, you should also specify that
909 element of the history as the value of INITIAL-CONTENTS. Positions
910 are counted starting from 1 at the beginning of the list.
911 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
912 If non-nil, it is available for history commands, and as the value
913 (or the first element of the list of default values) to return
914 if the user enters the empty string. But, unless READ is non-nil,
915 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
916 empty input! It returns the empty string.
917 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
918 the current input method and the setting of `enable-multibyte-characters'.
919 If the variable `minibuffer-allow-text-properties' is non-nil,
920 then the string which is returned includes whatever text properties
921 were present in the minibuffer. Otherwise the value has no text properties.
923 The remainder of this documentation string describes the
924 INITIAL-CONTENTS argument in more detail. It is only relevant when
925 studying existing code, or when HIST is a cons. If non-nil,
926 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
927 reading input. Normally, point is put at the end of that string.
928 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
929 input is STRING, but point is placed at _one-indexed_ position
930 POSITION in the minibuffer. Any integer value less than or equal to
931 one puts point at the beginning of the string. *Note* that this
932 behavior differs from the way such arguments are used in `completing-read'
933 and some related functions, which use zero-indexing for POSITION. */)
934 (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
)
936 Lisp_Object histvar
, histpos
, val
;
939 CHECK_STRING (prompt
);
941 keymap
= Vminibuffer_local_map
;
943 keymap
= get_keymap (keymap
, 1, 0);
952 histvar
= Fcar_safe (hist
);
953 histpos
= Fcdr_safe (hist
);
956 histvar
= Qminibuffer_history
;
958 XSETFASTINT (histpos
, 0);
960 GCPRO1 (default_value
);
961 val
= read_minibuf (keymap
, initial_contents
, prompt
,
963 histvar
, histpos
, default_value
,
964 minibuffer_allow_text_properties
,
965 !NILP (inherit_input_method
));
970 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
971 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
972 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
973 is a string to insert in the minibuffer before reading.
974 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
975 Such arguments are used as in `read-from-minibuffer'.) */)
976 (Lisp_Object prompt
, Lisp_Object initial_contents
)
978 CHECK_STRING (prompt
);
979 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
980 prompt
, Qnil
, 1, Qminibuffer_history
,
981 make_number (0), Qnil
, 0, 0);
984 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
985 doc
: /* Return value of Lisp expression read using the minibuffer.
986 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
987 is a string to insert in the minibuffer before reading.
988 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
989 Such arguments are used as in `read-from-minibuffer'.) */)
990 (Lisp_Object prompt
, Lisp_Object initial_contents
)
992 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
993 prompt
, Qnil
, 1, Qread_expression_history
,
994 make_number (0), Qnil
, 0, 0),
998 /* Functions that use the minibuffer to read various things. */
1000 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1001 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1002 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1003 This argument has been superseded by DEFAULT-VALUE and should normally
1004 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1005 documentation string of that function for details.
1006 The third arg HISTORY, if non-nil, specifies a history list
1007 and optionally the initial position in the list.
1008 See `read-from-minibuffer' for details of HISTORY argument.
1009 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1010 If non-nil, it is used for history commands, and as the value (or the first
1011 element of the list of default values) to return if the user enters the
1013 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1014 the current input method and the setting of `enable-multibyte-characters'. */)
1015 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1018 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1019 Qnil
, history
, default_value
,
1020 inherit_input_method
);
1021 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1022 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1026 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1027 doc
: /* Read a string from the terminal, not allowing blanks.
1028 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1029 non-nil, it should be a string, which is used as initial input, with
1030 point positioned at the end, so that SPACE will accept the input.
1031 \(Actually, INITIAL can also be a cons of a string and an integer.
1032 Such values are treated as in `read-from-minibuffer', but are normally
1033 not useful in this function.)
1034 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1035 the current input method and the setting of`enable-multibyte-characters'. */)
1036 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1038 CHECK_STRING (prompt
);
1039 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1040 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1041 !NILP (inherit_input_method
));
1044 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1045 doc
: /* Read the name of a command and return as a symbol.
1046 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1047 if it is a list. */)
1048 (Lisp_Object prompt
, Lisp_Object default_value
)
1050 Lisp_Object name
, default_string
;
1052 if (NILP (default_value
))
1053 default_string
= Qnil
;
1054 else if (SYMBOLP (default_value
))
1055 default_string
= SYMBOL_NAME (default_value
);
1057 default_string
= default_value
;
1059 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1060 Qnil
, Qnil
, default_string
, Qnil
);
1063 return Fintern (name
, Qnil
);
1067 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1068 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1069 Prompt with PROMPT. */)
1070 (Lisp_Object prompt
)
1072 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1077 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1078 doc
: /* Read the name of a user variable and return it as a symbol.
1079 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1081 A user variable is one for which `user-variable-p' returns non-nil. */)
1082 (Lisp_Object prompt
, Lisp_Object default_value
)
1084 Lisp_Object name
, default_string
;
1086 if (NILP (default_value
))
1087 default_string
= Qnil
;
1088 else if (SYMBOLP (default_value
))
1089 default_string
= SYMBOL_NAME (default_value
);
1091 default_string
= default_value
;
1093 name
= Fcompleting_read (prompt
, Vobarray
,
1094 Quser_variable_p
, Qt
,
1095 Qnil
, Qnil
, default_string
, Qnil
);
1098 return Fintern (name
, Qnil
);
1101 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1102 doc
: /* Read the name of a buffer and return as a string.
1104 Optional second arg DEF is value to return if user enters an empty line.
1105 If DEF is a list of default values, return its first element.
1106 Optional third arg REQUIRE-MATCH determines whether non-existing
1107 buffer names are allowed. It has the same meaning as the
1108 REQUIRE-MATCH argument of `completing-read'.
1109 The argument PROMPT should be a string ending with a colon and a space.
1110 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1111 case while reading the buffer name.
1112 If `read-buffer-function' is non-nil, this works by calling it as a
1113 function, instead of the usual behavior. */)
1114 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1116 Lisp_Object args
[4], result
;
1119 int count
= SPECPDL_INDEX ();
1122 def
= BVAR (XBUFFER (def
), name
);
1124 specbind (Qcompletion_ignore_case
,
1125 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1127 if (NILP (Vread_buffer_function
))
1131 /* A default value was provided: we must change PROMPT,
1132 editing the default value in before the colon. To achieve
1133 this, we replace PROMPT with a substring that doesn't
1134 contain the terminal space and colon (if present). They
1135 are then added back using Fformat. */
1137 if (STRINGP (prompt
))
1139 s
= SSDATA (prompt
);
1140 len
= SBYTES (prompt
);
1141 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1143 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1146 prompt
= make_specified_string (s
, -1, len
,
1147 STRING_MULTIBYTE (prompt
));
1150 args
[0] = build_string ("%s (default %s): ");
1152 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1153 prompt
= Fformat (3, args
);
1156 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1157 Qnil
, require_match
, Qnil
,
1158 Qbuffer_name_history
, def
, Qnil
);
1162 args
[0] = Vread_buffer_function
;
1165 args
[3] = require_match
;
1166 result
= Ffuncall (4, args
);
1168 return unbind_to (count
, result
);
1172 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1174 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1177 if (STRING_MULTIBYTE (string
))
1178 return Fstring_make_unibyte (string
);
1180 return Fstring_make_multibyte (string
);
1183 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1184 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1185 Test each possible completion specified by COLLECTION
1186 to see if it begins with STRING. The possible completions may be
1187 strings or symbols. Symbols are converted to strings before testing,
1189 All that match STRING are compared together; the longest initial sequence
1190 common to all these matches is the return value.
1191 If there is no match at all, the return value is nil.
1192 For a unique match which is exact, the return value is t.
1194 If COLLECTION is an alist, the keys (cars of elements) are the
1195 possible completions. If an element is not a cons cell, then the
1196 element itself is the possible completion.
1197 If COLLECTION is a hash-table, all the keys that are strings or symbols
1198 are the possible completions.
1199 If COLLECTION is an obarray, the names of all symbols in the obarray
1200 are the possible completions.
1202 COLLECTION can also be a function to do the completion itself.
1203 It receives three arguments: the values STRING, PREDICATE and nil.
1204 Whatever it returns becomes the value of `try-completion'.
1206 If optional third argument PREDICATE is non-nil,
1207 it is used to test each possible match.
1208 The match is a candidate only if PREDICATE returns non-nil.
1209 The argument given to PREDICATE is the alist element
1210 or the symbol from the obarray. If COLLECTION is a hash-table,
1211 predicate is called with two arguments: the key and the value.
1212 Additionally to this predicate, `completion-regexp-list'
1213 is used to further constrain the set of candidates. */)
1214 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1216 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1217 /* Size in bytes of BESTMATCH. */
1218 int bestmatchsize
= 0;
1219 /* These are in bytes, too. */
1220 int compare
, matchsize
;
1221 enum { function_table
, list_table
, obarray_table
, hash_table
}
1222 type
= (HASH_TABLE_P (collection
) ? hash_table
1223 : VECTORP (collection
) ? obarray_table
1224 : ((NILP (collection
)
1225 || (CONSP (collection
)
1226 && (!SYMBOLP (XCAR (collection
))
1227 || NILP (XCAR (collection
)))))
1228 ? list_table
: function_table
));
1229 EMACS_INT idx
= 0, obsize
= 0;
1232 Lisp_Object bucket
, zero
, end
, tem
;
1233 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1235 CHECK_STRING (string
);
1236 if (type
== function_table
)
1237 return call3 (collection
, string
, predicate
, Qnil
);
1239 bestmatch
= bucket
= Qnil
;
1240 zero
= make_number (0);
1242 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1244 if (type
== obarray_table
)
1246 collection
= check_obarray (collection
);
1247 obsize
= ASIZE (collection
);
1248 bucket
= XVECTOR (collection
)->contents
[idx
];
1253 /* Get the next element of the alist, obarray, or hash-table. */
1254 /* Exit the loop if the elements are all used up. */
1255 /* elt gets the alist element or symbol.
1256 eltstring gets the name to check as a completion. */
1258 if (type
== list_table
)
1263 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1266 else if (type
== obarray_table
)
1268 if (!EQ (bucket
, zero
))
1270 if (!SYMBOLP (bucket
))
1271 error ("Bad data in guts of obarray");
1274 if (XSYMBOL (bucket
)->next
)
1275 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1277 XSETFASTINT (bucket
, 0);
1279 else if (++idx
>= obsize
)
1283 bucket
= XVECTOR (collection
)->contents
[idx
];
1287 else /* if (type == hash_table) */
1289 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1290 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1292 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1295 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1298 /* Is this element a possible completion? */
1300 if (SYMBOLP (eltstring
))
1301 eltstring
= Fsymbol_name (eltstring
);
1303 if (STRINGP (eltstring
)
1304 && SCHARS (string
) <= SCHARS (eltstring
)
1305 && (tem
= Fcompare_strings (eltstring
, zero
,
1306 make_number (SCHARS (string
)),
1308 completion_ignore_case
? Qt
: Qnil
),
1312 Lisp_Object regexps
;
1314 /* Ignore this element if it fails to match all the regexps. */
1316 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1317 regexps
= XCDR (regexps
))
1319 if (bindcount
< 0) {
1320 bindcount
= SPECPDL_INDEX ();
1321 specbind (Qcase_fold_search
,
1322 completion_ignore_case
? Qt
: Qnil
);
1324 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1328 if (CONSP (regexps
))
1332 /* Ignore this element if there is a predicate
1333 and the predicate doesn't like it. */
1335 if (!NILP (predicate
))
1337 if (EQ (predicate
, Qcommandp
))
1338 tem
= Fcommandp (elt
, Qnil
);
1343 unbind_to (bindcount
, Qnil
);
1346 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1347 tem
= (type
== hash_table
1348 ? call2 (predicate
, elt
,
1349 HASH_VALUE (XHASH_TABLE (collection
),
1351 : call1 (predicate
, elt
));
1354 if (NILP (tem
)) continue;
1357 /* Update computation of how much all possible completions match */
1359 if (NILP (bestmatch
))
1362 bestmatch
= eltstring
;
1363 bestmatchsize
= SCHARS (eltstring
);
1367 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1368 tem
= Fcompare_strings (bestmatch
, zero
,
1369 make_number (compare
),
1371 make_number (compare
),
1372 completion_ignore_case
? Qt
: Qnil
);
1374 matchsize
= compare
;
1375 else if (XINT (tem
) < 0)
1376 matchsize
= - XINT (tem
) - 1;
1378 matchsize
= XINT (tem
) - 1;
1380 if (completion_ignore_case
)
1382 /* If this is an exact match except for case,
1383 use it as the best match rather than one that is not an
1384 exact match. This way, we get the case pattern
1385 of the actual match. */
1386 if ((matchsize
== SCHARS (eltstring
)
1387 && matchsize
< SCHARS (bestmatch
))
1389 /* If there is more than one exact match ignoring case,
1390 and one of them is exact including case,
1392 /* If there is no exact match ignoring case,
1393 prefer a match that does not change the case
1395 ((matchsize
== SCHARS (eltstring
))
1397 (matchsize
== SCHARS (bestmatch
))
1398 && (tem
= Fcompare_strings (eltstring
, zero
,
1399 make_number (SCHARS (string
)),
1404 && (tem
= Fcompare_strings (bestmatch
, zero
,
1405 make_number (SCHARS (string
)),
1410 bestmatch
= eltstring
;
1412 if (bestmatchsize
!= SCHARS (eltstring
)
1413 || bestmatchsize
!= matchsize
)
1414 /* Don't count the same string multiple times. */
1416 bestmatchsize
= matchsize
;
1417 if (matchsize
<= SCHARS (string
)
1418 /* If completion-ignore-case is non-nil, don't
1419 short-circuit because we want to find the best
1420 possible match *including* case differences. */
1421 && !completion_ignore_case
1423 /* No need to look any further. */
1429 if (bindcount
>= 0) {
1430 unbind_to (bindcount
, Qnil
);
1434 if (NILP (bestmatch
))
1435 return Qnil
; /* No completions found. */
1436 /* If we are ignoring case, and there is no exact match,
1437 and no additional text was supplied,
1438 don't change the case of what the user typed. */
1439 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1440 && SCHARS (bestmatch
) > bestmatchsize
)
1441 return minibuf_conform_representation (string
, bestmatch
);
1443 /* Return t if the supplied string is an exact match (counting case);
1444 it does not require any change to be made. */
1445 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1448 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1449 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1450 return Fsubstring (bestmatch
, zero
, end
);
1453 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1454 doc
: /* Search for partial matches to STRING in COLLECTION.
1455 Test each of the possible completions specified by COLLECTION
1456 to see if it begins with STRING. The possible completions may be
1457 strings or symbols. Symbols are converted to strings before testing,
1459 The value is a list of all the possible completions that match STRING.
1461 If COLLECTION is an alist, the keys (cars of elements) are the
1462 possible completions. If an element is not a cons cell, then the
1463 element itself is the possible completion.
1464 If COLLECTION is a hash-table, all the keys that are strings or symbols
1465 are the possible completions.
1466 If COLLECTION is an obarray, the names of all symbols in the obarray
1467 are the possible completions.
1469 COLLECTION can also be a function to do the completion itself.
1470 It receives three arguments: the values STRING, PREDICATE and t.
1471 Whatever it returns becomes the value of `all-completions'.
1473 If optional third argument PREDICATE is non-nil,
1474 it is used to test each possible match.
1475 The match is a candidate only if PREDICATE returns non-nil.
1476 The argument given to PREDICATE is the alist element
1477 or the symbol from the obarray. If COLLECTION is a hash-table,
1478 predicate is called with two arguments: the key and the value.
1479 Additionally to this predicate, `completion-regexp-list'
1480 is used to further constrain the set of candidates.
1482 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1483 backward compatibility. If non-nil, strings in COLLECTION that start
1484 with a space are ignored unless STRING itself starts with a space. */)
1485 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1487 Lisp_Object tail
, elt
, eltstring
;
1488 Lisp_Object allmatches
;
1489 int type
= HASH_TABLE_P (collection
) ? 3
1490 : VECTORP (collection
) ? 2
1491 : NILP (collection
) || (CONSP (collection
)
1492 && (!SYMBOLP (XCAR (collection
))
1493 || NILP (XCAR (collection
))));
1494 EMACS_INT idx
= 0, obsize
= 0;
1496 Lisp_Object bucket
, tem
, zero
;
1497 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1499 CHECK_STRING (string
);
1501 return call3 (collection
, string
, predicate
, Qt
);
1502 allmatches
= bucket
= Qnil
;
1503 zero
= make_number (0);
1505 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1509 collection
= check_obarray (collection
);
1510 obsize
= ASIZE (collection
);
1511 bucket
= XVECTOR (collection
)->contents
[idx
];
1516 /* Get the next element of the alist, obarray, or hash-table. */
1517 /* Exit the loop if the elements are all used up. */
1518 /* elt gets the alist element or symbol.
1519 eltstring gets the name to check as a completion. */
1526 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1531 if (!EQ (bucket
, zero
))
1533 if (!SYMBOLP (bucket
))
1534 error ("Bad data in guts of obarray");
1537 if (XSYMBOL (bucket
)->next
)
1538 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1540 XSETFASTINT (bucket
, 0);
1542 else if (++idx
>= obsize
)
1546 bucket
= XVECTOR (collection
)->contents
[idx
];
1550 else /* if (type == 3) */
1552 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1553 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1555 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1558 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1561 /* Is this element a possible completion? */
1563 if (SYMBOLP (eltstring
))
1564 eltstring
= Fsymbol_name (eltstring
);
1566 if (STRINGP (eltstring
)
1567 && SCHARS (string
) <= SCHARS (eltstring
)
1568 /* If HIDE_SPACES, reject alternatives that start with space
1569 unless the input starts with space. */
1570 && (NILP (hide_spaces
)
1571 || (SBYTES (string
) > 0
1572 && SREF (string
, 0) == ' ')
1573 || SREF (eltstring
, 0) != ' ')
1574 && (tem
= Fcompare_strings (eltstring
, zero
,
1575 make_number (SCHARS (string
)),
1577 make_number (SCHARS (string
)),
1578 completion_ignore_case
? Qt
: Qnil
),
1582 Lisp_Object regexps
;
1584 /* Ignore this element if it fails to match all the regexps. */
1586 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1587 regexps
= XCDR (regexps
))
1589 if (bindcount
< 0) {
1590 bindcount
= SPECPDL_INDEX ();
1591 specbind (Qcase_fold_search
,
1592 completion_ignore_case
? Qt
: Qnil
);
1594 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1598 if (CONSP (regexps
))
1602 /* Ignore this element if there is a predicate
1603 and the predicate doesn't like it. */
1605 if (!NILP (predicate
))
1607 if (EQ (predicate
, Qcommandp
))
1608 tem
= Fcommandp (elt
, Qnil
);
1611 if (bindcount
>= 0) {
1612 unbind_to (bindcount
, Qnil
);
1615 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1617 ? call2 (predicate
, elt
,
1618 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1619 : call1 (predicate
, elt
);
1622 if (NILP (tem
)) continue;
1624 /* Ok => put it on the list. */
1625 allmatches
= Fcons (eltstring
, allmatches
);
1629 if (bindcount
>= 0) {
1630 unbind_to (bindcount
, Qnil
);
1634 return Fnreverse (allmatches
);
1637 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1638 doc
: /* Read a string in the minibuffer, with completion.
1639 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1640 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1641 COLLECTION can also be a function to do the completion itself.
1642 PREDICATE limits completion to a subset of COLLECTION.
1643 See `try-completion' and `all-completions' for more details
1644 on completion, COLLECTION, and PREDICATE.
1646 REQUIRE-MATCH can take the following values:
1647 - t means that the user is not allowed to exit unless
1648 the input is (or completes to) an element of COLLECTION or is null.
1649 - nil means that the user can exit with any input.
1650 - `confirm' means that the user can exit with any input, but she needs
1651 to confirm her choice if the input is not an element of COLLECTION.
1652 - `confirm-after-completion' means that the user can exit with any
1653 input, but she needs to confirm her choice if she called
1654 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1655 and the input is not an element of COLLECTION.
1656 - anything else behaves like t except that typing RET does not exit if it
1657 does non-null completion.
1659 If the input is null, `completing-read' returns DEF, or the first element
1660 of the list of default values, or an empty string if DEF is nil,
1661 regardless of the value of REQUIRE-MATCH.
1663 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1664 with point positioned at the end.
1665 If it is (STRING . POSITION), the initial input is STRING, but point
1666 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1667 that this is different from `read-from-minibuffer' and related
1668 functions, which use one-indexing for POSITION.) This feature is
1669 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1670 default value DEF instead. The user can yank the default value into
1671 the minibuffer easily using \\[next-history-element].
1673 HIST, if non-nil, specifies a history list and optionally the initial
1674 position in the list. It can be a symbol, which is the history list
1675 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1676 that case, HISTVAR is the history list variable to use, and HISTPOS
1677 is the initial position (the position in the list used by the
1678 minibuffer history commands). For consistency, you should also
1679 specify that element of the history as the value of
1680 INITIAL-INPUT. (This is the only case in which you should use
1681 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1682 1 at the beginning of the list. The variable `history-length'
1683 controls the maximum length of a history list.
1685 DEF, if non-nil, is the default value or the list of default values.
1687 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1688 the current input method and the setting of `enable-multibyte-characters'.
1690 Completion ignores case if the ambient value of
1691 `completion-ignore-case' is non-nil.
1693 See also `completing-read-function'. */)
1694 (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
)
1696 Lisp_Object args
[9];
1697 args
[0] = Vcompleting_read_function
;
1699 args
[2] = collection
;
1700 args
[3] = predicate
;
1701 args
[4] = require_match
;
1702 args
[5] = initial_input
;
1705 args
[8] = inherit_input_method
;
1706 return Ffuncall (9, args
);
1709 DEFUN ("completing-read-default", Fcompleting_read_default
, Scompleting_read_default
, 2, 8, 0,
1710 doc
: /* Default method for reading from the minibuffer with completion.
1711 See `completing-read' for the meaning of the arguments. */)
1712 (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
)
1714 Lisp_Object val
, histvar
, histpos
, position
;
1717 int count
= SPECPDL_INDEX ();
1718 struct gcpro gcpro1
;
1720 init
= initial_input
;
1723 specbind (Qminibuffer_completion_table
, collection
);
1724 specbind (Qminibuffer_completion_predicate
, predicate
);
1725 specbind (Qminibuffer_completion_confirm
,
1726 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1733 position
= Fcdr (init
);
1736 CHECK_STRING (init
);
1737 if (!NILP (position
))
1739 CHECK_NUMBER (position
);
1740 /* Convert to distance from end of input. */
1741 pos
= XINT (position
) - SCHARS (init
);
1752 histvar
= Fcar_safe (hist
);
1753 histpos
= Fcdr_safe (hist
);
1756 histvar
= Qminibuffer_history
;
1758 XSETFASTINT (histpos
, 0);
1760 val
= read_minibuf (NILP (require_match
)
1761 ? (NILP (Vminibuffer_completing_file_name
)
1762 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1763 ? Vminibuffer_local_completion_map
1764 : Vminibuffer_local_filename_completion_map
)
1765 : (NILP (Vminibuffer_completing_file_name
)
1766 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1767 ? Vminibuffer_local_must_match_map
1768 : Vminibuffer_local_filename_must_match_map
),
1769 init
, prompt
, make_number (pos
), 0,
1770 histvar
, histpos
, def
, 0,
1771 !NILP (inherit_input_method
));
1773 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1774 val
= CONSP (def
) ? XCAR (def
) : def
;
1776 RETURN_UNGCPRO (unbind_to (count
, val
));
1779 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1781 /* Test whether TXT is an exact completion. */
1782 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1783 doc
: /* Return non-nil if STRING is a valid completion.
1784 Takes the same arguments as `all-completions' and `try-completion'.
1785 If COLLECTION is a function, it is called with three arguments:
1786 the values STRING, PREDICATE and `lambda'. */)
1787 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1789 Lisp_Object regexps
, tail
, tem
= Qnil
;
1792 CHECK_STRING (string
);
1794 if ((CONSP (collection
)
1795 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1796 || NILP (collection
))
1798 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1802 else if (VECTORP (collection
))
1804 /* Bypass intern-soft as that loses for nil. */
1805 tem
= oblookup (collection
,
1811 if (STRING_MULTIBYTE (string
))
1812 string
= Fstring_make_unibyte (string
);
1814 string
= Fstring_make_multibyte (string
);
1816 tem
= oblookup (collection
,
1822 if (completion_ignore_case
&& !SYMBOLP (tem
))
1824 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1826 tail
= XVECTOR (collection
)->contents
[i
];
1830 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1831 Fsymbol_name (tail
),
1832 make_number (0) , Qnil
, Qt
),
1838 if (XSYMBOL (tail
)->next
== 0)
1840 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1848 else if (HASH_TABLE_P (collection
))
1850 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1851 i
= hash_lookup (h
, string
, NULL
);
1853 tem
= HASH_KEY (h
, i
);
1855 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1856 if (!NILP (HASH_HASH (h
, i
))
1857 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1858 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1859 completion_ignore_case
? Qt
: Qnil
),
1862 tem
= HASH_KEY (h
, i
);
1869 return call3 (collection
, string
, predicate
, Qlambda
);
1871 /* Reject this element if it fails to match all the regexps. */
1872 if (CONSP (Vcompletion_regexp_list
))
1874 int count
= SPECPDL_INDEX ();
1875 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1876 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1877 regexps
= XCDR (regexps
))
1879 if (NILP (Fstring_match (XCAR (regexps
),
1880 SYMBOLP (tem
) ? string
: tem
,
1882 return unbind_to (count
, Qnil
);
1884 unbind_to (count
, Qnil
);
1887 /* Finally, check the predicate. */
1888 if (!NILP (predicate
))
1890 return HASH_TABLE_P (collection
)
1891 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1892 : call1 (predicate
, tem
);
1898 static Lisp_Object Qmetadata
;
1899 extern Lisp_Object Qbuffer
;
1901 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1902 doc
: /* Perform completion on buffer names.
1903 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1904 `all-completions', otherwise invoke `test-completion'.
1906 The arguments STRING and PREDICATE are as in `try-completion',
1907 `all-completions', and `test-completion'. */)
1908 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1911 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1912 else if (EQ (flag
, Qt
))
1914 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1915 if (SCHARS (string
) > 0)
1918 { /* Strip out internal buffers. */
1919 Lisp_Object bufs
= res
;
1920 /* First, look for a non-internal buffer in `res'. */
1921 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1924 /* All bufs in `res' are internal, so don't trip them out. */
1927 while (CONSP (XCDR (bufs
)))
1928 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1929 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1935 else if (EQ (flag
, Qlambda
))
1936 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1937 else if (EQ (flag
, Qmetadata
))
1938 return Fcons (Qmetadata
, Fcons (Fcons (Qcategory
, Qbuffer
), Qnil
));
1943 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1945 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1946 doc
: /* Like `assoc' but specifically for strings (and symbols).
1948 This returns the first element of LIST whose car matches the string or
1949 symbol KEY, or nil if no match exists. When performing the
1950 comparison, symbols are first converted to strings, and unibyte
1951 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1954 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1955 single string, rather than a cons cell whose car is a string. */)
1956 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1958 register Lisp_Object tail
;
1961 key
= Fsymbol_name (key
);
1963 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1965 register Lisp_Object elt
, tem
, thiscar
;
1967 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1968 if (SYMBOLP (thiscar
))
1969 thiscar
= Fsymbol_name (thiscar
);
1970 else if (!STRINGP (thiscar
))
1972 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1973 key
, make_number (0), Qnil
,
1983 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1984 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1987 return make_number (minibuf_level
);
1990 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1991 doc
: /* Return the prompt string of the currently-active minibuffer.
1992 If no minibuffer is active, return nil. */)
1995 return Fcopy_sequence (minibuf_prompt
);
2000 init_minibuf_once (void)
2002 Vminibuffer_list
= Qnil
;
2003 staticpro (&Vminibuffer_list
);
2007 syms_of_minibuf (void)
2010 minibuf_prompt
= Qnil
;
2011 staticpro (&minibuf_prompt
);
2013 minibuf_save_list
= Qnil
;
2014 staticpro (&minibuf_save_list
);
2016 DEFSYM (Qcompleting_read_default
, "completing-read-default");
2017 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
2018 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
2019 DEFSYM (Qminibuffer_default
, "minibuffer-default");
2020 Fset (Qminibuffer_default
, Qnil
);
2022 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
2023 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
2024 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
2026 staticpro (&last_minibuf_string
);
2027 last_minibuf_string
= Qnil
;
2029 DEFSYM (Quser_variable_p
, "user-variable-p");
2030 DEFSYM (Qminibuffer_history
, "minibuffer-history");
2031 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
2032 Fset (Qbuffer_name_history
, Qnil
);
2034 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
2035 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
2036 DEFSYM (Qhistory_length
, "history-length");
2037 DEFSYM (Qcurrent_input_method
, "current-input-method");
2038 DEFSYM (Qactivate_input_method
, "activate-input-method");
2039 DEFSYM (Qcase_fold_search
, "case-fold-search");
2040 DEFSYM (Qmetadata
, "metadata");
2042 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
2043 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
2044 For example, `eval-expression' uses this. */);
2045 Vread_expression_history
= Qnil
;
2047 DEFSYM (Qread_expression_history
, "read-expression-history");
2049 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
2050 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
2051 The function is called with the arguments passed to `read-buffer'. */);
2052 Vread_buffer_function
= Qnil
;
2054 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2055 read_buffer_completion_ignore_case
,
2056 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
2057 read_buffer_completion_ignore_case
= 0;
2059 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
2060 doc
: /* Normal hook run just after entry to minibuffer. */);
2061 Vminibuffer_setup_hook
= Qnil
;
2063 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
2064 doc
: /* Normal hook run just after exit from minibuffer. */);
2065 Vminibuffer_exit_hook
= Qnil
;
2067 DEFVAR_LISP ("history-length", Vhistory_length
,
2068 doc
: /* *Maximum length for history lists before truncation takes place.
2069 A number means that length; t means infinite. Truncation takes place
2070 just after a new element is inserted. Setting the `history-length'
2071 property of a history variable overrides this default. */);
2072 XSETFASTINT (Vhistory_length
, 30);
2074 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
2075 doc
: /* *Non-nil means to delete duplicates in history.
2076 If set to t when adding a new history element, all previous identical
2077 elements are deleted from the history list. */);
2078 history_delete_duplicates
= 0;
2080 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
2081 doc
: /* *Non-nil means to add new elements in history.
2082 If set to nil, minibuffer reading functions don't add new elements to the
2083 history list, so it is possible to do this afterwards by calling
2084 `add-to-history' explicitly. */);
2085 Vhistory_add_new_input
= Qt
;
2087 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
2088 doc
: /* Non-nil means don't consider case significant in completion.
2089 For file-name completion, `read-file-name-completion-ignore-case'
2090 controls the behavior, rather than this variable.
2091 For buffer name completion, `read-buffer-completion-ignore-case'
2092 controls the behavior, rather than this variable. */);
2093 completion_ignore_case
= 0;
2095 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
2096 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2097 This variable makes a difference whenever the minibuffer window is active. */);
2098 enable_recursive_minibuffers
= 0;
2100 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2101 doc
: /* Alist or obarray used for completion in the minibuffer.
2102 This becomes the ALIST argument to `try-completion' and `all-completions'.
2103 The value can also be a list of strings or a hash table.
2105 The value may alternatively be a function, which is given three arguments:
2106 STRING, the current buffer contents;
2107 PREDICATE, the predicate for filtering possible matches;
2108 CODE, which says what kind of things to do.
2109 CODE can be nil, t or `lambda':
2110 nil -- return the best completion of STRING, or nil if there is none.
2111 t -- return a list of all possible completions of STRING.
2112 lambda -- return t if STRING is a valid completion as it stands. */);
2113 Vminibuffer_completion_table
= Qnil
;
2115 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2116 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2117 Vminibuffer_completion_predicate
= Qnil
;
2119 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2120 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2121 If nil, confirmation is not required.
2122 If the value is `confirm', the user may exit with an input that is not
2123 a valid completion alternative, but Emacs asks for confirmation.
2124 If the value is `confirm-after-completion', the user may exit with an
2125 input that is not a valid completion alternative, but Emacs asks for
2126 confirmation if the user submitted the input right after any of the
2127 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2128 Vminibuffer_completion_confirm
= Qnil
;
2130 DEFVAR_LISP ("minibuffer-completing-file-name",
2131 Vminibuffer_completing_file_name
,
2132 doc
: /* Non-nil means completing file names. */);
2133 Vminibuffer_completing_file_name
= Qnil
;
2135 DEFVAR_LISP ("completing-read-function",
2136 Vcompleting_read_function
,
2137 doc
: /* The function called by `completing-read' to do the work.
2138 It should accept the same arguments as `completing-read'. */);
2139 Vcompleting_read_function
= Qcompleting_read_default
;
2141 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2142 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2143 Vminibuffer_help_form
= Qnil
;
2145 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2146 doc
: /* History list symbol to add minibuffer values to.
2147 Each string of minibuffer input, as it appears on exit from the minibuffer,
2149 (set minibuffer-history-variable
2150 (cons STRING (symbol-value minibuffer-history-variable))) */);
2151 XSETFASTINT (Vminibuffer_history_variable
, 0);
2153 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2154 doc
: /* Current position of redoing in the history list. */);
2155 Vminibuffer_history_position
= Qnil
;
2157 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2158 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2159 Some uses of the echo area also raise that frame (since they use it too). */);
2160 minibuffer_auto_raise
= 0;
2162 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2163 doc
: /* List of regexps that should restrict possible completions.
2164 The basic completion functions only consider a completion acceptable
2165 if it matches all regular expressions in this list, with
2166 `case-fold-search' bound to the value of `completion-ignore-case'.
2167 See Info node `(elisp)Basic Completion', for a description of these
2169 Vcompletion_regexp_list
= Qnil
;
2171 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2172 minibuffer_allow_text_properties
,
2173 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2174 This also affects `read-string', but it does not affect `read-minibuffer',
2175 `read-no-blanks-input', or any of the functions that do minibuffer input
2176 with completion; they always discard text properties. */);
2177 minibuffer_allow_text_properties
= 0;
2179 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2180 doc
: /* Text properties that are added to minibuffer prompts.
2181 These are in addition to the basic `field' property, and stickiness
2183 /* We use `intern' here instead of Qread_only to avoid
2184 initialization-order problems. */
2185 Vminibuffer_prompt_properties
2186 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2188 DEFVAR_LISP ("read-expression-map", Vread_expression_map
,
2189 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2190 Vread_expression_map
= Qnil
;
2192 defsubr (&Sactive_minibuffer_window
);
2193 defsubr (&Sset_minibuffer_window
);
2194 defsubr (&Sread_from_minibuffer
);
2195 defsubr (&Seval_minibuffer
);
2196 defsubr (&Sread_minibuffer
);
2197 defsubr (&Sread_string
);
2198 defsubr (&Sread_command
);
2199 defsubr (&Sread_variable
);
2200 defsubr (&Sinternal_complete_buffer
);
2201 defsubr (&Sread_buffer
);
2202 defsubr (&Sread_no_blanks_input
);
2203 defsubr (&Sminibuffer_depth
);
2204 defsubr (&Sminibuffer_prompt
);
2206 defsubr (&Sminibufferp
);
2207 defsubr (&Sminibuffer_prompt_end
);
2208 defsubr (&Sminibuffer_contents
);
2209 defsubr (&Sminibuffer_contents_no_properties
);
2210 defsubr (&Sminibuffer_completion_contents
);
2212 defsubr (&Stry_completion
);
2213 defsubr (&Sall_completions
);
2214 defsubr (&Stest_completion
);
2215 defsubr (&Sassoc_string
);
2216 defsubr (&Scompleting_read
);
2217 defsubr (&Scompleting_read_default
);