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
;
147 /* Put minibuf on currently selected frame's minibuffer.
148 We do this whenever the user starts a new minibuffer
149 or when a minibuffer exits. */
152 choose_minibuf_frame (void)
154 if (FRAMEP (selected_frame
)
155 && FRAME_LIVE_P (XFRAME (selected_frame
))
156 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
158 struct frame
*sf
= XFRAME (selected_frame
);
161 /* I don't think that any frames may validly have a null minibuffer
163 if (NILP (sf
->minibuffer_window
))
166 /* Under X, we come here with minibuf_window being the
167 minibuffer window of the unused termcap window created in
168 init_window_once. That window doesn't have a buffer. */
169 buffer
= XWINDOW (minibuf_window
)->buffer
;
170 if (BUFFERP (buffer
))
171 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
172 minibuf_window
= sf
->minibuffer_window
;
175 /* Make sure no other frame has a minibuffer as its selected window,
176 because the text would not be displayed in it, and that would be
177 confusing. Only allow the selected frame to do this,
178 and that only if the minibuffer is active. */
180 Lisp_Object tail
, frame
;
182 FOR_EACH_FRAME (tail
, frame
)
183 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
184 && !(EQ (frame
, selected_frame
)
185 && minibuf_level
> 0))
186 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
191 choose_minibuf_frame_1 (Lisp_Object ignore
)
193 choose_minibuf_frame ();
197 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
198 Sactive_minibuffer_window
, 0, 0, 0,
199 doc
: /* Return the currently active minibuffer window, or nil if none. */)
202 return minibuf_level
? minibuf_window
: Qnil
;
205 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
206 Sset_minibuffer_window
, 1, 1, 0,
207 doc
: /* Specify which minibuffer window to use for the minibuffer.
208 This affects where the minibuffer is displayed if you put text in it
209 without invoking the usual minibuffer commands. */)
212 CHECK_WINDOW (window
);
213 if (! MINI_WINDOW_P (XWINDOW (window
)))
214 error ("Window is not a minibuffer window");
216 minibuf_window
= window
;
222 /* Actual minibuffer invocation. */
224 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
225 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
226 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
227 Lisp_Object
, Lisp_Object
,
229 Lisp_Object
, Lisp_Object
,
231 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
232 Lisp_Object
, Lisp_Object
,
234 Lisp_Object
, Lisp_Object
,
236 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
239 /* Read a Lisp object from VAL and return it. If VAL is an empty
240 string, and DEFALT is a string, read from DEFALT instead of VAL. */
243 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
245 struct gcpro gcpro1
, gcpro2
;
246 Lisp_Object expr_and_pos
;
249 GCPRO2 (val
, defalt
);
251 if (STRINGP (val
) && SCHARS (val
) == 0)
253 if (STRINGP (defalt
))
255 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
259 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
260 pos
= XINT (Fcdr (expr_and_pos
));
261 if (pos
!= SCHARS (val
))
263 /* Ignore trailing whitespace; any other trailing junk
266 pos
= string_char_to_byte (val
, pos
);
267 for (i
= pos
; i
< SBYTES (val
); i
++)
269 int c
= SREF (val
, i
);
270 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
271 error ("Trailing garbage following expression");
275 val
= Fcar (expr_and_pos
);
276 RETURN_UNGCPRO (val
);
280 /* Like read_minibuf but reading from stdin. This function is called
281 from read_minibuf to do the job if noninteractive. */
284 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
285 Lisp_Object prompt
, Lisp_Object backup_n
,
287 Lisp_Object histvar
, Lisp_Object histpos
,
289 int allow_props
, int inherit_input_method
)
295 fprintf (stdout
, "%s", SDATA (prompt
));
301 line
= (char *) xmalloc (size
* sizeof *line
);
302 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
303 && (len
= strlen (line
),
304 len
== size
- 1 && line
[len
- 1] != '\n'))
307 line
= (char *) xrealloc (line
, size
);
314 if (len
> 0 && line
[len
- 1] == '\n')
317 val
= build_string (line
);
323 error ("Error reading from stdin");
326 /* If Lisp form desired instead of string, parse it. */
328 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
333 DEFUN ("minibufferp", Fminibufferp
,
334 Sminibufferp
, 0, 1, 0,
335 doc
: /* Return t if BUFFER is a minibuffer.
336 No argument or nil as argument means use current buffer as BUFFER.
337 BUFFER can be a buffer or a buffer name. */)
343 buffer
= Fcurrent_buffer ();
344 else if (STRINGP (buffer
))
345 buffer
= Fget_buffer (buffer
);
347 CHECK_BUFFER (buffer
);
349 tem
= Fmemq (buffer
, Vminibuffer_list
);
350 return ! NILP (tem
) ? Qt
: Qnil
;
353 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
354 Sminibuffer_prompt_end
, 0, 0, 0,
355 doc
: /* Return the buffer position of the end of the minibuffer prompt.
356 Return (point-min) if current buffer is not a minibuffer. */)
359 /* This function is written to be most efficient when there's a prompt. */
360 Lisp_Object beg
, end
, tem
;
361 beg
= make_number (BEGV
);
363 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
367 end
= Ffield_end (beg
, Qnil
, Qnil
);
369 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
375 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
376 Sminibuffer_contents
, 0, 0, 0,
377 doc
: /* Return the user input in a minibuffer as a string.
378 If the current buffer is not a minibuffer, return its entire contents. */)
381 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
382 return make_buffer_string (prompt_end
, ZV
, 1);
385 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
386 Sminibuffer_contents_no_properties
, 0, 0, 0,
387 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
388 If the current buffer is not a minibuffer, return its entire contents. */)
391 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
392 return make_buffer_string (prompt_end
, ZV
, 0);
395 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
396 Sminibuffer_completion_contents
, 0, 0, 0,
397 doc
: /* Return the user input in a minibuffer before point as a string.
398 That is what completion commands operate on.
399 If the current buffer is not a minibuffer, return its entire contents. */)
402 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
404 error ("Cannot do completion in the prompt");
405 return make_buffer_string (prompt_end
, PT
, 1);
409 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
410 putting point minus BACKUP_N bytes from the end of INITIAL,
411 prompting with PROMPT (a string), using history list HISTVAR
412 with initial position HISTPOS. INITIAL should be a string or a
413 cons of a string and an integer. BACKUP_N should be <= 0, or
414 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
415 ignored and replaced with an integer that puts point at one-indexed
416 position N in INITIAL, where N is the CDR of INITIAL, or at the
417 beginning of INITIAL if N <= 0.
419 Normally return the result as a string (the text that was read),
420 but if EXPFLAG is nonzero, read it and return the object read.
421 If HISTVAR is given, save the value read on that history only if it doesn't
422 match the front of that history list exactly. The value is pushed onto
423 the list as the string that was read.
425 DEFALT specifies the default value for the sake of history commands.
427 If ALLOW_PROPS is nonzero, we do not throw away text properties.
429 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
430 current input method. */
433 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
434 Lisp_Object backup_n
, int expflag
,
435 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
436 int allow_props
, int inherit_input_method
)
439 int count
= SPECPDL_INDEX ();
440 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
441 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
442 Lisp_Object enable_multibyte
;
443 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
444 /* String to add to the history. */
445 Lisp_Object histstring
;
447 Lisp_Object empty_minibuf
;
448 Lisp_Object dummy
, frame
;
450 specbind (Qminibuffer_default
, defalt
);
452 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
453 in previous recursive minibuffer, but was not set explicitly
454 to t for this invocation, so set it to nil in this minibuffer.
455 Save the old value now, before we change it. */
456 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
457 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
458 Vminibuffer_completing_file_name
= Qnil
;
460 #ifdef HAVE_WINDOW_SYSTEM
461 if (display_hourglass_p
)
469 backup_n
= Fcdr (initial
);
470 initial
= Fcar (initial
);
471 CHECK_STRING (initial
);
472 if (!NILP (backup_n
))
474 CHECK_NUMBER (backup_n
);
475 /* Convert to distance from end of input. */
476 if (XINT (backup_n
) < 1)
477 /* A number too small means the beginning of the string. */
478 pos
= - SCHARS (initial
);
480 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
484 CHECK_STRING (initial
);
487 ambient_dir
= current_buffer
->directory
;
489 enable_multibyte
= Qnil
;
491 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
492 store them away before we can GC. Don't need to protect
493 BACKUP_N because we use the value only if it is an integer. */
494 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
496 if (!STRINGP (prompt
))
497 prompt
= empty_unibyte_string
;
499 if (!enable_recursive_minibuffers
500 && minibuf_level
> 0)
502 if (EQ (selected_window
, minibuf_window
))
503 error ("Command attempted to use minibuffer while in minibuffer");
505 /* If we're in another window, cancel the minibuffer that's active. */
507 build_string ("Command attempted to use minibuffer while in minibuffer"));
511 /* In case we are running as a daemon, only do this before
512 detaching from the terminal. */
513 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
514 && NILP (Vexecuting_kbd_macro
))
516 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
518 expflag
, histvar
, histpos
, defalt
,
519 allow_props
, inherit_input_method
);
521 return unbind_to (count
, val
);
524 /* Choose the minibuffer window and frame, and take action on them. */
526 choose_minibuf_frame ();
528 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
530 record_unwind_protect (Fset_window_configuration
,
531 Fcurrent_window_configuration (Qnil
));
533 /* If the minibuffer window is on a different frame, save that
534 frame's configuration too. */
535 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
536 if (!EQ (mini_frame
, selected_frame
))
537 record_unwind_protect (Fset_window_configuration
,
538 Fcurrent_window_configuration (mini_frame
));
540 /* If the minibuffer is on an iconified or invisible frame,
541 make it visible now. */
542 Fmake_frame_visible (mini_frame
);
544 if (minibuffer_auto_raise
)
545 Fraise_frame (mini_frame
);
547 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
549 /* We have to do this after saving the window configuration
550 since that is what restores the current buffer. */
552 /* Arrange to restore a number of minibuffer-related variables.
553 We could bind each variable separately, but that would use lots of
556 = Fcons (Voverriding_local_map
,
557 Fcons (minibuf_window
,
560 = Fcons (minibuf_prompt
,
561 Fcons (make_number (minibuf_prompt_width
),
563 Fcons (Vcurrent_prefix_arg
,
564 Fcons (Vminibuffer_history_position
,
565 Fcons (Vminibuffer_history_variable
,
566 minibuf_save_list
))))));
568 record_unwind_protect (read_minibuf_unwind
, Qnil
);
570 /* We are exiting the minibuffer one way or the other, so run the hook.
571 It should be run before unwinding the minibuf settings. Do it
572 separately from read_minibuf_unwind because we need to make sure that
573 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
574 signals an error. --Stef */
575 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
577 /* Now that we can restore all those variables, start changing them. */
579 minibuf_prompt_width
= 0;
580 minibuf_prompt
= Fcopy_sequence (prompt
);
581 Vminibuffer_history_position
= histpos
;
582 Vminibuffer_history_variable
= histvar
;
583 Vhelp_form
= Vminibuffer_help_form
;
584 /* If this minibuffer is reading a file name, that doesn't mean
585 recursive ones are. But we cannot set it to nil, because
586 completion code still need to know the minibuffer is completing a
587 file name. So use `lambda' as intermediate value meaning
588 "t" in this minibuffer, but "nil" in next minibuffer. */
589 if (!NILP (Vminibuffer_completing_file_name
))
590 Vminibuffer_completing_file_name
= Qlambda
;
592 if (inherit_input_method
)
594 /* `current-input-method' is buffer local. So, remember it in
595 INPUT_METHOD before changing the current buffer. */
596 input_method
= Fsymbol_value (Qcurrent_input_method
);
597 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
600 /* Switch to the minibuffer. */
602 minibuffer
= get_minibuffer (minibuf_level
);
603 Fset_buffer (minibuffer
);
605 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
606 if (inherit_input_method
)
607 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
609 /* The current buffer's default directory is usually the right thing
610 for our minibuffer here. However, if you're typing a command at
611 a minibuffer-only frame when minibuf_level is zero, then buf IS
612 the current_buffer, so reset_buffer leaves buf's default
613 directory unchanged. This is a bummer when you've just started
614 up Emacs and buf's default directory is Qnil. Here's a hack; can
615 you think of something better to do? Find another buffer with a
616 better directory, and use that one instead. */
617 if (STRINGP (ambient_dir
))
618 current_buffer
->directory
= ambient_dir
;
621 Lisp_Object buf_list
;
623 for (buf_list
= Vbuffer_alist
;
625 buf_list
= XCDR (buf_list
))
627 Lisp_Object other_buf
;
629 other_buf
= XCDR (XCAR (buf_list
));
630 if (STRINGP (XBUFFER (other_buf
)->directory
))
632 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
638 if (!EQ (mini_frame
, selected_frame
))
639 Fredirect_frame_focus (selected_frame
, mini_frame
);
641 Vminibuf_scroll_window
= selected_window
;
642 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
643 minibuf_selected_window
= selected_window
;
645 /* Empty out the minibuffers of all frames other than the one
646 where we are going to display one now.
647 Set them to point to ` *Minibuf-0*', which is always empty. */
648 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
650 FOR_EACH_FRAME (dummy
, frame
)
652 Lisp_Object root_window
= Fframe_root_window (frame
);
653 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
655 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
656 && !NILP (Fwindow_minibuffer_p (mini_window
)))
657 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
660 /* Display this minibuffer in the proper window. */
661 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
662 Fselect_window (minibuf_window
, Qnil
);
663 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
665 Fmake_local_variable (Qprint_escape_newlines
);
666 print_escape_newlines
= 1;
668 /* Erase the buffer. */
670 int count1
= SPECPDL_INDEX ();
671 specbind (Qinhibit_read_only
, Qt
);
672 specbind (Qinhibit_modification_hooks
, Qt
);
675 if (!NILP (current_buffer
->enable_multibyte_characters
)
676 && ! STRING_MULTIBYTE (minibuf_prompt
))
677 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
679 /* Insert the prompt, record where it ends. */
680 Finsert (1, &minibuf_prompt
);
683 Fput_text_property (make_number (BEG
), make_number (PT
),
684 Qfront_sticky
, Qt
, Qnil
);
685 Fput_text_property (make_number (BEG
), make_number (PT
),
686 Qrear_nonsticky
, Qt
, Qnil
);
687 Fput_text_property (make_number (BEG
), make_number (PT
),
689 Fadd_text_properties (make_number (BEG
), make_number (PT
),
690 Vminibuffer_prompt_properties
, Qnil
);
692 unbind_to (count1
, Qnil
);
695 minibuf_prompt_width
= (int) current_column (); /* iftc */
697 /* Put in the initial input. */
700 Finsert (1, &initial
);
701 Fforward_char (make_number (pos
));
704 clear_message (1, 1);
705 current_buffer
->keymap
= map
;
707 /* Turn on an input method stored in INPUT_METHOD if any. */
708 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
709 call1 (Qactivate_input_method
, input_method
);
711 /* Run our hook, but not if it is empty.
712 (run-hooks would do nothing if it is empty,
713 but it's important to save time here in the usual case.) */
714 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
715 && !NILP (Vrun_hooks
))
716 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
718 /* Don't allow the user to undo past this point. */
719 current_buffer
->undo_list
= Qnil
;
723 /* If cursor is on the minibuffer line,
724 show the user we have exited by putting it in column 0. */
725 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
728 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
729 XWINDOW (minibuf_window
)->cursor
.x
= 0;
730 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
731 update_frame (XFRAME (selected_frame
), 1, 1);
733 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
734 struct redisplay_interface
*rif
= FRAME_RIF (f
);
735 if (rif
&& rif
->flush_display
)
736 rif
->flush_display (f
);
740 /* Make minibuffer contents into a string. */
741 Fset_buffer (minibuffer
);
743 val
= Fminibuffer_contents ();
745 val
= Fminibuffer_contents_no_properties ();
747 /* VAL is the string of minibuffer text. */
749 last_minibuf_string
= val
;
751 /* Choose the string to add to the history. */
752 if (SCHARS (val
) != 0)
754 else if (STRINGP (defalt
))
756 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
757 histstring
= XCAR (defalt
);
761 /* Add the value to the appropriate history list, if any. */
762 if (!NILP (Vhistory_add_new_input
)
763 && SYMBOLP (Vminibuffer_history_variable
)
764 && !NILP (histstring
))
766 /* If the caller wanted to save the value read on a history list,
767 then do so if the value is not already the front of the list. */
770 /* If variable is unbound, make it nil. */
772 histval
= find_symbol_value (Vminibuffer_history_variable
);
773 if (EQ (histval
, Qunbound
))
774 Fset (Vminibuffer_history_variable
, Qnil
);
776 /* The value of the history variable must be a cons or nil. Other
777 values are unacceptable. We silently ignore these values. */
781 /* Don't duplicate the most recent entry in the history. */
782 && (NILP (Fequal (histstring
, Fcar (histval
))))))
786 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
787 histval
= Fcons (histstring
, histval
);
788 Fset (Vminibuffer_history_variable
, histval
);
790 /* Truncate if requested. */
791 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
792 if (NILP (length
)) length
= Vhistory_length
;
793 if (INTEGERP (length
))
795 if (XINT (length
) <= 0)
796 Fset (Vminibuffer_history_variable
, Qnil
);
801 temp
= Fnthcdr (Fsub1 (length
), histval
);
802 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
808 /* If Lisp form desired instead of string, parse it. */
810 val
= string_to_object (val
, defalt
);
812 /* The appropriate frame will get selected
813 in set-window-configuration. */
815 return unbind_to (count
, val
);
818 /* Return a buffer to be used as the minibuffer at depth `depth'.
819 depth = 0 is the lowest allowed argument, and that is the value
820 used for nonrecursive minibuffer invocations */
823 get_minibuffer (int depth
)
825 Lisp_Object tail
, num
, buf
;
828 XSETFASTINT (num
, depth
);
829 tail
= Fnthcdr (num
, Vminibuffer_list
);
832 tail
= Fcons (Qnil
, Qnil
);
833 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
836 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
838 sprintf (name
, " *Minibuf-%d*", depth
);
839 buf
= Fget_buffer_create (build_string (name
));
841 /* Although the buffer's name starts with a space, undo should be
843 Fbuffer_enable_undo (buf
);
849 int count
= SPECPDL_INDEX ();
850 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
851 have to empty the list, otherwise we end up with overlays that
852 think they belong to this buffer while the buffer doesn't know about
854 delete_all_overlays (XBUFFER (buf
));
855 reset_buffer (XBUFFER (buf
));
856 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
858 Fkill_all_local_variables ();
859 unbind_to (count
, Qnil
);
866 run_exit_minibuf_hook (Lisp_Object data
)
868 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
869 && !NILP (Vrun_hooks
))
870 safe_run_hooks (Qminibuffer_exit_hook
);
875 /* This function is called on exiting minibuffer, whether normally or
876 not, and it restores the current window, buffer, etc. */
879 read_minibuf_unwind (Lisp_Object data
)
881 Lisp_Object old_deactivate_mark
;
884 /* If this was a recursive minibuffer,
885 tie the minibuffer window back to the outer level minibuffer buffer. */
888 window
= minibuf_window
;
889 /* To keep things predictable, in case it matters, let's be in the
890 minibuffer when we reset the relevant variables. */
891 Fset_buffer (XWINDOW (window
)->buffer
);
893 /* Restore prompt, etc, from outer minibuffer level. */
894 minibuf_prompt
= Fcar (minibuf_save_list
);
895 minibuf_save_list
= Fcdr (minibuf_save_list
);
896 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
897 minibuf_save_list
= Fcdr (minibuf_save_list
);
898 Vhelp_form
= Fcar (minibuf_save_list
);
899 minibuf_save_list
= Fcdr (minibuf_save_list
);
900 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
901 minibuf_save_list
= Fcdr (minibuf_save_list
);
902 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
903 minibuf_save_list
= Fcdr (minibuf_save_list
);
904 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
905 minibuf_save_list
= Fcdr (minibuf_save_list
);
906 Voverriding_local_map
= Fcar (minibuf_save_list
);
907 minibuf_save_list
= Fcdr (minibuf_save_list
);
909 temp
= Fcar (minibuf_save_list
);
910 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
911 minibuf_window
= temp
;
913 minibuf_save_list
= Fcdr (minibuf_save_list
);
915 /* Erase the minibuffer we were using at this level. */
917 int count
= SPECPDL_INDEX ();
918 /* Prevent error in erase-buffer. */
919 specbind (Qinhibit_read_only
, Qt
);
920 specbind (Qinhibit_modification_hooks
, Qt
);
921 old_deactivate_mark
= Vdeactivate_mark
;
923 Vdeactivate_mark
= old_deactivate_mark
;
924 unbind_to (count
, Qnil
);
927 /* When we get to the outmost level, make sure we resize the
928 mini-window back to its normal size. */
929 if (minibuf_level
== 0)
930 resize_mini_window (XWINDOW (window
), 0);
932 /* Make sure minibuffer window is erased, not ignored. */
933 windows_or_buffers_changed
++;
934 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
935 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
940 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
941 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
942 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
943 DEFAULT-VALUE. It normally should be nil in new code, except when
944 HIST is a cons. It is discussed in more detail below.
945 Third arg KEYMAP is a keymap to use whilst reading;
946 if omitted or nil, the default is `minibuffer-local-map'.
947 If fourth arg READ is non-nil, then interpret the result as a Lisp object
948 and return that object:
949 in other words, do `(car (read-from-string INPUT-STRING))'
950 Fifth arg HIST, if non-nil, specifies a history list and optionally
951 the initial position in the list. It can be a symbol, which is the
952 history list variable to use, or it can be a cons cell
953 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
954 to use, and HISTPOS is the initial position for use by the minibuffer
955 history commands. For consistency, you should also specify that
956 element of the history as the value of INITIAL-CONTENTS. Positions
957 are counted starting from 1 at the beginning of the list.
958 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
959 If non-nil, it is available for history commands, and as the value
960 (or the first element of the list of default values) to return
961 if the user enters the empty string. But, unless READ is non-nil,
962 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
963 empty input! It returns the empty string.
964 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
965 the current input method and the setting of `enable-multibyte-characters'.
966 If the variable `minibuffer-allow-text-properties' is non-nil,
967 then the string which is returned includes whatever text properties
968 were present in the minibuffer. Otherwise the value has no text properties.
970 The remainder of this documentation string describes the
971 INITIAL-CONTENTS argument in more detail. It is only relevant when
972 studying existing code, or when HIST is a cons. If non-nil,
973 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
974 reading input. Normally, point is put at the end of that string.
975 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
976 input is STRING, but point is placed at _one-indexed_ position
977 POSITION in the minibuffer. Any integer value less than or equal to
978 one puts point at the beginning of the string. *Note* that this
979 behavior differs from the way such arguments are used in `completing-read'
980 and some related functions, which use zero-indexing for POSITION. */)
981 (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
)
983 Lisp_Object histvar
, histpos
, val
;
986 CHECK_STRING (prompt
);
988 keymap
= Vminibuffer_local_map
;
990 keymap
= get_keymap (keymap
, 1, 0);
999 histvar
= Fcar_safe (hist
);
1000 histpos
= Fcdr_safe (hist
);
1003 histvar
= Qminibuffer_history
;
1005 XSETFASTINT (histpos
, 0);
1007 GCPRO1 (default_value
);
1008 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1010 histvar
, histpos
, default_value
,
1011 minibuffer_allow_text_properties
,
1012 !NILP (inherit_input_method
));
1017 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1018 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1019 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1020 is a string to insert in the minibuffer before reading.
1021 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1022 Such arguments are used as in `read-from-minibuffer'.) */)
1023 (Lisp_Object prompt
, Lisp_Object initial_contents
)
1025 CHECK_STRING (prompt
);
1026 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1027 prompt
, Qnil
, 1, Qminibuffer_history
,
1028 make_number (0), Qnil
, 0, 0);
1031 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1032 doc
: /* Return value of Lisp expression read using the minibuffer.
1033 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1034 is a string to insert in the minibuffer before reading.
1035 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1036 Such arguments are used as in `read-from-minibuffer'.) */)
1037 (Lisp_Object prompt
, Lisp_Object initial_contents
)
1039 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1040 prompt
, Qnil
, 1, Qread_expression_history
,
1041 make_number (0), Qnil
, 0, 0));
1044 /* Functions that use the minibuffer to read various things. */
1046 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1047 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1048 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1049 This argument has been superseded by DEFAULT-VALUE and should normally
1050 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1051 documentation string of that function for details.
1052 The third arg HISTORY, if non-nil, specifies a history list
1053 and optionally the initial position in the list.
1054 See `read-from-minibuffer' for details of HISTORY argument.
1055 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1056 If non-nil, it is used for history commands, and as the value (or the first
1057 element of the list of default values) to return if the user enters the
1059 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1060 the current input method and the setting of `enable-multibyte-characters'. */)
1061 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1064 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1065 Qnil
, history
, default_value
,
1066 inherit_input_method
);
1067 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1068 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1072 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1073 doc
: /* Read a string from the terminal, not allowing blanks.
1074 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1075 non-nil, it should be a string, which is used as initial input, with
1076 point positioned at the end, so that SPACE will accept the input.
1077 \(Actually, INITIAL can also be a cons of a string and an integer.
1078 Such values are treated as in `read-from-minibuffer', but are normally
1079 not useful in this function.)
1080 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1081 the current input method and the setting of`enable-multibyte-characters'. */)
1082 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1084 CHECK_STRING (prompt
);
1085 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1086 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1087 !NILP (inherit_input_method
));
1090 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1091 doc
: /* Read the name of a command and return as a symbol.
1092 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1093 if it is a list. */)
1094 (Lisp_Object prompt
, Lisp_Object default_value
)
1096 Lisp_Object name
, default_string
;
1098 if (NILP (default_value
))
1099 default_string
= Qnil
;
1100 else if (SYMBOLP (default_value
))
1101 default_string
= SYMBOL_NAME (default_value
);
1103 default_string
= default_value
;
1105 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1106 Qnil
, Qnil
, default_string
, Qnil
);
1109 return Fintern (name
, Qnil
);
1113 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1114 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1115 Prompt with PROMPT. */)
1116 (Lisp_Object prompt
)
1118 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1123 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1124 doc
: /* Read the name of a user variable and return it as a symbol.
1125 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1127 A user variable is one for which `user-variable-p' returns non-nil. */)
1128 (Lisp_Object prompt
, Lisp_Object default_value
)
1130 Lisp_Object name
, default_string
;
1132 if (NILP (default_value
))
1133 default_string
= Qnil
;
1134 else if (SYMBOLP (default_value
))
1135 default_string
= SYMBOL_NAME (default_value
);
1137 default_string
= default_value
;
1139 name
= Fcompleting_read (prompt
, Vobarray
,
1140 Quser_variable_p
, Qt
,
1141 Qnil
, Qnil
, default_string
, Qnil
);
1144 return Fintern (name
, Qnil
);
1147 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1148 doc
: /* Read the name of a buffer and return as a string.
1150 Optional second arg DEF is value to return if user enters an empty line.
1151 If DEF is a list of default values, return its first element.
1152 Optional third arg REQUIRE-MATCH determines whether non-existing
1153 buffer names are allowed. It has the same meaning as the
1154 REQUIRE-MATCH argument of `completing-read'.
1155 The argument PROMPT should be a string ending with a colon and a space.
1156 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1157 case while reading the buffer name.
1158 If `read-buffer-function' is non-nil, this works by calling it as a
1159 function, instead of the usual behavior. */)
1160 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1162 Lisp_Object args
[4], result
;
1165 int count
= SPECPDL_INDEX ();
1168 def
= XBUFFER (def
)->name
;
1170 specbind (Qcompletion_ignore_case
,
1171 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1173 if (NILP (Vread_buffer_function
))
1177 /* A default value was provided: we must change PROMPT,
1178 editing the default value in before the colon. To achieve
1179 this, we replace PROMPT with a substring that doesn't
1180 contain the terminal space and colon (if present). They
1181 are then added back using Fformat. */
1183 if (STRINGP (prompt
))
1187 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1189 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1192 prompt
= make_specified_string (s
, -1, len
,
1193 STRING_MULTIBYTE (prompt
));
1196 args
[0] = build_string ("%s (default %s): ");
1198 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1199 prompt
= Fformat (3, args
);
1202 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1203 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1208 args
[0] = Vread_buffer_function
;
1211 args
[3] = require_match
;
1212 result
= Ffuncall(4, args
);
1214 return unbind_to (count
, result
);
1218 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1220 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1223 if (STRING_MULTIBYTE (string
))
1224 return Fstring_make_unibyte (string
);
1226 return Fstring_make_multibyte (string
);
1229 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1230 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1231 Test each possible completion specified by COLLECTION
1232 to see if it begins with STRING. The possible completions may be
1233 strings or symbols. Symbols are converted to strings before testing,
1235 All that match STRING are compared together; the longest initial sequence
1236 common to all these matches is the return value.
1237 If there is no match at all, the return value is nil.
1238 For a unique match which is exact, the return value is t.
1240 If COLLECTION is an alist, the keys (cars of elements) are the
1241 possible completions. If an element is not a cons cell, then the
1242 element itself is the possible completion.
1243 If COLLECTION is a hash-table, all the keys that are strings or symbols
1244 are the possible completions.
1245 If COLLECTION is an obarray, the names of all symbols in the obarray
1246 are the possible completions.
1248 COLLECTION can also be a function to do the completion itself.
1249 It receives three arguments: the values STRING, PREDICATE and nil.
1250 Whatever it returns becomes the value of `try-completion'.
1252 If optional third argument PREDICATE is non-nil,
1253 it is used to test each possible match.
1254 The match is a candidate only if PREDICATE returns non-nil.
1255 The argument given to PREDICATE is the alist element
1256 or the symbol from the obarray. If COLLECTION is a hash-table,
1257 predicate is called with two arguments: the key and the value.
1258 Additionally to this predicate, `completion-regexp-list'
1259 is used to further constrain the set of candidates. */)
1260 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1262 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1263 /* Size in bytes of BESTMATCH. */
1264 int bestmatchsize
= 0;
1265 /* These are in bytes, too. */
1266 int compare
, matchsize
;
1267 enum { function_table
, list_table
, obarray_table
, hash_table
}
1268 type
= (HASH_TABLE_P (collection
) ? hash_table
1269 : VECTORP (collection
) ? obarray_table
1270 : ((NILP (collection
)
1271 || (CONSP (collection
)
1272 && (!SYMBOLP (XCAR (collection
))
1273 || NILP (XCAR (collection
)))))
1274 ? list_table
: function_table
));
1275 int index
= 0, obsize
= 0;
1278 Lisp_Object bucket
, zero
, end
, tem
;
1279 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1281 CHECK_STRING (string
);
1282 if (type
== function_table
)
1283 return call3 (collection
, string
, predicate
, Qnil
);
1285 bestmatch
= bucket
= Qnil
;
1286 zero
= make_number (0);
1288 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1290 if (type
== obarray_table
)
1292 collection
= check_obarray (collection
);
1293 obsize
= XVECTOR (collection
)->size
;
1294 bucket
= XVECTOR (collection
)->contents
[index
];
1299 /* Get the next element of the alist, obarray, or hash-table. */
1300 /* Exit the loop if the elements are all used up. */
1301 /* elt gets the alist element or symbol.
1302 eltstring gets the name to check as a completion. */
1304 if (type
== list_table
)
1309 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1312 else if (type
== obarray_table
)
1314 if (!EQ (bucket
, zero
))
1316 if (!SYMBOLP (bucket
))
1317 error ("Bad data in guts of obarray");
1320 if (XSYMBOL (bucket
)->next
)
1321 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1323 XSETFASTINT (bucket
, 0);
1325 else if (++index
>= obsize
)
1329 bucket
= XVECTOR (collection
)->contents
[index
];
1333 else /* if (type == hash_table) */
1335 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1336 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1338 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1341 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1344 /* Is this element a possible completion? */
1346 if (SYMBOLP (eltstring
))
1347 eltstring
= Fsymbol_name (eltstring
);
1349 if (STRINGP (eltstring
)
1350 && SCHARS (string
) <= SCHARS (eltstring
)
1351 && (tem
= Fcompare_strings (eltstring
, zero
,
1352 make_number (SCHARS (string
)),
1354 completion_ignore_case
? Qt
: Qnil
),
1358 Lisp_Object regexps
;
1360 /* Ignore this element if it fails to match all the regexps. */
1362 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1363 regexps
= XCDR (regexps
))
1365 if (bindcount
< 0) {
1366 bindcount
= SPECPDL_INDEX ();
1367 specbind (Qcase_fold_search
,
1368 completion_ignore_case
? Qt
: Qnil
);
1370 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1374 if (CONSP (regexps
))
1378 /* Ignore this element if there is a predicate
1379 and the predicate doesn't like it. */
1381 if (!NILP (predicate
))
1383 if (EQ (predicate
, Qcommandp
))
1384 tem
= Fcommandp (elt
, Qnil
);
1389 unbind_to (bindcount
, Qnil
);
1392 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1393 tem
= (type
== hash_table
1394 ? call2 (predicate
, elt
,
1395 HASH_VALUE (XHASH_TABLE (collection
),
1397 : call1 (predicate
, elt
));
1400 if (NILP (tem
)) continue;
1403 /* Update computation of how much all possible completions match */
1405 if (NILP (bestmatch
))
1408 bestmatch
= eltstring
;
1409 bestmatchsize
= SCHARS (eltstring
);
1413 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1414 tem
= Fcompare_strings (bestmatch
, zero
,
1415 make_number (compare
),
1417 make_number (compare
),
1418 completion_ignore_case
? Qt
: Qnil
);
1420 matchsize
= compare
;
1421 else if (XINT (tem
) < 0)
1422 matchsize
= - XINT (tem
) - 1;
1424 matchsize
= XINT (tem
) - 1;
1426 if (completion_ignore_case
)
1428 /* If this is an exact match except for case,
1429 use it as the best match rather than one that is not an
1430 exact match. This way, we get the case pattern
1431 of the actual match. */
1432 if ((matchsize
== SCHARS (eltstring
)
1433 && matchsize
< SCHARS (bestmatch
))
1435 /* If there is more than one exact match ignoring case,
1436 and one of them is exact including case,
1438 /* If there is no exact match ignoring case,
1439 prefer a match that does not change the case
1441 ((matchsize
== SCHARS (eltstring
))
1443 (matchsize
== SCHARS (bestmatch
))
1444 && (tem
= Fcompare_strings (eltstring
, zero
,
1445 make_number (SCHARS (string
)),
1450 && (tem
= Fcompare_strings (bestmatch
, zero
,
1451 make_number (SCHARS (string
)),
1456 bestmatch
= eltstring
;
1458 if (bestmatchsize
!= SCHARS (eltstring
)
1459 || bestmatchsize
!= matchsize
)
1460 /* Don't count the same string multiple times. */
1462 bestmatchsize
= matchsize
;
1463 if (matchsize
<= SCHARS (string
)
1464 /* If completion-ignore-case is non-nil, don't
1465 short-circuit because we want to find the best
1466 possible match *including* case differences. */
1467 && !completion_ignore_case
1469 /* No need to look any further. */
1475 if (bindcount
>= 0) {
1476 unbind_to (bindcount
, Qnil
);
1480 if (NILP (bestmatch
))
1481 return Qnil
; /* No completions found */
1482 /* If we are ignoring case, and there is no exact match,
1483 and no additional text was supplied,
1484 don't change the case of what the user typed. */
1485 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1486 && SCHARS (bestmatch
) > bestmatchsize
)
1487 return minibuf_conform_representation (string
, bestmatch
);
1489 /* Return t if the supplied string is an exact match (counting case);
1490 it does not require any change to be made. */
1491 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1494 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1495 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1496 return Fsubstring (bestmatch
, zero
, end
);
1499 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1500 doc
: /* Search for partial matches to STRING in COLLECTION.
1501 Test each of the possible completions specified by COLLECTION
1502 to see if it begins with STRING. The possible completions may be
1503 strings or symbols. Symbols are converted to strings before testing,
1505 The value is a list of all the possible completions that match STRING.
1507 If COLLECTION is an alist, the keys (cars of elements) are the
1508 possible completions. If an element is not a cons cell, then the
1509 element itself is the possible completion.
1510 If COLLECTION is a hash-table, all the keys that are strings or symbols
1511 are the possible completions.
1512 If COLLECTION is an obarray, the names of all symbols in the obarray
1513 are the possible completions.
1515 COLLECTION can also be a function to do the completion itself.
1516 It receives three arguments: the values STRING, PREDICATE and t.
1517 Whatever it returns becomes the value of `all-completions'.
1519 If optional third argument PREDICATE is non-nil,
1520 it is used to test each possible match.
1521 The match is a candidate only if PREDICATE returns non-nil.
1522 The argument given to PREDICATE is the alist element
1523 or the symbol from the obarray. If COLLECTION is a hash-table,
1524 predicate is called with two arguments: the key and the value.
1525 Additionally to this predicate, `completion-regexp-list'
1526 is used to further constrain the set of candidates.
1528 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1529 backward compatibility. If non-nil, strings in COLLECTION that start
1530 with a space are ignored unless STRING itself starts with a space. */)
1531 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1533 Lisp_Object tail
, elt
, eltstring
;
1534 Lisp_Object allmatches
;
1535 int type
= HASH_TABLE_P (collection
) ? 3
1536 : VECTORP (collection
) ? 2
1537 : NILP (collection
) || (CONSP (collection
)
1538 && (!SYMBOLP (XCAR (collection
))
1539 || NILP (XCAR (collection
))));
1540 int index
= 0, obsize
= 0;
1542 Lisp_Object bucket
, tem
, zero
;
1543 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1545 CHECK_STRING (string
);
1547 return call3 (collection
, string
, predicate
, Qt
);
1548 allmatches
= bucket
= Qnil
;
1549 zero
= make_number (0);
1551 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1555 collection
= check_obarray (collection
);
1556 obsize
= XVECTOR (collection
)->size
;
1557 bucket
= XVECTOR (collection
)->contents
[index
];
1562 /* Get the next element of the alist, obarray, or hash-table. */
1563 /* Exit the loop if the elements are all used up. */
1564 /* elt gets the alist element or symbol.
1565 eltstring gets the name to check as a completion. */
1572 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1577 if (!EQ (bucket
, zero
))
1579 if (!SYMBOLP (bucket
))
1580 error ("Bad data in guts of obarray");
1583 if (XSYMBOL (bucket
)->next
)
1584 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1586 XSETFASTINT (bucket
, 0);
1588 else if (++index
>= obsize
)
1592 bucket
= XVECTOR (collection
)->contents
[index
];
1596 else /* if (type == 3) */
1598 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1599 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1601 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1604 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1607 /* Is this element a possible completion? */
1609 if (SYMBOLP (eltstring
))
1610 eltstring
= Fsymbol_name (eltstring
);
1612 if (STRINGP (eltstring
)
1613 && SCHARS (string
) <= SCHARS (eltstring
)
1614 /* If HIDE_SPACES, reject alternatives that start with space
1615 unless the input starts with space. */
1616 && (NILP (hide_spaces
)
1617 || (SBYTES (string
) > 0
1618 && SREF (string
, 0) == ' ')
1619 || SREF (eltstring
, 0) != ' ')
1620 && (tem
= Fcompare_strings (eltstring
, zero
,
1621 make_number (SCHARS (string
)),
1623 make_number (SCHARS (string
)),
1624 completion_ignore_case
? Qt
: Qnil
),
1628 Lisp_Object regexps
;
1630 XSETFASTINT (zero
, 0);
1632 /* Ignore this element if it fails to match all the regexps. */
1634 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1635 regexps
= XCDR (regexps
))
1637 if (bindcount
< 0) {
1638 bindcount
= SPECPDL_INDEX ();
1639 specbind (Qcase_fold_search
,
1640 completion_ignore_case
? Qt
: Qnil
);
1642 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1646 if (CONSP (regexps
))
1650 /* Ignore this element if there is a predicate
1651 and the predicate doesn't like it. */
1653 if (!NILP (predicate
))
1655 if (EQ (predicate
, Qcommandp
))
1656 tem
= Fcommandp (elt
, Qnil
);
1659 if (bindcount
>= 0) {
1660 unbind_to (bindcount
, Qnil
);
1663 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1665 ? call2 (predicate
, elt
,
1666 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1667 : call1 (predicate
, elt
);
1670 if (NILP (tem
)) continue;
1672 /* Ok => put it on the list. */
1673 allmatches
= Fcons (eltstring
, allmatches
);
1677 if (bindcount
>= 0) {
1678 unbind_to (bindcount
, Qnil
);
1682 return Fnreverse (allmatches
);
1685 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1686 doc
: /* Read a string in the minibuffer, with completion.
1687 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1688 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1689 COLLECTION can also be a function to do the completion itself.
1690 PREDICATE limits completion to a subset of COLLECTION.
1691 See `try-completion' and `all-completions' for more details
1692 on completion, COLLECTION, and PREDICATE.
1694 REQUIRE-MATCH can take the following values:
1695 - t means that the user is not allowed to exit unless
1696 the input is (or completes to) an element of COLLECTION or is null.
1697 - nil means that the user can exit with any input.
1698 - `confirm' means that the user can exit with any input, but she needs
1699 to confirm her choice if the input is not an element of COLLECTION.
1700 - `confirm-after-completion' means that the user can exit with any
1701 input, but she needs to confirm her choice if she called
1702 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1703 and the input is not an element of COLLECTION.
1704 - anything else behaves like t except that typing RET does not exit if it
1705 does non-null completion.
1707 If the input is null, `completing-read' returns DEF, or the first element
1708 of the list of default values, or an empty string if DEF is nil,
1709 regardless of the value of REQUIRE-MATCH.
1711 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1712 with point positioned at the end.
1713 If it is (STRING . POSITION), the initial input is STRING, but point
1714 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1715 that this is different from `read-from-minibuffer' and related
1716 functions, which use one-indexing for POSITION.) This feature is
1717 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1718 default value DEF instead. The user can yank the default value into
1719 the minibuffer easily using \\[next-history-element].
1721 HIST, if non-nil, specifies a history list and optionally the initial
1722 position in the list. It can be a symbol, which is the history list
1723 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1724 that case, HISTVAR is the history list variable to use, and HISTPOS
1725 is the initial position (the position in the list used by the
1726 minibuffer history commands). For consistency, you should also
1727 specify that element of the history as the value of
1728 INITIAL-INPUT. (This is the only case in which you should use
1729 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1730 1 at the beginning of the list. The variable `history-length'
1731 controls the maximum length of a history list.
1733 DEF, if non-nil, is the default value or the list of default values.
1735 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1736 the current input method and the setting of `enable-multibyte-characters'.
1738 Completion ignores case if the ambient value of
1739 `completion-ignore-case' is non-nil. */)
1740 (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
)
1742 Lisp_Object val
, histvar
, histpos
, position
;
1745 int count
= SPECPDL_INDEX ();
1746 struct gcpro gcpro1
;
1748 init
= initial_input
;
1751 specbind (Qminibuffer_completion_table
, collection
);
1752 specbind (Qminibuffer_completion_predicate
, predicate
);
1753 specbind (Qminibuffer_completion_confirm
,
1754 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1761 position
= Fcdr (init
);
1764 CHECK_STRING (init
);
1765 if (!NILP (position
))
1767 CHECK_NUMBER (position
);
1768 /* Convert to distance from end of input. */
1769 pos
= XINT (position
) - SCHARS (init
);
1780 histvar
= Fcar_safe (hist
);
1781 histpos
= Fcdr_safe (hist
);
1784 histvar
= Qminibuffer_history
;
1786 XSETFASTINT (histpos
, 0);
1788 val
= read_minibuf (NILP (require_match
)
1789 ? (NILP (Vminibuffer_completing_file_name
)
1790 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1791 ? Vminibuffer_local_completion_map
1792 : Vminibuffer_local_filename_completion_map
)
1793 : (NILP (Vminibuffer_completing_file_name
)
1794 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1795 ? Vminibuffer_local_must_match_map
1796 : Vminibuffer_local_filename_must_match_map
),
1797 init
, prompt
, make_number (pos
), 0,
1798 histvar
, histpos
, def
, 0,
1799 !NILP (inherit_input_method
));
1801 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1802 val
= CONSP (def
) ? XCAR (def
) : def
;
1804 RETURN_UNGCPRO (unbind_to (count
, val
));
1807 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1809 /* Test whether TXT is an exact completion. */
1810 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1811 doc
: /* Return non-nil if STRING is a valid completion.
1812 Takes the same arguments as `all-completions' and `try-completion'.
1813 If COLLECTION is a function, it is called with three arguments:
1814 the values STRING, PREDICATE and `lambda'. */)
1815 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1817 Lisp_Object regexps
, tail
, tem
= Qnil
;
1820 CHECK_STRING (string
);
1822 if ((CONSP (collection
)
1823 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1824 || NILP (collection
))
1826 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1830 else if (VECTORP (collection
))
1832 /* Bypass intern-soft as that loses for nil. */
1833 tem
= oblookup (collection
,
1839 if (STRING_MULTIBYTE (string
))
1840 string
= Fstring_make_unibyte (string
);
1842 string
= Fstring_make_multibyte (string
);
1844 tem
= oblookup (collection
,
1850 if (completion_ignore_case
&& !SYMBOLP (tem
))
1852 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1854 tail
= XVECTOR (collection
)->contents
[i
];
1858 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1859 Fsymbol_name (tail
),
1860 make_number (0) , Qnil
, Qt
)),
1866 if (XSYMBOL (tail
)->next
== 0)
1868 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1876 else if (HASH_TABLE_P (collection
))
1878 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1879 i
= hash_lookup (h
, string
, NULL
);
1881 tem
= HASH_KEY (h
, i
);
1883 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1884 if (!NILP (HASH_HASH (h
, i
)) &&
1885 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1886 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1887 completion_ignore_case
? Qt
: Qnil
),
1890 tem
= HASH_KEY (h
, i
);
1897 return call3 (collection
, string
, predicate
, Qlambda
);
1899 /* Reject this element if it fails to match all the regexps. */
1900 if (CONSP (Vcompletion_regexp_list
))
1902 int count
= SPECPDL_INDEX ();
1903 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1904 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1905 regexps
= XCDR (regexps
))
1907 if (NILP (Fstring_match (XCAR (regexps
),
1908 SYMBOLP (tem
) ? string
: tem
,
1910 return unbind_to (count
, Qnil
);
1912 unbind_to (count
, Qnil
);
1915 /* Finally, check the predicate. */
1916 if (!NILP (predicate
))
1918 return HASH_TABLE_P (collection
)
1919 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1920 : call1 (predicate
, tem
);
1926 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1927 doc
: /* Perform completion on buffer names.
1928 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1929 `all-completions', otherwise invoke `test-completion'.
1931 The arguments STRING and PREDICATE are as in `try-completion',
1932 `all-completions', and `test-completion'. */)
1933 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1936 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1937 else if (EQ (flag
, Qt
))
1939 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1940 if (SCHARS (string
) > 0)
1943 { /* Strip out internal buffers. */
1944 Lisp_Object bufs
= res
;
1945 /* First, look for a non-internal buffer in `res'. */
1946 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1949 /* All bufs in `res' are internal, so don't trip them out. */
1952 while (CONSP (XCDR (bufs
)))
1953 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1954 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1960 else /* assume `lambda' */
1961 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1964 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1966 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1967 doc
: /* Like `assoc' but specifically for strings (and symbols).
1969 This returns the first element of LIST whose car matches the string or
1970 symbol KEY, or nil if no match exists. When performing the
1971 comparison, symbols are first converted to strings, and unibyte
1972 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1975 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1976 single string, rather than a cons cell whose car is a string. */)
1977 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1979 register Lisp_Object tail
;
1982 key
= Fsymbol_name (key
);
1984 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1986 register Lisp_Object elt
, tem
, thiscar
;
1988 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1989 if (SYMBOLP (thiscar
))
1990 thiscar
= Fsymbol_name (thiscar
);
1991 else if (!STRINGP (thiscar
))
1993 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1994 key
, make_number (0), Qnil
,
2004 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2005 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2008 return make_number (minibuf_level
);
2011 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2012 doc
: /* Return the prompt string of the currently-active minibuffer.
2013 If no minibuffer is active, return nil. */)
2016 return Fcopy_sequence (minibuf_prompt
);
2021 init_minibuf_once (void)
2023 Vminibuffer_list
= Qnil
;
2024 staticpro (&Vminibuffer_list
);
2028 syms_of_minibuf (void)
2031 minibuf_prompt
= Qnil
;
2032 staticpro (&minibuf_prompt
);
2034 minibuf_save_list
= Qnil
;
2035 staticpro (&minibuf_save_list
);
2037 Qcompletion_ignore_case
= intern_c_string ("completion-ignore-case");
2038 staticpro (&Qcompletion_ignore_case
);
2040 Qread_file_name_internal
= intern_c_string ("read-file-name-internal");
2041 staticpro (&Qread_file_name_internal
);
2043 Qminibuffer_default
= intern_c_string ("minibuffer-default");
2044 staticpro (&Qminibuffer_default
);
2045 Fset (Qminibuffer_default
, Qnil
);
2047 Qminibuffer_completion_table
= intern_c_string ("minibuffer-completion-table");
2048 staticpro (&Qminibuffer_completion_table
);
2050 Qminibuffer_completion_confirm
= intern_c_string ("minibuffer-completion-confirm");
2051 staticpro (&Qminibuffer_completion_confirm
);
2053 Qminibuffer_completion_predicate
= intern_c_string ("minibuffer-completion-predicate");
2054 staticpro (&Qminibuffer_completion_predicate
);
2056 staticpro (&last_minibuf_string
);
2057 last_minibuf_string
= Qnil
;
2059 Quser_variable_p
= intern_c_string ("user-variable-p");
2060 staticpro (&Quser_variable_p
);
2062 Qminibuffer_history
= intern_c_string ("minibuffer-history");
2063 staticpro (&Qminibuffer_history
);
2065 Qbuffer_name_history
= intern_c_string ("buffer-name-history");
2066 staticpro (&Qbuffer_name_history
);
2067 Fset (Qbuffer_name_history
, Qnil
);
2069 Qminibuffer_setup_hook
= intern_c_string ("minibuffer-setup-hook");
2070 staticpro (&Qminibuffer_setup_hook
);
2072 Qminibuffer_exit_hook
= intern_c_string ("minibuffer-exit-hook");
2073 staticpro (&Qminibuffer_exit_hook
);
2075 Qhistory_length
= intern_c_string ("history-length");
2076 staticpro (&Qhistory_length
);
2078 Qcurrent_input_method
= intern_c_string ("current-input-method");
2079 staticpro (&Qcurrent_input_method
);
2081 Qactivate_input_method
= intern_c_string ("activate-input-method");
2082 staticpro (&Qactivate_input_method
);
2084 Qcase_fold_search
= intern_c_string ("case-fold-search");
2085 staticpro (&Qcase_fold_search
);
2087 Qread_expression_history
= intern_c_string ("read-expression-history");
2088 staticpro (&Qread_expression_history
);
2090 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2091 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
2092 The function is called with the arguments passed to `read-buffer'. */);
2093 Vread_buffer_function
= Qnil
;
2095 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2096 &read_buffer_completion_ignore_case
,
2097 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
2098 read_buffer_completion_ignore_case
= 0;
2100 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2101 doc
: /* Normal hook run just after entry to minibuffer. */);
2102 Vminibuffer_setup_hook
= Qnil
;
2104 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2105 doc
: /* Normal hook run just after exit from minibuffer. */);
2106 Vminibuffer_exit_hook
= Qnil
;
2108 DEFVAR_LISP ("history-length", &Vhistory_length
,
2109 doc
: /* *Maximum length for history lists before truncation takes place.
2110 A number means that length; t means infinite. Truncation takes place
2111 just after a new element is inserted. Setting the `history-length'
2112 property of a history variable overrides this default. */);
2113 XSETFASTINT (Vhistory_length
, 30);
2115 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2116 doc
: /* *Non-nil means to delete duplicates in history.
2117 If set to t when adding a new history element, all previous identical
2118 elements are deleted from the history list. */);
2119 history_delete_duplicates
= 0;
2121 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2122 doc
: /* *Non-nil means to add new elements in history.
2123 If set to nil, minibuffer reading functions don't add new elements to the
2124 history list, so it is possible to do this afterwards by calling
2125 `add-to-history' explicitly. */);
2126 Vhistory_add_new_input
= Qt
;
2128 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2129 doc
: /* Non-nil means don't consider case significant in completion.
2130 For file-name completion, `read-file-name-completion-ignore-case'
2131 controls the behavior, rather than this variable.
2132 For buffer name completion, `read-buffer-completion-ignore-case'
2133 controls the behavior, rather than this variable. */);
2134 completion_ignore_case
= 0;
2136 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2137 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2138 This variable makes a difference whenever the minibuffer window is active. */);
2139 enable_recursive_minibuffers
= 0;
2141 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2142 doc
: /* Alist or obarray used for completion in the minibuffer.
2143 This becomes the ALIST argument to `try-completion' and `all-completions'.
2144 The value can also be a list of strings or a hash table.
2146 The value may alternatively be a function, which is given three arguments:
2147 STRING, the current buffer contents;
2148 PREDICATE, the predicate for filtering possible matches;
2149 CODE, which says what kind of things to do.
2150 CODE can be nil, t or `lambda':
2151 nil -- return the best completion of STRING, or nil if there is none.
2152 t -- return a list of all possible completions of STRING.
2153 lambda -- return t if STRING is a valid completion as it stands. */);
2154 Vminibuffer_completion_table
= Qnil
;
2156 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2157 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2158 Vminibuffer_completion_predicate
= Qnil
;
2160 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2161 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2162 If nil, confirmation is not required.
2163 If the value is `confirm', the user may exit with an input that is not
2164 a valid completion alternative, but Emacs asks for confirmation.
2165 If the value is `confirm-after-completion', the user may exit with an
2166 input that is not a valid completion alternative, but Emacs asks for
2167 confirmation if the user submitted the input right after any of the
2168 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2169 Vminibuffer_completion_confirm
= Qnil
;
2171 DEFVAR_LISP ("minibuffer-completing-file-name",
2172 &Vminibuffer_completing_file_name
,
2173 doc
: /* Non-nil means completing file names. */);
2174 Vminibuffer_completing_file_name
= Qnil
;
2176 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2177 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2178 Vminibuffer_help_form
= Qnil
;
2180 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2181 doc
: /* History list symbol to add minibuffer values to.
2182 Each string of minibuffer input, as it appears on exit from the minibuffer,
2184 (set minibuffer-history-variable
2185 (cons STRING (symbol-value minibuffer-history-variable))) */);
2186 XSETFASTINT (Vminibuffer_history_variable
, 0);
2188 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2189 doc
: /* Current position of redoing in the history list. */);
2190 Vminibuffer_history_position
= Qnil
;
2192 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2193 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2194 Some uses of the echo area also raise that frame (since they use it too). */);
2195 minibuffer_auto_raise
= 0;
2197 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2198 doc
: /* List of regexps that should restrict possible completions.
2199 The basic completion functions only consider a completion acceptable
2200 if it matches all regular expressions in this list, with
2201 `case-fold-search' bound to the value of `completion-ignore-case'.
2202 See Info node `(elisp)Basic Completion', for a description of these
2204 Vcompletion_regexp_list
= Qnil
;
2206 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2207 &minibuffer_allow_text_properties
,
2208 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2209 This also affects `read-string', but it does not affect `read-minibuffer',
2210 `read-no-blanks-input', or any of the functions that do minibuffer input
2211 with completion; they always discard text properties. */);
2212 minibuffer_allow_text_properties
= 0;
2214 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2215 doc
: /* Text properties that are added to minibuffer prompts.
2216 These are in addition to the basic `field' property, and stickiness
2218 /* We use `intern' here instead of Qread_only to avoid
2219 initialization-order problems. */
2220 Vminibuffer_prompt_properties
2221 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2223 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
2224 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2225 Vread_expression_map
= Qnil
;
2227 defsubr (&Sactive_minibuffer_window
);
2228 defsubr (&Sset_minibuffer_window
);
2229 defsubr (&Sread_from_minibuffer
);
2230 defsubr (&Seval_minibuffer
);
2231 defsubr (&Sread_minibuffer
);
2232 defsubr (&Sread_string
);
2233 defsubr (&Sread_command
);
2234 defsubr (&Sread_variable
);
2235 defsubr (&Sinternal_complete_buffer
);
2236 defsubr (&Sread_buffer
);
2237 defsubr (&Sread_no_blanks_input
);
2238 defsubr (&Sminibuffer_depth
);
2239 defsubr (&Sminibuffer_prompt
);
2241 defsubr (&Sminibufferp
);
2242 defsubr (&Sminibuffer_prompt_end
);
2243 defsubr (&Sminibuffer_contents
);
2244 defsubr (&Sminibuffer_contents_no_properties
);
2245 defsubr (&Sminibuffer_completion_contents
);
2247 defsubr (&Stry_completion
);
2248 defsubr (&Sall_completions
);
2249 defsubr (&Stest_completion
);
2250 defsubr (&Sassoc_string
);
2251 defsubr (&Scompleting_read
);
2254 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2255 (do not change this comment) */