1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
27 #include "character.h"
29 #include "dispextern.h"
34 #include "intervals.h"
36 #include "termhooks.h"
38 /* List of buffers for use as minibuffers.
39 The first element of the list is used for the outermost minibuffer
40 invocation, the next element is used for a recursive minibuffer
41 invocation, etc. The list is extended at the end as deeper
42 minibuffer recursions are encountered. */
44 Lisp_Object Vminibuffer_list
;
46 /* Data to remember during recursive minibuffer invocations. */
48 static Lisp_Object minibuf_save_list
;
50 /* Depth in minibuffer invocations. */
52 EMACS_INT minibuf_level
;
54 /* The maximum length of a minibuffer history. */
56 static Lisp_Object Qhistory_length
;
58 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string
;
62 static Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
64 static Lisp_Object Qread_file_name_internal
;
66 /* Normal hooks for entry to and exit from minibuffer. */
68 static Lisp_Object Qminibuffer_setup_hook
;
69 static Lisp_Object Qminibuffer_exit_hook
;
71 Lisp_Object Qcompletion_ignore_case
;
72 static Lisp_Object Qminibuffer_completion_table
;
73 static Lisp_Object Qminibuffer_completion_predicate
;
74 static Lisp_Object Qminibuffer_completion_confirm
;
75 static Lisp_Object Qcustom_variable_p
;
77 static Lisp_Object Qminibuffer_default
;
79 static Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
81 static Lisp_Object Qcase_fold_search
;
83 static Lisp_Object Qread_expression_history
;
85 /* Prompt to display in front of the mini-buffer contents. */
87 static Lisp_Object minibuf_prompt
;
89 /* Width of current mini-buffer prompt. Only set after display_line
90 of the line that contains the prompt. */
92 static ptrdiff_t minibuf_prompt_width
;
95 /* Put minibuf on currently selected frame's minibuffer.
96 We do this whenever the user starts a new minibuffer
97 or when a minibuffer exits. */
100 choose_minibuf_frame (void)
102 if (FRAMEP (selected_frame
)
103 && FRAME_LIVE_P (XFRAME (selected_frame
))
104 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
106 struct frame
*sf
= XFRAME (selected_frame
);
109 /* I don't think that any frames may validly have a null minibuffer
111 if (NILP (sf
->minibuffer_window
))
114 /* Under X, we come here with minibuf_window being the
115 minibuffer window of the unused termcap window created in
116 init_window_once. That window doesn't have a buffer. */
117 buffer
= XWINDOW (minibuf_window
)->contents
;
118 if (BUFFERP (buffer
))
119 /* Use set_window_buffer instead of Fset_window_buffer (see
120 discussion of bug#11984, bug#12025, bug#12026). */
121 set_window_buffer (sf
->minibuffer_window
, buffer
, 0, 0);
122 minibuf_window
= sf
->minibuffer_window
;
125 /* Make sure no other frame has a minibuffer as its selected window,
126 because the text would not be displayed in it, and that would be
127 confusing. Only allow the selected frame to do this,
128 and that only if the minibuffer is active. */
130 Lisp_Object tail
, frame
;
132 FOR_EACH_FRAME (tail
, frame
)
133 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
134 && !(EQ (frame
, selected_frame
)
135 && minibuf_level
> 0))
136 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
140 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
141 Sactive_minibuffer_window
, 0, 0, 0,
142 doc
: /* Return the currently active minibuffer window, or nil if none. */)
145 return minibuf_level
? minibuf_window
: Qnil
;
148 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
149 Sset_minibuffer_window
, 1, 1, 0,
150 doc
: /* Specify which minibuffer window to use for the minibuffer.
151 This affects where the minibuffer is displayed if you put text in it
152 without invoking the usual minibuffer commands. */)
155 CHECK_WINDOW (window
);
156 if (! MINI_WINDOW_P (XWINDOW (window
)))
157 error ("Window is not a minibuffer window");
159 minibuf_window
= window
;
165 /* Actual minibuffer invocation. */
167 static void read_minibuf_unwind (void);
168 static void run_exit_minibuf_hook (void);
171 /* Read a Lisp object from VAL and return it. If VAL is an empty
172 string, and DEFALT is a string, read from DEFALT instead of VAL. */
175 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
177 struct gcpro gcpro1
, gcpro2
;
178 Lisp_Object expr_and_pos
;
181 GCPRO2 (val
, defalt
);
183 if (STRINGP (val
) && SCHARS (val
) == 0)
185 if (STRINGP (defalt
))
187 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
191 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
192 pos
= XINT (Fcdr (expr_and_pos
));
193 if (pos
!= SCHARS (val
))
195 /* Ignore trailing whitespace; any other trailing junk
198 pos
= string_char_to_byte (val
, pos
);
199 for (i
= pos
; i
< SBYTES (val
); i
++)
201 int c
= SREF (val
, i
);
202 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
203 error ("Trailing garbage following expression");
207 val
= Fcar (expr_and_pos
);
212 /* Like read_minibuf but reading from stdin. This function is called
213 from read_minibuf to do the job if noninteractive. */
216 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
217 Lisp_Object prompt
, Lisp_Object backup_n
,
219 Lisp_Object histvar
, Lisp_Object histpos
,
221 bool allow_props
, bool inherit_input_method
)
228 fprintf (stdout
, "%s", SDATA (prompt
));
234 line
= xmalloc_atomic (size
);
236 while ((c
= getchar ()) != '\n')
247 if (STRING_BYTES_BOUND
/ 2 < size
)
248 memory_full (SIZE_MAX
);
250 line
= xrealloc (line
, size
);
256 if (len
|| c
== '\n')
258 val
= make_string (line
, len
);
264 error ("Error reading from stdin");
267 /* If Lisp form desired instead of string, parse it. */
269 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
274 DEFUN ("minibufferp", Fminibufferp
,
275 Sminibufferp
, 0, 1, 0,
276 doc
: /* Return t if BUFFER is a minibuffer.
277 No argument or nil as argument means use current buffer as BUFFER.
278 BUFFER can be a buffer or a buffer name. */)
284 buffer
= Fcurrent_buffer ();
285 else if (STRINGP (buffer
))
286 buffer
= Fget_buffer (buffer
);
288 CHECK_BUFFER (buffer
);
290 tem
= Fmemq (buffer
, Vminibuffer_list
);
291 return ! NILP (tem
) ? Qt
: Qnil
;
294 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
295 Sminibuffer_prompt_end
, 0, 0, 0,
296 doc
: /* Return the buffer position of the end of the minibuffer prompt.
297 Return (point-min) if current buffer is not a minibuffer. */)
300 /* This function is written to be most efficient when there's a prompt. */
301 Lisp_Object beg
, end
, tem
;
302 beg
= make_number (BEGV
);
304 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
308 end
= Ffield_end (beg
, Qnil
, Qnil
);
310 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
316 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
317 Sminibuffer_contents
, 0, 0, 0,
318 doc
: /* Return the user input in a minibuffer as a string.
319 If the current buffer is not a minibuffer, return its entire contents. */)
322 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
323 return make_buffer_string (prompt_end
, ZV
, 1);
326 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
327 Sminibuffer_contents_no_properties
, 0, 0, 0,
328 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
329 If the current buffer is not a minibuffer, return its entire contents. */)
332 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
333 return make_buffer_string (prompt_end
, ZV
, 0);
336 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
337 Sminibuffer_completion_contents
, 0, 0, 0,
338 doc
: /* Return the user input in a minibuffer before point as a string.
339 That is what completion commands operate on.
340 If the current buffer is not a minibuffer, return its entire contents. */)
343 ptrdiff_t prompt_end
= XINT (Fminibuffer_prompt_end ());
345 error ("Cannot do completion in the prompt");
346 return make_buffer_string (prompt_end
, PT
, 1);
350 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
351 putting point minus BACKUP_N bytes from the end of INITIAL,
352 prompting with PROMPT (a string), using history list HISTVAR
353 with initial position HISTPOS. INITIAL should be a string or a
354 cons of a string and an integer. BACKUP_N should be <= 0, or
355 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
356 ignored and replaced with an integer that puts point at one-indexed
357 position N in INITIAL, where N is the CDR of INITIAL, or at the
358 beginning of INITIAL if N <= 0.
360 Normally return the result as a string (the text that was read),
361 but if EXPFLAG, read it and return the object read.
362 If HISTVAR is given, save the value read on that history only if it doesn't
363 match the front of that history list exactly. The value is pushed onto
364 the list as the string that was read.
366 DEFALT specifies the default value for the sake of history commands.
368 If ALLOW_PROPS, do not throw away text properties.
370 if INHERIT_INPUT_METHOD, the minibuffer inherits the
371 current input method. */
374 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
376 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
377 bool allow_props
, bool inherit_input_method
)
381 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
382 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
383 Lisp_Object enable_multibyte
;
385 /* String to add to the history. */
386 Lisp_Object histstring
;
389 Lisp_Object empty_minibuf
;
390 Lisp_Object dummy
, frame
;
392 specbind (Qminibuffer_default
, defalt
);
393 specbind (intern ("inhibit-read-only"), Qnil
);
395 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
396 in previous recursive minibuffer, but was not set explicitly
397 to t for this invocation, so set it to nil in this minibuffer.
398 Save the old value now, before we change it. */
399 specbind (intern ("minibuffer-completing-file-name"),
400 Vminibuffer_completing_file_name
);
401 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
402 Vminibuffer_completing_file_name
= Qnil
;
404 #ifdef HAVE_WINDOW_SYSTEM
405 if (display_hourglass_p
)
413 Lisp_Object backup_n
= XCDR (initial
);
414 initial
= XCAR (initial
);
415 CHECK_STRING (initial
);
416 if (!NILP (backup_n
))
418 CHECK_NUMBER (backup_n
);
419 /* Convert to distance from end of input. */
420 if (XINT (backup_n
) < 1)
421 /* A number too small means the beginning of the string. */
422 pos
= - SCHARS (initial
);
424 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
428 CHECK_STRING (initial
);
431 ambient_dir
= BVAR (current_buffer
, directory
);
433 enable_multibyte
= Qnil
;
435 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
436 store them away before we can GC. Don't need to protect
437 BACKUP_N because we use the value only if it is an integer. */
438 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
440 if (!STRINGP (prompt
))
441 prompt
= empty_unibyte_string
;
443 if (!enable_recursive_minibuffers
444 && minibuf_level
> 0)
446 if (EQ (selected_window
, minibuf_window
))
447 error ("Command attempted to use minibuffer while in minibuffer");
449 /* If we're in another window, cancel the minibuffer that's active. */
451 build_string ("Command attempted to use minibuffer while in minibuffer"));
455 /* In case we are running as a daemon, only do this before
456 detaching from the terminal. */
457 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
458 && NILP (Vexecuting_kbd_macro
))
460 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
462 expflag
, histvar
, histpos
, defalt
,
463 allow_props
, inherit_input_method
);
469 /* Choose the minibuffer window and frame, and take action on them. */
471 /* Prepare for restoring the current buffer since choose_minibuf_frame
472 calling Fset_frame_selected_window may change it (Bug#12766). */
473 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
475 choose_minibuf_frame ();
477 record_unwind_protect_void (choose_minibuf_frame
);
479 record_unwind_protect (restore_window_configuration
,
480 Fcurrent_window_configuration (Qnil
));
482 /* If the minibuffer window is on a different frame, save that
483 frame's configuration too. */
484 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
485 if (!EQ (mini_frame
, selected_frame
))
486 record_unwind_protect (restore_window_configuration
,
487 Fcurrent_window_configuration (mini_frame
));
489 /* If the minibuffer is on an iconified or invisible frame,
490 make it visible now. */
491 Fmake_frame_visible (mini_frame
);
493 if (minibuffer_auto_raise
)
494 Fraise_frame (mini_frame
);
496 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
498 /* We have to do this after saving the window configuration
499 since that is what restores the current buffer. */
501 /* Arrange to restore a number of minibuffer-related variables.
502 We could bind each variable separately, but that would use lots of
505 = Fcons (Voverriding_local_map
,
506 Fcons (minibuf_window
,
509 = Fcons (minibuf_prompt
,
510 Fcons (make_number (minibuf_prompt_width
),
512 Fcons (Vcurrent_prefix_arg
,
513 Fcons (Vminibuffer_history_position
,
514 Fcons (Vminibuffer_history_variable
,
515 minibuf_save_list
))))));
517 record_unwind_protect_void (read_minibuf_unwind
);
519 /* We are exiting the minibuffer one way or the other, so run the hook.
520 It should be run before unwinding the minibuf settings. Do it
521 separately from read_minibuf_unwind because we need to make sure that
522 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
523 signals an error. --Stef */
524 record_unwind_protect_void (run_exit_minibuf_hook
);
526 /* Now that we can restore all those variables, start changing them. */
528 minibuf_prompt_width
= 0;
529 minibuf_prompt
= Fcopy_sequence (prompt
);
530 Vminibuffer_history_position
= histpos
;
531 Vminibuffer_history_variable
= histvar
;
532 Vhelp_form
= Vminibuffer_help_form
;
533 /* If this minibuffer is reading a file name, that doesn't mean
534 recursive ones are. But we cannot set it to nil, because
535 completion code still need to know the minibuffer is completing a
536 file name. So use `lambda' as intermediate value meaning
537 "t" in this minibuffer, but "nil" in next minibuffer. */
538 if (!NILP (Vminibuffer_completing_file_name
))
539 Vminibuffer_completing_file_name
= Qlambda
;
541 /* If variable is unbound, make it nil. */
542 histval
= find_symbol_value (Vminibuffer_history_variable
);
543 if (EQ (histval
, Qunbound
))
545 Fset (Vminibuffer_history_variable
, Qnil
);
549 if (inherit_input_method
)
551 /* `current-input-method' is buffer local. So, remember it in
552 INPUT_METHOD before changing the current buffer. */
553 input_method
= Fsymbol_value (Qcurrent_input_method
);
554 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
557 /* Switch to the minibuffer. */
559 minibuffer
= get_minibuffer (minibuf_level
);
560 Fset_buffer (minibuffer
);
562 /* Defeat (setq-default truncate-lines t), since truncated lines do
563 not work correctly in minibuffers. (Bug#5715, etc) */
564 bset_truncate_lines (current_buffer
, Qnil
);
566 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
567 if (inherit_input_method
)
568 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
570 /* The current buffer's default directory is usually the right thing
571 for our minibuffer here. However, if you're typing a command at
572 a minibuffer-only frame when minibuf_level is zero, then buf IS
573 the current_buffer, so reset_buffer leaves buf's default
574 directory unchanged. This is a bummer when you've just started
575 up Emacs and buf's default directory is Qnil. Here's a hack; can
576 you think of something better to do? Find another buffer with a
577 better directory, and use that one instead. */
578 if (STRINGP (ambient_dir
))
579 bset_directory (current_buffer
, ambient_dir
);
582 Lisp_Object tail
, buf
;
584 FOR_EACH_LIVE_BUFFER (tail
, buf
)
585 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
587 bset_directory (current_buffer
,
588 BVAR (XBUFFER (buf
), directory
));
593 if (!EQ (mini_frame
, selected_frame
))
594 Fredirect_frame_focus (selected_frame
, mini_frame
);
596 Vminibuf_scroll_window
= selected_window
;
597 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
598 minibuf_selected_window
= selected_window
;
600 /* Empty out the minibuffers of all frames other than the one
601 where we are going to display one now.
602 Set them to point to ` *Minibuf-0*', which is always empty. */
603 empty_minibuf
= get_minibuffer (0);
605 FOR_EACH_FRAME (dummy
, frame
)
607 Lisp_Object root_window
= Fframe_root_window (frame
);
608 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
610 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
611 && !NILP (Fwindow_minibuffer_p (mini_window
)))
612 /* Use set_window_buffer instead of Fset_window_buffer (see
613 discussion of bug#11984, bug#12025, bug#12026). */
614 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
617 /* Display this minibuffer in the proper window. */
618 /* Use set_window_buffer instead of Fset_window_buffer (see
619 discussion of bug#11984, bug#12025, bug#12026). */
620 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
621 Fselect_window (minibuf_window
, Qnil
);
622 XWINDOW (minibuf_window
)->hscroll
= 0;
624 Fmake_local_variable (Qprint_escape_newlines
);
625 print_escape_newlines
= 1;
627 /* Erase the buffer. */
630 specbind (Qinhibit_read_only
, Qt
);
631 specbind (Qinhibit_modification_hooks
, Qt
);
634 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
635 && ! STRING_MULTIBYTE (minibuf_prompt
))
636 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
638 /* Insert the prompt, record where it ends. */
639 Finsert (1, &minibuf_prompt
);
642 Fput_text_property (make_number (BEG
), make_number (PT
),
643 Qfront_sticky
, Qt
, Qnil
);
644 Fput_text_property (make_number (BEG
), make_number (PT
),
645 Qrear_nonsticky
, Qt
, Qnil
);
646 Fput_text_property (make_number (BEG
), make_number (PT
),
648 Fadd_text_properties (make_number (BEG
), make_number (PT
),
649 Vminibuffer_prompt_properties
, Qnil
);
654 minibuf_prompt_width
= current_column ();
656 /* Put in the initial input. */
659 Finsert (1, &initial
);
660 Fforward_char (make_number (pos
));
663 clear_message (1, 1);
664 bset_keymap (current_buffer
, map
);
666 /* Turn on an input method stored in INPUT_METHOD if any. */
667 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
668 call1 (Qactivate_input_method
, input_method
);
670 Frun_hooks (1, &Qminibuffer_setup_hook
);
672 /* Don't allow the user to undo past this point. */
673 bset_undo_list (current_buffer
, Qnil
);
677 /* If cursor is on the minibuffer line,
678 show the user we have exited by putting it in column 0. */
679 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
682 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
683 XWINDOW (minibuf_window
)->cursor
.x
= 0;
684 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
685 update_frame (XFRAME (selected_frame
), 1, 1);
686 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
689 /* Make minibuffer contents into a string. */
690 Fset_buffer (minibuffer
);
692 val
= Fminibuffer_contents ();
694 val
= Fminibuffer_contents_no_properties ();
696 /* VAL is the string of minibuffer text. */
698 last_minibuf_string
= val
;
700 /* Choose the string to add to the history. */
701 if (SCHARS (val
) != 0)
703 else if (STRINGP (defalt
))
705 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
706 histstring
= XCAR (defalt
);
710 /* Add the value to the appropriate history list, if any. */
711 if (!NILP (Vhistory_add_new_input
)
712 && SYMBOLP (Vminibuffer_history_variable
)
713 && !NILP (histstring
))
715 /* If the caller wanted to save the value read on a history list,
716 then do so if the value is not already the front of the list. */
718 /* The value of the history variable must be a cons or nil. Other
719 values are unacceptable. We silently ignore these values. */
723 /* Don't duplicate the most recent entry in the history. */
724 && (NILP (Fequal (histstring
, Fcar (histval
))))))
728 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
729 histval
= Fcons (histstring
, histval
);
730 Fset (Vminibuffer_history_variable
, histval
);
732 /* Truncate if requested. */
733 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
734 if (NILP (length
)) length
= Vhistory_length
;
735 if (INTEGERP (length
))
737 if (XINT (length
) <= 0)
738 Fset (Vminibuffer_history_variable
, Qnil
);
743 temp
= Fnthcdr (Fsub1 (length
), histval
);
744 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
750 /* If Lisp form desired instead of string, parse it. */
752 val
= string_to_object (val
, defalt
);
754 /* The appropriate frame will get selected
755 in set-window-configuration. */
761 /* Return a buffer to be used as the minibuffer at depth `depth'.
762 depth = 0 is the lowest allowed argument, and that is the value
763 used for nonrecursive minibuffer invocations. */
766 get_minibuffer (EMACS_INT depth
)
768 Lisp_Object tail
, num
, buf
;
769 char name
[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT
)];
771 XSETFASTINT (num
, depth
);
772 tail
= Fnthcdr (num
, Vminibuffer_list
);
776 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
779 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
781 buf
= Fget_buffer_create
782 (make_formatted_string (name
, " *Minibuf-%"pI
"d*", depth
));
784 /* Although the buffer's name starts with a space, undo should be
786 Fbuffer_enable_undo (buf
);
793 /* We have to empty both overlay lists. Otherwise we end
794 up with overlays that think they belong to this buffer
795 while the buffer doesn't know about them any more. */
796 delete_all_overlays (XBUFFER (buf
));
797 reset_buffer (XBUFFER (buf
));
798 record_unwind_current_buffer ();
800 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
801 call0 (intern ("minibuffer-inactive-mode"));
803 Fkill_all_local_variables ();
811 run_exit_minibuf_hook (void)
813 safe_run_hooks (Qminibuffer_exit_hook
);
816 /* This function is called on exiting minibuffer, whether normally or
817 not, and it restores the current window, buffer, etc. */
820 read_minibuf_unwind (void)
822 Lisp_Object old_deactivate_mark
;
825 /* If this was a recursive minibuffer,
826 tie the minibuffer window back to the outer level minibuffer buffer. */
829 window
= minibuf_window
;
830 /* To keep things predictable, in case it matters, let's be in the
831 minibuffer when we reset the relevant variables. */
832 Fset_buffer (XWINDOW (window
)->contents
);
834 /* Restore prompt, etc, from outer minibuffer level. */
835 minibuf_prompt
= Fcar (minibuf_save_list
);
836 minibuf_save_list
= Fcdr (minibuf_save_list
);
837 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
838 minibuf_save_list
= Fcdr (minibuf_save_list
);
839 Vhelp_form
= Fcar (minibuf_save_list
);
840 minibuf_save_list
= Fcdr (minibuf_save_list
);
841 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
842 minibuf_save_list
= Fcdr (minibuf_save_list
);
843 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
844 minibuf_save_list
= Fcdr (minibuf_save_list
);
845 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
846 minibuf_save_list
= Fcdr (minibuf_save_list
);
847 Voverriding_local_map
= Fcar (minibuf_save_list
);
848 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 temp
= Fcar (minibuf_save_list
);
851 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
852 minibuf_window
= temp
;
854 minibuf_save_list
= Fcdr (minibuf_save_list
);
856 /* Erase the minibuffer we were using at this level. */
859 /* Prevent error in erase-buffer. */
860 specbind (Qinhibit_read_only
, Qt
);
861 specbind (Qinhibit_modification_hooks
, Qt
);
862 old_deactivate_mark
= Vdeactivate_mark
;
864 Vdeactivate_mark
= old_deactivate_mark
;
868 /* When we get to the outmost level, make sure we resize the
869 mini-window back to its normal size. */
870 if (minibuf_level
== 0)
871 resize_mini_window (XWINDOW (window
), 0);
873 /* In case the previous minibuffer displayed in this miniwindow is
874 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
875 to make sure we don't leave around bindings and stuff which only
876 made sense during the read_minibuf invocation. */
877 call0 (intern ("minibuffer-inactive-mode"));
881 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
882 Sread_from_minibuffer
, 1, 7, 0,
883 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
884 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
885 DEFAULT-VALUE. It normally should be nil in new code, except when
886 HIST is a cons. It is discussed in more detail below.
888 Third arg KEYMAP is a keymap to use whilst reading;
889 if omitted or nil, the default is `minibuffer-local-map'.
891 If fourth arg READ is non-nil, interpret the result as a Lisp object
892 and return that object:
893 in other words, do `(car (read-from-string INPUT-STRING))'
895 Fifth arg HIST, if non-nil, specifies a history list and optionally
896 the initial position in the list. It can be a symbol, which is the
897 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
898 In that case, HISTVAR is the history list variable to use, and
899 HISTPOS is the initial position for use by the minibuffer history
900 commands. For consistency, you should also specify that element of
901 the history as the value of INITIAL-CONTENTS. Positions are counted
902 starting from 1 at the beginning of the list.
904 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
905 as the default to `read' if READ is non-nil and the user enters
906 empty input. But if READ is nil, this function does _not_ return
907 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
909 Whatever the value of READ, DEFAULT-VALUE is made available via the
910 minibuffer history commands. DEFAULT-VALUE can also be a list of
911 strings, in which case all the strings are available in the history,
912 and the first string is the default to `read' if READ is non-nil.
914 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
915 the current input method and the setting of `enable-multibyte-characters'.
917 If the variable `minibuffer-allow-text-properties' is non-nil,
918 then the string which is returned includes whatever text properties
919 were present in the minibuffer. Otherwise the value has no text properties.
921 The remainder of this documentation string describes the
922 INITIAL-CONTENTS argument in more detail. It is only relevant when
923 studying existing code, or when HIST is a cons. If non-nil,
924 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
925 reading input. Normally, point is put at the end of that string.
926 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
927 input is STRING, but point is placed at _one-indexed_ position
928 POSITION in the minibuffer. Any integer value less than or equal to
929 one puts point at the beginning of the string. *Note* that this
930 behavior differs from the way such arguments are used in `completing-read'
931 and some related functions, which use zero-indexing for POSITION. */)
932 (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
)
934 Lisp_Object histvar
, histpos
, val
;
937 CHECK_STRING (prompt
);
939 keymap
= Vminibuffer_local_map
;
941 keymap
= get_keymap (keymap
, 1, 0);
950 histvar
= Fcar_safe (hist
);
951 histpos
= Fcdr_safe (hist
);
954 histvar
= Qminibuffer_history
;
956 XSETFASTINT (histpos
, 0);
958 GCPRO1 (default_value
);
959 val
= read_minibuf (keymap
, initial_contents
, prompt
,
961 histvar
, histpos
, default_value
,
962 minibuffer_allow_text_properties
,
963 !NILP (inherit_input_method
));
968 /* Functions that use the minibuffer to read various things. */
970 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
971 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
972 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
973 This argument has been superseded by DEFAULT-VALUE and should normally be nil
974 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
976 The third arg HISTORY, if non-nil, specifies a history list
977 and optionally the initial position in the list.
978 See `read-from-minibuffer' for details of HISTORY argument.
979 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
980 If non-nil, it is used for history commands, and as the value (or the first
981 element of the list of default values) to return if the user enters the
983 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
984 the current input method and the setting of `enable-multibyte-characters'. */)
985 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
990 /* Just in case we're in a recursive minibuffer, make it clear that the
991 previous minibuffer's completion table does not apply to the new
993 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
994 specbind (Qminibuffer_completion_table
, Qnil
);
996 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
997 Qnil
, history
, default_value
,
998 inherit_input_method
);
999 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1000 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1005 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1006 doc
: /* Read a string from the terminal, not allowing blanks.
1007 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1008 non-nil, it should be a string, which is used as initial input, with
1009 point positioned at the end, so that SPACE will accept the input.
1010 \(Actually, INITIAL can also be a cons of a string and an integer.
1011 Such values are treated as in `read-from-minibuffer', but are normally
1012 not useful in this function.)
1013 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1014 the current input method and the setting of`enable-multibyte-characters'. */)
1015 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1017 CHECK_STRING (prompt
);
1018 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
1019 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1020 !NILP (inherit_input_method
));
1023 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1024 doc
: /* Read the name of a command and return as a symbol.
1025 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1026 if it is a list. */)
1027 (Lisp_Object prompt
, Lisp_Object default_value
)
1029 Lisp_Object name
, default_string
;
1031 if (NILP (default_value
))
1032 default_string
= Qnil
;
1033 else if (SYMBOLP (default_value
))
1034 default_string
= SYMBOL_NAME (default_value
);
1036 default_string
= default_value
;
1038 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1039 Qnil
, Qnil
, default_string
, Qnil
);
1042 return Fintern (name
, Qnil
);
1046 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1047 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1048 Prompt with PROMPT. */)
1049 (Lisp_Object prompt
)
1051 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1056 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1057 doc
: /* Read the name of a user option and return it as a symbol.
1058 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1060 A user option, or customizable variable, is one for which
1061 `custom-variable-p' returns non-nil. */)
1062 (Lisp_Object prompt
, Lisp_Object default_value
)
1064 Lisp_Object name
, default_string
;
1066 if (NILP (default_value
))
1067 default_string
= Qnil
;
1068 else if (SYMBOLP (default_value
))
1069 default_string
= SYMBOL_NAME (default_value
);
1071 default_string
= default_value
;
1073 name
= Fcompleting_read (prompt
, Vobarray
,
1074 Qcustom_variable_p
, Qt
,
1075 Qnil
, Qnil
, default_string
, Qnil
);
1078 return Fintern (name
, Qnil
);
1081 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1082 doc
: /* Read the name of a buffer and return as a string.
1084 Optional second arg DEF is value to return if user enters an empty line.
1085 If DEF is a list of default values, return its first element.
1086 Optional third arg REQUIRE-MATCH determines whether non-existing
1087 buffer names are allowed. It has the same meaning as the
1088 REQUIRE-MATCH argument of `completing-read'.
1089 The argument PROMPT should be a string ending with a colon and a space.
1090 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1091 case while reading the buffer name.
1092 If `read-buffer-function' is non-nil, this works by calling it as a
1093 function, instead of the usual behavior. */)
1094 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1096 Lisp_Object args
[4], result
;
1102 def
= BVAR (XBUFFER (def
), name
);
1104 specbind (Qcompletion_ignore_case
,
1105 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1107 if (NILP (Vread_buffer_function
))
1111 /* A default value was provided: we must change PROMPT,
1112 editing the default value in before the colon. To achieve
1113 this, we replace PROMPT with a substring that doesn't
1114 contain the terminal space and colon (if present). They
1115 are then added back using Fformat. */
1117 if (STRINGP (prompt
))
1119 s
= SSDATA (prompt
);
1120 len
= SBYTES (prompt
);
1121 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1123 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1126 prompt
= make_specified_string (s
, -1, len
,
1127 STRING_MULTIBYTE (prompt
));
1130 args
[0] = build_string ("%s (default %s): ");
1132 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1133 prompt
= Fformat (3, args
);
1136 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1137 Qnil
, require_match
, Qnil
,
1138 Qbuffer_name_history
, def
, Qnil
);
1142 args
[0] = Vread_buffer_function
;
1145 args
[3] = require_match
;
1146 result
= Ffuncall (4, args
);
1153 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1155 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1158 if (STRING_MULTIBYTE (string
))
1159 return Fstring_make_unibyte (string
);
1161 return Fstring_make_multibyte (string
);
1164 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1165 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1166 Test each possible completion specified by COLLECTION
1167 to see if it begins with STRING. The possible completions may be
1168 strings or symbols. Symbols are converted to strings before testing,
1170 All that match STRING are compared together; the longest initial sequence
1171 common to all these matches is the return value.
1172 If there is no match at all, the return value is nil.
1173 For a unique match which is exact, the return value is t.
1175 If COLLECTION is an alist, the keys (cars of elements) are the
1176 possible completions. If an element is not a cons cell, then the
1177 element itself is the possible completion.
1178 If COLLECTION is a hash-table, all the keys that are strings or symbols
1179 are the possible completions.
1180 If COLLECTION is an obarray, the names of all symbols in the obarray
1181 are the possible completions.
1183 COLLECTION can also be a function to do the completion itself.
1184 It receives three arguments: the values STRING, PREDICATE and nil.
1185 Whatever it returns becomes the value of `try-completion'.
1187 If optional third argument PREDICATE is non-nil,
1188 it is used to test each possible match.
1189 The match is a candidate only if PREDICATE returns non-nil.
1190 The argument given to PREDICATE is the alist element
1191 or the symbol from the obarray. If COLLECTION is a hash-table,
1192 predicate is called with two arguments: the key and the value.
1193 Additionally to this predicate, `completion-regexp-list'
1194 is used to further constrain the set of candidates. */)
1195 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1197 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1198 /* Size in bytes of BESTMATCH. */
1199 ptrdiff_t bestmatchsize
= 0;
1200 /* These are in bytes, too. */
1201 ptrdiff_t compare
, matchsize
;
1202 enum { function_table
, list_table
, obarray_table
, hash_table
}
1203 type
= (HASH_TABLE_P (collection
) ? hash_table
1204 : VECTORP (collection
) ? obarray_table
1205 : ((NILP (collection
)
1206 || (CONSP (collection
) && !FUNCTIONP (collection
)))
1207 ? list_table
: function_table
));
1208 ptrdiff_t idx
= 0, obsize
= 0;
1210 Lisp_Object bucket
, zero
, end
, tem
;
1211 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1213 CHECK_STRING (string
);
1214 if (type
== function_table
)
1215 return call3 (collection
, string
, predicate
, Qnil
);
1217 bestmatch
= bucket
= Qnil
;
1218 zero
= make_number (0);
1220 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1222 if (type
== obarray_table
)
1224 collection
= check_obarray (collection
);
1225 obsize
= ASIZE (collection
);
1226 bucket
= AREF (collection
, idx
);
1231 /* Get the next element of the alist, obarray, or hash-table. */
1232 /* Exit the loop if the elements are all used up. */
1233 /* elt gets the alist element or symbol.
1234 eltstring gets the name to check as a completion. */
1236 if (type
== list_table
)
1241 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1244 else if (type
== obarray_table
)
1246 if (!EQ (bucket
, zero
))
1248 if (!SYMBOLP (bucket
))
1249 error ("Bad data in guts of obarray");
1252 if (XSYMBOL (bucket
)->next
)
1253 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1255 XSETFASTINT (bucket
, 0);
1257 else if (++idx
>= obsize
)
1261 bucket
= AREF (collection
, idx
);
1265 else /* if (type == hash_table) */
1267 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1268 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1270 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1273 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1276 /* Is this element a possible completion? */
1278 if (SYMBOLP (eltstring
))
1279 eltstring
= Fsymbol_name (eltstring
);
1281 if (STRINGP (eltstring
)
1282 && SCHARS (string
) <= SCHARS (eltstring
)
1283 && (tem
= Fcompare_strings (eltstring
, zero
,
1284 make_number (SCHARS (string
)),
1286 completion_ignore_case
? Qt
: Qnil
),
1290 Lisp_Object regexps
;
1292 /* Ignore this element if it fails to match all the regexps. */
1295 specbind (Qcase_fold_search
,
1296 completion_ignore_case
? Qt
: Qnil
);
1297 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1298 regexps
= XCDR (regexps
))
1300 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1305 if (CONSP (regexps
))
1309 /* Ignore this element if there is a predicate
1310 and the predicate doesn't like it. */
1312 if (!NILP (predicate
))
1314 if (EQ (predicate
, Qcommandp
))
1315 tem
= Fcommandp (elt
, Qnil
);
1318 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1319 tem
= (type
== hash_table
1320 ? call2 (predicate
, elt
,
1321 HASH_VALUE (XHASH_TABLE (collection
),
1323 : call1 (predicate
, elt
));
1326 if (NILP (tem
)) continue;
1329 /* Update computation of how much all possible completions match */
1331 if (NILP (bestmatch
))
1334 bestmatch
= eltstring
;
1335 bestmatchsize
= SCHARS (eltstring
);
1339 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1340 tem
= Fcompare_strings (bestmatch
, zero
,
1341 make_number (compare
),
1343 make_number (compare
),
1344 completion_ignore_case
? Qt
: Qnil
);
1345 matchsize
= EQ (tem
, Qt
) ? compare
: eabs (XINT (tem
)) - 1;
1347 if (completion_ignore_case
)
1349 /* If this is an exact match except for case,
1350 use it as the best match rather than one that is not an
1351 exact match. This way, we get the case pattern
1352 of the actual match. */
1353 if ((matchsize
== SCHARS (eltstring
)
1354 && matchsize
< SCHARS (bestmatch
))
1356 /* If there is more than one exact match ignoring case,
1357 and one of them is exact including case,
1359 /* If there is no exact match ignoring case,
1360 prefer a match that does not change the case
1362 ((matchsize
== SCHARS (eltstring
))
1364 (matchsize
== SCHARS (bestmatch
))
1365 && (tem
= Fcompare_strings (eltstring
, zero
,
1366 make_number (SCHARS (string
)),
1371 && (tem
= Fcompare_strings (bestmatch
, zero
,
1372 make_number (SCHARS (string
)),
1377 bestmatch
= eltstring
;
1379 if (bestmatchsize
!= SCHARS (eltstring
)
1380 || bestmatchsize
!= matchsize
)
1381 /* Don't count the same string multiple times. */
1382 matchcount
+= matchcount
<= 1;
1383 bestmatchsize
= matchsize
;
1384 if (matchsize
<= SCHARS (string
)
1385 /* If completion-ignore-case is non-nil, don't
1386 short-circuit because we want to find the best
1387 possible match *including* case differences. */
1388 && !completion_ignore_case
1390 /* No need to look any further. */
1396 if (NILP (bestmatch
))
1397 return Qnil
; /* No completions found. */
1398 /* If we are ignoring case, and there is no exact match,
1399 and no additional text was supplied,
1400 don't change the case of what the user typed. */
1401 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1402 && SCHARS (bestmatch
) > bestmatchsize
)
1403 return minibuf_conform_representation (string
, bestmatch
);
1405 /* Return t if the supplied string is an exact match (counting case);
1406 it does not require any change to be made. */
1407 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1410 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1411 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1412 return Fsubstring (bestmatch
, zero
, end
);
1415 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1416 doc
: /* Search for partial matches to STRING in COLLECTION.
1417 Test each of the possible completions specified by COLLECTION
1418 to see if it begins with STRING. The possible completions may be
1419 strings or symbols. Symbols are converted to strings before testing,
1421 The value is a list of all the possible completions that match STRING.
1423 If COLLECTION is an alist, the keys (cars of elements) are the
1424 possible completions. If an element is not a cons cell, then the
1425 element itself is the possible completion.
1426 If COLLECTION is a hash-table, all the keys that are strings or symbols
1427 are the possible completions.
1428 If COLLECTION is an obarray, the names of all symbols in the obarray
1429 are the possible completions.
1431 COLLECTION can also be a function to do the completion itself.
1432 It receives three arguments: the values STRING, PREDICATE and t.
1433 Whatever it returns becomes the value of `all-completions'.
1435 If optional third argument PREDICATE is non-nil,
1436 it is used to test each possible match.
1437 The match is a candidate only if PREDICATE returns non-nil.
1438 The argument given to PREDICATE is the alist element
1439 or the symbol from the obarray. If COLLECTION is a hash-table,
1440 predicate is called with two arguments: the key and the value.
1441 Additionally to this predicate, `completion-regexp-list'
1442 is used to further constrain the set of candidates.
1444 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1445 backward compatibility. If non-nil, strings in COLLECTION that start
1446 with a space are ignored unless STRING itself starts with a space. */)
1447 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1449 Lisp_Object tail
, elt
, eltstring
;
1450 Lisp_Object allmatches
;
1451 int type
= HASH_TABLE_P (collection
) ? 3
1452 : VECTORP (collection
) ? 2
1453 : NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
));
1454 ptrdiff_t idx
= 0, obsize
= 0;
1455 Lisp_Object bucket
, tem
, zero
;
1456 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1458 CHECK_STRING (string
);
1460 return call3 (collection
, string
, predicate
, Qt
);
1461 allmatches
= bucket
= Qnil
;
1462 zero
= make_number (0);
1464 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1468 collection
= check_obarray (collection
);
1469 obsize
= ASIZE (collection
);
1470 bucket
= AREF (collection
, idx
);
1475 /* Get the next element of the alist, obarray, or hash-table. */
1476 /* Exit the loop if the elements are all used up. */
1477 /* elt gets the alist element or symbol.
1478 eltstring gets the name to check as a completion. */
1485 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1490 if (!EQ (bucket
, zero
))
1492 if (!SYMBOLP (bucket
))
1493 error ("Bad data in guts of obarray");
1496 if (XSYMBOL (bucket
)->next
)
1497 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1499 XSETFASTINT (bucket
, 0);
1501 else if (++idx
>= obsize
)
1505 bucket
= AREF (collection
, idx
);
1509 else /* if (type == 3) */
1511 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1512 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1514 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1517 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1520 /* Is this element a possible completion? */
1522 if (SYMBOLP (eltstring
))
1523 eltstring
= Fsymbol_name (eltstring
);
1525 if (STRINGP (eltstring
)
1526 && SCHARS (string
) <= SCHARS (eltstring
)
1527 /* If HIDE_SPACES, reject alternatives that start with space
1528 unless the input starts with space. */
1529 && (NILP (hide_spaces
)
1530 || (SBYTES (string
) > 0
1531 && SREF (string
, 0) == ' ')
1532 || SREF (eltstring
, 0) != ' ')
1533 && (tem
= Fcompare_strings (eltstring
, zero
,
1534 make_number (SCHARS (string
)),
1536 make_number (SCHARS (string
)),
1537 completion_ignore_case
? Qt
: Qnil
),
1541 Lisp_Object regexps
;
1543 /* Ignore this element if it fails to match all the regexps. */
1546 specbind (Qcase_fold_search
,
1547 completion_ignore_case
? Qt
: Qnil
);
1548 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1549 regexps
= XCDR (regexps
))
1551 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1556 if (CONSP (regexps
))
1560 /* Ignore this element if there is a predicate
1561 and the predicate doesn't like it. */
1563 if (!NILP (predicate
))
1565 if (EQ (predicate
, Qcommandp
))
1566 tem
= Fcommandp (elt
, Qnil
);
1569 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1571 ? call2 (predicate
, elt
,
1572 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1573 : call1 (predicate
, elt
);
1576 if (NILP (tem
)) continue;
1578 /* Ok => put it on the list. */
1579 allmatches
= Fcons (eltstring
, allmatches
);
1583 return Fnreverse (allmatches
);
1586 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1587 doc
: /* Read a string in the minibuffer, with completion.
1588 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1589 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1590 COLLECTION can also be a function to do the completion itself.
1591 PREDICATE limits completion to a subset of COLLECTION.
1592 See `try-completion' and `all-completions' for more details
1593 on completion, COLLECTION, and PREDICATE.
1595 REQUIRE-MATCH can take the following values:
1596 - t means that the user is not allowed to exit unless
1597 the input is (or completes to) an element of COLLECTION or is null.
1598 - nil means that the user can exit with any input.
1599 - `confirm' means that the user can exit with any input, but she needs
1600 to confirm her choice if the input is not an element of COLLECTION.
1601 - `confirm-after-completion' means that the user can exit with any
1602 input, but she needs to confirm her choice if she called
1603 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1604 and the input is not an element of COLLECTION.
1605 - anything else behaves like t except that typing RET does not exit if it
1606 does non-null completion.
1608 If the input is null, `completing-read' returns DEF, or the first element
1609 of the list of default values, or an empty string if DEF is nil,
1610 regardless of the value of REQUIRE-MATCH.
1612 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1613 with point positioned at the end.
1614 If it is (STRING . POSITION), the initial input is STRING, but point
1615 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1616 that this is different from `read-from-minibuffer' and related
1617 functions, which use one-indexing for POSITION.) This feature is
1618 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1619 default value DEF instead. The user can yank the default value into
1620 the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1622 HIST, if non-nil, specifies a history list and optionally the initial
1623 position in the list. It can be a symbol, which is the history list
1624 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1625 that case, HISTVAR is the history list variable to use, and HISTPOS
1626 is the initial position (the position in the list used by the
1627 minibuffer history commands). For consistency, you should also
1628 specify that element of the history as the value of
1629 INITIAL-INPUT. (This is the only case in which you should use
1630 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1631 1 at the beginning of the list. The variable `history-length'
1632 controls the maximum length of a history list.
1634 DEF, if non-nil, is the default value or the list of default values.
1636 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1637 the current input method and the setting of `enable-multibyte-characters'.
1639 Completion ignores case if the ambient value of
1640 `completion-ignore-case' is non-nil.
1642 See also `completing-read-function'. */)
1643 (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
)
1645 Lisp_Object args
[9];
1646 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1648 args
[2] = collection
;
1649 args
[3] = predicate
;
1650 args
[4] = require_match
;
1651 args
[5] = initial_input
;
1654 args
[8] = inherit_input_method
;
1655 return Ffuncall (9, args
);
1658 /* Test whether TXT is an exact completion. */
1659 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1660 doc
: /* Return non-nil if STRING is a valid completion.
1661 Takes the same arguments as `all-completions' and `try-completion'.
1662 If COLLECTION is a function, it is called with three arguments:
1663 the values STRING, PREDICATE and `lambda'. */)
1664 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1666 Lisp_Object regexps
, tail
, tem
= Qnil
;
1669 CHECK_STRING (string
);
1671 if (NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
)))
1673 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1677 else if (VECTORP (collection
))
1679 /* Bypass intern-soft as that loses for nil. */
1680 tem
= oblookup (collection
,
1686 if (STRING_MULTIBYTE (string
))
1687 string
= Fstring_make_unibyte (string
);
1689 string
= Fstring_make_multibyte (string
);
1691 tem
= oblookup (collection
,
1697 if (completion_ignore_case
&& !SYMBOLP (tem
))
1699 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1701 tail
= AREF (collection
, i
);
1705 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1706 Fsymbol_name (tail
),
1707 make_number (0) , Qnil
, Qt
),
1713 if (XSYMBOL (tail
)->next
== 0)
1715 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1723 else if (HASH_TABLE_P (collection
))
1725 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1726 Lisp_Object key
= Qnil
;
1727 i
= hash_lookup (h
, string
, NULL
);
1729 tem
= HASH_KEY (h
, i
);
1731 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1732 if (!NILP (HASH_HASH (h
, i
))
1733 && (key
= HASH_KEY (h
, i
),
1734 SYMBOLP (key
) ? key
= Fsymbol_name (key
) : key
,
1736 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1737 key
, make_number (0) , Qnil
,
1738 completion_ignore_case
? Qt
: Qnil
),
1748 return call3 (collection
, string
, predicate
, Qlambda
);
1750 /* Reject this element if it fails to match all the regexps. */
1751 if (CONSP (Vcompletion_regexp_list
))
1754 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1755 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1756 regexps
= XCDR (regexps
))
1758 if (NILP (Fstring_match (XCAR (regexps
),
1759 SYMBOLP (tem
) ? string
: tem
,
1769 /* Finally, check the predicate. */
1770 if (!NILP (predicate
))
1772 return HASH_TABLE_P (collection
)
1773 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1774 : call1 (predicate
, tem
);
1780 static Lisp_Object Qmetadata
;
1782 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1783 doc
: /* Perform completion on buffer names.
1784 STRING and PREDICATE have the same meanings as in `try-completion',
1785 `all-completions', and `test-completion'.
1787 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1788 `all-completions'; otherwise invoke `test-completion'. */)
1789 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1792 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1793 else if (EQ (flag
, Qt
))
1795 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1796 if (SCHARS (string
) > 0)
1799 { /* Strip out internal buffers. */
1800 Lisp_Object bufs
= res
;
1801 /* First, look for a non-internal buffer in `res'. */
1802 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1805 return (EQ (Flength (res
), Flength (Vbuffer_alist
))
1806 /* If all bufs are internal don't strip them out. */
1809 while (CONSP (XCDR (bufs
)))
1810 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1811 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1817 else if (EQ (flag
, Qlambda
))
1818 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1819 else if (EQ (flag
, Qmetadata
))
1820 return list2 (Qmetadata
, Fcons (Qcategory
, Qbuffer
));
1825 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1827 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1828 doc
: /* Like `assoc' but specifically for strings (and symbols).
1830 This returns the first element of LIST whose car matches the string or
1831 symbol KEY, or nil if no match exists. When performing the
1832 comparison, symbols are first converted to strings, and unibyte
1833 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1836 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1837 single string, rather than a cons cell whose car is a string. */)
1838 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1840 register Lisp_Object tail
;
1843 key
= Fsymbol_name (key
);
1845 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1847 register Lisp_Object elt
, tem
, thiscar
;
1849 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1850 if (SYMBOLP (thiscar
))
1851 thiscar
= Fsymbol_name (thiscar
);
1852 else if (!STRINGP (thiscar
))
1854 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1855 key
, make_number (0), Qnil
,
1865 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1866 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1869 return make_number (minibuf_level
);
1872 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1873 doc
: /* Return the prompt string of the currently-active minibuffer.
1874 If no minibuffer is active, return nil. */)
1877 return Fcopy_sequence (minibuf_prompt
);
1882 init_minibuf_once (void)
1884 Vminibuffer_list
= Qnil
;
1885 staticpro (&Vminibuffer_list
);
1889 syms_of_minibuf (void)
1891 #include "minibuf.x"
1894 minibuf_prompt
= Qnil
;
1895 staticpro (&minibuf_prompt
);
1897 minibuf_save_list
= Qnil
;
1898 staticpro (&minibuf_save_list
);
1900 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1901 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1902 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1903 Fset (Qminibuffer_default
, Qnil
);
1905 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1906 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1907 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1909 staticpro (&last_minibuf_string
);
1910 last_minibuf_string
= Qnil
;
1912 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1913 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1914 Fset (Qbuffer_name_history
, Qnil
);
1916 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1917 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1918 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1919 DEFSYM (Qhistory_length
, "history-length");
1920 DEFSYM (Qcurrent_input_method
, "current-input-method");
1921 DEFSYM (Qactivate_input_method
, "activate-input-method");
1922 DEFSYM (Qcase_fold_search
, "case-fold-search");
1923 DEFSYM (Qmetadata
, "metadata");
1925 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1926 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1927 For example, `eval-expression' uses this. */);
1928 Vread_expression_history
= Qnil
;
1930 DEFSYM (Qread_expression_history
, "read-expression-history");
1932 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1933 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1934 The function is called with the arguments passed to `read-buffer'. */);
1935 Vread_buffer_function
= Qnil
;
1937 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1938 read_buffer_completion_ignore_case
,
1939 doc
: /* Non-nil means completion ignores case when reading a buffer name. */);
1940 read_buffer_completion_ignore_case
= 0;
1942 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1943 doc
: /* Normal hook run just after entry to minibuffer. */);
1944 Vminibuffer_setup_hook
= Qnil
;
1946 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1947 doc
: /* Normal hook run just after exit from minibuffer. */);
1948 Vminibuffer_exit_hook
= Qnil
;
1950 DEFVAR_LISP ("history-length", Vhistory_length
,
1951 doc
: /* Maximum length of history lists before truncation takes place.
1952 A number means truncate to that length; truncation deletes old
1953 elements, and is done just after inserting a new element.
1954 A value of t means no truncation.
1956 This variable only affects history lists that don't specify their own
1957 maximum lengths. Setting the `history-length' property of a history
1958 variable overrides this default. */);
1959 XSETFASTINT (Vhistory_length
, 100);
1961 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
1962 doc
: /* Non-nil means to delete duplicates in history.
1963 If set to t when adding a new history element, all previous identical
1964 elements are deleted from the history list. */);
1965 history_delete_duplicates
= 0;
1967 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
1968 doc
: /* Non-nil means to add new elements in history.
1969 If set to nil, minibuffer reading functions don't add new elements to the
1970 history list, so it is possible to do this afterwards by calling
1971 `add-to-history' explicitly. */);
1972 Vhistory_add_new_input
= Qt
;
1974 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
1975 doc
: /* Non-nil means don't consider case significant in completion.
1976 For file-name completion, `read-file-name-completion-ignore-case'
1977 controls the behavior, rather than this variable.
1978 For buffer name completion, `read-buffer-completion-ignore-case'
1979 controls the behavior, rather than this variable. */);
1980 completion_ignore_case
= 0;
1982 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
1983 doc
: /* Non-nil means to allow minibuffer commands while in the minibuffer.
1984 This variable makes a difference whenever the minibuffer window is active. */);
1985 enable_recursive_minibuffers
= 0;
1987 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
1988 doc
: /* Alist or obarray used for completion in the minibuffer.
1989 This becomes the ALIST argument to `try-completion' and `all-completions'.
1990 The value can also be a list of strings or a hash table.
1992 The value may alternatively be a function, which is given three arguments:
1993 STRING, the current buffer contents;
1994 PREDICATE, the predicate for filtering possible matches;
1995 CODE, which says what kind of things to do.
1996 CODE can be nil, t or `lambda':
1997 nil -- return the best completion of STRING, or nil if there is none.
1998 t -- return a list of all possible completions of STRING.
1999 lambda -- return t if STRING is a valid completion as it stands. */);
2000 Vminibuffer_completion_table
= Qnil
;
2002 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2003 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2004 Vminibuffer_completion_predicate
= Qnil
;
2006 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2007 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2008 If nil, confirmation is not required.
2009 If the value is `confirm', the user may exit with an input that is not
2010 a valid completion alternative, but Emacs asks for confirmation.
2011 If the value is `confirm-after-completion', the user may exit with an
2012 input that is not a valid completion alternative, but Emacs asks for
2013 confirmation if the user submitted the input right after any of the
2014 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2015 Vminibuffer_completion_confirm
= Qnil
;
2017 DEFVAR_LISP ("minibuffer-completing-file-name",
2018 Vminibuffer_completing_file_name
,
2019 doc
: /* Non-nil means completing file names. */);
2020 Vminibuffer_completing_file_name
= Qnil
;
2022 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2023 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2024 Vminibuffer_help_form
= Qnil
;
2026 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2027 doc
: /* History list symbol to add minibuffer values to.
2028 Each string of minibuffer input, as it appears on exit from the minibuffer,
2030 (set minibuffer-history-variable
2031 (cons STRING (symbol-value minibuffer-history-variable))) */);
2032 XSETFASTINT (Vminibuffer_history_variable
, 0);
2034 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2035 doc
: /* Current position of redoing in the history list. */);
2036 Vminibuffer_history_position
= Qnil
;
2038 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2039 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2040 Some uses of the echo area also raise that frame (since they use it too). */);
2041 minibuffer_auto_raise
= 0;
2043 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2044 doc
: /* List of regexps that should restrict possible completions.
2045 The basic completion functions only consider a completion acceptable
2046 if it matches all regular expressions in this list, with
2047 `case-fold-search' bound to the value of `completion-ignore-case'.
2048 See Info node `(elisp)Basic Completion', for a description of these
2050 Vcompletion_regexp_list
= Qnil
;
2052 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2053 minibuffer_allow_text_properties
,
2054 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2055 This also affects `read-string', but it does not affect `read-minibuffer',
2056 `read-no-blanks-input', or any of the functions that do minibuffer input
2057 with completion; they always discard text properties. */);
2058 minibuffer_allow_text_properties
= 0;
2060 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2061 doc
: /* Text properties that are added to minibuffer prompts.
2062 These are in addition to the basic `field' property, and stickiness
2064 /* We use `intern' here instead of Qread_only to avoid
2065 initialization-order problems. */
2066 Vminibuffer_prompt_properties
= list2 (intern_c_string ("read-only"), Qt
);