1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
29 #include "character.h"
30 #include "dispextern.h"
35 #include "intervals.h"
37 #include "termhooks.h"
41 /* List of buffers for use as minibuffers.
42 The first element of the list is used for the outermost minibuffer
43 invocation, the next element is used for a recursive minibuffer
44 invocation, etc. The list is extended at the end as deeper
45 minibuffer recursions are encountered. */
47 Lisp_Object Vminibuffer_list
;
49 /* Data to remember during recursive minibuffer invocations */
51 Lisp_Object minibuf_save_list
;
53 /* Depth in minibuffer invocations. */
57 /* The maximum length of a minibuffer history. */
59 Lisp_Object Qhistory_length
, Vhistory_length
;
61 /* No duplicates in history. */
63 int history_delete_duplicates
;
65 /* Non-nil means add new input to history. */
67 Lisp_Object Vhistory_add_new_input
;
69 /* Fread_minibuffer leaves the input here as a string. */
71 Lisp_Object last_minibuf_string
;
73 /* Nonzero means let functions called when within a minibuffer
74 invoke recursive minibuffers (to read arguments, or whatever) */
76 int enable_recursive_minibuffers
;
78 /* Nonzero means don't ignore text properties
79 in Fread_from_minibuffer. */
81 int minibuffer_allow_text_properties
;
83 /* help-form is bound to this while in the minibuffer. */
85 Lisp_Object Vminibuffer_help_form
;
87 /* Variable which is the history list to add minibuffer values to. */
89 Lisp_Object Vminibuffer_history_variable
;
91 /* Current position in the history list (adjusted by M-n and M-p). */
93 Lisp_Object Vminibuffer_history_position
;
95 /* Text properties that are added to minibuffer prompts.
96 These are in addition to the basic `field' property, and stickiness
99 Lisp_Object Vminibuffer_prompt_properties
;
101 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
103 Lisp_Object Qread_file_name_internal
;
105 /* Normal hooks for entry to and exit from minibuffer. */
107 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
108 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
110 /* Function to call to read a buffer name. */
111 Lisp_Object Vread_buffer_function
;
113 /* Nonzero means completion ignores case. */
115 int completion_ignore_case
;
116 Lisp_Object Qcompletion_ignore_case
;
117 int read_buffer_completion_ignore_case
;
119 /* List of regexps that should restrict possible completions. */
121 Lisp_Object Vcompletion_regexp_list
;
123 /* Nonzero means raise the minibuffer frame when the minibuffer
126 int minibuffer_auto_raise
;
128 /* Keymap for reading expressions. */
129 Lisp_Object Vread_expression_map
;
131 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
132 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
133 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
134 Lisp_Object Vminibuffer_completing_file_name
;
136 Lisp_Object Quser_variable_p
;
138 Lisp_Object Qminibuffer_default
;
140 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
142 Lisp_Object Qcase_fold_search
;
144 Lisp_Object Qread_expression_history
;
146 extern Lisp_Object Voverriding_local_map
;
148 extern Lisp_Object Qmouse_face
;
150 extern Lisp_Object Qfield
;
152 /* Put minibuf on currently selected frame's minibuffer.
153 We do this whenever the user starts a new minibuffer
154 or when a minibuffer exits. */
157 choose_minibuf_frame (void)
159 if (FRAMEP (selected_frame
)
160 && FRAME_LIVE_P (XFRAME (selected_frame
))
161 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
163 struct frame
*sf
= XFRAME (selected_frame
);
166 /* I don't think that any frames may validly have a null minibuffer
168 if (NILP (sf
->minibuffer_window
))
171 /* Under X, we come here with minibuf_window being the
172 minibuffer window of the unused termcap window created in
173 init_window_once. That window doesn't have a buffer. */
174 buffer
= XWINDOW (minibuf_window
)->buffer
;
175 if (BUFFERP (buffer
))
176 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
177 minibuf_window
= sf
->minibuffer_window
;
180 /* Make sure no other frame has a minibuffer as its selected window,
181 because the text would not be displayed in it, and that would be
182 confusing. Only allow the selected frame to do this,
183 and that only if the minibuffer is active. */
185 Lisp_Object tail
, frame
;
187 FOR_EACH_FRAME (tail
, frame
)
188 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
189 && !(EQ (frame
, selected_frame
)
190 && minibuf_level
> 0))
191 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
196 choose_minibuf_frame_1 (Lisp_Object ignore
)
198 choose_minibuf_frame ();
202 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
203 Sset_minibuffer_window
, 1, 1, 0,
204 doc
: /* Specify which minibuffer window to use for the minibuffer.
205 This affects where the minibuffer is displayed if you put text in it
206 without invoking the usual minibuffer commands. */)
209 CHECK_WINDOW (window
);
210 if (! MINI_WINDOW_P (XWINDOW (window
)))
211 error ("Window is not a minibuffer window");
213 minibuf_window
= window
;
219 /* Actual minibuffer invocation. */
221 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
222 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
223 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
224 Lisp_Object
, Lisp_Object
,
226 Lisp_Object
, Lisp_Object
,
228 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
229 Lisp_Object
, Lisp_Object
,
231 Lisp_Object
, Lisp_Object
,
233 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
236 /* Read a Lisp object from VAL and return it. If VAL is an empty
237 string, and DEFALT is a string, read from DEFALT instead of VAL. */
240 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
242 struct gcpro gcpro1
, gcpro2
;
243 Lisp_Object expr_and_pos
;
246 GCPRO2 (val
, defalt
);
248 if (STRINGP (val
) && SCHARS (val
) == 0)
250 if (STRINGP (defalt
))
252 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
256 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
257 pos
= XINT (Fcdr (expr_and_pos
));
258 if (pos
!= SCHARS (val
))
260 /* Ignore trailing whitespace; any other trailing junk
263 pos
= string_char_to_byte (val
, pos
);
264 for (i
= pos
; i
< SBYTES (val
); i
++)
266 int c
= SREF (val
, i
);
267 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
268 error ("Trailing garbage following expression");
272 val
= Fcar (expr_and_pos
);
273 RETURN_UNGCPRO (val
);
277 /* Like read_minibuf but reading from stdin. This function is called
278 from read_minibuf to do the job if noninteractive. */
281 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
282 histvar
, histpos
, defalt
, allow_props
,
283 inherit_input_method
)
287 Lisp_Object backup_n
;
293 int inherit_input_method
;
299 fprintf (stdout
, "%s", SDATA (prompt
));
305 line
= (char *) xmalloc (size
* sizeof *line
);
306 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
307 && (len
= strlen (line
),
308 len
== size
- 1 && line
[len
- 1] != '\n'))
311 line
= (char *) xrealloc (line
, size
);
318 if (len
> 0 && line
[len
- 1] == '\n')
321 val
= build_string (line
);
327 error ("Error reading from stdin");
330 /* If Lisp form desired instead of string, parse it. */
332 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
337 DEFUN ("minibufferp", Fminibufferp
,
338 Sminibufferp
, 0, 1, 0,
339 doc
: /* Return t if BUFFER is a minibuffer.
340 No argument or nil as argument means use current buffer as BUFFER.
341 BUFFER can be a buffer or a buffer name. */)
347 buffer
= Fcurrent_buffer ();
348 else if (STRINGP (buffer
))
349 buffer
= Fget_buffer (buffer
);
351 CHECK_BUFFER (buffer
);
353 tem
= Fmemq (buffer
, Vminibuffer_list
);
354 return ! NILP (tem
) ? Qt
: Qnil
;
357 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
358 Sminibuffer_prompt_end
, 0, 0, 0,
359 doc
: /* Return the buffer position of the end of the minibuffer prompt.
360 Return (point-min) if current buffer is not a minibuffer. */)
363 /* This function is written to be most efficient when there's a prompt. */
364 Lisp_Object beg
, end
, tem
;
365 beg
= make_number (BEGV
);
367 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
371 end
= Ffield_end (beg
, Qnil
, Qnil
);
373 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
379 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
380 Sminibuffer_contents
, 0, 0, 0,
381 doc
: /* Return the user input in a minibuffer as a string.
382 If the current buffer is not a minibuffer, return its entire contents. */)
385 int prompt_end
= XINT (Fminibuffer_prompt_end ());
386 return make_buffer_string (prompt_end
, ZV
, 1);
389 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
390 Sminibuffer_contents_no_properties
, 0, 0, 0,
391 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
392 If the current buffer is not a minibuffer, return its entire contents. */)
395 int prompt_end
= XINT (Fminibuffer_prompt_end ());
396 return make_buffer_string (prompt_end
, ZV
, 0);
399 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
400 Sminibuffer_completion_contents
, 0, 0, 0,
401 doc
: /* Return the user input in a minibuffer before point as a string.
402 That is what completion commands operate on.
403 If the current buffer is not a minibuffer, return its entire contents. */)
406 int prompt_end
= XINT (Fminibuffer_prompt_end ());
408 error ("Cannot do completion in the prompt");
409 return make_buffer_string (prompt_end
, PT
, 1);
413 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
414 putting point minus BACKUP_N bytes from the end of INITIAL,
415 prompting with PROMPT (a string), using history list HISTVAR
416 with initial position HISTPOS. INITIAL should be a string or a
417 cons of a string and an integer. BACKUP_N should be <= 0, or
418 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
419 ignored and replaced with an integer that puts point at one-indexed
420 position N in INITIAL, where N is the CDR of INITIAL, or at the
421 beginning of INITIAL if N <= 0.
423 Normally return the result as a string (the text that was read),
424 but if EXPFLAG is nonzero, read it and return the object read.
425 If HISTVAR is given, save the value read on that history only if it doesn't
426 match the front of that history list exactly. The value is pushed onto
427 the list as the string that was read.
429 DEFALT specifies the default value for the sake of history commands.
431 If ALLOW_PROPS is nonzero, we do not throw away text properties.
433 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
434 current input method. */
437 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
438 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
442 Lisp_Object backup_n
;
448 int inherit_input_method
;
451 int count
= SPECPDL_INDEX ();
452 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
453 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
454 Lisp_Object enable_multibyte
;
455 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
456 /* String to add to the history. */
457 Lisp_Object histstring
;
459 Lisp_Object empty_minibuf
;
460 Lisp_Object dummy
, frame
;
462 extern Lisp_Object Qfront_sticky
;
463 extern Lisp_Object Qrear_nonsticky
;
465 specbind (Qminibuffer_default
, defalt
);
467 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
468 in previous recursive minibuffer, but was not set explicitly
469 to t for this invocation, so set it to nil in this minibuffer.
470 Save the old value now, before we change it. */
471 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
472 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
473 Vminibuffer_completing_file_name
= Qnil
;
475 #ifdef HAVE_WINDOW_SYSTEM
476 if (display_hourglass_p
)
484 backup_n
= Fcdr (initial
);
485 initial
= Fcar (initial
);
486 CHECK_STRING (initial
);
487 if (!NILP (backup_n
))
489 CHECK_NUMBER (backup_n
);
490 /* Convert to distance from end of input. */
491 if (XINT (backup_n
) < 1)
492 /* A number too small means the beginning of the string. */
493 pos
= - SCHARS (initial
);
495 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
499 CHECK_STRING (initial
);
502 ambient_dir
= current_buffer
->directory
;
504 enable_multibyte
= Qnil
;
506 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
507 store them away before we can GC. Don't need to protect
508 BACKUP_N because we use the value only if it is an integer. */
509 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
511 if (!STRINGP (prompt
))
512 prompt
= empty_unibyte_string
;
514 if (!enable_recursive_minibuffers
515 && minibuf_level
> 0)
517 if (EQ (selected_window
, minibuf_window
))
518 error ("Command attempted to use minibuffer while in minibuffer");
520 /* If we're in another window, cancel the minibuffer that's active. */
522 build_string ("Command attempted to use minibuffer while in minibuffer"));
526 /* In case we are running as a daemon, only do this before
527 detaching from the terminal. */
528 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
529 && NILP (Vexecuting_kbd_macro
))
531 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
533 expflag
, histvar
, histpos
, defalt
,
534 allow_props
, inherit_input_method
);
536 return unbind_to (count
, val
);
539 /* Choose the minibuffer window and frame, and take action on them. */
541 choose_minibuf_frame ();
543 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
545 record_unwind_protect (Fset_window_configuration
,
546 Fcurrent_window_configuration (Qnil
));
548 /* If the minibuffer window is on a different frame, save that
549 frame's configuration too. */
550 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
551 if (!EQ (mini_frame
, selected_frame
))
552 record_unwind_protect (Fset_window_configuration
,
553 Fcurrent_window_configuration (mini_frame
));
555 /* If the minibuffer is on an iconified or invisible frame,
556 make it visible now. */
557 Fmake_frame_visible (mini_frame
);
559 if (minibuffer_auto_raise
)
560 Fraise_frame (mini_frame
);
562 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
564 /* We have to do this after saving the window configuration
565 since that is what restores the current buffer. */
567 /* Arrange to restore a number of minibuffer-related variables.
568 We could bind each variable separately, but that would use lots of
571 = Fcons (Voverriding_local_map
,
572 Fcons (minibuf_window
,
575 = Fcons (minibuf_prompt
,
576 Fcons (make_number (minibuf_prompt_width
),
578 Fcons (Vcurrent_prefix_arg
,
579 Fcons (Vminibuffer_history_position
,
580 Fcons (Vminibuffer_history_variable
,
581 minibuf_save_list
))))));
583 record_unwind_protect (read_minibuf_unwind
, Qnil
);
585 /* We are exiting the minibuffer one way or the other, so run the hook.
586 It should be run before unwinding the minibuf settings. Do it
587 separately from read_minibuf_unwind because we need to make sure that
588 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
589 signals an error. --Stef */
590 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
592 /* Now that we can restore all those variables, start changing them. */
594 minibuf_prompt_width
= 0;
595 minibuf_prompt
= Fcopy_sequence (prompt
);
596 Vminibuffer_history_position
= histpos
;
597 Vminibuffer_history_variable
= histvar
;
598 Vhelp_form
= Vminibuffer_help_form
;
599 /* If this minibuffer is reading a file name, that doesn't mean
600 recursive ones are. But we cannot set it to nil, because
601 completion code still need to know the minibuffer is completing a
602 file name. So use `lambda' as intermediate value meaning
603 "t" in this minibuffer, but "nil" in next minibuffer. */
604 if (!NILP (Vminibuffer_completing_file_name
))
605 Vminibuffer_completing_file_name
= Qlambda
;
607 if (inherit_input_method
)
609 /* `current-input-method' is buffer local. So, remember it in
610 INPUT_METHOD before changing the current buffer. */
611 input_method
= Fsymbol_value (Qcurrent_input_method
);
612 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
615 /* Switch to the minibuffer. */
617 minibuffer
= get_minibuffer (minibuf_level
);
618 Fset_buffer (minibuffer
);
620 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
621 if (inherit_input_method
)
622 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
624 /* The current buffer's default directory is usually the right thing
625 for our minibuffer here. However, if you're typing a command at
626 a minibuffer-only frame when minibuf_level is zero, then buf IS
627 the current_buffer, so reset_buffer leaves buf's default
628 directory unchanged. This is a bummer when you've just started
629 up Emacs and buf's default directory is Qnil. Here's a hack; can
630 you think of something better to do? Find another buffer with a
631 better directory, and use that one instead. */
632 if (STRINGP (ambient_dir
))
633 current_buffer
->directory
= ambient_dir
;
636 Lisp_Object buf_list
;
638 for (buf_list
= Vbuffer_alist
;
640 buf_list
= XCDR (buf_list
))
642 Lisp_Object other_buf
;
644 other_buf
= XCDR (XCAR (buf_list
));
645 if (STRINGP (XBUFFER (other_buf
)->directory
))
647 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
653 if (!EQ (mini_frame
, selected_frame
))
654 Fredirect_frame_focus (selected_frame
, mini_frame
);
656 Vminibuf_scroll_window
= selected_window
;
657 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
658 minibuf_selected_window
= selected_window
;
660 /* Empty out the minibuffers of all frames other than the one
661 where we are going to display one now.
662 Set them to point to ` *Minibuf-0*', which is always empty. */
663 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
665 FOR_EACH_FRAME (dummy
, frame
)
667 Lisp_Object root_window
= Fframe_root_window (frame
);
668 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
670 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
671 && !NILP (Fwindow_minibuffer_p (mini_window
)))
672 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
675 /* Display this minibuffer in the proper window. */
676 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
677 Fselect_window (minibuf_window
, Qnil
);
678 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
680 Fmake_local_variable (Qprint_escape_newlines
);
681 print_escape_newlines
= 1;
683 /* Erase the buffer. */
685 int count1
= SPECPDL_INDEX ();
686 specbind (Qinhibit_read_only
, Qt
);
687 specbind (Qinhibit_modification_hooks
, Qt
);
690 if (!NILP (current_buffer
->enable_multibyte_characters
)
691 && ! STRING_MULTIBYTE (minibuf_prompt
))
692 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
694 /* Insert the prompt, record where it ends. */
695 Finsert (1, &minibuf_prompt
);
698 Fput_text_property (make_number (BEG
), make_number (PT
),
699 Qfront_sticky
, Qt
, Qnil
);
700 Fput_text_property (make_number (BEG
), make_number (PT
),
701 Qrear_nonsticky
, Qt
, Qnil
);
702 Fput_text_property (make_number (BEG
), make_number (PT
),
704 Fadd_text_properties (make_number (BEG
), make_number (PT
),
705 Vminibuffer_prompt_properties
, Qnil
);
707 unbind_to (count1
, Qnil
);
710 minibuf_prompt_width
= (int) current_column (); /* iftc */
712 /* Put in the initial input. */
715 Finsert (1, &initial
);
716 Fforward_char (make_number (pos
));
719 clear_message (1, 1);
720 current_buffer
->keymap
= map
;
722 /* Turn on an input method stored in INPUT_METHOD if any. */
723 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
724 call1 (Qactivate_input_method
, input_method
);
726 /* Run our hook, but not if it is empty.
727 (run-hooks would do nothing if it is empty,
728 but it's important to save time here in the usual case.) */
729 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
730 && !NILP (Vrun_hooks
))
731 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
733 /* Don't allow the user to undo past this point. */
734 current_buffer
->undo_list
= Qnil
;
738 /* If cursor is on the minibuffer line,
739 show the user we have exited by putting it in column 0. */
740 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
743 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
744 XWINDOW (minibuf_window
)->cursor
.x
= 0;
745 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
746 update_frame (XFRAME (selected_frame
), 1, 1);
748 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
749 struct redisplay_interface
*rif
= FRAME_RIF (f
);
750 if (rif
&& rif
->flush_display
)
751 rif
->flush_display (f
);
755 /* Make minibuffer contents into a string. */
756 Fset_buffer (minibuffer
);
758 val
= Fminibuffer_contents ();
760 val
= Fminibuffer_contents_no_properties ();
762 /* VAL is the string of minibuffer text. */
764 last_minibuf_string
= val
;
766 /* Choose the string to add to the history. */
767 if (SCHARS (val
) != 0)
769 else if (STRINGP (defalt
))
771 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
772 histstring
= XCAR (defalt
);
776 /* Add the value to the appropriate history list, if any. */
777 if (!NILP (Vhistory_add_new_input
)
778 && SYMBOLP (Vminibuffer_history_variable
)
779 && !NILP (histstring
))
781 /* If the caller wanted to save the value read on a history list,
782 then do so if the value is not already the front of the list. */
785 /* If variable is unbound, make it nil. */
787 histval
= find_symbol_value (Vminibuffer_history_variable
);
788 if (EQ (histval
, Qunbound
))
789 Fset (Vminibuffer_history_variable
, Qnil
);
791 /* The value of the history variable must be a cons or nil. Other
792 values are unacceptable. We silently ignore these values. */
796 /* Don't duplicate the most recent entry in the history. */
797 && (NILP (Fequal (histstring
, Fcar (histval
))))))
801 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
802 histval
= Fcons (histstring
, histval
);
803 Fset (Vminibuffer_history_variable
, histval
);
805 /* Truncate if requested. */
806 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
807 if (NILP (length
)) length
= Vhistory_length
;
808 if (INTEGERP (length
))
810 if (XINT (length
) <= 0)
811 Fset (Vminibuffer_history_variable
, Qnil
);
816 temp
= Fnthcdr (Fsub1 (length
), histval
);
817 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
823 /* If Lisp form desired instead of string, parse it. */
825 val
= string_to_object (val
, defalt
);
827 /* The appropriate frame will get selected
828 in set-window-configuration. */
830 return unbind_to (count
, val
);
833 /* Return a buffer to be used as the minibuffer at depth `depth'.
834 depth = 0 is the lowest allowed argument, and that is the value
835 used for nonrecursive minibuffer invocations */
838 get_minibuffer (int depth
)
840 Lisp_Object tail
, num
, buf
;
842 extern Lisp_Object
nconc2 (Lisp_Object
, Lisp_Object
);
844 XSETFASTINT (num
, depth
);
845 tail
= Fnthcdr (num
, Vminibuffer_list
);
848 tail
= Fcons (Qnil
, Qnil
);
849 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
852 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
854 sprintf (name
, " *Minibuf-%d*", depth
);
855 buf
= Fget_buffer_create (build_string (name
));
857 /* Although the buffer's name starts with a space, undo should be
859 Fbuffer_enable_undo (buf
);
865 int count
= SPECPDL_INDEX ();
866 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
867 have to empty the list, otherwise we end up with overlays that
868 think they belong to this buffer while the buffer doesn't know about
870 delete_all_overlays (XBUFFER (buf
));
871 reset_buffer (XBUFFER (buf
));
872 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
874 Fkill_all_local_variables ();
875 unbind_to (count
, Qnil
);
882 run_exit_minibuf_hook (Lisp_Object data
)
884 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
885 && !NILP (Vrun_hooks
))
886 safe_run_hooks (Qminibuffer_exit_hook
);
891 /* This function is called on exiting minibuffer, whether normally or
892 not, and it restores the current window, buffer, etc. */
895 read_minibuf_unwind (Lisp_Object data
)
897 Lisp_Object old_deactivate_mark
;
900 /* If this was a recursive minibuffer,
901 tie the minibuffer window back to the outer level minibuffer buffer. */
904 window
= minibuf_window
;
905 /* To keep things predictable, in case it matters, let's be in the
906 minibuffer when we reset the relevant variables. */
907 Fset_buffer (XWINDOW (window
)->buffer
);
909 /* Restore prompt, etc, from outer minibuffer level. */
910 minibuf_prompt
= Fcar (minibuf_save_list
);
911 minibuf_save_list
= Fcdr (minibuf_save_list
);
912 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
913 minibuf_save_list
= Fcdr (minibuf_save_list
);
914 Vhelp_form
= Fcar (minibuf_save_list
);
915 minibuf_save_list
= Fcdr (minibuf_save_list
);
916 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
917 minibuf_save_list
= Fcdr (minibuf_save_list
);
918 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
919 minibuf_save_list
= Fcdr (minibuf_save_list
);
920 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
921 minibuf_save_list
= Fcdr (minibuf_save_list
);
922 Voverriding_local_map
= Fcar (minibuf_save_list
);
923 minibuf_save_list
= Fcdr (minibuf_save_list
);
925 temp
= Fcar (minibuf_save_list
);
926 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
927 minibuf_window
= temp
;
929 minibuf_save_list
= Fcdr (minibuf_save_list
);
931 /* Erase the minibuffer we were using at this level. */
933 int count
= SPECPDL_INDEX ();
934 /* Prevent error in erase-buffer. */
935 specbind (Qinhibit_read_only
, Qt
);
936 specbind (Qinhibit_modification_hooks
, Qt
);
937 old_deactivate_mark
= Vdeactivate_mark
;
939 Vdeactivate_mark
= old_deactivate_mark
;
940 unbind_to (count
, Qnil
);
943 /* When we get to the outmost level, make sure we resize the
944 mini-window back to its normal size. */
945 if (minibuf_level
== 0)
946 resize_mini_window (XWINDOW (window
), 0);
948 /* Make sure minibuffer window is erased, not ignored. */
949 windows_or_buffers_changed
++;
950 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
951 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
956 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
957 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
958 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
959 DEFAULT-VALUE. It normally should be nil in new code, except when
960 HIST is a cons. It is discussed in more detail below.
961 Third arg KEYMAP is a keymap to use whilst reading;
962 if omitted or nil, the default is `minibuffer-local-map'.
963 If fourth arg READ is non-nil, then interpret the result as a Lisp object
964 and return that object:
965 in other words, do `(car (read-from-string INPUT-STRING))'
966 Fifth arg HIST, if non-nil, specifies a history list and optionally
967 the initial position in the list. It can be a symbol, which is the
968 history list variable to use, or it can be a cons cell
969 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
970 to use, and HISTPOS is the initial position for use by the minibuffer
971 history commands. For consistency, you should also specify that
972 element of the history as the value of INITIAL-CONTENTS. Positions
973 are counted starting from 1 at the beginning of the list.
974 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
975 If non-nil, it is available for history commands, and as the value
976 (or the first element of the list of default values) to return
977 if the user enters the empty string. But, unless READ is non-nil,
978 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
979 empty input! It returns the empty string.
980 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
981 the current input method and the setting of `enable-multibyte-characters'.
982 If the variable `minibuffer-allow-text-properties' is non-nil,
983 then the string which is returned includes whatever text properties
984 were present in the minibuffer. Otherwise the value has no text properties.
986 The remainder of this documentation string describes the
987 INITIAL-CONTENTS argument in more detail. It is only relevant when
988 studying existing code, or when HIST is a cons. If non-nil,
989 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
990 reading input. Normally, point is put at the end of that string.
991 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
992 input is STRING, but point is placed at _one-indexed_ position
993 POSITION in the minibuffer. Any integer value less than or equal to
994 one puts point at the beginning of the string. *Note* that this
995 behavior differs from the way such arguments are used in `completing-read'
996 and some related functions, which use zero-indexing for POSITION. */)
997 (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
)
999 Lisp_Object histvar
, histpos
, val
;
1000 struct gcpro gcpro1
;
1002 CHECK_STRING (prompt
);
1004 keymap
= Vminibuffer_local_map
;
1006 keymap
= get_keymap (keymap
, 1, 0);
1015 histvar
= Fcar_safe (hist
);
1016 histpos
= Fcdr_safe (hist
);
1019 histvar
= Qminibuffer_history
;
1021 XSETFASTINT (histpos
, 0);
1023 GCPRO1 (default_value
);
1024 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1026 histvar
, histpos
, default_value
,
1027 minibuffer_allow_text_properties
,
1028 !NILP (inherit_input_method
));
1033 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1034 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1035 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1036 is a string to insert in the minibuffer before reading.
1037 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1038 Such arguments are used as in `read-from-minibuffer'.) */)
1039 (Lisp_Object prompt
, Lisp_Object initial_contents
)
1041 CHECK_STRING (prompt
);
1042 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1043 prompt
, Qnil
, 1, Qminibuffer_history
,
1044 make_number (0), Qnil
, 0, 0);
1047 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1048 doc
: /* Return value of Lisp expression read using the minibuffer.
1049 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1050 is a string to insert in the minibuffer before reading.
1051 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1052 Such arguments are used as in `read-from-minibuffer'.) */)
1053 (Lisp_Object prompt
, Lisp_Object initial_contents
)
1055 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1056 prompt
, Qnil
, 1, Qread_expression_history
,
1057 make_number (0), Qnil
, 0, 0));
1060 /* Functions that use the minibuffer to read various things. */
1062 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1063 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1064 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1065 This argument has been superseded by DEFAULT-VALUE and should normally
1066 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1067 documentation string of that function for details.
1068 The third arg HISTORY, if non-nil, specifies a history list
1069 and optionally the initial position in the list.
1070 See `read-from-minibuffer' for details of HISTORY argument.
1071 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1072 If non-nil, it is used for history commands, and as the value (or the first
1073 element of the list of default values) to return if the user enters the
1075 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1076 the current input method and the setting of `enable-multibyte-characters'. */)
1077 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1080 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1081 Qnil
, history
, default_value
,
1082 inherit_input_method
);
1083 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1084 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1088 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1089 doc
: /* Read a string from the terminal, not allowing blanks.
1090 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1091 non-nil, it should be a string, which is used as initial input, with
1092 point positioned at the end, so that SPACE will accept the input.
1093 \(Actually, INITIAL can also be a cons of a string and an integer.
1094 Such values are treated as in `read-from-minibuffer', but are normally
1095 not useful in this function.)
1096 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1097 the current input method and the setting of`enable-multibyte-characters'. */)
1098 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1100 CHECK_STRING (prompt
);
1101 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1102 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1103 !NILP (inherit_input_method
));
1106 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1107 doc
: /* Read the name of a command and return as a symbol.
1108 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1109 if it is a list. */)
1110 (Lisp_Object prompt
, Lisp_Object default_value
)
1112 Lisp_Object name
, default_string
;
1114 if (NILP (default_value
))
1115 default_string
= Qnil
;
1116 else if (SYMBOLP (default_value
))
1117 default_string
= SYMBOL_NAME (default_value
);
1119 default_string
= default_value
;
1121 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1122 Qnil
, Qnil
, default_string
, Qnil
);
1125 return Fintern (name
, Qnil
);
1129 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1130 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1131 Prompt with PROMPT. */)
1132 (Lisp_Object prompt
)
1134 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1139 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1140 doc
: /* Read the name of a user variable and return it as a symbol.
1141 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1143 A user variable is one for which `user-variable-p' returns non-nil. */)
1144 (Lisp_Object prompt
, Lisp_Object default_value
)
1146 Lisp_Object name
, default_string
;
1148 if (NILP (default_value
))
1149 default_string
= Qnil
;
1150 else if (SYMBOLP (default_value
))
1151 default_string
= SYMBOL_NAME (default_value
);
1153 default_string
= default_value
;
1155 name
= Fcompleting_read (prompt
, Vobarray
,
1156 Quser_variable_p
, Qt
,
1157 Qnil
, Qnil
, default_string
, Qnil
);
1160 return Fintern (name
, Qnil
);
1163 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1164 doc
: /* Read the name of a buffer and return as a string.
1166 Optional second arg DEF is value to return if user enters an empty line.
1167 If DEF is a list of default values, return its first element.
1168 Optional third arg REQUIRE-MATCH determines whether non-existing
1169 buffer names are allowed. It has the same meaning as the
1170 REQUIRE-MATCH argument of `confirm-after-completion'.
1171 The argument PROMPT should be a string ending with a colon and a space.
1172 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1173 case while reading the buffer name.
1174 If `read-buffer-function' is non-nil, this works by calling it as a
1175 function, instead of the usual behavior. */)
1176 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1178 Lisp_Object args
[4], result
;
1181 int count
= SPECPDL_INDEX ();
1184 def
= XBUFFER (def
)->name
;
1186 specbind (Qcompletion_ignore_case
,
1187 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1189 if (NILP (Vread_buffer_function
))
1193 /* A default value was provided: we must change PROMPT,
1194 editing the default value in before the colon. To achieve
1195 this, we replace PROMPT with a substring that doesn't
1196 contain the terminal space and colon (if present). They
1197 are then added back using Fformat. */
1199 if (STRINGP (prompt
))
1203 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1205 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1208 prompt
= make_specified_string (s
, -1, len
,
1209 STRING_MULTIBYTE (prompt
));
1212 args
[0] = build_string ("%s (default %s): ");
1214 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1215 prompt
= Fformat (3, args
);
1218 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1219 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1224 args
[0] = Vread_buffer_function
;
1227 args
[3] = require_match
;
1228 result
= Ffuncall(4, args
);
1230 return unbind_to (count
, result
);
1234 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1236 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1239 if (STRING_MULTIBYTE (string
))
1240 return Fstring_make_unibyte (string
);
1242 return Fstring_make_multibyte (string
);
1245 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1246 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1247 Test each possible completion specified by COLLECTION
1248 to see if it begins with STRING. The possible completions may be
1249 strings or symbols. Symbols are converted to strings before testing,
1251 All that match STRING are compared together; the longest initial sequence
1252 common to all these matches is the return value.
1253 If there is no match at all, the return value is nil.
1254 For a unique match which is exact, the return value is t.
1256 If COLLECTION is an alist, the keys (cars of elements) are the
1257 possible completions. If an element is not a cons cell, then the
1258 element itself is the possible completion.
1259 If COLLECTION is a hash-table, all the keys that are strings or symbols
1260 are the possible completions.
1261 If COLLECTION is an obarray, the names of all symbols in the obarray
1262 are the possible completions.
1264 COLLECTION can also be a function to do the completion itself.
1265 It receives three arguments: the values STRING, PREDICATE and nil.
1266 Whatever it returns becomes the value of `try-completion'.
1268 If optional third argument PREDICATE is non-nil,
1269 it is used to test each possible match.
1270 The match is a candidate only if PREDICATE returns non-nil.
1271 The argument given to PREDICATE is the alist element
1272 or the symbol from the obarray. If COLLECTION is a hash-table,
1273 predicate is called with two arguments: the key and the value.
1274 Additionally to this predicate, `completion-regexp-list'
1275 is used to further constrain the set of candidates. */)
1276 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1278 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1279 /* Size in bytes of BESTMATCH. */
1280 int bestmatchsize
= 0;
1281 /* These are in bytes, too. */
1282 int compare
, matchsize
;
1283 enum { function_table
, list_table
, obarray_table
, hash_table
}
1284 type
= (HASH_TABLE_P (collection
) ? hash_table
1285 : VECTORP (collection
) ? obarray_table
1286 : ((NILP (collection
)
1287 || (CONSP (collection
)
1288 && (!SYMBOLP (XCAR (collection
))
1289 || NILP (XCAR (collection
)))))
1290 ? list_table
: function_table
));
1291 int index
= 0, obsize
= 0;
1294 Lisp_Object bucket
, zero
, end
, tem
;
1295 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1297 CHECK_STRING (string
);
1298 if (type
== function_table
)
1299 return call3 (collection
, string
, predicate
, Qnil
);
1301 bestmatch
= bucket
= Qnil
;
1302 zero
= make_number (0);
1304 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1306 if (type
== obarray_table
)
1308 collection
= check_obarray (collection
);
1309 obsize
= XVECTOR (collection
)->size
;
1310 bucket
= XVECTOR (collection
)->contents
[index
];
1315 /* Get the next element of the alist, obarray, or hash-table. */
1316 /* Exit the loop if the elements are all used up. */
1317 /* elt gets the alist element or symbol.
1318 eltstring gets the name to check as a completion. */
1320 if (type
== list_table
)
1325 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1328 else if (type
== obarray_table
)
1330 if (!EQ (bucket
, zero
))
1332 if (!SYMBOLP (bucket
))
1333 error ("Bad data in guts of obarray");
1336 if (XSYMBOL (bucket
)->next
)
1337 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1339 XSETFASTINT (bucket
, 0);
1341 else if (++index
>= obsize
)
1345 bucket
= XVECTOR (collection
)->contents
[index
];
1349 else /* if (type == hash_table) */
1351 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1352 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1354 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1357 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1360 /* Is this element a possible completion? */
1362 if (SYMBOLP (eltstring
))
1363 eltstring
= Fsymbol_name (eltstring
);
1365 if (STRINGP (eltstring
)
1366 && SCHARS (string
) <= SCHARS (eltstring
)
1367 && (tem
= Fcompare_strings (eltstring
, zero
,
1368 make_number (SCHARS (string
)),
1370 completion_ignore_case
? Qt
: Qnil
),
1374 Lisp_Object regexps
;
1376 /* Ignore this element if it fails to match all the regexps. */
1378 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1379 regexps
= XCDR (regexps
))
1381 if (bindcount
< 0) {
1382 bindcount
= SPECPDL_INDEX ();
1383 specbind (Qcase_fold_search
,
1384 completion_ignore_case
? Qt
: Qnil
);
1386 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1390 if (CONSP (regexps
))
1394 /* Ignore this element if there is a predicate
1395 and the predicate doesn't like it. */
1397 if (!NILP (predicate
))
1399 if (EQ (predicate
, Qcommandp
))
1400 tem
= Fcommandp (elt
, Qnil
);
1405 unbind_to (bindcount
, Qnil
);
1408 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1409 tem
= (type
== hash_table
1410 ? call2 (predicate
, elt
,
1411 HASH_VALUE (XHASH_TABLE (collection
),
1413 : call1 (predicate
, elt
));
1416 if (NILP (tem
)) continue;
1419 /* Update computation of how much all possible completions match */
1421 if (NILP (bestmatch
))
1424 bestmatch
= eltstring
;
1425 bestmatchsize
= SCHARS (eltstring
);
1429 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1430 tem
= Fcompare_strings (bestmatch
, zero
,
1431 make_number (compare
),
1433 make_number (compare
),
1434 completion_ignore_case
? Qt
: Qnil
);
1436 matchsize
= compare
;
1437 else if (XINT (tem
) < 0)
1438 matchsize
= - XINT (tem
) - 1;
1440 matchsize
= XINT (tem
) - 1;
1442 if (completion_ignore_case
)
1444 /* If this is an exact match except for case,
1445 use it as the best match rather than one that is not an
1446 exact match. This way, we get the case pattern
1447 of the actual match. */
1448 if ((matchsize
== SCHARS (eltstring
)
1449 && matchsize
< SCHARS (bestmatch
))
1451 /* If there is more than one exact match ignoring case,
1452 and one of them is exact including case,
1454 /* If there is no exact match ignoring case,
1455 prefer a match that does not change the case
1457 ((matchsize
== SCHARS (eltstring
))
1459 (matchsize
== SCHARS (bestmatch
))
1460 && (tem
= Fcompare_strings (eltstring
, zero
,
1461 make_number (SCHARS (string
)),
1466 && (tem
= Fcompare_strings (bestmatch
, zero
,
1467 make_number (SCHARS (string
)),
1472 bestmatch
= eltstring
;
1474 if (bestmatchsize
!= SCHARS (eltstring
)
1475 || bestmatchsize
!= matchsize
)
1476 /* Don't count the same string multiple times. */
1478 bestmatchsize
= matchsize
;
1479 if (matchsize
<= SCHARS (string
)
1480 /* If completion-ignore-case is non-nil, don't
1481 short-circuit because we want to find the best
1482 possible match *including* case differences. */
1483 && !completion_ignore_case
1485 /* No need to look any further. */
1491 if (bindcount
>= 0) {
1492 unbind_to (bindcount
, Qnil
);
1496 if (NILP (bestmatch
))
1497 return Qnil
; /* No completions found */
1498 /* If we are ignoring case, and there is no exact match,
1499 and no additional text was supplied,
1500 don't change the case of what the user typed. */
1501 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1502 && SCHARS (bestmatch
) > bestmatchsize
)
1503 return minibuf_conform_representation (string
, bestmatch
);
1505 /* Return t if the supplied string is an exact match (counting case);
1506 it does not require any change to be made. */
1507 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1510 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1511 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1512 return Fsubstring (bestmatch
, zero
, end
);
1515 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1516 doc
: /* Search for partial matches to STRING in COLLECTION.
1517 Test each of the possible completions specified by COLLECTION
1518 to see if it begins with STRING. The possible completions may be
1519 strings or symbols. Symbols are converted to strings before testing,
1521 The value is a list of all the possible completions that match STRING.
1523 If COLLECTION is an alist, the keys (cars of elements) are the
1524 possible completions. If an element is not a cons cell, then the
1525 element itself is the possible completion.
1526 If COLLECTION is a hash-table, all the keys that are strings or symbols
1527 are the possible completions.
1528 If COLLECTION is an obarray, the names of all symbols in the obarray
1529 are the possible completions.
1531 COLLECTION can also be a function to do the completion itself.
1532 It receives three arguments: the values STRING, PREDICATE and t.
1533 Whatever it returns becomes the value of `all-completions'.
1535 If optional third argument PREDICATE is non-nil,
1536 it is used to test each possible match.
1537 The match is a candidate only if PREDICATE returns non-nil.
1538 The argument given to PREDICATE is the alist element
1539 or the symbol from the obarray. If COLLECTION is a hash-table,
1540 predicate is called with two arguments: the key and the value.
1541 Additionally to this predicate, `completion-regexp-list'
1542 is used to further constrain the set of candidates.
1544 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1545 backward compatibility. If non-nil, strings in COLLECTION that start
1546 with a space are ignored unless STRING itself starts with a space. */)
1547 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1549 Lisp_Object tail
, elt
, eltstring
;
1550 Lisp_Object allmatches
;
1551 int type
= HASH_TABLE_P (collection
) ? 3
1552 : VECTORP (collection
) ? 2
1553 : NILP (collection
) || (CONSP (collection
)
1554 && (!SYMBOLP (XCAR (collection
))
1555 || NILP (XCAR (collection
))));
1556 int index
= 0, obsize
= 0;
1558 Lisp_Object bucket
, tem
, zero
;
1559 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1561 CHECK_STRING (string
);
1563 return call3 (collection
, string
, predicate
, Qt
);
1564 allmatches
= bucket
= Qnil
;
1565 zero
= make_number (0);
1567 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1571 collection
= check_obarray (collection
);
1572 obsize
= XVECTOR (collection
)->size
;
1573 bucket
= XVECTOR (collection
)->contents
[index
];
1578 /* Get the next element of the alist, obarray, or hash-table. */
1579 /* Exit the loop if the elements are all used up. */
1580 /* elt gets the alist element or symbol.
1581 eltstring gets the name to check as a completion. */
1588 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1593 if (!EQ (bucket
, zero
))
1595 if (!SYMBOLP (bucket
))
1596 error ("Bad data in guts of obarray");
1599 if (XSYMBOL (bucket
)->next
)
1600 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1602 XSETFASTINT (bucket
, 0);
1604 else if (++index
>= obsize
)
1608 bucket
= XVECTOR (collection
)->contents
[index
];
1612 else /* if (type == 3) */
1614 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1615 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1617 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1620 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1623 /* Is this element a possible completion? */
1625 if (SYMBOLP (eltstring
))
1626 eltstring
= Fsymbol_name (eltstring
);
1628 if (STRINGP (eltstring
)
1629 && SCHARS (string
) <= SCHARS (eltstring
)
1630 /* If HIDE_SPACES, reject alternatives that start with space
1631 unless the input starts with space. */
1632 && (NILP (hide_spaces
)
1633 || (SBYTES (string
) > 0
1634 && SREF (string
, 0) == ' ')
1635 || SREF (eltstring
, 0) != ' ')
1636 && (tem
= Fcompare_strings (eltstring
, zero
,
1637 make_number (SCHARS (string
)),
1639 make_number (SCHARS (string
)),
1640 completion_ignore_case
? Qt
: Qnil
),
1644 Lisp_Object regexps
;
1646 XSETFASTINT (zero
, 0);
1648 /* Ignore this element if it fails to match all the regexps. */
1650 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1651 regexps
= XCDR (regexps
))
1653 if (bindcount
< 0) {
1654 bindcount
= SPECPDL_INDEX ();
1655 specbind (Qcase_fold_search
,
1656 completion_ignore_case
? Qt
: Qnil
);
1658 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1662 if (CONSP (regexps
))
1666 /* Ignore this element if there is a predicate
1667 and the predicate doesn't like it. */
1669 if (!NILP (predicate
))
1671 if (EQ (predicate
, Qcommandp
))
1672 tem
= Fcommandp (elt
, Qnil
);
1675 if (bindcount
>= 0) {
1676 unbind_to (bindcount
, Qnil
);
1679 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1681 ? call2 (predicate
, elt
,
1682 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1683 : call1 (predicate
, elt
);
1686 if (NILP (tem
)) continue;
1688 /* Ok => put it on the list. */
1689 allmatches
= Fcons (eltstring
, allmatches
);
1693 if (bindcount
>= 0) {
1694 unbind_to (bindcount
, Qnil
);
1698 return Fnreverse (allmatches
);
1701 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1702 doc
: /* Read a string in the minibuffer, with completion.
1703 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1704 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1705 COLLECTION can also be a function to do the completion itself.
1706 PREDICATE limits completion to a subset of COLLECTION.
1707 See `try-completion' and `all-completions' for more details
1708 on completion, COLLECTION, and PREDICATE.
1710 REQUIRE-MATCH can take the following values:
1711 - t means that the user is not allowed to exit unless
1712 the input is (or completes to) an element of COLLECTION or is null.
1713 - nil means that the user can exit with any input.
1714 - `confirm' means that the user can exit with any input, but she needs
1715 to confirm her choice if the input is not an element of COLLECTION.
1716 - `confirm-after-completion' means that the user can exit with any
1717 input, but she needs to confirm her choice if she called
1718 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1719 and the input is not an element of COLLECTION.
1720 - anything else behaves like t except that typing RET does not exit if it
1721 does non-null completion.
1723 If the input is null, `completing-read' returns DEF, or the first element
1724 of the list of default values, or an empty string if DEF is nil,
1725 regardless of the value of REQUIRE-MATCH.
1727 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1728 with point positioned at the end.
1729 If it is (STRING . POSITION), the initial input is STRING, but point
1730 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1731 that this is different from `read-from-minibuffer' and related
1732 functions, which use one-indexing for POSITION.) This feature is
1733 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1734 default value DEF instead. The user can yank the default value into
1735 the minibuffer easily using \\[next-history-element].
1737 HIST, if non-nil, specifies a history list and optionally the initial
1738 position in the list. It can be a symbol, which is the history list
1739 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1740 that case, HISTVAR is the history list variable to use, and HISTPOS
1741 is the initial position (the position in the list used by the
1742 minibuffer history commands). For consistency, you should also
1743 specify that element of the history as the value of
1744 INITIAL-INPUT. (This is the only case in which you should use
1745 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1746 1 at the beginning of the list. The variable `history-length'
1747 controls the maximum length of a history list.
1749 DEF, if non-nil, is the default value or the list of default values.
1751 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1752 the current input method and the setting of `enable-multibyte-characters'.
1754 Completion ignores case if the ambient value of
1755 `completion-ignore-case' is non-nil. */)
1756 (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
)
1758 Lisp_Object val
, histvar
, histpos
, position
;
1761 int count
= SPECPDL_INDEX ();
1762 struct gcpro gcpro1
;
1764 init
= initial_input
;
1767 specbind (Qminibuffer_completion_table
, collection
);
1768 specbind (Qminibuffer_completion_predicate
, predicate
);
1769 specbind (Qminibuffer_completion_confirm
,
1770 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1777 position
= Fcdr (init
);
1780 CHECK_STRING (init
);
1781 if (!NILP (position
))
1783 CHECK_NUMBER (position
);
1784 /* Convert to distance from end of input. */
1785 pos
= XINT (position
) - SCHARS (init
);
1796 histvar
= Fcar_safe (hist
);
1797 histpos
= Fcdr_safe (hist
);
1800 histvar
= Qminibuffer_history
;
1802 XSETFASTINT (histpos
, 0);
1804 val
= read_minibuf (NILP (require_match
)
1805 ? (NILP (Vminibuffer_completing_file_name
)
1806 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1807 ? Vminibuffer_local_completion_map
1808 : Vminibuffer_local_filename_completion_map
)
1809 : (NILP (Vminibuffer_completing_file_name
)
1810 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1811 ? Vminibuffer_local_must_match_map
1812 : Vminibuffer_local_filename_must_match_map
),
1813 init
, prompt
, make_number (pos
), 0,
1814 histvar
, histpos
, def
, 0,
1815 !NILP (inherit_input_method
));
1817 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1818 val
= CONSP (def
) ? XCAR (def
) : def
;
1820 RETURN_UNGCPRO (unbind_to (count
, val
));
1823 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1825 /* Test whether TXT is an exact completion. */
1826 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1827 doc
: /* Return non-nil if STRING is a valid completion.
1828 Takes the same arguments as `all-completions' and `try-completion'.
1829 If COLLECTION is a function, it is called with three arguments:
1830 the values STRING, PREDICATE and `lambda'. */)
1831 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1833 Lisp_Object regexps
, tail
, tem
= Qnil
;
1836 CHECK_STRING (string
);
1838 if ((CONSP (collection
)
1839 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1840 || NILP (collection
))
1842 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1846 else if (VECTORP (collection
))
1848 /* Bypass intern-soft as that loses for nil. */
1849 tem
= oblookup (collection
,
1855 if (STRING_MULTIBYTE (string
))
1856 string
= Fstring_make_unibyte (string
);
1858 string
= Fstring_make_multibyte (string
);
1860 tem
= oblookup (collection
,
1866 if (completion_ignore_case
&& !SYMBOLP (tem
))
1868 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1870 tail
= XVECTOR (collection
)->contents
[i
];
1874 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1875 Fsymbol_name (tail
),
1876 make_number (0) , Qnil
, Qt
)),
1882 if (XSYMBOL (tail
)->next
== 0)
1884 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1892 else if (HASH_TABLE_P (collection
))
1894 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1895 i
= hash_lookup (h
, string
, NULL
);
1897 tem
= HASH_KEY (h
, i
);
1899 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1900 if (!NILP (HASH_HASH (h
, i
)) &&
1901 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1902 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1903 completion_ignore_case
? Qt
: Qnil
),
1906 tem
= HASH_KEY (h
, i
);
1913 return call3 (collection
, string
, predicate
, Qlambda
);
1915 /* Reject this element if it fails to match all the regexps. */
1916 if (CONSP (Vcompletion_regexp_list
))
1918 int count
= SPECPDL_INDEX ();
1919 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1920 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1921 regexps
= XCDR (regexps
))
1923 if (NILP (Fstring_match (XCAR (regexps
),
1924 SYMBOLP (tem
) ? string
: tem
,
1926 return unbind_to (count
, Qnil
);
1928 unbind_to (count
, Qnil
);
1931 /* Finally, check the predicate. */
1932 if (!NILP (predicate
))
1934 return HASH_TABLE_P (collection
)
1935 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1936 : call1 (predicate
, tem
);
1942 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1943 doc
: /* Perform completion on buffer names.
1944 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1945 `all-completions', otherwise invoke `test-completion'.
1947 The arguments STRING and PREDICATE are as in `try-completion',
1948 `all-completions', and `test-completion'. */)
1949 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1952 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1953 else if (EQ (flag
, Qt
))
1955 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1956 if (SCHARS (string
) > 0)
1959 { /* Strip out internal buffers. */
1960 Lisp_Object bufs
= res
;
1961 /* First, look for a non-internal buffer in `res'. */
1962 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1965 /* All bufs in `res' are internal, so don't trip them out. */
1968 while (CONSP (XCDR (bufs
)))
1969 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1970 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1976 else /* assume `lambda' */
1977 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1980 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1982 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1983 doc
: /* Like `assoc' but specifically for strings (and symbols).
1985 This returns the first element of LIST whose car matches the string or
1986 symbol KEY, or nil if no match exists. When performing the
1987 comparison, symbols are first converted to strings, and unibyte
1988 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1991 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1992 single string, rather than a cons cell whose car is a string. */)
1993 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1995 register Lisp_Object tail
;
1998 key
= Fsymbol_name (key
);
2000 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
2002 register Lisp_Object elt
, tem
, thiscar
;
2004 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2005 if (SYMBOLP (thiscar
))
2006 thiscar
= Fsymbol_name (thiscar
);
2007 else if (!STRINGP (thiscar
))
2009 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2010 key
, make_number (0), Qnil
,
2020 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2021 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2024 return make_number (minibuf_level
);
2027 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2028 doc
: /* Return the prompt string of the currently-active minibuffer.
2029 If no minibuffer is active, return nil. */)
2032 return Fcopy_sequence (minibuf_prompt
);
2037 init_minibuf_once (void)
2039 Vminibuffer_list
= Qnil
;
2040 staticpro (&Vminibuffer_list
);
2044 syms_of_minibuf (void)
2047 minibuf_prompt
= Qnil
;
2048 staticpro (&minibuf_prompt
);
2050 minibuf_save_list
= Qnil
;
2051 staticpro (&minibuf_save_list
);
2053 Qcompletion_ignore_case
= intern_c_string ("completion-ignore-case");
2054 staticpro (&Qcompletion_ignore_case
);
2056 Qread_file_name_internal
= intern_c_string ("read-file-name-internal");
2057 staticpro (&Qread_file_name_internal
);
2059 Qminibuffer_default
= intern_c_string ("minibuffer-default");
2060 staticpro (&Qminibuffer_default
);
2061 Fset (Qminibuffer_default
, Qnil
);
2063 Qminibuffer_completion_table
= intern_c_string ("minibuffer-completion-table");
2064 staticpro (&Qminibuffer_completion_table
);
2066 Qminibuffer_completion_confirm
= intern_c_string ("minibuffer-completion-confirm");
2067 staticpro (&Qminibuffer_completion_confirm
);
2069 Qminibuffer_completion_predicate
= intern_c_string ("minibuffer-completion-predicate");
2070 staticpro (&Qminibuffer_completion_predicate
);
2072 staticpro (&last_minibuf_string
);
2073 last_minibuf_string
= Qnil
;
2075 Quser_variable_p
= intern_c_string ("user-variable-p");
2076 staticpro (&Quser_variable_p
);
2078 Qminibuffer_history
= intern_c_string ("minibuffer-history");
2079 staticpro (&Qminibuffer_history
);
2081 Qbuffer_name_history
= intern_c_string ("buffer-name-history");
2082 staticpro (&Qbuffer_name_history
);
2083 Fset (Qbuffer_name_history
, Qnil
);
2085 Qminibuffer_setup_hook
= intern_c_string ("minibuffer-setup-hook");
2086 staticpro (&Qminibuffer_setup_hook
);
2088 Qminibuffer_exit_hook
= intern_c_string ("minibuffer-exit-hook");
2089 staticpro (&Qminibuffer_exit_hook
);
2091 Qhistory_length
= intern_c_string ("history-length");
2092 staticpro (&Qhistory_length
);
2094 Qcurrent_input_method
= intern_c_string ("current-input-method");
2095 staticpro (&Qcurrent_input_method
);
2097 Qactivate_input_method
= intern_c_string ("activate-input-method");
2098 staticpro (&Qactivate_input_method
);
2100 Qcase_fold_search
= intern_c_string ("case-fold-search");
2101 staticpro (&Qcase_fold_search
);
2103 Qread_expression_history
= intern_c_string ("read-expression-history");
2104 staticpro (&Qread_expression_history
);
2106 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2107 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2108 Vread_buffer_function
= Qnil
;
2110 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2111 &read_buffer_completion_ignore_case
,
2112 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
2113 read_buffer_completion_ignore_case
= 0;
2115 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2116 doc
: /* Normal hook run just after entry to minibuffer. */);
2117 Vminibuffer_setup_hook
= Qnil
;
2119 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2120 doc
: /* Normal hook run just after exit from minibuffer. */);
2121 Vminibuffer_exit_hook
= Qnil
;
2123 DEFVAR_LISP ("history-length", &Vhistory_length
,
2124 doc
: /* *Maximum length for history lists before truncation takes place.
2125 A number means that length; t means infinite. Truncation takes place
2126 just after a new element is inserted. Setting the `history-length'
2127 property of a history variable overrides this default. */);
2128 XSETFASTINT (Vhistory_length
, 30);
2130 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2131 doc
: /* *Non-nil means to delete duplicates in history.
2132 If set to t when adding a new history element, all previous identical
2133 elements are deleted from the history list. */);
2134 history_delete_duplicates
= 0;
2136 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2137 doc
: /* *Non-nil means to add new elements in history.
2138 If set to nil, minibuffer reading functions don't add new elements to the
2139 history list, so it is possible to do this afterwards by calling
2140 `add-to-history' explicitly. */);
2141 Vhistory_add_new_input
= Qt
;
2143 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2144 doc
: /* Non-nil means don't consider case significant in completion.
2145 For file-name completion, `read-file-name-completion-ignore-case'
2146 controls the behavior, rather than this variable.
2147 For buffer name completion, `read-buffer-completion-ignore-case'
2148 controls the behavior, rather than this variable. */);
2149 completion_ignore_case
= 0;
2151 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2152 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2153 This variable makes a difference whenever the minibuffer window is active. */);
2154 enable_recursive_minibuffers
= 0;
2156 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2157 doc
: /* Alist or obarray used for completion in the minibuffer.
2158 This becomes the ALIST argument to `try-completion' and `all-completions'.
2159 The value can also be a list of strings or a hash table.
2161 The value may alternatively be a function, which is given three arguments:
2162 STRING, the current buffer contents;
2163 PREDICATE, the predicate for filtering possible matches;
2164 CODE, which says what kind of things to do.
2165 CODE can be nil, t or `lambda':
2166 nil -- return the best completion of STRING, or nil if there is none.
2167 t -- return a list of all possible completions of STRING.
2168 lambda -- return t if STRING is a valid completion as it stands. */);
2169 Vminibuffer_completion_table
= Qnil
;
2171 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2172 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2173 Vminibuffer_completion_predicate
= Qnil
;
2175 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2176 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2177 If nil, confirmation is not required.
2178 If the value is `confirm', the user may exit with an input that is not
2179 a valid completion alternative, but Emacs asks for confirmation.
2180 If the value is `confirm-after-completion', the user may exit with an
2181 input that is not a valid completion alternative, but Emacs asks for
2182 confirmation if the user submitted the input right after any of the
2183 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2184 Vminibuffer_completion_confirm
= Qnil
;
2186 DEFVAR_LISP ("minibuffer-completing-file-name",
2187 &Vminibuffer_completing_file_name
,
2188 doc
: /* Non-nil means completing file names. */);
2189 Vminibuffer_completing_file_name
= Qnil
;
2191 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2192 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2193 Vminibuffer_help_form
= Qnil
;
2195 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2196 doc
: /* History list symbol to add minibuffer values to.
2197 Each string of minibuffer input, as it appears on exit from the minibuffer,
2199 (set minibuffer-history-variable
2200 (cons STRING (symbol-value minibuffer-history-variable))) */);
2201 XSETFASTINT (Vminibuffer_history_variable
, 0);
2203 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2204 doc
: /* Current position of redoing in the history list. */);
2205 Vminibuffer_history_position
= Qnil
;
2207 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2208 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2209 Some uses of the echo area also raise that frame (since they use it too). */);
2210 minibuffer_auto_raise
= 0;
2212 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2213 doc
: /* List of regexps that should restrict possible completions.
2214 The basic completion functions only consider a completion acceptable
2215 if it matches all regular expressions in this list, with
2216 `case-fold-search' bound to the value of `completion-ignore-case'.
2217 See Info node `(elisp)Basic Completion', for a description of these
2219 Vcompletion_regexp_list
= Qnil
;
2221 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2222 &minibuffer_allow_text_properties
,
2223 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2224 This also affects `read-string', but it does not affect `read-minibuffer',
2225 `read-no-blanks-input', or any of the functions that do minibuffer input
2226 with completion; they always discard text properties. */);
2227 minibuffer_allow_text_properties
= 0;
2229 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2230 doc
: /* Text properties that are added to minibuffer prompts.
2231 These are in addition to the basic `field' property, and stickiness
2233 /* We use `intern' here instead of Qread_only to avoid
2234 initialization-order problems. */
2235 Vminibuffer_prompt_properties
2236 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2238 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
2239 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2240 Vread_expression_map
= Qnil
;
2242 defsubr (&Sset_minibuffer_window
);
2243 defsubr (&Sread_from_minibuffer
);
2244 defsubr (&Seval_minibuffer
);
2245 defsubr (&Sread_minibuffer
);
2246 defsubr (&Sread_string
);
2247 defsubr (&Sread_command
);
2248 defsubr (&Sread_variable
);
2249 defsubr (&Sinternal_complete_buffer
);
2250 defsubr (&Sread_buffer
);
2251 defsubr (&Sread_no_blanks_input
);
2252 defsubr (&Sminibuffer_depth
);
2253 defsubr (&Sminibuffer_prompt
);
2255 defsubr (&Sminibufferp
);
2256 defsubr (&Sminibuffer_prompt_end
);
2257 defsubr (&Sminibuffer_contents
);
2258 defsubr (&Sminibuffer_contents_no_properties
);
2259 defsubr (&Sminibuffer_completion_contents
);
2261 defsubr (&Stry_completion
);
2262 defsubr (&Sall_completions
);
2263 defsubr (&Stest_completion
);
2264 defsubr (&Sassoc_string
);
2265 defsubr (&Scompleting_read
);
2268 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2269 (do not change this comment) */