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
);
208 RETURN_UNGCPRO (val
);
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
)
380 ptrdiff_t count
= SPECPDL_INDEX ();
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
);
465 return unbind_to (count
, val
);
468 /* Choose the minibuffer window and frame, and take action on them. */
470 /* Prepare for restoring the current buffer since choose_minibuf_frame
471 calling Fset_frame_selected_window may change it (Bug#12766). */
472 record_unwind_protect (restore_buffer
, Fcurrent_buffer ());
474 choose_minibuf_frame ();
476 record_unwind_protect_void (choose_minibuf_frame
);
478 record_unwind_protect (restore_window_configuration
,
479 Fcurrent_window_configuration (Qnil
));
481 /* If the minibuffer window is on a different frame, save that
482 frame's configuration too. */
483 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
484 if (!EQ (mini_frame
, selected_frame
))
485 record_unwind_protect (restore_window_configuration
,
486 Fcurrent_window_configuration (mini_frame
));
488 /* If the minibuffer is on an iconified or invisible frame,
489 make it visible now. */
490 Fmake_frame_visible (mini_frame
);
492 if (minibuffer_auto_raise
)
493 Fraise_frame (mini_frame
);
495 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
497 /* We have to do this after saving the window configuration
498 since that is what restores the current buffer. */
500 /* Arrange to restore a number of minibuffer-related variables.
501 We could bind each variable separately, but that would use lots of
504 = Fcons (Voverriding_local_map
,
505 Fcons (minibuf_window
,
508 = Fcons (minibuf_prompt
,
509 Fcons (make_number (minibuf_prompt_width
),
511 Fcons (Vcurrent_prefix_arg
,
512 Fcons (Vminibuffer_history_position
,
513 Fcons (Vminibuffer_history_variable
,
514 minibuf_save_list
))))));
516 record_unwind_protect_void (read_minibuf_unwind
);
518 /* We are exiting the minibuffer one way or the other, so run the hook.
519 It should be run before unwinding the minibuf settings. Do it
520 separately from read_minibuf_unwind because we need to make sure that
521 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
522 signals an error. --Stef */
523 record_unwind_protect_void (run_exit_minibuf_hook
);
525 /* Now that we can restore all those variables, start changing them. */
527 minibuf_prompt_width
= 0;
528 minibuf_prompt
= Fcopy_sequence (prompt
);
529 Vminibuffer_history_position
= histpos
;
530 Vminibuffer_history_variable
= histvar
;
531 Vhelp_form
= Vminibuffer_help_form
;
532 /* If this minibuffer is reading a file name, that doesn't mean
533 recursive ones are. But we cannot set it to nil, because
534 completion code still need to know the minibuffer is completing a
535 file name. So use `lambda' as intermediate value meaning
536 "t" in this minibuffer, but "nil" in next minibuffer. */
537 if (!NILP (Vminibuffer_completing_file_name
))
538 Vminibuffer_completing_file_name
= Qlambda
;
540 /* If variable is unbound, make it nil. */
541 histval
= find_symbol_value (Vminibuffer_history_variable
);
542 if (EQ (histval
, Qunbound
))
544 Fset (Vminibuffer_history_variable
, Qnil
);
548 if (inherit_input_method
)
550 /* `current-input-method' is buffer local. So, remember it in
551 INPUT_METHOD before changing the current buffer. */
552 input_method
= Fsymbol_value (Qcurrent_input_method
);
553 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
556 /* Switch to the minibuffer. */
558 minibuffer
= get_minibuffer (minibuf_level
);
559 Fset_buffer (minibuffer
);
561 /* Defeat (setq-default truncate-lines t), since truncated lines do
562 not work correctly in minibuffers. (Bug#5715, etc) */
563 bset_truncate_lines (current_buffer
, Qnil
);
565 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
566 if (inherit_input_method
)
567 bset_enable_multibyte_characters (current_buffer
, enable_multibyte
);
569 /* The current buffer's default directory is usually the right thing
570 for our minibuffer here. However, if you're typing a command at
571 a minibuffer-only frame when minibuf_level is zero, then buf IS
572 the current_buffer, so reset_buffer leaves buf's default
573 directory unchanged. This is a bummer when you've just started
574 up Emacs and buf's default directory is Qnil. Here's a hack; can
575 you think of something better to do? Find another buffer with a
576 better directory, and use that one instead. */
577 if (STRINGP (ambient_dir
))
578 bset_directory (current_buffer
, ambient_dir
);
581 Lisp_Object tail
, buf
;
583 FOR_EACH_LIVE_BUFFER (tail
, buf
)
584 if (STRINGP (BVAR (XBUFFER (buf
), directory
)))
586 bset_directory (current_buffer
,
587 BVAR (XBUFFER (buf
), directory
));
592 if (!EQ (mini_frame
, selected_frame
))
593 Fredirect_frame_focus (selected_frame
, mini_frame
);
595 Vminibuf_scroll_window
= selected_window
;
596 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
597 minibuf_selected_window
= selected_window
;
599 /* Empty out the minibuffers of all frames other than the one
600 where we are going to display one now.
601 Set them to point to ` *Minibuf-0*', which is always empty. */
602 empty_minibuf
= get_minibuffer (0);
604 FOR_EACH_FRAME (dummy
, frame
)
606 Lisp_Object root_window
= Fframe_root_window (frame
);
607 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
609 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
610 && !NILP (Fwindow_minibuffer_p (mini_window
)))
611 /* Use set_window_buffer instead of Fset_window_buffer (see
612 discussion of bug#11984, bug#12025, bug#12026). */
613 set_window_buffer (mini_window
, empty_minibuf
, 0, 0);
616 /* Display this minibuffer in the proper window. */
617 /* Use set_window_buffer instead of Fset_window_buffer (see
618 discussion of bug#11984, bug#12025, bug#12026). */
619 set_window_buffer (minibuf_window
, Fcurrent_buffer (), 0, 0);
620 Fselect_window (minibuf_window
, Qnil
);
621 XWINDOW (minibuf_window
)->hscroll
= 0;
623 Fmake_local_variable (Qprint_escape_newlines
);
624 print_escape_newlines
= 1;
626 /* Erase the buffer. */
628 ptrdiff_t count1
= SPECPDL_INDEX ();
629 specbind (Qinhibit_read_only
, Qt
);
630 specbind (Qinhibit_modification_hooks
, Qt
);
633 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
634 && ! STRING_MULTIBYTE (minibuf_prompt
))
635 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
637 /* Insert the prompt, record where it ends. */
638 Finsert (1, &minibuf_prompt
);
641 Fput_text_property (make_number (BEG
), make_number (PT
),
642 Qfront_sticky
, Qt
, Qnil
);
643 Fput_text_property (make_number (BEG
), make_number (PT
),
644 Qrear_nonsticky
, Qt
, Qnil
);
645 Fput_text_property (make_number (BEG
), make_number (PT
),
647 Fadd_text_properties (make_number (BEG
), make_number (PT
),
648 Vminibuffer_prompt_properties
, Qnil
);
650 unbind_to (count1
, Qnil
);
653 minibuf_prompt_width
= current_column ();
655 /* Put in the initial input. */
658 Finsert (1, &initial
);
659 Fforward_char (make_number (pos
));
662 clear_message (1, 1);
663 bset_keymap (current_buffer
, map
);
665 /* Turn on an input method stored in INPUT_METHOD if any. */
666 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
667 call1 (Qactivate_input_method
, input_method
);
669 Frun_hooks (1, &Qminibuffer_setup_hook
);
671 /* Don't allow the user to undo past this point. */
672 bset_undo_list (current_buffer
, Qnil
);
676 /* If cursor is on the minibuffer line,
677 show the user we have exited by putting it in column 0. */
678 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
681 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
682 XWINDOW (minibuf_window
)->cursor
.x
= 0;
683 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
684 update_frame (XFRAME (selected_frame
), 1, 1);
685 flush_frame (XFRAME (XWINDOW (minibuf_window
)->frame
));
688 /* Make minibuffer contents into a string. */
689 Fset_buffer (minibuffer
);
691 val
= Fminibuffer_contents ();
693 val
= Fminibuffer_contents_no_properties ();
695 /* VAL is the string of minibuffer text. */
697 last_minibuf_string
= val
;
699 /* Choose the string to add to the history. */
700 if (SCHARS (val
) != 0)
702 else if (STRINGP (defalt
))
704 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
705 histstring
= XCAR (defalt
);
709 /* Add the value to the appropriate history list, if any. */
710 if (!NILP (Vhistory_add_new_input
)
711 && SYMBOLP (Vminibuffer_history_variable
)
712 && !NILP (histstring
))
714 /* If the caller wanted to save the value read on a history list,
715 then do so if the value is not already the front of the list. */
717 /* The value of the history variable must be a cons or nil. Other
718 values are unacceptable. We silently ignore these values. */
722 /* Don't duplicate the most recent entry in the history. */
723 && (NILP (Fequal (histstring
, Fcar (histval
))))))
727 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
728 histval
= Fcons (histstring
, histval
);
729 Fset (Vminibuffer_history_variable
, histval
);
731 /* Truncate if requested. */
732 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
733 if (NILP (length
)) length
= Vhistory_length
;
734 if (INTEGERP (length
))
736 if (XINT (length
) <= 0)
737 Fset (Vminibuffer_history_variable
, Qnil
);
742 temp
= Fnthcdr (Fsub1 (length
), histval
);
743 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
749 /* If Lisp form desired instead of string, parse it. */
751 val
= string_to_object (val
, defalt
);
753 /* The appropriate frame will get selected
754 in set-window-configuration. */
756 return unbind_to (count
, val
);
759 /* Return a buffer to be used as the minibuffer at depth `depth'.
760 depth = 0 is the lowest allowed argument, and that is the value
761 used for nonrecursive minibuffer invocations. */
764 get_minibuffer (EMACS_INT depth
)
766 Lisp_Object tail
, num
, buf
;
767 char name
[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT
)];
769 XSETFASTINT (num
, depth
);
770 tail
= Fnthcdr (num
, Vminibuffer_list
);
774 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
777 if (NILP (buf
) || !BUFFER_LIVE_P (XBUFFER (buf
)))
779 buf
= Fget_buffer_create
780 (make_formatted_string (name
, " *Minibuf-%"pI
"d*", depth
));
782 /* Although the buffer's name starts with a space, undo should be
784 Fbuffer_enable_undo (buf
);
790 ptrdiff_t count
= SPECPDL_INDEX ();
791 /* We have to empty both overlay lists. Otherwise we end
792 up with overlays that think they belong to this buffer
793 while the buffer doesn't know about them any more. */
794 delete_all_overlays (XBUFFER (buf
));
795 reset_buffer (XBUFFER (buf
));
796 record_unwind_current_buffer ();
798 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
799 call0 (intern ("minibuffer-inactive-mode"));
801 Fkill_all_local_variables ();
802 unbind_to (count
, Qnil
);
809 run_exit_minibuf_hook (void)
811 safe_run_hooks (Qminibuffer_exit_hook
);
814 /* This function is called on exiting minibuffer, whether normally or
815 not, and it restores the current window, buffer, etc. */
818 read_minibuf_unwind (void)
820 Lisp_Object old_deactivate_mark
;
823 /* If this was a recursive minibuffer,
824 tie the minibuffer window back to the outer level minibuffer buffer. */
827 window
= minibuf_window
;
828 /* To keep things predictable, in case it matters, let's be in the
829 minibuffer when we reset the relevant variables. */
830 Fset_buffer (XWINDOW (window
)->contents
);
832 /* Restore prompt, etc, from outer minibuffer level. */
833 minibuf_prompt
= Fcar (minibuf_save_list
);
834 minibuf_save_list
= Fcdr (minibuf_save_list
);
835 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
836 minibuf_save_list
= Fcdr (minibuf_save_list
);
837 Vhelp_form
= Fcar (minibuf_save_list
);
838 minibuf_save_list
= Fcdr (minibuf_save_list
);
839 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
840 minibuf_save_list
= Fcdr (minibuf_save_list
);
841 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
842 minibuf_save_list
= Fcdr (minibuf_save_list
);
843 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
844 minibuf_save_list
= Fcdr (minibuf_save_list
);
845 Voverriding_local_map
= Fcar (minibuf_save_list
);
846 minibuf_save_list
= Fcdr (minibuf_save_list
);
848 temp
= Fcar (minibuf_save_list
);
849 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
850 minibuf_window
= temp
;
852 minibuf_save_list
= Fcdr (minibuf_save_list
);
854 /* Erase the minibuffer we were using at this level. */
856 ptrdiff_t count
= SPECPDL_INDEX ();
857 /* Prevent error in erase-buffer. */
858 specbind (Qinhibit_read_only
, Qt
);
859 specbind (Qinhibit_modification_hooks
, Qt
);
860 old_deactivate_mark
= Vdeactivate_mark
;
862 Vdeactivate_mark
= old_deactivate_mark
;
863 unbind_to (count
, Qnil
);
866 /* When we get to the outmost level, make sure we resize the
867 mini-window back to its normal size. */
868 if (minibuf_level
== 0)
869 resize_mini_window (XWINDOW (window
), 0);
871 /* In case the previous minibuffer displayed in this miniwindow is
872 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
873 to make sure we don't leave around bindings and stuff which only
874 made sense during the read_minibuf invocation. */
875 call0 (intern ("minibuffer-inactive-mode"));
879 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
,
880 Sread_from_minibuffer
, 1, 7, 0,
881 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
882 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
883 DEFAULT-VALUE. It normally should be nil in new code, except when
884 HIST is a cons. It is discussed in more detail below.
886 Third arg KEYMAP is a keymap to use whilst reading;
887 if omitted or nil, the default is `minibuffer-local-map'.
889 If fourth arg READ is non-nil, interpret the result as a Lisp object
890 and return that object:
891 in other words, do `(car (read-from-string INPUT-STRING))'
893 Fifth arg HIST, if non-nil, specifies a history list and optionally
894 the initial position in the list. It can be a symbol, which is the
895 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
896 In that case, HISTVAR is the history list variable to use, and
897 HISTPOS is the initial position for use by the minibuffer history
898 commands. For consistency, you should also specify that element of
899 the history as the value of INITIAL-CONTENTS. Positions are counted
900 starting from 1 at the beginning of the list.
902 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
903 as the default to `read' if READ is non-nil and the user enters
904 empty input. But if READ is nil, this function does _not_ return
905 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
907 Whatever the value of READ, DEFAULT-VALUE is made available via the
908 minibuffer history commands. DEFAULT-VALUE can also be a list of
909 strings, in which case all the strings are available in the history,
910 and the first string is the default to `read' if READ is non-nil.
912 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
913 the current input method and the setting of `enable-multibyte-characters'.
915 If the variable `minibuffer-allow-text-properties' is non-nil,
916 then the string which is returned includes whatever text properties
917 were present in the minibuffer. Otherwise the value has no text properties.
919 The remainder of this documentation string describes the
920 INITIAL-CONTENTS argument in more detail. It is only relevant when
921 studying existing code, or when HIST is a cons. If non-nil,
922 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
923 reading input. Normally, point is put at the end of that string.
924 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
925 input is STRING, but point is placed at _one-indexed_ position
926 POSITION in the minibuffer. Any integer value less than or equal to
927 one puts point at the beginning of the string. *Note* that this
928 behavior differs from the way such arguments are used in `completing-read'
929 and some related functions, which use zero-indexing for POSITION. */)
930 (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
)
932 Lisp_Object histvar
, histpos
, val
;
935 CHECK_STRING (prompt
);
937 keymap
= Vminibuffer_local_map
;
939 keymap
= get_keymap (keymap
, 1, 0);
948 histvar
= Fcar_safe (hist
);
949 histpos
= Fcdr_safe (hist
);
952 histvar
= Qminibuffer_history
;
954 XSETFASTINT (histpos
, 0);
956 GCPRO1 (default_value
);
957 val
= read_minibuf (keymap
, initial_contents
, prompt
,
959 histvar
, histpos
, default_value
,
960 minibuffer_allow_text_properties
,
961 !NILP (inherit_input_method
));
966 /* Functions that use the minibuffer to read various things. */
968 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
969 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
970 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
971 This argument has been superseded by DEFAULT-VALUE and should normally be nil
972 in new code. It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
974 The third arg HISTORY, if non-nil, specifies a history list
975 and optionally the initial position in the list.
976 See `read-from-minibuffer' for details of HISTORY argument.
977 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
978 If non-nil, it is used for history commands, and as the value (or the first
979 element of the list of default values) to return if the user enters the
981 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
982 the current input method and the setting of `enable-multibyte-characters'. */)
983 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
986 ptrdiff_t count
= SPECPDL_INDEX ();
988 /* Just in case we're in a recursive minibuffer, make it clear that the
989 previous minibuffer's completion table does not apply to the new
991 FIXME: `minibuffer-completion-table' should be buffer-local instead. */
992 specbind (Qminibuffer_completion_table
, Qnil
);
994 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
995 Qnil
, history
, default_value
,
996 inherit_input_method
);
997 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
998 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
999 return unbind_to (count
, val
);
1002 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1003 doc
: /* Read a string from the terminal, not allowing blanks.
1004 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1005 non-nil, it should be a string, which is used as initial input, with
1006 point positioned at the end, so that SPACE will accept the input.
1007 \(Actually, INITIAL can also be a cons of a string and an integer.
1008 Such values are treated as in `read-from-minibuffer', but are normally
1009 not useful in this function.)
1010 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1011 the current input method and the setting of`enable-multibyte-characters'. */)
1012 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1014 CHECK_STRING (prompt
);
1015 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
,
1016 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1017 !NILP (inherit_input_method
));
1020 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1021 doc
: /* Read the name of a command and return as a symbol.
1022 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1023 if it is a list. */)
1024 (Lisp_Object prompt
, Lisp_Object default_value
)
1026 Lisp_Object name
, default_string
;
1028 if (NILP (default_value
))
1029 default_string
= Qnil
;
1030 else if (SYMBOLP (default_value
))
1031 default_string
= SYMBOL_NAME (default_value
);
1033 default_string
= default_value
;
1035 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1036 Qnil
, Qnil
, default_string
, Qnil
);
1039 return Fintern (name
, Qnil
);
1043 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1044 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1045 Prompt with PROMPT. */)
1046 (Lisp_Object prompt
)
1048 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1053 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1054 doc
: /* Read the name of a user option and return it as a symbol.
1055 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1057 A user option, or customizable variable, is one for which
1058 `custom-variable-p' returns non-nil. */)
1059 (Lisp_Object prompt
, Lisp_Object default_value
)
1061 Lisp_Object name
, default_string
;
1063 if (NILP (default_value
))
1064 default_string
= Qnil
;
1065 else if (SYMBOLP (default_value
))
1066 default_string
= SYMBOL_NAME (default_value
);
1068 default_string
= default_value
;
1070 name
= Fcompleting_read (prompt
, Vobarray
,
1071 Qcustom_variable_p
, Qt
,
1072 Qnil
, Qnil
, default_string
, Qnil
);
1075 return Fintern (name
, Qnil
);
1078 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1079 doc
: /* Read the name of a buffer and return as a string.
1081 Optional second arg DEF is value to return if user enters an empty line.
1082 If DEF is a list of default values, return its first element.
1083 Optional third arg REQUIRE-MATCH determines whether non-existing
1084 buffer names are allowed. It has the same meaning as the
1085 REQUIRE-MATCH argument of `completing-read'.
1086 The argument PROMPT should be a string ending with a colon and a space.
1087 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1088 case while reading the buffer name.
1089 If `read-buffer-function' is non-nil, this works by calling it as a
1090 function, instead of the usual behavior. */)
1091 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1093 Lisp_Object args
[4], result
;
1096 ptrdiff_t count
= SPECPDL_INDEX ();
1099 def
= BVAR (XBUFFER (def
), name
);
1101 specbind (Qcompletion_ignore_case
,
1102 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1104 if (NILP (Vread_buffer_function
))
1108 /* A default value was provided: we must change PROMPT,
1109 editing the default value in before the colon. To achieve
1110 this, we replace PROMPT with a substring that doesn't
1111 contain the terminal space and colon (if present). They
1112 are then added back using Fformat. */
1114 if (STRINGP (prompt
))
1116 s
= SSDATA (prompt
);
1117 len
= SBYTES (prompt
);
1118 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1120 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1123 prompt
= make_specified_string (s
, -1, len
,
1124 STRING_MULTIBYTE (prompt
));
1127 args
[0] = build_string ("%s (default %s): ");
1129 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1130 prompt
= Fformat (3, args
);
1133 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1134 Qnil
, require_match
, Qnil
,
1135 Qbuffer_name_history
, def
, Qnil
);
1139 args
[0] = Vread_buffer_function
;
1142 args
[3] = require_match
;
1143 result
= Ffuncall (4, args
);
1145 return unbind_to (count
, result
);
1149 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1151 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1154 if (STRING_MULTIBYTE (string
))
1155 return Fstring_make_unibyte (string
);
1157 return Fstring_make_multibyte (string
);
1160 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1161 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1162 Test each possible completion specified by COLLECTION
1163 to see if it begins with STRING. The possible completions may be
1164 strings or symbols. Symbols are converted to strings before testing,
1166 All that match STRING are compared together; the longest initial sequence
1167 common to all these matches is the return value.
1168 If there is no match at all, the return value is nil.
1169 For a unique match which is exact, the return value is t.
1171 If COLLECTION is an alist, the keys (cars of elements) are the
1172 possible completions. If an element is not a cons cell, then the
1173 element itself is the possible completion.
1174 If COLLECTION is a hash-table, all the keys that are strings or symbols
1175 are the possible completions.
1176 If COLLECTION is an obarray, the names of all symbols in the obarray
1177 are the possible completions.
1179 COLLECTION can also be a function to do the completion itself.
1180 It receives three arguments: the values STRING, PREDICATE and nil.
1181 Whatever it returns becomes the value of `try-completion'.
1183 If optional third argument PREDICATE is non-nil,
1184 it is used to test each possible match.
1185 The match is a candidate only if PREDICATE returns non-nil.
1186 The argument given to PREDICATE is the alist element
1187 or the symbol from the obarray. If COLLECTION is a hash-table,
1188 predicate is called with two arguments: the key and the value.
1189 Additionally to this predicate, `completion-regexp-list'
1190 is used to further constrain the set of candidates. */)
1191 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1193 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1194 /* Size in bytes of BESTMATCH. */
1195 ptrdiff_t bestmatchsize
= 0;
1196 /* These are in bytes, too. */
1197 ptrdiff_t compare
, matchsize
;
1198 enum { function_table
, list_table
, obarray_table
, hash_table
}
1199 type
= (HASH_TABLE_P (collection
) ? hash_table
1200 : VECTORP (collection
) ? obarray_table
1201 : ((NILP (collection
)
1202 || (CONSP (collection
) && !FUNCTIONP (collection
)))
1203 ? list_table
: function_table
));
1204 ptrdiff_t idx
= 0, obsize
= 0;
1206 Lisp_Object bucket
, zero
, end
, tem
;
1207 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1209 CHECK_STRING (string
);
1210 if (type
== function_table
)
1211 return call3 (collection
, string
, predicate
, Qnil
);
1213 bestmatch
= bucket
= Qnil
;
1214 zero
= make_number (0);
1216 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1218 if (type
== obarray_table
)
1220 collection
= check_obarray (collection
);
1221 obsize
= ASIZE (collection
);
1222 bucket
= AREF (collection
, idx
);
1227 /* Get the next element of the alist, obarray, or hash-table. */
1228 /* Exit the loop if the elements are all used up. */
1229 /* elt gets the alist element or symbol.
1230 eltstring gets the name to check as a completion. */
1232 if (type
== list_table
)
1237 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1240 else if (type
== obarray_table
)
1242 if (!EQ (bucket
, zero
))
1244 if (!SYMBOLP (bucket
))
1245 error ("Bad data in guts of obarray");
1248 if (XSYMBOL (bucket
)->next
)
1249 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1251 XSETFASTINT (bucket
, 0);
1253 else if (++idx
>= obsize
)
1257 bucket
= AREF (collection
, idx
);
1261 else /* if (type == hash_table) */
1263 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1264 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1266 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1269 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1272 /* Is this element a possible completion? */
1274 if (SYMBOLP (eltstring
))
1275 eltstring
= Fsymbol_name (eltstring
);
1277 if (STRINGP (eltstring
)
1278 && SCHARS (string
) <= SCHARS (eltstring
)
1279 && (tem
= Fcompare_strings (eltstring
, zero
,
1280 make_number (SCHARS (string
)),
1282 completion_ignore_case
? Qt
: Qnil
),
1286 Lisp_Object regexps
;
1288 /* Ignore this element if it fails to match all the regexps. */
1291 specbind (Qcase_fold_search
,
1292 completion_ignore_case
? Qt
: Qnil
);
1293 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1294 regexps
= XCDR (regexps
))
1296 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1301 if (CONSP (regexps
))
1305 /* Ignore this element if there is a predicate
1306 and the predicate doesn't like it. */
1308 if (!NILP (predicate
))
1310 if (EQ (predicate
, Qcommandp
))
1311 tem
= Fcommandp (elt
, Qnil
);
1314 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1315 tem
= (type
== hash_table
1316 ? call2 (predicate
, elt
,
1317 HASH_VALUE (XHASH_TABLE (collection
),
1319 : call1 (predicate
, elt
));
1322 if (NILP (tem
)) continue;
1325 /* Update computation of how much all possible completions match */
1327 if (NILP (bestmatch
))
1330 bestmatch
= eltstring
;
1331 bestmatchsize
= SCHARS (eltstring
);
1335 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1336 tem
= Fcompare_strings (bestmatch
, zero
,
1337 make_number (compare
),
1339 make_number (compare
),
1340 completion_ignore_case
? Qt
: Qnil
);
1341 matchsize
= EQ (tem
, Qt
) ? compare
: eabs (XINT (tem
)) - 1;
1343 if (completion_ignore_case
)
1345 /* If this is an exact match except for case,
1346 use it as the best match rather than one that is not an
1347 exact match. This way, we get the case pattern
1348 of the actual match. */
1349 if ((matchsize
== SCHARS (eltstring
)
1350 && matchsize
< SCHARS (bestmatch
))
1352 /* If there is more than one exact match ignoring case,
1353 and one of them is exact including case,
1355 /* If there is no exact match ignoring case,
1356 prefer a match that does not change the case
1358 ((matchsize
== SCHARS (eltstring
))
1360 (matchsize
== SCHARS (bestmatch
))
1361 && (tem
= Fcompare_strings (eltstring
, zero
,
1362 make_number (SCHARS (string
)),
1367 && (tem
= Fcompare_strings (bestmatch
, zero
,
1368 make_number (SCHARS (string
)),
1373 bestmatch
= eltstring
;
1375 if (bestmatchsize
!= SCHARS (eltstring
)
1376 || bestmatchsize
!= matchsize
)
1377 /* Don't count the same string multiple times. */
1378 matchcount
+= matchcount
<= 1;
1379 bestmatchsize
= matchsize
;
1380 if (matchsize
<= SCHARS (string
)
1381 /* If completion-ignore-case is non-nil, don't
1382 short-circuit because we want to find the best
1383 possible match *including* case differences. */
1384 && !completion_ignore_case
1386 /* No need to look any further. */
1392 if (NILP (bestmatch
))
1393 return Qnil
; /* No completions found. */
1394 /* If we are ignoring case, and there is no exact match,
1395 and no additional text was supplied,
1396 don't change the case of what the user typed. */
1397 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1398 && SCHARS (bestmatch
) > bestmatchsize
)
1399 return minibuf_conform_representation (string
, bestmatch
);
1401 /* Return t if the supplied string is an exact match (counting case);
1402 it does not require any change to be made. */
1403 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1406 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1407 XSETFASTINT (end
, bestmatchsize
); /* all completions agree. */
1408 return Fsubstring (bestmatch
, zero
, end
);
1411 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1412 doc
: /* Search for partial matches to STRING in COLLECTION.
1413 Test each of the possible completions specified by COLLECTION
1414 to see if it begins with STRING. The possible completions may be
1415 strings or symbols. Symbols are converted to strings before testing,
1417 The value is a list of all the possible completions that match STRING.
1419 If COLLECTION is an alist, the keys (cars of elements) are the
1420 possible completions. If an element is not a cons cell, then the
1421 element itself is the possible completion.
1422 If COLLECTION is a hash-table, all the keys that are strings or symbols
1423 are the possible completions.
1424 If COLLECTION is an obarray, the names of all symbols in the obarray
1425 are the possible completions.
1427 COLLECTION can also be a function to do the completion itself.
1428 It receives three arguments: the values STRING, PREDICATE and t.
1429 Whatever it returns becomes the value of `all-completions'.
1431 If optional third argument PREDICATE is non-nil,
1432 it is used to test each possible match.
1433 The match is a candidate only if PREDICATE returns non-nil.
1434 The argument given to PREDICATE is the alist element
1435 or the symbol from the obarray. If COLLECTION is a hash-table,
1436 predicate is called with two arguments: the key and the value.
1437 Additionally to this predicate, `completion-regexp-list'
1438 is used to further constrain the set of candidates.
1440 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1441 backward compatibility. If non-nil, strings in COLLECTION that start
1442 with a space are ignored unless STRING itself starts with a space. */)
1443 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1445 Lisp_Object tail
, elt
, eltstring
;
1446 Lisp_Object allmatches
;
1447 int type
= HASH_TABLE_P (collection
) ? 3
1448 : VECTORP (collection
) ? 2
1449 : NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
));
1450 ptrdiff_t idx
= 0, obsize
= 0;
1451 Lisp_Object bucket
, tem
, zero
;
1452 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1454 CHECK_STRING (string
);
1456 return call3 (collection
, string
, predicate
, Qt
);
1457 allmatches
= bucket
= Qnil
;
1458 zero
= make_number (0);
1460 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1464 collection
= check_obarray (collection
);
1465 obsize
= ASIZE (collection
);
1466 bucket
= AREF (collection
, idx
);
1471 /* Get the next element of the alist, obarray, or hash-table. */
1472 /* Exit the loop if the elements are all used up. */
1473 /* elt gets the alist element or symbol.
1474 eltstring gets the name to check as a completion. */
1481 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1486 if (!EQ (bucket
, zero
))
1488 if (!SYMBOLP (bucket
))
1489 error ("Bad data in guts of obarray");
1492 if (XSYMBOL (bucket
)->next
)
1493 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1495 XSETFASTINT (bucket
, 0);
1497 else if (++idx
>= obsize
)
1501 bucket
= AREF (collection
, idx
);
1505 else /* if (type == 3) */
1507 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1508 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1510 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1513 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1516 /* Is this element a possible completion? */
1518 if (SYMBOLP (eltstring
))
1519 eltstring
= Fsymbol_name (eltstring
);
1521 if (STRINGP (eltstring
)
1522 && SCHARS (string
) <= SCHARS (eltstring
)
1523 /* If HIDE_SPACES, reject alternatives that start with space
1524 unless the input starts with space. */
1525 && (NILP (hide_spaces
)
1526 || (SBYTES (string
) > 0
1527 && SREF (string
, 0) == ' ')
1528 || SREF (eltstring
, 0) != ' ')
1529 && (tem
= Fcompare_strings (eltstring
, zero
,
1530 make_number (SCHARS (string
)),
1532 make_number (SCHARS (string
)),
1533 completion_ignore_case
? Qt
: Qnil
),
1537 Lisp_Object regexps
;
1539 /* Ignore this element if it fails to match all the regexps. */
1542 specbind (Qcase_fold_search
,
1543 completion_ignore_case
? Qt
: Qnil
);
1544 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1545 regexps
= XCDR (regexps
))
1547 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1552 if (CONSP (regexps
))
1556 /* Ignore this element if there is a predicate
1557 and the predicate doesn't like it. */
1559 if (!NILP (predicate
))
1561 if (EQ (predicate
, Qcommandp
))
1562 tem
= Fcommandp (elt
, Qnil
);
1565 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1567 ? call2 (predicate
, elt
,
1568 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1569 : call1 (predicate
, elt
);
1572 if (NILP (tem
)) continue;
1574 /* Ok => put it on the list. */
1575 allmatches
= Fcons (eltstring
, allmatches
);
1579 return Fnreverse (allmatches
);
1582 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1583 doc
: /* Read a string in the minibuffer, with completion.
1584 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1585 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1586 COLLECTION can also be a function to do the completion itself.
1587 PREDICATE limits completion to a subset of COLLECTION.
1588 See `try-completion' and `all-completions' for more details
1589 on completion, COLLECTION, and PREDICATE.
1591 REQUIRE-MATCH can take the following values:
1592 - t means that the user is not allowed to exit unless
1593 the input is (or completes to) an element of COLLECTION or is null.
1594 - nil means that the user can exit with any input.
1595 - `confirm' means that the user can exit with any input, but she needs
1596 to confirm her choice if the input is not an element of COLLECTION.
1597 - `confirm-after-completion' means that the user can exit with any
1598 input, but she needs to confirm her choice if she called
1599 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1600 and the input is not an element of COLLECTION.
1601 - anything else behaves like t except that typing RET does not exit if it
1602 does non-null completion.
1604 If the input is null, `completing-read' returns DEF, or the first element
1605 of the list of default values, or an empty string if DEF is nil,
1606 regardless of the value of REQUIRE-MATCH.
1608 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1609 with point positioned at the end.
1610 If it is (STRING . POSITION), the initial input is STRING, but point
1611 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1612 that this is different from `read-from-minibuffer' and related
1613 functions, which use one-indexing for POSITION.) This feature is
1614 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1615 default value DEF instead. The user can yank the default value into
1616 the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1618 HIST, if non-nil, specifies a history list and optionally the initial
1619 position in the list. It can be a symbol, which is the history list
1620 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1621 that case, HISTVAR is the history list variable to use, and HISTPOS
1622 is the initial position (the position in the list used by the
1623 minibuffer history commands). For consistency, you should also
1624 specify that element of the history as the value of
1625 INITIAL-INPUT. (This is the only case in which you should use
1626 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1627 1 at the beginning of the list. The variable `history-length'
1628 controls the maximum length of a history list.
1630 DEF, if non-nil, is the default value or the list of default values.
1632 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1633 the current input method and the setting of `enable-multibyte-characters'.
1635 Completion ignores case if the ambient value of
1636 `completion-ignore-case' is non-nil.
1638 See also `completing-read-function'. */)
1639 (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
)
1641 Lisp_Object args
[9];
1642 args
[0] = Fsymbol_value (intern ("completing-read-function"));
1644 args
[2] = collection
;
1645 args
[3] = predicate
;
1646 args
[4] = require_match
;
1647 args
[5] = initial_input
;
1650 args
[8] = inherit_input_method
;
1651 return Ffuncall (9, args
);
1654 /* Test whether TXT is an exact completion. */
1655 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1656 doc
: /* Return non-nil if STRING is a valid completion.
1657 Takes the same arguments as `all-completions' and `try-completion'.
1658 If COLLECTION is a function, it is called with three arguments:
1659 the values STRING, PREDICATE and `lambda'. */)
1660 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1662 Lisp_Object regexps
, tail
, tem
= Qnil
;
1665 CHECK_STRING (string
);
1667 if (NILP (collection
) || (CONSP (collection
) && !FUNCTIONP (collection
)))
1669 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1673 else if (VECTORP (collection
))
1675 /* Bypass intern-soft as that loses for nil. */
1676 tem
= oblookup (collection
,
1682 if (STRING_MULTIBYTE (string
))
1683 string
= Fstring_make_unibyte (string
);
1685 string
= Fstring_make_multibyte (string
);
1687 tem
= oblookup (collection
,
1693 if (completion_ignore_case
&& !SYMBOLP (tem
))
1695 for (i
= ASIZE (collection
) - 1; i
>= 0; i
--)
1697 tail
= AREF (collection
, i
);
1701 if (EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1702 Fsymbol_name (tail
),
1703 make_number (0) , Qnil
, Qt
),
1709 if (XSYMBOL (tail
)->next
== 0)
1711 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1719 else if (HASH_TABLE_P (collection
))
1721 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1722 Lisp_Object key
= Qnil
;
1723 i
= hash_lookup (h
, string
, NULL
);
1725 tem
= HASH_KEY (h
, i
);
1727 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1728 if (!NILP (HASH_HASH (h
, i
))
1729 && (key
= HASH_KEY (h
, i
),
1730 SYMBOLP (key
) ? key
= Fsymbol_name (key
) : key
,
1732 && EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1733 key
, make_number (0) , Qnil
,
1734 completion_ignore_case
? Qt
: Qnil
),
1744 return call3 (collection
, string
, predicate
, Qlambda
);
1746 /* Reject this element if it fails to match all the regexps. */
1747 if (CONSP (Vcompletion_regexp_list
))
1749 ptrdiff_t count
= SPECPDL_INDEX ();
1750 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1751 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1752 regexps
= XCDR (regexps
))
1754 if (NILP (Fstring_match (XCAR (regexps
),
1755 SYMBOLP (tem
) ? string
: tem
,
1757 return unbind_to (count
, Qnil
);
1759 unbind_to (count
, Qnil
);
1762 /* Finally, check the predicate. */
1763 if (!NILP (predicate
))
1765 return HASH_TABLE_P (collection
)
1766 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1767 : call1 (predicate
, tem
);
1773 static Lisp_Object Qmetadata
;
1775 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1776 doc
: /* Perform completion on buffer names.
1777 STRING and PREDICATE have the same meanings as in `try-completion',
1778 `all-completions', and `test-completion'.
1780 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1781 `all-completions'; otherwise invoke `test-completion'. */)
1782 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1785 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1786 else if (EQ (flag
, Qt
))
1788 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1789 if (SCHARS (string
) > 0)
1792 { /* Strip out internal buffers. */
1793 Lisp_Object bufs
= res
;
1794 /* First, look for a non-internal buffer in `res'. */
1795 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1798 return (EQ (Flength (res
), Flength (Vbuffer_alist
))
1799 /* If all bufs are internal don't strip them out. */
1802 while (CONSP (XCDR (bufs
)))
1803 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1804 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1810 else if (EQ (flag
, Qlambda
))
1811 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1812 else if (EQ (flag
, Qmetadata
))
1813 return list2 (Qmetadata
, Fcons (Qcategory
, Qbuffer
));
1818 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1820 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1821 doc
: /* Like `assoc' but specifically for strings (and symbols).
1823 This returns the first element of LIST whose car matches the string or
1824 symbol KEY, or nil if no match exists. When performing the
1825 comparison, symbols are first converted to strings, and unibyte
1826 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1829 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1830 single string, rather than a cons cell whose car is a string. */)
1831 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1833 register Lisp_Object tail
;
1836 key
= Fsymbol_name (key
);
1838 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1840 register Lisp_Object elt
, tem
, thiscar
;
1842 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1843 if (SYMBOLP (thiscar
))
1844 thiscar
= Fsymbol_name (thiscar
);
1845 else if (!STRINGP (thiscar
))
1847 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1848 key
, make_number (0), Qnil
,
1858 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1859 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1862 return make_number (minibuf_level
);
1865 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1866 doc
: /* Return the prompt string of the currently-active minibuffer.
1867 If no minibuffer is active, return nil. */)
1870 return Fcopy_sequence (minibuf_prompt
);
1875 init_minibuf_once (void)
1877 Vminibuffer_list
= Qnil
;
1878 staticpro (&Vminibuffer_list
);
1882 syms_of_minibuf (void)
1884 #include "minibuf.x"
1887 minibuf_prompt
= Qnil
;
1888 staticpro (&minibuf_prompt
);
1890 minibuf_save_list
= Qnil
;
1891 staticpro (&minibuf_save_list
);
1893 DEFSYM (Qcompletion_ignore_case
, "completion-ignore-case");
1894 DEFSYM (Qread_file_name_internal
, "read-file-name-internal");
1895 DEFSYM (Qminibuffer_default
, "minibuffer-default");
1896 Fset (Qminibuffer_default
, Qnil
);
1898 DEFSYM (Qminibuffer_completion_table
, "minibuffer-completion-table");
1899 DEFSYM (Qminibuffer_completion_confirm
, "minibuffer-completion-confirm");
1900 DEFSYM (Qminibuffer_completion_predicate
, "minibuffer-completion-predicate");
1902 staticpro (&last_minibuf_string
);
1903 last_minibuf_string
= Qnil
;
1905 DEFSYM (Qminibuffer_history
, "minibuffer-history");
1906 DEFSYM (Qbuffer_name_history
, "buffer-name-history");
1907 Fset (Qbuffer_name_history
, Qnil
);
1909 DEFSYM (Qcustom_variable_p
, "custom-variable-p");
1910 DEFSYM (Qminibuffer_setup_hook
, "minibuffer-setup-hook");
1911 DEFSYM (Qminibuffer_exit_hook
, "minibuffer-exit-hook");
1912 DEFSYM (Qhistory_length
, "history-length");
1913 DEFSYM (Qcurrent_input_method
, "current-input-method");
1914 DEFSYM (Qactivate_input_method
, "activate-input-method");
1915 DEFSYM (Qcase_fold_search
, "case-fold-search");
1916 DEFSYM (Qmetadata
, "metadata");
1918 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
1919 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
1920 For example, `eval-expression' uses this. */);
1921 Vread_expression_history
= Qnil
;
1923 DEFSYM (Qread_expression_history
, "read-expression-history");
1925 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
1926 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
1927 The function is called with the arguments passed to `read-buffer'. */);
1928 Vread_buffer_function
= Qnil
;
1930 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1931 read_buffer_completion_ignore_case
,
1932 doc
: /* Non-nil means completion ignores case when reading a buffer name. */);
1933 read_buffer_completion_ignore_case
= 0;
1935 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
1936 doc
: /* Normal hook run just after entry to minibuffer. */);
1937 Vminibuffer_setup_hook
= Qnil
;
1939 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
1940 doc
: /* Normal hook run just after exit from minibuffer. */);
1941 Vminibuffer_exit_hook
= Qnil
;
1943 DEFVAR_LISP ("history-length", Vhistory_length
,
1944 doc
: /* Maximum length of history lists before truncation takes place.
1945 A number means truncate to that length; truncation deletes old
1946 elements, and is done just after inserting a new element.
1947 A value of t means no truncation.
1949 This variable only affects history lists that don't specify their own
1950 maximum lengths. Setting the `history-length' property of a history
1951 variable overrides this default. */);
1952 XSETFASTINT (Vhistory_length
, 100);
1954 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
1955 doc
: /* Non-nil means to delete duplicates in history.
1956 If set to t when adding a new history element, all previous identical
1957 elements are deleted from the history list. */);
1958 history_delete_duplicates
= 0;
1960 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
1961 doc
: /* Non-nil means to add new elements in history.
1962 If set to nil, minibuffer reading functions don't add new elements to the
1963 history list, so it is possible to do this afterwards by calling
1964 `add-to-history' explicitly. */);
1965 Vhistory_add_new_input
= Qt
;
1967 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
1968 doc
: /* Non-nil means don't consider case significant in completion.
1969 For file-name completion, `read-file-name-completion-ignore-case'
1970 controls the behavior, rather than this variable.
1971 For buffer name completion, `read-buffer-completion-ignore-case'
1972 controls the behavior, rather than this variable. */);
1973 completion_ignore_case
= 0;
1975 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
1976 doc
: /* Non-nil means to allow minibuffer commands while in the minibuffer.
1977 This variable makes a difference whenever the minibuffer window is active. */);
1978 enable_recursive_minibuffers
= 0;
1980 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
1981 doc
: /* Alist or obarray used for completion in the minibuffer.
1982 This becomes the ALIST argument to `try-completion' and `all-completions'.
1983 The value can also be a list of strings or a hash table.
1985 The value may alternatively be a function, which is given three arguments:
1986 STRING, the current buffer contents;
1987 PREDICATE, the predicate for filtering possible matches;
1988 CODE, which says what kind of things to do.
1989 CODE can be nil, t or `lambda':
1990 nil -- return the best completion of STRING, or nil if there is none.
1991 t -- return a list of all possible completions of STRING.
1992 lambda -- return t if STRING is a valid completion as it stands. */);
1993 Vminibuffer_completion_table
= Qnil
;
1995 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
1996 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
1997 Vminibuffer_completion_predicate
= Qnil
;
1999 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2000 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2001 If nil, confirmation is not required.
2002 If the value is `confirm', the user may exit with an input that is not
2003 a valid completion alternative, but Emacs asks for confirmation.
2004 If the value is `confirm-after-completion', the user may exit with an
2005 input that is not a valid completion alternative, but Emacs asks for
2006 confirmation if the user submitted the input right after any of the
2007 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2008 Vminibuffer_completion_confirm
= Qnil
;
2010 DEFVAR_LISP ("minibuffer-completing-file-name",
2011 Vminibuffer_completing_file_name
,
2012 doc
: /* Non-nil means completing file names. */);
2013 Vminibuffer_completing_file_name
= Qnil
;
2015 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2016 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2017 Vminibuffer_help_form
= Qnil
;
2019 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2020 doc
: /* History list symbol to add minibuffer values to.
2021 Each string of minibuffer input, as it appears on exit from the minibuffer,
2023 (set minibuffer-history-variable
2024 (cons STRING (symbol-value minibuffer-history-variable))) */);
2025 XSETFASTINT (Vminibuffer_history_variable
, 0);
2027 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2028 doc
: /* Current position of redoing in the history list. */);
2029 Vminibuffer_history_position
= Qnil
;
2031 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2032 doc
: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2033 Some uses of the echo area also raise that frame (since they use it too). */);
2034 minibuffer_auto_raise
= 0;
2036 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2037 doc
: /* List of regexps that should restrict possible completions.
2038 The basic completion functions only consider a completion acceptable
2039 if it matches all regular expressions in this list, with
2040 `case-fold-search' bound to the value of `completion-ignore-case'.
2041 See Info node `(elisp)Basic Completion', for a description of these
2043 Vcompletion_regexp_list
= Qnil
;
2045 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2046 minibuffer_allow_text_properties
,
2047 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2048 This also affects `read-string', but it does not affect `read-minibuffer',
2049 `read-no-blanks-input', or any of the functions that do minibuffer input
2050 with completion; they always discard text properties. */);
2051 minibuffer_allow_text_properties
= 0;
2053 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2054 doc
: /* Text properties that are added to minibuffer prompts.
2055 These are in addition to the basic `field' property, and stickiness
2057 /* We use `intern' here instead of Qread_only to avoid
2058 initialization-order problems. */
2059 Vminibuffer_prompt_properties
= list2 (intern_c_string ("read-only"), Qt
);