1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005,
4 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
30 #include "character.h"
31 #include "dispextern.h"
36 #include "intervals.h"
41 /* List of buffers for use as minibuffers.
42 The first element of the list is used for the outermost minibuffer
43 invocation, the next element is used for a recursive minibuffer
44 invocation, etc. The list is extended at the end as deeper
45 minibuffer recursions are encountered. */
47 Lisp_Object Vminibuffer_list
;
49 /* Data to remember during recursive minibuffer invocations */
51 Lisp_Object minibuf_save_list
;
53 /* Depth in minibuffer invocations. */
57 /* Nonzero means display completion help for invalid input. */
59 Lisp_Object Vcompletion_auto_help
;
61 /* The maximum length of a minibuffer history. */
63 Lisp_Object Qhistory_length
, Vhistory_length
;
65 /* No duplicates in history. */
67 int history_delete_duplicates
;
69 /* Non-nil means add new input to history. */
71 Lisp_Object Vhistory_add_new_input
;
73 /* Fread_minibuffer leaves the input here as a string. */
75 Lisp_Object last_minibuf_string
;
77 /* Nonzero means let functions called when within a minibuffer
78 invoke recursive minibuffers (to read arguments, or whatever) */
80 int enable_recursive_minibuffers
;
82 /* Nonzero means don't ignore text properties
83 in Fread_from_minibuffer. */
85 int minibuffer_allow_text_properties
;
87 /* help-form is bound to this while in the minibuffer. */
89 Lisp_Object Vminibuffer_help_form
;
91 /* Variable which is the history list to add minibuffer values to. */
93 Lisp_Object Vminibuffer_history_variable
;
95 /* Current position in the history list (adjusted by M-n and M-p). */
97 Lisp_Object Vminibuffer_history_position
;
99 /* Text properties that are added to minibuffer prompts.
100 These are in addition to the basic `field' property, and stickiness
103 Lisp_Object Vminibuffer_prompt_properties
;
105 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
107 Lisp_Object Qread_file_name_internal
;
109 /* Normal hooks for entry to and exit from minibuffer. */
111 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
112 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
114 /* Function to call to read a buffer name. */
115 Lisp_Object Vread_buffer_function
;
117 /* Nonzero means completion ignores case. */
119 int completion_ignore_case
;
121 /* List of regexps that should restrict possible completions. */
123 Lisp_Object Vcompletion_regexp_list
;
125 /* Nonzero means raise the minibuffer frame when the minibuffer
128 int minibuffer_auto_raise
;
130 /* If last completion attempt reported "Complete but not unique"
131 then this is the string completed then; otherwise this is nil. */
133 static Lisp_Object last_exact_completion
;
135 /* Keymap for reading expressions. */
136 Lisp_Object Vread_expression_map
;
138 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
139 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
140 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
141 Lisp_Object Vminibuffer_completing_file_name
;
143 Lisp_Object Quser_variable_p
;
145 Lisp_Object Qminibuffer_default
;
147 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
149 Lisp_Object Qcase_fold_search
;
151 Lisp_Object Qread_expression_history
;
153 extern Lisp_Object Voverriding_local_map
;
155 extern Lisp_Object Qmouse_face
;
157 extern Lisp_Object Qfield
;
159 /* Put minibuf on currently selected frame's minibuffer.
160 We do this whenever the user starts a new minibuffer
161 or when a minibuffer exits. */
164 choose_minibuf_frame ()
166 if (FRAMEP (selected_frame
)
167 && FRAME_LIVE_P (XFRAME (selected_frame
))
168 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
170 struct frame
*sf
= XFRAME (selected_frame
);
173 /* I don't think that any frames may validly have a null minibuffer
175 if (NILP (sf
->minibuffer_window
))
178 /* Under X, we come here with minibuf_window being the
179 minibuffer window of the unused termcap window created in
180 init_window_once. That window doesn't have a buffer. */
181 buffer
= XWINDOW (minibuf_window
)->buffer
;
182 if (BUFFERP (buffer
))
183 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
184 minibuf_window
= sf
->minibuffer_window
;
187 /* Make sure no other frame has a minibuffer as its selected window,
188 because the text would not be displayed in it, and that would be
189 confusing. Only allow the selected frame to do this,
190 and that only if the minibuffer is active. */
192 Lisp_Object tail
, frame
;
194 FOR_EACH_FRAME (tail
, frame
)
195 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
196 && !(EQ (frame
, selected_frame
)
197 && minibuf_level
> 0))
198 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
203 choose_minibuf_frame_1 (ignore
)
206 choose_minibuf_frame ();
210 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
211 Sset_minibuffer_window
, 1, 1, 0,
212 doc
: /* Specify which minibuffer window to use for the minibuffer.
213 This affects where the minibuffer is displayed if you put text in it
214 without invoking the usual minibuffer commands. */)
218 CHECK_WINDOW (window
);
219 if (! MINI_WINDOW_P (XWINDOW (window
)))
220 error ("Window is not a minibuffer window");
222 minibuf_window
= window
;
228 /* Actual minibuffer invocation. */
230 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
231 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
232 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
233 Lisp_Object
, Lisp_Object
,
235 Lisp_Object
, Lisp_Object
,
237 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
238 Lisp_Object
, Lisp_Object
,
240 Lisp_Object
, Lisp_Object
,
242 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
245 /* Read a Lisp object from VAL and return it. If VAL is an empty
246 string, and DEFALT is a string, read from DEFALT instead of VAL. */
249 string_to_object (val
, defalt
)
250 Lisp_Object val
, defalt
;
252 struct gcpro gcpro1
, gcpro2
;
253 Lisp_Object expr_and_pos
;
256 GCPRO2 (val
, defalt
);
258 if (STRINGP (val
) && SCHARS (val
) == 0
262 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
263 pos
= XINT (Fcdr (expr_and_pos
));
264 if (pos
!= SCHARS (val
))
266 /* Ignore trailing whitespace; any other trailing junk
269 pos
= string_char_to_byte (val
, pos
);
270 for (i
= pos
; i
< SBYTES (val
); i
++)
272 int c
= SREF (val
, i
);
273 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
274 error ("Trailing garbage following expression");
278 val
= Fcar (expr_and_pos
);
279 RETURN_UNGCPRO (val
);
283 /* Like read_minibuf but reading from stdin. This function is called
284 from read_minibuf to do the job if noninteractive. */
287 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
288 histvar
, histpos
, defalt
, allow_props
,
289 inherit_input_method
)
293 Lisp_Object backup_n
;
299 int inherit_input_method
;
305 fprintf (stdout
, "%s", SDATA (prompt
));
311 line
= (char *) xmalloc (size
* sizeof *line
);
312 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
313 && (len
= strlen (line
),
314 len
== size
- 1 && line
[len
- 1] != '\n'))
317 line
= (char *) xrealloc (line
, size
);
324 if (len
> 0 && line
[len
- 1] == '\n')
327 val
= build_string (line
);
333 error ("Error reading from stdin");
336 /* If Lisp form desired instead of string, parse it. */
338 val
= string_to_object (val
, defalt
);
343 DEFUN ("minibufferp", Fminibufferp
,
344 Sminibufferp
, 0, 1, 0,
345 doc
: /* Return t if BUFFER is a minibuffer.
346 No argument or nil as argument means use current buffer as BUFFER.
347 BUFFER can be a buffer or a buffer name. */)
354 buffer
= Fcurrent_buffer ();
355 else if (STRINGP (buffer
))
356 buffer
= Fget_buffer (buffer
);
358 CHECK_BUFFER (buffer
);
360 tem
= Fmemq (buffer
, Vminibuffer_list
);
361 return ! NILP (tem
) ? Qt
: Qnil
;
364 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
365 Sminibuffer_prompt_end
, 0, 0, 0,
366 doc
: /* Return the buffer position of the end of the minibuffer prompt.
367 Return (point-min) if current buffer is not a minibuffer. */)
370 /* This function is written to be most efficient when there's a prompt. */
371 Lisp_Object beg
, end
, tem
;
372 beg
= make_number (BEGV
);
374 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
378 end
= Ffield_end (beg
, Qnil
, Qnil
);
380 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
386 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
387 Sminibuffer_contents
, 0, 0, 0,
388 doc
: /* Return the user input in a minibuffer as a string.
389 If the current buffer is not a minibuffer, return its entire contents. */)
392 int prompt_end
= XINT (Fminibuffer_prompt_end ());
393 return make_buffer_string (prompt_end
, ZV
, 1);
396 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
397 Sminibuffer_contents_no_properties
, 0, 0, 0,
398 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
399 If the current buffer is not a minibuffer, return its entire contents. */)
402 int prompt_end
= XINT (Fminibuffer_prompt_end ());
403 return make_buffer_string (prompt_end
, ZV
, 0);
406 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
407 Sminibuffer_completion_contents
, 0, 0, 0,
408 doc
: /* Return the user input in a minibuffer before point as a string.
409 That is what completion commands operate on.
410 If the current buffer is not a minibuffer, return its entire contents. */)
413 int prompt_end
= XINT (Fminibuffer_prompt_end ());
415 error ("Cannot do completion in the prompt");
416 return make_buffer_string (prompt_end
, PT
, 1);
419 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
420 Sdelete_minibuffer_contents
, 0, 0, 0,
421 doc
: /* Delete all user input in a minibuffer.
422 If the current buffer is not a minibuffer, erase its entire contents. */)
425 int prompt_end
= XINT (Fminibuffer_prompt_end ());
427 del_range (prompt_end
, ZV
);
432 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
433 putting point minus BACKUP_N bytes from the end of INITIAL,
434 prompting with PROMPT (a string), using history list HISTVAR
435 with initial position HISTPOS. INITIAL should be a string or a
436 cons of a string and an integer. BACKUP_N should be <= 0, or
437 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
438 ignored and replaced with an integer that puts point at one-indexed
439 position N in INITIAL, where N is the CDR of INITIAL, or at the
440 beginning of INITIAL if N <= 0.
442 Normally return the result as a string (the text that was read),
443 but if EXPFLAG is nonzero, read it and return the object read.
444 If HISTVAR is given, save the value read on that history only if it doesn't
445 match the front of that history list exactly. The value is pushed onto
446 the list as the string that was read.
448 DEFALT specifies the default value for the sake of history commands.
450 If ALLOW_PROPS is nonzero, we do not throw away text properties.
452 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
453 current input method. */
456 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
457 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
461 Lisp_Object backup_n
;
467 int inherit_input_method
;
470 int count
= SPECPDL_INDEX ();
471 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
472 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
473 Lisp_Object enable_multibyte
;
474 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
475 /* String to add to the history. */
476 Lisp_Object histstring
;
478 Lisp_Object empty_minibuf
;
479 Lisp_Object dummy
, frame
;
481 extern Lisp_Object Qfront_sticky
;
482 extern Lisp_Object Qrear_nonsticky
;
484 specbind (Qminibuffer_default
, defalt
);
486 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
487 in previous recursive minibuffer, but was not set explicitly
488 to t for this invocation, so set it to nil in this minibuffer.
489 Save the old value now, before we change it. */
490 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
491 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
492 Vminibuffer_completing_file_name
= Qnil
;
494 single_kboard_state ();
495 #ifdef HAVE_X_WINDOWS
496 if (display_hourglass_p
)
504 backup_n
= Fcdr (initial
);
505 initial
= Fcar (initial
);
506 CHECK_STRING (initial
);
507 if (!NILP (backup_n
))
509 CHECK_NUMBER (backup_n
);
510 /* Convert to distance from end of input. */
511 if (XINT (backup_n
) < 1)
512 /* A number too small means the beginning of the string. */
513 pos
= - SCHARS (initial
);
515 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
519 CHECK_STRING (initial
);
522 ambient_dir
= current_buffer
->directory
;
524 enable_multibyte
= Qnil
;
526 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
527 store them away before we can GC. Don't need to protect
528 BACKUP_N because we use the value only if it is an integer. */
529 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
531 if (!STRINGP (prompt
))
532 prompt
= empty_unibyte_string
;
534 if (!enable_recursive_minibuffers
535 && minibuf_level
> 0)
537 if (EQ (selected_window
, minibuf_window
))
538 error ("Command attempted to use minibuffer while in minibuffer");
540 /* If we're in another window, cancel the minibuffer that's active. */
542 build_string ("Command attempted to use minibuffer while in minibuffer"));
545 if (noninteractive
&& NILP (Vexecuting_kbd_macro
))
547 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
549 expflag
, histvar
, histpos
, defalt
,
550 allow_props
, inherit_input_method
);
552 return unbind_to (count
, val
);
555 /* Choose the minibuffer window and frame, and take action on them. */
557 choose_minibuf_frame ();
559 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
561 record_unwind_protect (Fset_window_configuration
,
562 Fcurrent_window_configuration (Qnil
));
564 /* If the minibuffer window is on a different frame, save that
565 frame's configuration too. */
566 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
567 if (!EQ (mini_frame
, selected_frame
))
568 record_unwind_protect (Fset_window_configuration
,
569 Fcurrent_window_configuration (mini_frame
));
571 /* If the minibuffer is on an iconified or invisible frame,
572 make it visible now. */
573 Fmake_frame_visible (mini_frame
);
575 if (minibuffer_auto_raise
)
576 Fraise_frame (mini_frame
);
578 /* We have to do this after saving the window configuration
579 since that is what restores the current buffer. */
581 /* Arrange to restore a number of minibuffer-related variables.
582 We could bind each variable separately, but that would use lots of
585 = Fcons (Voverriding_local_map
,
586 Fcons (minibuf_window
,
589 = Fcons (minibuf_prompt
,
590 Fcons (make_number (minibuf_prompt_width
),
592 Fcons (Vcurrent_prefix_arg
,
593 Fcons (Vminibuffer_history_position
,
594 Fcons (Vminibuffer_history_variable
,
595 minibuf_save_list
))))));
597 record_unwind_protect (read_minibuf_unwind
, Qnil
);
599 /* We are exiting the minibuffer one way or the other, so run the hook.
600 It should be run before unwinding the minibuf settings. Do it
601 separately from read_minibuf_unwind because we need to make sure that
602 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
603 signals an error. --Stef */
604 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
606 /* Now that we can restore all those variables, start changing them. */
608 minibuf_prompt_width
= 0;
609 minibuf_prompt
= Fcopy_sequence (prompt
);
610 Vminibuffer_history_position
= histpos
;
611 Vminibuffer_history_variable
= histvar
;
612 Vhelp_form
= Vminibuffer_help_form
;
613 /* If this minibuffer is reading a file name, that doesn't mean
614 recursive ones are. But we cannot set it to nil, because
615 completion code still need to know the minibuffer is completing a
616 file name. So use `lambda' as intermediate value meaning
617 "t" in this minibuffer, but "nil" in next minibuffer. */
618 if (!NILP (Vminibuffer_completing_file_name
))
619 Vminibuffer_completing_file_name
= Qlambda
;
621 if (inherit_input_method
)
623 /* `current-input-method' is buffer local. So, remember it in
624 INPUT_METHOD before changing the current buffer. */
625 input_method
= Fsymbol_value (Qcurrent_input_method
);
626 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
629 /* Switch to the minibuffer. */
631 minibuffer
= get_minibuffer (minibuf_level
);
632 Fset_buffer (minibuffer
);
634 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
635 if (inherit_input_method
)
636 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
638 /* The current buffer's default directory is usually the right thing
639 for our minibuffer here. However, if you're typing a command at
640 a minibuffer-only frame when minibuf_level is zero, then buf IS
641 the current_buffer, so reset_buffer leaves buf's default
642 directory unchanged. This is a bummer when you've just started
643 up Emacs and buf's default directory is Qnil. Here's a hack; can
644 you think of something better to do? Find another buffer with a
645 better directory, and use that one instead. */
646 if (STRINGP (ambient_dir
))
647 current_buffer
->directory
= ambient_dir
;
650 Lisp_Object buf_list
;
652 for (buf_list
= Vbuffer_alist
;
654 buf_list
= XCDR (buf_list
))
656 Lisp_Object other_buf
;
658 other_buf
= XCDR (XCAR (buf_list
));
659 if (STRINGP (XBUFFER (other_buf
)->directory
))
661 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
667 if (!EQ (mini_frame
, selected_frame
))
668 Fredirect_frame_focus (selected_frame
, mini_frame
);
670 Vminibuf_scroll_window
= selected_window
;
671 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
672 minibuf_selected_window
= selected_window
;
674 /* Empty out the minibuffers of all frames other than the one
675 where we are going to display one now.
676 Set them to point to ` *Minibuf-0*', which is always empty. */
677 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
679 FOR_EACH_FRAME (dummy
, frame
)
681 Lisp_Object root_window
= Fframe_root_window (frame
);
682 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
684 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
685 && !NILP (Fwindow_minibuffer_p (mini_window
)))
686 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
689 /* Display this minibuffer in the proper window. */
690 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
691 Fselect_window (minibuf_window
, Qnil
);
692 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
694 Fmake_local_variable (Qprint_escape_newlines
);
695 print_escape_newlines
= 1;
697 /* Erase the buffer. */
699 int count1
= SPECPDL_INDEX ();
700 specbind (Qinhibit_read_only
, Qt
);
701 specbind (Qinhibit_modification_hooks
, Qt
);
704 if (!NILP (current_buffer
->enable_multibyte_characters
)
705 && ! STRING_MULTIBYTE (minibuf_prompt
))
706 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
708 /* Insert the prompt, record where it ends. */
709 Finsert (1, &minibuf_prompt
);
712 Fput_text_property (make_number (BEG
), make_number (PT
),
713 Qfront_sticky
, Qt
, Qnil
);
714 Fput_text_property (make_number (BEG
), make_number (PT
),
715 Qrear_nonsticky
, Qt
, Qnil
);
716 Fput_text_property (make_number (BEG
), make_number (PT
),
718 Fadd_text_properties (make_number (BEG
), make_number (PT
),
719 Vminibuffer_prompt_properties
, Qnil
);
721 unbind_to (count1
, Qnil
);
724 minibuf_prompt_width
= (int) current_column (); /* iftc */
726 /* Put in the initial input. */
729 Finsert (1, &initial
);
730 Fforward_char (make_number (pos
));
733 clear_message (1, 1);
734 current_buffer
->keymap
= map
;
736 /* Turn on an input method stored in INPUT_METHOD if any. */
737 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
738 call1 (Qactivate_input_method
, input_method
);
740 /* Run our hook, but not if it is empty.
741 (run-hooks would do nothing if it is empty,
742 but it's important to save time here in the usual case.) */
743 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
744 && !NILP (Vrun_hooks
))
745 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
747 /* Don't allow the user to undo past this point. */
748 current_buffer
->undo_list
= Qnil
;
752 /* If cursor is on the minibuffer line,
753 show the user we have exited by putting it in column 0. */
754 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
757 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
758 XWINDOW (minibuf_window
)->cursor
.x
= 0;
759 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
760 update_frame (XFRAME (selected_frame
), 1, 1);
761 if (rif
&& rif
->flush_display
)
762 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
765 /* Make minibuffer contents into a string. */
766 Fset_buffer (minibuffer
);
768 val
= Fminibuffer_contents ();
770 val
= Fminibuffer_contents_no_properties ();
772 /* VAL is the string of minibuffer text. */
774 last_minibuf_string
= val
;
776 /* Choose the string to add to the history. */
777 if (SCHARS (val
) != 0)
779 else if (STRINGP (defalt
))
784 /* Add the value to the appropriate history list, if any. */
785 if (!NILP (Vhistory_add_new_input
)
786 && SYMBOLP (Vminibuffer_history_variable
)
787 && !NILP (histstring
))
789 /* If the caller wanted to save the value read on a history list,
790 then do so if the value is not already the front of the list. */
793 /* If variable is unbound, make it nil. */
794 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
795 Fset (Vminibuffer_history_variable
, Qnil
);
797 histval
= Fsymbol_value (Vminibuffer_history_variable
);
799 /* The value of the history variable must be a cons or nil. Other
800 values are unacceptable. We silently ignore these values. */
804 /* Don't duplicate the most recent entry in the history. */
805 && (NILP (Fequal (histstring
, Fcar (histval
))))))
809 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
810 histval
= Fcons (histstring
, histval
);
811 Fset (Vminibuffer_history_variable
, histval
);
813 /* Truncate if requested. */
814 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
815 if (NILP (length
)) length
= Vhistory_length
;
816 if (INTEGERP (length
))
818 if (XINT (length
) <= 0)
819 Fset (Vminibuffer_history_variable
, Qnil
);
824 temp
= Fnthcdr (Fsub1 (length
), histval
);
825 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
831 /* If Lisp form desired instead of string, parse it. */
833 val
= string_to_object (val
, defalt
);
835 /* The appropriate frame will get selected
836 in set-window-configuration. */
838 return unbind_to (count
, val
);
841 /* Return a buffer to be used as the minibuffer at depth `depth'.
842 depth = 0 is the lowest allowed argument, and that is the value
843 used for nonrecursive minibuffer invocations */
846 get_minibuffer (depth
)
849 Lisp_Object tail
, num
, buf
;
851 extern Lisp_Object
nconc2 ();
853 XSETFASTINT (num
, depth
);
854 tail
= Fnthcdr (num
, Vminibuffer_list
);
857 tail
= Fcons (Qnil
, Qnil
);
858 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
861 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
863 sprintf (name
, " *Minibuf-%d*", depth
);
864 buf
= Fget_buffer_create (build_string (name
));
866 /* Although the buffer's name starts with a space, undo should be
868 Fbuffer_enable_undo (buf
);
874 int count
= SPECPDL_INDEX ();
875 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
876 have to empty the list, otherwise we end up with overlays that
877 think they belong to this buffer while the buffer doesn't know about
879 delete_all_overlays (XBUFFER (buf
));
880 reset_buffer (XBUFFER (buf
));
881 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
883 Fkill_all_local_variables ();
884 unbind_to (count
, Qnil
);
891 run_exit_minibuf_hook (data
)
894 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
895 && !NILP (Vrun_hooks
))
896 safe_run_hooks (Qminibuffer_exit_hook
);
901 /* This function is called on exiting minibuffer, whether normally or
902 not, and it restores the current window, buffer, etc. */
905 read_minibuf_unwind (data
)
908 Lisp_Object old_deactivate_mark
;
911 /* If this was a recursive minibuffer,
912 tie the minibuffer window back to the outer level minibuffer buffer. */
915 window
= minibuf_window
;
916 /* To keep things predictable, in case it matters, let's be in the
917 minibuffer when we reset the relevant variables. */
918 Fset_buffer (XWINDOW (window
)->buffer
);
920 /* Restore prompt, etc, from outer minibuffer level. */
921 minibuf_prompt
= Fcar (minibuf_save_list
);
922 minibuf_save_list
= Fcdr (minibuf_save_list
);
923 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
924 minibuf_save_list
= Fcdr (minibuf_save_list
);
925 Vhelp_form
= Fcar (minibuf_save_list
);
926 minibuf_save_list
= Fcdr (minibuf_save_list
);
927 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
928 minibuf_save_list
= Fcdr (minibuf_save_list
);
929 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
930 minibuf_save_list
= Fcdr (minibuf_save_list
);
931 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
932 minibuf_save_list
= Fcdr (minibuf_save_list
);
933 Voverriding_local_map
= Fcar (minibuf_save_list
);
934 minibuf_save_list
= Fcdr (minibuf_save_list
);
936 temp
= Fcar (minibuf_save_list
);
937 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
938 minibuf_window
= temp
;
940 minibuf_save_list
= Fcdr (minibuf_save_list
);
942 /* Erase the minibuffer we were using at this level. */
944 int count
= SPECPDL_INDEX ();
945 /* Prevent error in erase-buffer. */
946 specbind (Qinhibit_read_only
, Qt
);
947 specbind (Qinhibit_modification_hooks
, Qt
);
948 old_deactivate_mark
= Vdeactivate_mark
;
950 Vdeactivate_mark
= old_deactivate_mark
;
951 unbind_to (count
, Qnil
);
954 /* When we get to the outmost level, make sure we resize the
955 mini-window back to its normal size. */
956 if (minibuf_level
== 0)
957 resize_mini_window (XWINDOW (window
), 0);
959 /* Make sure minibuffer window is erased, not ignored. */
960 windows_or_buffers_changed
++;
961 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
962 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
967 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
968 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
969 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
970 DEFAULT-VALUE. It normally should be nil in new code, except when
971 HIST is a cons. It is discussed in more detail below.
972 Third arg KEYMAP is a keymap to use whilst reading;
973 if omitted or nil, the default is `minibuffer-local-map'.
974 If fourth arg READ is non-nil, then interpret the result as a Lisp object
975 and return that object:
976 in other words, do `(car (read-from-string INPUT-STRING))'
977 Fifth arg HIST, if non-nil, specifies a history list and optionally
978 the initial position in the list. It can be a symbol, which is the
979 history list variable to use, or it can be a cons cell
980 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
981 to use, and HISTPOS is the initial position for use by the minibuffer
982 history commands. For consistency, you should also specify that
983 element of the history as the value of INITIAL-CONTENTS. Positions
984 are counted starting from 1 at the beginning of the list.
985 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
986 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
987 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
989 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
990 the current input method and the setting of `enable-multibyte-characters'.
991 If the variable `minibuffer-allow-text-properties' is non-nil,
992 then the string which is returned includes whatever text properties
993 were present in the minibuffer. Otherwise the value has no text properties.
995 The remainder of this documentation string describes the
996 INITIAL-CONTENTS argument in more detail. It is only relevant when
997 studying existing code, or when HIST is a cons. If non-nil,
998 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
999 reading input. Normally, point is put at the end of that string.
1000 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
1001 input is STRING, but point is placed at _one-indexed_ position
1002 POSITION in the minibuffer. Any integer value less than or equal to
1003 one puts point at the beginning of the string. *Note* that this
1004 behavior differs from the way such arguments are used in `completing-read'
1005 and some related functions, which use zero-indexing for POSITION. */)
1006 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
1007 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
1008 Lisp_Object inherit_input_method
;
1010 Lisp_Object histvar
, histpos
, val
;
1011 struct gcpro gcpro1
;
1013 CHECK_STRING (prompt
);
1015 keymap
= Vminibuffer_local_map
;
1017 keymap
= get_keymap (keymap
, 1, 0);
1026 histvar
= Fcar_safe (hist
);
1027 histpos
= Fcdr_safe (hist
);
1030 histvar
= Qminibuffer_history
;
1032 XSETFASTINT (histpos
, 0);
1034 GCPRO1 (default_value
);
1035 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1037 histvar
, histpos
, default_value
,
1038 minibuffer_allow_text_properties
,
1039 !NILP (inherit_input_method
));
1044 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1045 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1046 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1047 is a string to insert in the minibuffer before reading.
1048 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1049 arguments are used as in `read-from-minibuffer'.) */)
1050 (prompt
, initial_contents
)
1051 Lisp_Object prompt
, initial_contents
;
1053 CHECK_STRING (prompt
);
1054 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1055 prompt
, Qnil
, 1, Qminibuffer_history
,
1056 make_number (0), Qnil
, 0, 0);
1059 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1060 doc
: /* Return value of Lisp expression read using the minibuffer.
1061 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1062 is a string to insert in the minibuffer before reading.
1063 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1064 arguments are used as in `read-from-minibuffer'.) */)
1065 (prompt
, initial_contents
)
1066 Lisp_Object prompt
, initial_contents
;
1068 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1069 prompt
, Qnil
, 1, Qread_expression_history
,
1070 make_number (0), Qnil
, 0, 0));
1073 /* Functions that use the minibuffer to read various things. */
1075 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1076 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1077 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1078 This argument has been superseded by DEFAULT-VALUE and should normally
1079 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1080 documentation string of that function for details.
1081 The third arg HISTORY, if non-nil, specifies a history list
1082 and optionally the initial position in the list.
1083 See `read-from-minibuffer' for details of HISTORY argument.
1084 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1085 for history commands, and as the value to return if the user enters
1087 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1088 the current input method and the setting of `enable-multibyte-characters'. */)
1089 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1090 Lisp_Object prompt
, initial_input
, history
, default_value
;
1091 Lisp_Object inherit_input_method
;
1094 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1095 Qnil
, history
, default_value
,
1096 inherit_input_method
);
1097 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1098 val
= default_value
;
1102 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1103 doc
: /* Read a string from the terminal, not allowing blanks.
1104 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1105 non-nil, it should be a string, which is used as initial input, with
1106 point positioned at the end, so that SPACE will accept the input.
1107 \(Actually, INITIAL can also be a cons of a string and an integer.
1108 Such values are treated as in `read-from-minibuffer', but are normally
1109 not useful in this function.)
1110 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1111 the current input method and the setting of`enable-multibyte-characters'. */)
1112 (prompt
, initial
, inherit_input_method
)
1113 Lisp_Object prompt
, initial
, inherit_input_method
;
1115 CHECK_STRING (prompt
);
1116 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1117 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1118 !NILP (inherit_input_method
));
1121 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1122 doc
: /* Read the name of a command and return as a symbol.
1123 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1124 (prompt
, default_value
)
1125 Lisp_Object prompt
, default_value
;
1127 Lisp_Object name
, default_string
;
1129 if (NILP (default_value
))
1130 default_string
= Qnil
;
1131 else if (SYMBOLP (default_value
))
1132 default_string
= SYMBOL_NAME (default_value
);
1134 default_string
= default_value
;
1136 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1137 Qnil
, Qnil
, default_string
, Qnil
);
1140 return Fintern (name
, Qnil
);
1144 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1145 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1146 Prompt with PROMPT. */)
1150 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1155 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1156 doc
: /* Read the name of a user variable and return it as a symbol.
1157 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1158 A user variable is one for which `user-variable-p' returns non-nil. */)
1159 (prompt
, default_value
)
1160 Lisp_Object prompt
, default_value
;
1162 Lisp_Object name
, default_string
;
1164 if (NILP (default_value
))
1165 default_string
= Qnil
;
1166 else if (SYMBOLP (default_value
))
1167 default_string
= SYMBOL_NAME (default_value
);
1169 default_string
= default_value
;
1171 name
= Fcompleting_read (prompt
, Vobarray
,
1172 Quser_variable_p
, Qt
,
1173 Qnil
, Qnil
, default_string
, Qnil
);
1176 return Fintern (name
, Qnil
);
1179 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1180 doc
: /* Read the name of a buffer and return as a string.
1182 Optional second arg DEF is value to return if user enters an empty line.
1183 If optional third arg REQUIRE-MATCH is non-nil,
1184 only existing buffer names are allowed.
1185 The argument PROMPT should be a string ending with a colon and a space. */)
1186 (prompt
, def
, require_match
)
1187 Lisp_Object prompt
, def
, require_match
;
1189 Lisp_Object args
[4];
1194 def
= XBUFFER (def
)->name
;
1196 if (NILP (Vread_buffer_function
))
1200 /* A default value was provided: we must change PROMPT,
1201 editing the default value in before the colon. To achieve
1202 this, we replace PROMPT with a substring that doesn't
1203 contain the terminal space and colon (if present). They
1204 are then added back using Fformat. */
1206 if (STRINGP (prompt
))
1210 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1212 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1215 prompt
= make_specified_string (s
, -1, len
,
1216 STRING_MULTIBYTE (prompt
));
1219 args
[0] = build_string ("%s (default %s): ");
1222 prompt
= Fformat (3, args
);
1225 return Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1226 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1231 args
[0] = Vread_buffer_function
;
1234 args
[3] = require_match
;
1235 return Ffuncall(4, args
);
1240 minibuf_conform_representation (string
, basis
)
1241 Lisp_Object string
, basis
;
1243 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1246 if (STRING_MULTIBYTE (string
))
1247 return Fstring_make_unibyte (string
);
1249 return Fstring_make_multibyte (string
);
1252 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1253 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1254 Test each possible completion specified by COLLECTION
1255 to see if it begins with STRING. The possible completions may be
1256 strings or symbols. Symbols are converted to strings before testing,
1258 All that match STRING are compared together; the longest initial sequence
1259 common to all these matches is the return value.
1260 If there is no match at all, the return value is nil.
1261 For a unique match which is exact, the return value is t.
1263 If COLLECTION is an alist, the keys (cars of elements) are the
1264 possible completions. If an element is not a cons cell, then the
1265 element itself is the possible completion.
1266 If COLLECTION is a hash-table, all the keys that are strings or symbols
1267 are the possible completions.
1268 If COLLECTION is an obarray, the names of all symbols in the obarray
1269 are the possible completions.
1271 COLLECTION can also be a function to do the completion itself.
1272 It receives three arguments: the values STRING, PREDICATE and nil.
1273 Whatever it returns becomes the value of `try-completion'.
1275 If optional third argument PREDICATE is non-nil,
1276 it is used to test each possible match.
1277 The match is a candidate only if PREDICATE returns non-nil.
1278 The argument given to PREDICATE is the alist element
1279 or the symbol from the obarray. If COLLECTION is a hash-table,
1280 predicate is called with two arguments: the key and the value.
1281 Additionally to this predicate, `completion-regexp-list'
1282 is used to further constrain the set of candidates. */)
1283 (string
, collection
, predicate
)
1284 Lisp_Object string
, collection
, predicate
;
1286 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1287 /* Size in bytes of BESTMATCH. */
1288 int bestmatchsize
= 0;
1289 /* These are in bytes, too. */
1290 int compare
, matchsize
;
1291 enum { function_table
, list_table
, obarray_table
, hash_table
}
1292 type
= (HASH_TABLE_P (collection
) ? hash_table
1293 : VECTORP (collection
) ? obarray_table
1294 : ((NILP (collection
)
1295 || (CONSP (collection
)
1296 && (!SYMBOLP (XCAR (collection
))
1297 || NILP (XCAR (collection
)))))
1298 ? list_table
: function_table
));
1299 int index
= 0, obsize
= 0;
1302 Lisp_Object bucket
, zero
, end
, tem
;
1303 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1305 CHECK_STRING (string
);
1306 if (type
== function_table
)
1307 return call3 (collection
, string
, predicate
, Qnil
);
1309 bestmatch
= bucket
= Qnil
;
1310 zero
= make_number (0);
1312 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1314 if (type
== obarray_table
)
1316 collection
= check_obarray (collection
);
1317 obsize
= XVECTOR (collection
)->size
;
1318 bucket
= XVECTOR (collection
)->contents
[index
];
1323 /* Get the next element of the alist, obarray, or hash-table. */
1324 /* Exit the loop if the elements are all used up. */
1325 /* elt gets the alist element or symbol.
1326 eltstring gets the name to check as a completion. */
1328 if (type
== list_table
)
1333 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1336 else if (type
== obarray_table
)
1338 if (!EQ (bucket
, zero
))
1340 if (!SYMBOLP (bucket
))
1341 error ("Bad data in guts of obarray");
1344 if (XSYMBOL (bucket
)->next
)
1345 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1347 XSETFASTINT (bucket
, 0);
1349 else if (++index
>= obsize
)
1353 bucket
= XVECTOR (collection
)->contents
[index
];
1357 else /* if (type == hash_table) */
1359 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1360 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1362 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1365 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1368 /* Is this element a possible completion? */
1370 if (SYMBOLP (eltstring
))
1371 eltstring
= Fsymbol_name (eltstring
);
1373 if (STRINGP (eltstring
)
1374 && SCHARS (string
) <= SCHARS (eltstring
)
1375 && (tem
= Fcompare_strings (eltstring
, zero
,
1376 make_number (SCHARS (string
)),
1378 completion_ignore_case
? Qt
: Qnil
),
1382 Lisp_Object regexps
;
1384 /* Ignore this element if it fails to match all the regexps. */
1386 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1387 regexps
= XCDR (regexps
))
1389 if (bindcount
< 0) {
1390 bindcount
= SPECPDL_INDEX ();
1391 specbind (Qcase_fold_search
,
1392 completion_ignore_case
? Qt
: Qnil
);
1394 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1398 if (CONSP (regexps
))
1402 /* Ignore this element if there is a predicate
1403 and the predicate doesn't like it. */
1405 if (!NILP (predicate
))
1407 if (EQ (predicate
, Qcommandp
))
1408 tem
= Fcommandp (elt
, Qnil
);
1413 unbind_to (bindcount
, Qnil
);
1416 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1417 tem
= (type
== hash_table
1418 ? call2 (predicate
, elt
,
1419 HASH_VALUE (XHASH_TABLE (collection
),
1421 : call1 (predicate
, elt
));
1424 if (NILP (tem
)) continue;
1427 /* Update computation of how much all possible completions match */
1429 if (NILP (bestmatch
))
1432 bestmatch
= eltstring
;
1433 bestmatchsize
= SCHARS (eltstring
);
1437 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1438 tem
= Fcompare_strings (bestmatch
, zero
,
1439 make_number (compare
),
1441 make_number (compare
),
1442 completion_ignore_case
? Qt
: Qnil
);
1444 matchsize
= compare
;
1445 else if (XINT (tem
) < 0)
1446 matchsize
= - XINT (tem
) - 1;
1448 matchsize
= XINT (tem
) - 1;
1451 /* When can this happen ? -stef */
1452 matchsize
= compare
;
1453 if (completion_ignore_case
)
1455 /* If this is an exact match except for case,
1456 use it as the best match rather than one that is not an
1457 exact match. This way, we get the case pattern
1458 of the actual match. */
1459 if ((matchsize
== SCHARS (eltstring
)
1460 && matchsize
< SCHARS (bestmatch
))
1462 /* If there is more than one exact match ignoring case,
1463 and one of them is exact including case,
1465 /* If there is no exact match ignoring case,
1466 prefer a match that does not change the case
1468 ((matchsize
== SCHARS (eltstring
))
1470 (matchsize
== SCHARS (bestmatch
))
1471 && (tem
= Fcompare_strings (eltstring
, zero
,
1472 make_number (SCHARS (string
)),
1477 && (tem
= Fcompare_strings (bestmatch
, zero
,
1478 make_number (SCHARS (string
)),
1483 bestmatch
= eltstring
;
1485 if (bestmatchsize
!= SCHARS (eltstring
)
1486 || bestmatchsize
!= matchsize
)
1487 /* Don't count the same string multiple times. */
1489 bestmatchsize
= matchsize
;
1490 if (matchsize
<= SCHARS (string
)
1491 /* If completion-ignore-case is non-nil, don't
1492 short-circuit because we want to find the best
1493 possible match *including* case differences. */
1494 && !completion_ignore_case
1496 /* No need to look any further. */
1502 if (bindcount
>= 0) {
1503 unbind_to (bindcount
, Qnil
);
1507 if (NILP (bestmatch
))
1508 return Qnil
; /* No completions found */
1509 /* If we are ignoring case, and there is no exact match,
1510 and no additional text was supplied,
1511 don't change the case of what the user typed. */
1512 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1513 && SCHARS (bestmatch
) > bestmatchsize
)
1514 return minibuf_conform_representation (string
, bestmatch
);
1516 /* Return t if the supplied string is an exact match (counting case);
1517 it does not require any change to be made. */
1518 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1519 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1520 make_number (bestmatchsize
),
1521 string
, make_number (0),
1522 make_number (bestmatchsize
),
1527 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1528 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1529 return Fsubstring (bestmatch
, zero
, end
);
1532 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1533 doc
: /* Search for partial matches to STRING in COLLECTION.
1534 Test each of the possible completions specified by COLLECTION
1535 to see if it begins with STRING. The possible completions may be
1536 strings or symbols. Symbols are converted to strings before testing,
1538 The value is a list of all the possible completions that match STRING.
1540 If COLLECTION is an alist, the keys (cars of elements) are the
1541 possible completions. If an element is not a cons cell, then the
1542 element itself is the possible completion.
1543 If COLLECTION is a hash-table, all the keys that are strings or symbols
1544 are the possible completions.
1545 If COLLECTION is an obarray, the names of all symbols in the obarray
1546 are the possible completions.
1548 COLLECTION can also be a function to do the completion itself.
1549 It receives three arguments: the values STRING, PREDICATE and t.
1550 Whatever it returns becomes the value of `all-completions'.
1552 If optional third argument PREDICATE is non-nil,
1553 it is used to test each possible match.
1554 The match is a candidate only if PREDICATE returns non-nil.
1555 The argument given to PREDICATE is the alist element
1556 or the symbol from the obarray. If COLLECTION is a hash-table,
1557 predicate is called with two arguments: the key and the value.
1558 Additionally to this predicate, `completion-regexp-list'
1559 is used to further constrain the set of candidates.
1561 If the optional fourth argument HIDE-SPACES is non-nil,
1562 strings in COLLECTION that start with a space
1563 are ignored unless STRING itself starts with a space. */)
1564 (string
, collection
, predicate
, hide_spaces
)
1565 Lisp_Object string
, collection
, predicate
, hide_spaces
;
1567 Lisp_Object tail
, elt
, eltstring
;
1568 Lisp_Object allmatches
;
1569 int type
= HASH_TABLE_P (collection
) ? 3
1570 : VECTORP (collection
) ? 2
1571 : NILP (collection
) || (CONSP (collection
)
1572 && (!SYMBOLP (XCAR (collection
))
1573 || NILP (XCAR (collection
))));
1574 int index
= 0, obsize
= 0;
1576 Lisp_Object bucket
, tem
, zero
;
1577 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1579 CHECK_STRING (string
);
1581 return call3 (collection
, string
, predicate
, Qt
);
1582 allmatches
= bucket
= Qnil
;
1583 zero
= make_number (0);
1585 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1589 obsize
= XVECTOR (collection
)->size
;
1590 bucket
= XVECTOR (collection
)->contents
[index
];
1595 /* Get the next element of the alist, obarray, or hash-table. */
1596 /* Exit the loop if the elements are all used up. */
1597 /* elt gets the alist element or symbol.
1598 eltstring gets the name to check as a completion. */
1605 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1610 if (!EQ (bucket
, zero
))
1614 if (XSYMBOL (bucket
)->next
)
1615 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1617 XSETFASTINT (bucket
, 0);
1619 else if (++index
>= obsize
)
1623 bucket
= XVECTOR (collection
)->contents
[index
];
1627 else /* if (type == 3) */
1629 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1630 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1632 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1635 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1638 /* Is this element a possible completion? */
1640 if (SYMBOLP (eltstring
))
1641 eltstring
= Fsymbol_name (eltstring
);
1643 if (STRINGP (eltstring
)
1644 && SCHARS (string
) <= SCHARS (eltstring
)
1645 /* If HIDE_SPACES, reject alternatives that start with space
1646 unless the input starts with space. */
1647 && ((SBYTES (string
) > 0
1648 && SREF (string
, 0) == ' ')
1649 || SREF (eltstring
, 0) != ' '
1650 || NILP (hide_spaces
))
1651 && (tem
= Fcompare_strings (eltstring
, zero
,
1652 make_number (SCHARS (string
)),
1654 make_number (SCHARS (string
)),
1655 completion_ignore_case
? Qt
: Qnil
),
1659 Lisp_Object regexps
;
1661 XSETFASTINT (zero
, 0);
1663 /* Ignore this element if it fails to match all the regexps. */
1665 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1666 regexps
= XCDR (regexps
))
1668 if (bindcount
< 0) {
1669 bindcount
= SPECPDL_INDEX ();
1670 specbind (Qcase_fold_search
,
1671 completion_ignore_case
? Qt
: Qnil
);
1673 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1677 if (CONSP (regexps
))
1681 /* Ignore this element if there is a predicate
1682 and the predicate doesn't like it. */
1684 if (!NILP (predicate
))
1686 if (EQ (predicate
, Qcommandp
))
1687 tem
= Fcommandp (elt
, Qnil
);
1690 if (bindcount
>= 0) {
1691 unbind_to (bindcount
, Qnil
);
1694 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1696 ? call2 (predicate
, elt
,
1697 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1698 : call1 (predicate
, elt
);
1701 if (NILP (tem
)) continue;
1703 /* Ok => put it on the list. */
1704 allmatches
= Fcons (eltstring
, allmatches
);
1708 if (bindcount
>= 0) {
1709 unbind_to (bindcount
, Qnil
);
1713 return Fnreverse (allmatches
);
1716 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1717 doc
: /* Read a string in the minibuffer, with completion.
1718 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1719 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1720 COLLECTION can also be a function to do the completion itself.
1721 PREDICATE limits completion to a subset of COLLECTION.
1722 See `try-completion' and `all-completions' for more details
1723 on completion, COLLECTION, and PREDICATE.
1725 REQUIRE-MATCH can take the following values:
1726 - t means that the user is not allowed to exit unless
1727 the input is (or completes to) an element of COLLECTION or is null.
1728 - nil means that the user can exit with any input.
1729 - `confirm-only' means that the user can exit with any input, but she will
1730 need to confirm her choice if the input is not an element of COLLECTION.
1731 - anything else behaves like t except that typing RET does not exit if it
1732 does non-null completion.
1734 If the input is null, `completing-read' returns DEF, or an empty string
1735 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1737 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1738 with point positioned at the end.
1739 If it is (STRING . POSITION), the initial input is STRING, but point
1740 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1741 that this is different from `read-from-minibuffer' and related
1742 functions, which use one-indexing for POSITION.) This feature is
1743 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1744 default value DEF instead. The user can yank the default value into
1745 the minibuffer easily using \\[next-history-element].
1747 HIST, if non-nil, specifies a history list and optionally the initial
1748 position in the list. It can be a symbol, which is the history list
1749 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1750 that case, HISTVAR is the history list variable to use, and HISTPOS
1751 is the initial position (the position in the list used by the
1752 minibuffer history commands). For consistency, you should also
1753 specify that element of the history as the value of
1754 INITIAL-INPUT. (This is the only case in which you should use
1755 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1756 1 at the beginning of the list. The variable `history-length'
1757 controls the maximum length of a history list.
1759 DEF, if non-nil, is the default value.
1761 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1762 the current input method and the setting of `enable-multibyte-characters'.
1764 Completion ignores case if the ambient value of
1765 `completion-ignore-case' is non-nil. */)
1766 (prompt
, collection
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1767 Lisp_Object prompt
, collection
, predicate
, require_match
, initial_input
;
1768 Lisp_Object hist
, def
, inherit_input_method
;
1770 Lisp_Object val
, histvar
, histpos
, position
;
1773 int count
= SPECPDL_INDEX ();
1774 struct gcpro gcpro1
;
1776 init
= initial_input
;
1779 specbind (Qminibuffer_completion_table
, collection
);
1780 specbind (Qminibuffer_completion_predicate
, predicate
);
1781 specbind (Qminibuffer_completion_confirm
,
1782 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1783 last_exact_completion
= Qnil
;
1790 position
= Fcdr (init
);
1793 CHECK_STRING (init
);
1794 if (!NILP (position
))
1796 CHECK_NUMBER (position
);
1797 /* Convert to distance from end of input. */
1798 pos
= XINT (position
) - SCHARS (init
);
1809 histvar
= Fcar_safe (hist
);
1810 histpos
= Fcdr_safe (hist
);
1813 histvar
= Qminibuffer_history
;
1815 XSETFASTINT (histpos
, 0);
1817 val
= read_minibuf (NILP (require_match
)
1818 ? (NILP (Vminibuffer_completing_file_name
)
1819 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1820 ? Vminibuffer_local_completion_map
1821 : Vminibuffer_local_filename_completion_map
)
1822 : (NILP (Vminibuffer_completing_file_name
)
1823 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1824 ? Vminibuffer_local_must_match_map
1825 : Vminibuffer_local_must_match_filename_map
),
1826 init
, prompt
, make_number (pos
), 0,
1827 histvar
, histpos
, def
, 0,
1828 !NILP (inherit_input_method
));
1830 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1833 RETURN_UNGCPRO (unbind_to (count
, val
));
1836 Lisp_Object
Fminibuffer_completion_help ();
1837 Lisp_Object
Fassoc_string ();
1839 /* Test whether TXT is an exact completion. */
1840 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1841 doc
: /* Return non-nil if STRING is a valid completion.
1842 Takes the same arguments as `all-completions' and `try-completion'.
1843 If COLLECTION is a function, it is called with three arguments:
1844 the values STRING, PREDICATE and `lambda'. */)
1845 (string
, collection
, predicate
)
1846 Lisp_Object string
, collection
, predicate
;
1848 Lisp_Object regexps
, tail
, tem
= Qnil
;
1851 CHECK_STRING (string
);
1853 if ((CONSP (collection
)
1854 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1855 || NILP (collection
))
1857 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1861 else if (VECTORP (collection
))
1863 /* Bypass intern-soft as that loses for nil. */
1864 tem
= oblookup (collection
,
1870 if (STRING_MULTIBYTE (string
))
1871 string
= Fstring_make_unibyte (string
);
1873 string
= Fstring_make_multibyte (string
);
1875 tem
= oblookup (collection
,
1881 if (completion_ignore_case
&& !SYMBOLP (tem
))
1883 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1885 tail
= XVECTOR (collection
)->contents
[i
];
1889 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1890 Fsymbol_name (tail
),
1891 make_number (0) , Qnil
, Qt
)),
1897 if (XSYMBOL (tail
)->next
== 0)
1899 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1907 else if (HASH_TABLE_P (collection
))
1909 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1910 i
= hash_lookup (h
, string
, NULL
);
1912 tem
= HASH_KEY (h
, i
);
1914 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1915 if (!NILP (HASH_HASH (h
, i
)) &&
1916 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1917 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1918 completion_ignore_case
? Qt
: Qnil
),
1921 tem
= HASH_KEY (h
, i
);
1928 return call3 (collection
, string
, predicate
, Qlambda
);
1930 /* Reject this element if it fails to match all the regexps. */
1931 if (CONSP (Vcompletion_regexp_list
))
1933 int count
= SPECPDL_INDEX ();
1934 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1935 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1936 regexps
= XCDR (regexps
))
1938 if (NILP (Fstring_match (XCAR (regexps
),
1939 SYMBOLP (tem
) ? string
: tem
,
1941 return unbind_to (count
, Qnil
);
1943 unbind_to (count
, Qnil
);
1946 /* Finally, check the predicate. */
1947 if (!NILP (predicate
))
1949 return HASH_TABLE_P (collection
)
1950 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1951 : call1 (predicate
, tem
);
1957 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1958 doc
: /* Perform completion on buffer names.
1959 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1960 `all-completions', otherwise invoke `test-completion'.
1962 The arguments STRING and PREDICATE are as in `try-completion',
1963 `all-completions', and `test-completion'. */)
1964 (string
, predicate
, flag
)
1965 Lisp_Object string
, predicate
, flag
;
1968 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1969 else if (EQ (flag
, Qt
))
1970 return Fall_completions (string
, Vbuffer_alist
, predicate
, Qt
);
1971 else /* assume `lambda' */
1972 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1976 * 0 no possible completion
1977 * 1 was already an exact and unique completion
1978 * 3 was already an exact completion
1979 * 4 completed to an exact completion
1980 * 5 some completion happened
1981 * 6 no completion happened
1986 Lisp_Object completion
, string
, tem
;
1989 struct gcpro gcpro1
, gcpro2
;
1991 completion
= Ftry_completion (Fminibuffer_completion_contents (),
1992 Vminibuffer_completion_table
,
1993 Vminibuffer_completion_predicate
);
1994 last
= last_exact_completion
;
1995 last_exact_completion
= Qnil
;
1997 GCPRO2 (completion
, last
);
1999 if (NILP (completion
))
2002 temp_echo_area_glyphs (build_string (" [No match]"));
2007 if (EQ (completion
, Qt
)) /* exact and unique match */
2013 string
= Fminibuffer_completion_contents ();
2015 /* COMPLETEDP should be true if some completion was done, which
2016 doesn't include simply changing the case of the entered string.
2017 However, for appearance, the string is rewritten if the case
2019 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
2020 completedp
= !EQ (tem
, Qt
);
2022 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
2024 /* Rewrite the user's input. */
2026 int prompt_end
= XINT (Fminibuffer_prompt_end ());
2027 /* Some completion happened */
2029 if (! NILP (Vminibuffer_completing_file_name
)
2030 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2032 && FETCH_CHAR (PT_BYTE
) == '/')
2034 del_range (prompt_end
, PT
+ 1);
2037 del_range (prompt_end
, PT
);
2039 Finsert (1, &completion
);
2042 /* The case of the string changed, but that's all. We're not
2043 sure whether this is a unique completion or not, so try again
2044 using the real case (this shouldn't recurse again, because
2045 the next time try-completion will return either `t' or the
2049 return do_completion ();
2053 /* It did find a match. Do we match some possibility exactly now? */
2054 tem
= Ftest_completion (Fminibuffer_contents (),
2055 Vminibuffer_completion_table
,
2056 Vminibuffer_completion_predicate
);
2059 /* not an exact match */
2063 else if (!NILP (Vcompletion_auto_help
))
2064 Fminibuffer_completion_help ();
2066 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
2069 else if (completedp
)
2074 /* If the last exact completion and this one were the same,
2075 it means we've already given a "Complete but not unique"
2076 message and the user's hit TAB again, so now we give him help. */
2077 last_exact_completion
= completion
;
2080 tem
= Fminibuffer_completion_contents ();
2081 if (!NILP (Fequal (tem
, last
)))
2082 Fminibuffer_completion_help ();
2088 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2090 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
2091 doc
: /* Like `assoc' but specifically for strings (and symbols).
2092 Symbols are converted to strings, and unibyte strings are converted to
2093 multibyte for comparison.
2094 Case is ignored if optional arg CASE-FOLD is non-nil.
2095 As opposed to `assoc', it will also match an entry consisting of a single
2096 string rather than a cons cell whose car is a string. */)
2097 (key
, list
, case_fold
)
2098 register Lisp_Object key
;
2099 Lisp_Object list
, case_fold
;
2101 register Lisp_Object tail
;
2104 key
= Fsymbol_name (key
);
2106 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2108 register Lisp_Object elt
, tem
, thiscar
;
2110 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2111 if (SYMBOLP (thiscar
))
2112 thiscar
= Fsymbol_name (thiscar
);
2113 else if (!STRINGP (thiscar
))
2115 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2116 key
, make_number (0), Qnil
,
2125 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2126 doc
: /* Complete the minibuffer contents as far as possible.
2127 Return nil if there is no valid completion, else t.
2128 If no characters can be completed, display a list of possible completions.
2129 If you repeat this command after it displayed such a list,
2130 scroll the window of possible completions. */)
2134 Lisp_Object window
, tem
;
2136 /* If the previous command was not this,
2137 mark the completion buffer obsolete. */
2138 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2139 Vminibuf_scroll_window
= Qnil
;
2141 window
= Vminibuf_scroll_window
;
2142 /* If there's a fresh completion window with a live buffer,
2143 and this command is repeated, scroll that window. */
2144 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2145 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2147 struct buffer
*obuf
= current_buffer
;
2149 Fset_buffer (XWINDOW (window
)->buffer
);
2150 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2152 /* If end is in view, scroll up to the beginning. */
2153 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2155 /* Else scroll down one screen. */
2156 Fscroll_other_window (Qnil
);
2158 set_buffer_internal (obuf
);
2162 i
= do_completion ();
2170 Fgoto_char (make_number (ZV
));
2171 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2176 Fgoto_char (make_number (ZV
));
2177 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2184 /* Subroutines of Fminibuffer_complete_and_exit. */
2186 /* This one is called by internal_condition_case to do the real work. */
2189 complete_and_exit_1 ()
2191 return make_number (do_completion ());
2194 /* This one is called by internal_condition_case if an error happens.
2195 Pretend the current value is an exact match. */
2198 complete_and_exit_2 (ignore
)
2201 return make_number (1);
2204 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2206 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2207 Sminibuffer_complete_and_exit
, 0, 0, "",
2208 doc
: /* If the minibuffer contents is a valid completion then exit.
2209 Otherwise try to complete it. If completion leads to a valid completion,
2210 a repetition of this command will exit. */)
2214 Lisp_Object val
, tem
;
2216 /* Allow user to specify null string */
2217 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2220 val
= Fminibuffer_contents ();
2221 tem
= Ftest_completion (val
,
2222 Vminibuffer_completion_table
,
2223 Vminibuffer_completion_predicate
);
2226 if (completion_ignore_case
)
2227 { /* Fixup case of the field, if necessary. */
2229 = Ftry_completion (val
,
2230 Vminibuffer_completion_table
,
2231 Vminibuffer_completion_predicate
);
2233 /* If it weren't for this piece of paranoia, I'd replace
2234 the whole thing with a call to do_completion. */
2235 && EQ (Flength (val
), Flength (compl)))
2237 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2238 Finsert (1, &compl);
2244 if (EQ (Vminibuffer_completion_confirm
, intern ("confirm-only")))
2245 { /* The user is permitted to exit with an input that's rejected
2246 by test-completion, but at the condition to confirm her choice. */
2247 if (EQ (current_kboard
->Vlast_command
, Vthis_command
))
2251 temp_echo_area_glyphs (build_string (" [Confirm]"));
2256 /* Call do_completion, but ignore errors. */
2258 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2259 complete_and_exit_2
);
2269 if (!NILP (Vminibuffer_completion_confirm
))
2271 temp_echo_area_glyphs (build_string (" [Confirm]"));
2281 return Fexit_minibuffer ();
2285 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2287 doc
: /* Complete the minibuffer contents at most a single word.
2288 After one word is completed as much as possible, a space or hyphen
2289 is added, provided that matches some possible completion.
2290 Return nil if there is no valid completion, else t. */)
2293 Lisp_Object completion
, tem
, tem1
;
2294 register int i
, i_byte
;
2295 struct gcpro gcpro1
, gcpro2
;
2296 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2298 /* We keep calling Fbuffer_string rather than arrange for GC to
2299 hold onto a pointer to one of the strings thus made. */
2301 completion
= Ftry_completion (Fminibuffer_completion_contents (),
2302 Vminibuffer_completion_table
,
2303 Vminibuffer_completion_predicate
);
2304 if (NILP (completion
))
2307 temp_echo_area_glyphs (build_string (" [No match]"));
2310 if (EQ (completion
, Qt
))
2313 #if 0 /* How the below code used to look, for reference. */
2314 tem
= Fminibuffer_contents ();
2316 i
= ZV
- 1 - SCHARS (completion
);
2317 p
= SDATA (completion
);
2319 0 <= scmp (b
, p
, ZV
- 1))
2322 /* Set buffer to longest match of buffer tail and completion head. */
2323 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2325 del_range (1, i
+ 1);
2328 #else /* Rewritten code */
2330 int buffer_nchars
, completion_nchars
;
2332 CHECK_STRING (completion
);
2333 tem
= Fminibuffer_completion_contents ();
2334 GCPRO2 (completion
, tem
);
2335 /* If reading a file name,
2336 expand any $ENVVAR refs in the buffer and in TEM. */
2337 if (! NILP (Vminibuffer_completing_file_name
))
2339 Lisp_Object substituted
;
2340 substituted
= Fsubstitute_in_file_name (tem
);
2341 if (! EQ (substituted
, tem
))
2344 del_range (prompt_end_charpos
, PT
);
2348 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2349 completion_nchars
= SCHARS (completion
);
2350 i
= buffer_nchars
- completion_nchars
;
2353 (tem1
= Fcompare_strings (tem
, make_number (0),
2354 make_number (buffer_nchars
),
2355 completion
, make_number (0),
2356 make_number (buffer_nchars
),
2357 completion_ignore_case
? Qt
: Qnil
),
2362 /* Make buffer (before point) contain the longest match
2363 of TEM's tail and COMPLETION's head. */
2369 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2370 completion
, make_number (0),
2371 make_number (buffer_nchars
),
2372 completion_ignore_case
? Qt
: Qnil
);
2379 del_range (start_pos
, start_pos
+ buffer_nchars
);
2383 #endif /* Rewritten code */
2386 int prompt_end_bytepos
;
2387 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2388 i
= PT
- prompt_end_charpos
;
2389 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2392 /* If completion finds next char not unique,
2393 consider adding a space or a hyphen. */
2394 if (i
== SCHARS (completion
))
2396 GCPRO1 (completion
);
2397 tem
= Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2398 build_string (" ")),
2399 Vminibuffer_completion_table
,
2400 Vminibuffer_completion_predicate
);
2407 GCPRO1 (completion
);
2409 Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2410 build_string ("-")),
2411 Vminibuffer_completion_table
,
2412 Vminibuffer_completion_predicate
);
2420 /* Now find first word-break in the stuff found by completion.
2421 i gets index in string of where to stop completing. */
2422 while (i_byte
< SBYTES (completion
))
2426 FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c
, completion
, i
, i_byte
);
2427 if (SYNTAX (c
) != Sword
)
2431 /* If got no characters, print help for user. */
2433 if (i
== PT
- prompt_end_charpos
)
2435 if (!NILP (Vcompletion_auto_help
))
2436 Fminibuffer_completion_help ();
2440 /* Otherwise insert in minibuffer the chars we got */
2442 if (! NILP (Vminibuffer_completing_file_name
)
2443 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2445 && FETCH_CHAR (PT_BYTE
) == '/')
2447 del_range (prompt_end_charpos
, PT
+ 1);
2450 del_range (prompt_end_charpos
, PT
);
2452 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2456 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2458 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2459 Each element may be just a symbol or string
2460 or may be a list of two strings to be printed as if concatenated.
2461 If it is a list of two strings, the first is the actual completion
2462 alternative, the second serves as annotation.
2463 `standard-output' must be a buffer.
2464 The actual completion alternatives, as inserted, are given `mouse-face'
2465 properties of `highlight'.
2466 At the end, this runs the normal hook `completion-setup-hook'.
2467 It can find the completion buffer in `standard-output'.
2468 The optional second arg COMMON-SUBSTRING is a string.
2469 It is used to put faces, `completions-first-difference' and
2470 `completions-common-part' on the completion buffer. The
2471 `completions-common-part' face is put on the common substring
2472 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
2473 and the current buffer is not the minibuffer, the faces are not put.
2474 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2475 during running `completion-setup-hook'. */)
2476 (completions
, common_substring
)
2477 Lisp_Object completions
;
2478 Lisp_Object common_substring
;
2480 Lisp_Object tail
, elt
;
2483 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2484 struct buffer
*old
= current_buffer
;
2487 /* Note that (when it matters) every variable
2488 points to a non-string that is pointed to by COMPLETIONS,
2489 except for ELT. ELT can be pointing to a string
2490 when terpri or Findent_to calls a change hook. */
2492 GCPRO3 (completions
, elt
, common_substring
);
2494 if (BUFFERP (Vstandard_output
))
2495 set_buffer_internal (XBUFFER (Vstandard_output
));
2497 if (NILP (completions
))
2498 write_string ("There are no possible completions of what you have typed.",
2502 write_string ("Possible completions are:", -1);
2503 for (tail
= completions
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2505 Lisp_Object tem
, string
;
2507 Lisp_Object startpos
, endpos
;
2513 elt
= SYMBOL_NAME (elt
);
2514 /* Compute the length of this element. */
2519 length
= SCHARS (tem
);
2521 tem
= Fcar (XCDR (elt
));
2523 length
+= SCHARS (tem
);
2528 length
= SCHARS (elt
);
2531 /* This does a bad job for narrower than usual windows.
2532 Sadly, the window it will appear in is not known
2533 until after the text has been made. */
2535 if (BUFFERP (Vstandard_output
))
2536 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2538 /* If the previous completion was very wide,
2539 or we have two on this line already,
2540 don't put another on the same line. */
2541 if (column
> 33 || first
2542 /* If this is really wide, don't put it second on a line. */
2543 || (column
> 0 && length
> 45))
2548 /* Otherwise advance to column 35. */
2551 if (BUFFERP (Vstandard_output
))
2553 tem
= Findent_to (make_number (35), make_number (2));
2555 column
= XINT (tem
);
2561 write_string (" ", -1);
2564 while (column
< 35);
2568 if (BUFFERP (Vstandard_output
))
2570 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2571 Fset_text_properties (startpos
, endpos
,
2572 Qnil
, Vstandard_output
);
2575 /* Output this element.
2576 If necessary, convert it to unibyte or to multibyte first. */
2578 string
= Fcar (elt
);
2581 if (NILP (current_buffer
->enable_multibyte_characters
)
2582 && STRING_MULTIBYTE (string
))
2583 string
= Fstring_make_unibyte (string
);
2584 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2585 && !STRING_MULTIBYTE (string
))
2586 string
= Fstring_make_multibyte (string
);
2588 if (BUFFERP (Vstandard_output
))
2590 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2592 Fprinc (string
, Qnil
);
2594 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2596 Fput_text_property (startpos
, endpos
,
2597 Qmouse_face
, intern ("highlight"),
2602 Fprinc (string
, Qnil
);
2605 /* Output the annotation for this element. */
2608 if (BUFFERP (Vstandard_output
))
2610 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2612 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2614 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2616 Fset_text_properties (startpos
, endpos
, Qnil
,
2621 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2626 /* Update COLUMN for what we have output. */
2629 /* If output is to a buffer, recompute COLUMN in a way
2630 that takes account of character widths. */
2631 if (BUFFERP (Vstandard_output
))
2633 tem
= Fcurrent_column ();
2634 column
= XINT (tem
);
2641 if (BUFFERP (Vstandard_output
))
2642 set_buffer_internal (old
);
2644 if (!NILP (Vrun_hooks
))
2646 int count1
= SPECPDL_INDEX ();
2648 specbind (intern ("completion-common-substring"), common_substring
);
2649 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2651 unbind_to (count1
, Qnil
);
2661 display_completion_list_1 (list
)
2664 return Fdisplay_completion_list (list
, Qnil
);
2667 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2669 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2672 Lisp_Object completions
;
2674 message ("Making completion list...");
2675 completions
= Fall_completions (Fminibuffer_completion_contents (),
2676 Vminibuffer_completion_table
,
2677 Vminibuffer_completion_predicate
,
2679 clear_message (1, 0);
2681 if (NILP (completions
))
2684 temp_echo_area_glyphs (build_string (" [No completions]"));
2688 /* Sort and remove duplicates. */
2689 Lisp_Object tmp
= completions
= Fsort (completions
, Qstring_lessp
);
2692 if (CONSP (XCDR (tmp
))
2693 && !NILP (Fequal (XCAR (tmp
), XCAR (XCDR (tmp
)))))
2694 XSETCDR (tmp
, XCDR (XCDR (tmp
)));
2698 internal_with_output_to_temp_buffer ("*Completions*",
2699 display_completion_list_1
,
2705 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2706 doc
: /* Terminate minibuffer input. */)
2709 if (CHARACTERP (last_command_char
))
2710 internal_self_insert (XINT (last_command_char
), 0);
2714 return Fexit_minibuffer ();
2717 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2718 doc
: /* Terminate this minibuffer argument. */)
2721 /* If the command that uses this has made modifications in the minibuffer,
2722 we don't want them to cause deactivation of the mark in the original
2724 A better solution would be to make deactivate-mark buffer-local
2725 (or to turn it into a list of buffers, ...), but in the mean time,
2726 this should do the trick in most cases. */
2727 Vdeactivate_mark
= Qnil
;
2728 Fthrow (Qexit
, Qnil
);
2731 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2732 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2735 return make_number (minibuf_level
);
2738 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2739 doc
: /* Return the prompt string of the currently-active minibuffer.
2740 If no minibuffer is active, return nil. */)
2743 return Fcopy_sequence (minibuf_prompt
);
2747 /* Temporarily display STRING at the end of the current
2748 minibuffer contents. This is used to display things like
2749 "[No Match]" when the user requests a completion for a prefix
2750 that has no possible completions, and other quick, unobtrusive
2753 extern Lisp_Object Vminibuffer_message_timeout
;
2756 temp_echo_area_glyphs (string
)
2760 int osize_byte
= ZV_BYTE
;
2762 int opoint_byte
= PT_BYTE
;
2763 Lisp_Object oinhibit
;
2764 oinhibit
= Vinhibit_quit
;
2766 /* Clear out any old echo-area message to make way for our new thing. */
2769 SET_PT_BOTH (osize
, osize_byte
);
2770 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2771 SET_PT_BOTH (opoint
, opoint_byte
);
2774 if (NUMBERP (Vminibuffer_message_timeout
))
2775 sit_for (Vminibuffer_message_timeout
, 0, 2);
2779 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2780 SET_PT_BOTH (opoint
, opoint_byte
);
2781 if (!NILP (Vquit_flag
))
2784 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2786 Vinhibit_quit
= oinhibit
;
2789 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2791 doc
: /* Temporarily display STRING at the end of the minibuffer.
2792 The text is displayed for a period controlled by `minibuffer-message-timeout',
2793 or until the next input event arrives, whichever comes first. */)
2797 CHECK_STRING (string
);
2798 temp_echo_area_glyphs (string
);
2803 init_minibuf_once ()
2805 Vminibuffer_list
= Qnil
;
2806 staticpro (&Vminibuffer_list
);
2813 minibuf_prompt
= Qnil
;
2814 staticpro (&minibuf_prompt
);
2816 minibuf_save_list
= Qnil
;
2817 staticpro (&minibuf_save_list
);
2819 Qread_file_name_internal
= intern ("read-file-name-internal");
2820 staticpro (&Qread_file_name_internal
);
2822 Qminibuffer_default
= intern ("minibuffer-default");
2823 staticpro (&Qminibuffer_default
);
2824 Fset (Qminibuffer_default
, Qnil
);
2826 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2827 staticpro (&Qminibuffer_completion_table
);
2829 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2830 staticpro (&Qminibuffer_completion_confirm
);
2832 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2833 staticpro (&Qminibuffer_completion_predicate
);
2835 staticpro (&last_exact_completion
);
2836 last_exact_completion
= Qnil
;
2838 staticpro (&last_minibuf_string
);
2839 last_minibuf_string
= Qnil
;
2841 Quser_variable_p
= intern ("user-variable-p");
2842 staticpro (&Quser_variable_p
);
2844 Qminibuffer_history
= intern ("minibuffer-history");
2845 staticpro (&Qminibuffer_history
);
2847 Qbuffer_name_history
= intern ("buffer-name-history");
2848 staticpro (&Qbuffer_name_history
);
2849 Fset (Qbuffer_name_history
, Qnil
);
2851 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2852 staticpro (&Qminibuffer_setup_hook
);
2854 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2855 staticpro (&Qminibuffer_exit_hook
);
2857 Qhistory_length
= intern ("history-length");
2858 staticpro (&Qhistory_length
);
2860 Qcurrent_input_method
= intern ("current-input-method");
2861 staticpro (&Qcurrent_input_method
);
2863 Qactivate_input_method
= intern ("activate-input-method");
2864 staticpro (&Qactivate_input_method
);
2866 Qcase_fold_search
= intern ("case-fold-search");
2867 staticpro (&Qcase_fold_search
);
2869 Qread_expression_history
= intern ("read-expression-history");
2870 staticpro (&Qread_expression_history
);
2872 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2873 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2874 Vread_buffer_function
= Qnil
;
2876 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2877 doc
: /* Normal hook run just after entry to minibuffer. */);
2878 Vminibuffer_setup_hook
= Qnil
;
2880 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2881 doc
: /* Normal hook run just after exit from minibuffer. */);
2882 Vminibuffer_exit_hook
= Qnil
;
2884 DEFVAR_LISP ("history-length", &Vhistory_length
,
2885 doc
: /* *Maximum length for history lists before truncation takes place.
2886 A number means that length; t means infinite. Truncation takes place
2887 just after a new element is inserted. Setting the `history-length'
2888 property of a history variable overrides this default. */);
2889 XSETFASTINT (Vhistory_length
, 30);
2891 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2892 doc
: /* *Non-nil means to delete duplicates in history.
2893 If set to t when adding a new history element, all previous identical
2894 elements are deleted from the history list. */);
2895 history_delete_duplicates
= 0;
2897 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2898 doc
: /* *Non-nil means to add new elements in history.
2899 If set to nil, minibuffer reading functions don't add new elements to the
2900 history list, so it is possible to do this afterwards by calling
2901 `add-to-history' explicitly. */);
2902 Vhistory_add_new_input
= Qt
;
2904 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2905 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2906 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2907 see the doc string of `partial-completion-mode' for more details. */);
2908 Vcompletion_auto_help
= Qt
;
2910 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2911 doc
: /* Non-nil means don't consider case significant in completion.
2913 For file-name completion, the variable `read-file-name-completion-ignore-case'
2914 controls the behavior, rather than this variable. */);
2915 completion_ignore_case
= 0;
2917 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2918 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2919 This variable makes a difference whenever the minibuffer window is active. */);
2920 enable_recursive_minibuffers
= 0;
2922 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2923 doc
: /* Alist or obarray used for completion in the minibuffer.
2924 This becomes the ALIST argument to `try-completion' and `all-completions'.
2925 The value can also be a list of strings or a hash table.
2927 The value may alternatively be a function, which is given three arguments:
2928 STRING, the current buffer contents;
2929 PREDICATE, the predicate for filtering possible matches;
2930 CODE, which says what kind of things to do.
2931 CODE can be nil, t or `lambda':
2932 nil -- return the best completion of STRING, or nil if there is none.
2933 t -- return a list of all possible completions of STRING.
2934 lambda -- return t if STRING is a valid completion as it stands. */);
2935 Vminibuffer_completion_table
= Qnil
;
2937 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2938 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2939 Vminibuffer_completion_predicate
= Qnil
;
2941 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2942 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2943 Vminibuffer_completion_confirm
= Qnil
;
2945 DEFVAR_LISP ("minibuffer-completing-file-name",
2946 &Vminibuffer_completing_file_name
,
2947 doc
: /* Non-nil and non-`lambda' means completing file names. */);
2948 Vminibuffer_completing_file_name
= Qnil
;
2950 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2951 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2952 Vminibuffer_help_form
= Qnil
;
2954 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2955 doc
: /* History list symbol to add minibuffer values to.
2956 Each string of minibuffer input, as it appears on exit from the minibuffer,
2958 (set minibuffer-history-variable
2959 (cons STRING (symbol-value minibuffer-history-variable))) */);
2960 XSETFASTINT (Vminibuffer_history_variable
, 0);
2962 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2963 doc
: /* Current position of redoing in the history list. */);
2964 Vminibuffer_history_position
= Qnil
;
2966 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2967 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2968 Some uses of the echo area also raise that frame (since they use it too). */);
2969 minibuffer_auto_raise
= 0;
2971 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2972 doc
: /* List of regexps that should restrict possible completions.
2973 The basic completion functions only consider a completion acceptable
2974 if it matches all regular expressions in this list, with
2975 `case-fold-search' bound to the value of `completion-ignore-case'.
2976 See Info node `(elisp)Basic Completion', for a description of these
2978 Vcompletion_regexp_list
= Qnil
;
2980 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2981 &minibuffer_allow_text_properties
,
2982 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2983 This also affects `read-string', but it does not affect `read-minibuffer',
2984 `read-no-blanks-input', or any of the functions that do minibuffer input
2985 with completion; they always discard text properties. */);
2986 minibuffer_allow_text_properties
= 0;
2988 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2989 doc
: /* Text properties that are added to minibuffer prompts.
2990 These are in addition to the basic `field' property, and stickiness
2992 /* We use `intern' here instead of Qread_only to avoid
2993 initialization-order problems. */
2994 Vminibuffer_prompt_properties
2995 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2997 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
2998 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2999 Vread_expression_map
= Qnil
;
3001 defsubr (&Sset_minibuffer_window
);
3002 defsubr (&Sread_from_minibuffer
);
3003 defsubr (&Seval_minibuffer
);
3004 defsubr (&Sread_minibuffer
);
3005 defsubr (&Sread_string
);
3006 defsubr (&Sread_command
);
3007 defsubr (&Sread_variable
);
3008 defsubr (&Sinternal_complete_buffer
);
3009 defsubr (&Sread_buffer
);
3010 defsubr (&Sread_no_blanks_input
);
3011 defsubr (&Sminibuffer_depth
);
3012 defsubr (&Sminibuffer_prompt
);
3014 defsubr (&Sminibufferp
);
3015 defsubr (&Sminibuffer_prompt_end
);
3016 defsubr (&Sminibuffer_contents
);
3017 defsubr (&Sminibuffer_contents_no_properties
);
3018 defsubr (&Sminibuffer_completion_contents
);
3019 defsubr (&Sdelete_minibuffer_contents
);
3021 defsubr (&Stry_completion
);
3022 defsubr (&Sall_completions
);
3023 defsubr (&Stest_completion
);
3024 defsubr (&Sassoc_string
);
3025 defsubr (&Scompleting_read
);
3026 defsubr (&Sminibuffer_complete
);
3027 defsubr (&Sminibuffer_complete_word
);
3028 defsubr (&Sminibuffer_complete_and_exit
);
3029 defsubr (&Sdisplay_completion_list
);
3030 defsubr (&Sminibuffer_completion_help
);
3032 defsubr (&Sself_insert_and_exit
);
3033 defsubr (&Sexit_minibuffer
);
3035 defsubr (&Sminibuffer_message
);
3041 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
3042 "abort-recursive-edit");
3043 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
3045 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
3048 initial_define_key (Vminibuffer_local_ns_map
, ' ',
3050 initial_define_key (Vminibuffer_local_ns_map
, '\t',
3052 initial_define_key (Vminibuffer_local_ns_map
, '?',
3053 "self-insert-and-exit");
3055 initial_define_key (Vminibuffer_local_completion_map
, '\t',
3056 "minibuffer-complete");
3057 initial_define_key (Vminibuffer_local_completion_map
, ' ',
3058 "minibuffer-complete-word");
3059 initial_define_key (Vminibuffer_local_completion_map
, '?',
3060 "minibuffer-completion-help");
3062 Fdefine_key (Vminibuffer_local_filename_completion_map
,
3063 build_string (" "), Qnil
);
3065 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
3066 "minibuffer-complete-and-exit");
3067 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
3068 "minibuffer-complete-and-exit");
3070 Fdefine_key (Vminibuffer_local_must_match_filename_map
,
3071 build_string (" "), Qnil
);
3074 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
3075 (do not change this comment) */