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 2, 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. */
31 #include "dispextern.h"
36 #include "intervals.h"
38 #include "termhooks.h"
42 /* List of buffers for use as minibuffers.
43 The first element of the list is used for the outermost minibuffer
44 invocation, the next element is used for a recursive minibuffer
45 invocation, etc. The list is extended at the end as deeper
46 minibuffer recursions are encountered. */
48 Lisp_Object Vminibuffer_list
;
50 /* Data to remember during recursive minibuffer invocations */
52 Lisp_Object minibuf_save_list
;
54 /* Depth in minibuffer invocations. */
58 /* Nonzero means display completion help for invalid input. */
60 Lisp_Object Vcompletion_auto_help
;
62 /* The maximum length of a minibuffer history. */
64 Lisp_Object Qhistory_length
, Vhistory_length
;
66 /* No duplicates in history. */
68 int history_delete_duplicates
;
70 /* Non-nil means add new input to history. */
72 Lisp_Object Vhistory_add_new_input
;
74 /* Fread_minibuffer leaves the input here as a string. */
76 Lisp_Object last_minibuf_string
;
78 /* Nonzero means let functions called when within a minibuffer
79 invoke recursive minibuffers (to read arguments, or whatever) */
81 int enable_recursive_minibuffers
;
83 /* Nonzero means don't ignore text properties
84 in Fread_from_minibuffer. */
86 int minibuffer_allow_text_properties
;
88 /* help-form is bound to this while in the minibuffer. */
90 Lisp_Object Vminibuffer_help_form
;
92 /* Variable which is the history list to add minibuffer values to. */
94 Lisp_Object Vminibuffer_history_variable
;
96 /* Current position in the history list (adjusted by M-n and M-p). */
98 Lisp_Object Vminibuffer_history_position
;
100 /* Text properties that are added to minibuffer prompts.
101 These are in addition to the basic `field' property, and stickiness
104 Lisp_Object Vminibuffer_prompt_properties
;
106 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
108 Lisp_Object Qread_file_name_internal
;
110 /* Normal hooks for entry to and exit from minibuffer. */
112 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
113 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
115 /* Function to call to read a buffer name. */
116 Lisp_Object Vread_buffer_function
;
118 /* Nonzero means completion ignores case. */
120 int completion_ignore_case
;
122 /* List of regexps that should restrict possible completions. */
124 Lisp_Object Vcompletion_regexp_list
;
126 /* Nonzero means raise the minibuffer frame when the minibuffer
129 int minibuffer_auto_raise
;
131 /* If last completion attempt reported "Complete but not unique"
132 then this is the string completed then; otherwise this is nil. */
134 static Lisp_Object last_exact_completion
;
136 /* Keymap for reading expressions. */
137 Lisp_Object Vread_expression_map
;
139 Lisp_Object Quser_variable_p
;
141 Lisp_Object Qminibuffer_default
;
143 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
145 Lisp_Object Qcase_fold_search
;
147 Lisp_Object Qread_expression_history
;
149 extern Lisp_Object Voverriding_local_map
;
151 extern Lisp_Object Qmouse_face
;
153 extern Lisp_Object Qfield
;
155 /* Put minibuf on currently selected frame's minibuffer.
156 We do this whenever the user starts a new minibuffer
157 or when a minibuffer exits. */
160 choose_minibuf_frame ()
162 if (FRAMEP (selected_frame
)
163 && FRAME_LIVE_P (XFRAME (selected_frame
))
164 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
166 struct frame
*sf
= XFRAME (selected_frame
);
169 /* I don't think that any frames may validly have a null minibuffer
171 if (NILP (sf
->minibuffer_window
))
174 /* Under X, we come here with minibuf_window being the
175 minibuffer window of the unused termcap window created in
176 init_window_once. That window doesn't have a buffer. */
177 buffer
= XWINDOW (minibuf_window
)->buffer
;
178 if (BUFFERP (buffer
))
179 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
180 minibuf_window
= sf
->minibuffer_window
;
183 /* Make sure no other frame has a minibuffer as its selected window,
184 because the text would not be displayed in it, and that would be
185 confusing. Only allow the selected frame to do this,
186 and that only if the minibuffer is active. */
188 Lisp_Object tail
, frame
;
190 FOR_EACH_FRAME (tail
, frame
)
191 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
192 && !(EQ (frame
, selected_frame
)
193 && minibuf_level
> 0))
194 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
199 choose_minibuf_frame_1 (ignore
)
202 choose_minibuf_frame ();
206 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
207 Sset_minibuffer_window
, 1, 1, 0,
208 doc
: /* Specify which minibuffer window to use for the minibuffer.
209 This affects where the minibuffer is displayed if you put text in it
210 without invoking the usual minibuffer commands. */)
214 CHECK_WINDOW (window
);
215 if (! MINI_WINDOW_P (XWINDOW (window
)))
216 error ("Window is not a minibuffer window");
218 minibuf_window
= window
;
224 /* Actual minibuffer invocation. */
226 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
227 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
228 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
229 Lisp_Object
, Lisp_Object
,
231 Lisp_Object
, Lisp_Object
,
233 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
234 Lisp_Object
, Lisp_Object
,
236 Lisp_Object
, Lisp_Object
,
238 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
241 /* Read a Lisp object from VAL and return it. If VAL is an empty
242 string, and DEFALT is a string, read from DEFALT instead of VAL. */
245 string_to_object (val
, defalt
)
246 Lisp_Object val
, defalt
;
248 struct gcpro gcpro1
, gcpro2
;
249 Lisp_Object expr_and_pos
;
252 GCPRO2 (val
, defalt
);
254 if (STRINGP (val
) && SCHARS (val
) == 0
258 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
259 pos
= XINT (Fcdr (expr_and_pos
));
260 if (pos
!= SCHARS (val
))
262 /* Ignore trailing whitespace; any other trailing junk
265 pos
= string_char_to_byte (val
, pos
);
266 for (i
= pos
; i
< SBYTES (val
); i
++)
268 int c
= SREF (val
, i
);
269 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
270 error ("Trailing garbage following expression");
274 val
= Fcar (expr_and_pos
);
275 RETURN_UNGCPRO (val
);
279 /* Like read_minibuf but reading from stdin. This function is called
280 from read_minibuf to do the job if noninteractive. */
283 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
284 histvar
, histpos
, defalt
, allow_props
,
285 inherit_input_method
)
289 Lisp_Object backup_n
;
295 int inherit_input_method
;
301 fprintf (stdout
, "%s", SDATA (prompt
));
307 line
= (char *) xmalloc (size
* sizeof *line
);
308 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
309 && (len
= strlen (line
),
310 len
== size
- 1 && line
[len
- 1] != '\n'))
313 line
= (char *) xrealloc (line
, size
);
320 if (len
> 0 && line
[len
- 1] == '\n')
323 val
= build_string (line
);
329 error ("Error reading from stdin");
332 /* If Lisp form desired instead of string, parse it. */
334 val
= string_to_object (val
, defalt
);
339 DEFUN ("minibufferp", Fminibufferp
,
340 Sminibufferp
, 0, 1, 0,
341 doc
: /* Return t if BUFFER is a minibuffer.
342 No argument or nil as argument means use current buffer as BUFFER.
343 BUFFER can be a buffer or a buffer name. */)
350 buffer
= Fcurrent_buffer ();
351 else if (STRINGP (buffer
))
352 buffer
= Fget_buffer (buffer
);
354 CHECK_BUFFER (buffer
);
356 tem
= Fmemq (buffer
, Vminibuffer_list
);
357 return ! NILP (tem
) ? Qt
: Qnil
;
360 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
361 Sminibuffer_prompt_end
, 0, 0, 0,
362 doc
: /* Return the buffer position of the end of the minibuffer prompt.
363 Return (point-min) if current buffer is not a minibuffer. */)
366 /* This function is written to be most efficient when there's a prompt. */
367 Lisp_Object beg
, end
, tem
;
368 beg
= make_number (BEGV
);
370 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
374 end
= Ffield_end (beg
, Qnil
, Qnil
);
376 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
382 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
383 Sminibuffer_contents
, 0, 0, 0,
384 doc
: /* Return the user input in a minibuffer as a string.
385 The current buffer must be a minibuffer. */)
388 int prompt_end
= XINT (Fminibuffer_prompt_end ());
389 return make_buffer_string (prompt_end
, ZV
, 1);
392 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
393 Sminibuffer_contents_no_properties
, 0, 0, 0,
394 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
395 The current buffer must be a minibuffer. */)
398 int prompt_end
= XINT (Fminibuffer_prompt_end ());
399 return make_buffer_string (prompt_end
, ZV
, 0);
402 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
403 Sminibuffer_completion_contents
, 0, 0, 0,
404 doc
: /* Return the user input in a minibuffer before point as a string.
405 That is what completion commands operate on.
406 The current buffer must be a minibuffer. */)
409 int prompt_end
= XINT (Fminibuffer_prompt_end ());
411 error ("Cannot do completion in the prompt");
412 return make_buffer_string (prompt_end
, PT
, 1);
415 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
416 Sdelete_minibuffer_contents
, 0, 0, 0,
417 doc
: /* Delete all user input in a minibuffer.
418 The current buffer must be a minibuffer. */)
421 int prompt_end
= XINT (Fminibuffer_prompt_end ());
423 del_range (prompt_end
, ZV
);
428 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
429 putting point minus BACKUP_N bytes from the end of INITIAL,
430 prompting with PROMPT (a string), using history list HISTVAR
431 with initial position HISTPOS. INITIAL should be a string or a
432 cons of a string and an integer. BACKUP_N should be <= 0, or
433 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
434 ignored and replaced with an integer that puts point at one-indexed
435 position N in INITIAL, where N is the CDR of INITIAL, or at the
436 beginning of INITIAL if N <= 0.
438 Normally return the result as a string (the text that was read),
439 but if EXPFLAG is nonzero, read it and return the object read.
440 If HISTVAR is given, save the value read on that history only if it doesn't
441 match the front of that history list exactly. The value is pushed onto
442 the list as the string that was read.
444 DEFALT specifies the default value for the sake of history commands.
446 If ALLOW_PROPS is nonzero, we do not throw away text properties.
448 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
449 current input method. */
452 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
453 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
457 Lisp_Object backup_n
;
463 int inherit_input_method
;
466 int count
= SPECPDL_INDEX ();
467 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
468 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
469 Lisp_Object enable_multibyte
;
470 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
472 /* String to add to the history. */
473 Lisp_Object histstring
;
475 Lisp_Object empty_minibuf
;
476 Lisp_Object dummy
, frame
;
478 extern Lisp_Object Qfront_sticky
;
479 extern Lisp_Object Qrear_nonsticky
;
481 specbind (Qminibuffer_default
, defalt
);
483 #ifdef HAVE_X_WINDOWS
484 if (display_hourglass_p
)
492 backup_n
= Fcdr (initial
);
493 initial
= Fcar (initial
);
494 CHECK_STRING (initial
);
495 if (!NILP (backup_n
))
497 CHECK_NUMBER (backup_n
);
498 /* Convert to distance from end of input. */
499 if (XINT (backup_n
) < 1)
500 /* A number too small means the beginning of the string. */
501 pos
= - SCHARS (initial
);
503 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
507 CHECK_STRING (initial
);
510 ambient_dir
= current_buffer
->directory
;
512 enable_multibyte
= Qnil
;
514 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
515 store them away before we can GC. Don't need to protect
516 BACKUP_N because we use the value only if it is an integer. */
517 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
519 if (!STRINGP (prompt
))
520 prompt
= empty_string
;
522 if (!enable_recursive_minibuffers
523 && minibuf_level
> 0)
525 if (EQ (selected_window
, minibuf_window
))
526 error ("Command attempted to use minibuffer while in minibuffer");
528 /* If we're in another window, cancel the minibuffer that's active. */
530 build_string ("Command attempted to use minibuffer while in minibuffer"));
533 if (noninteractive
&& NILP (Vexecuting_kbd_macro
))
535 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
537 expflag
, histvar
, histpos
, defalt
,
538 allow_props
, inherit_input_method
);
540 return unbind_to (count
, val
);
543 /* Choose the minibuffer window and frame, and take action on them. */
545 choose_minibuf_frame ();
547 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
549 record_unwind_protect (Fset_window_configuration
,
550 Fcurrent_window_configuration (Qnil
));
552 /* If the minibuffer window is on a different frame, save that
553 frame's configuration too. */
554 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
555 if (!EQ (mini_frame
, selected_frame
))
556 record_unwind_protect (Fset_window_configuration
,
557 Fcurrent_window_configuration (mini_frame
));
559 /* If the minibuffer is on an iconified or invisible frame,
560 make it visible now. */
561 Fmake_frame_visible (mini_frame
);
563 if (minibuffer_auto_raise
)
564 Fraise_frame (mini_frame
);
566 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
568 /* We have to do this after saving the window configuration
569 since that is what restores the current buffer. */
571 /* Arrange to restore a number of minibuffer-related variables.
572 We could bind each variable separately, but that would use lots of
575 = Fcons (Voverriding_local_map
,
576 Fcons (minibuf_window
, minibuf_save_list
));
578 = Fcons (minibuf_prompt
,
579 Fcons (make_number (minibuf_prompt_width
),
581 Fcons (Vcurrent_prefix_arg
,
582 Fcons (Vminibuffer_history_position
,
583 Fcons (Vminibuffer_history_variable
,
584 minibuf_save_list
))))));
586 record_unwind_protect (read_minibuf_unwind
, Qnil
);
588 /* We are exiting the minibuffer one way or the other, so run the hook.
589 It should be run before unwinding the minibuf settings. Do it
590 separately from read_minibuf_unwind because we need to make sure that
591 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
592 signals an error. --Stef */
593 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
595 /* Now that we can restore all those variables, start changing them. */
597 minibuf_prompt_width
= 0;
598 minibuf_prompt
= Fcopy_sequence (prompt
);
599 Vminibuffer_history_position
= histpos
;
600 Vminibuffer_history_variable
= histvar
;
601 Vhelp_form
= Vminibuffer_help_form
;
603 if (inherit_input_method
)
605 /* `current-input-method' is buffer local. So, remember it in
606 INPUT_METHOD before changing the current buffer. */
607 input_method
= Fsymbol_value (Qcurrent_input_method
);
608 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
611 /* Switch to the minibuffer. */
613 minibuffer
= get_minibuffer (minibuf_level
);
614 Fset_buffer (minibuffer
);
616 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
617 if (inherit_input_method
)
618 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
620 /* The current buffer's default directory is usually the right thing
621 for our minibuffer here. However, if you're typing a command at
622 a minibuffer-only frame when minibuf_level is zero, then buf IS
623 the current_buffer, so reset_buffer leaves buf's default
624 directory unchanged. This is a bummer when you've just started
625 up Emacs and buf's default directory is Qnil. Here's a hack; can
626 you think of something better to do? Find another buffer with a
627 better directory, and use that one instead. */
628 if (STRINGP (ambient_dir
))
629 current_buffer
->directory
= ambient_dir
;
632 Lisp_Object buf_list
;
634 for (buf_list
= Vbuffer_alist
;
636 buf_list
= XCDR (buf_list
))
638 Lisp_Object other_buf
;
640 other_buf
= XCDR (XCAR (buf_list
));
641 if (STRINGP (XBUFFER (other_buf
)->directory
))
643 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
649 if (!EQ (mini_frame
, selected_frame
))
650 Fredirect_frame_focus (selected_frame
, mini_frame
);
652 Vminibuf_scroll_window
= selected_window
;
653 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
654 minibuf_selected_window
= selected_window
;
656 /* Empty out the minibuffers of all frames other than the one
657 where we are going to display one now.
658 Set them to point to ` *Minibuf-0*', which is always empty. */
659 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
661 FOR_EACH_FRAME (dummy
, frame
)
663 Lisp_Object root_window
= Fframe_root_window (frame
);
664 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
666 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
667 && !NILP (Fwindow_minibuffer_p (mini_window
)))
668 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
671 /* Display this minibuffer in the proper window. */
672 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
673 Fselect_window (minibuf_window
, Qnil
);
674 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
676 Fmake_local_variable (Qprint_escape_newlines
);
677 print_escape_newlines
= 1;
679 /* Erase the buffer. */
681 int count1
= SPECPDL_INDEX ();
682 specbind (Qinhibit_read_only
, Qt
);
683 specbind (Qinhibit_modification_hooks
, Qt
);
685 unbind_to (count1
, Qnil
);
688 if (!NILP (current_buffer
->enable_multibyte_characters
)
689 && ! STRING_MULTIBYTE (minibuf_prompt
))
690 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
692 /* Insert the prompt, record where it ends. */
693 Finsert (1, &minibuf_prompt
);
696 Fput_text_property (make_number (BEG
), make_number (PT
),
697 Qfront_sticky
, Qt
, Qnil
);
698 Fput_text_property (make_number (BEG
), make_number (PT
),
699 Qrear_nonsticky
, Qt
, Qnil
);
700 Fput_text_property (make_number (BEG
), make_number (PT
),
702 Fadd_text_properties (make_number (BEG
), make_number (PT
),
703 Vminibuffer_prompt_properties
, Qnil
);
706 minibuf_prompt_width
= (int) current_column (); /* iftc */
708 /* Put in the initial input. */
711 Finsert (1, &initial
);
712 Fforward_char (make_number (pos
));
715 clear_message (1, 1);
716 current_buffer
->keymap
= map
;
718 /* Turn on an input method stored in INPUT_METHOD if any. */
719 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
720 call1 (Qactivate_input_method
, input_method
);
722 /* Run our hook, but not if it is empty.
723 (run-hooks would do nothing if it is empty,
724 but it's important to save time here in the usual case.) */
725 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
726 && !NILP (Vrun_hooks
))
727 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
729 /* Don't allow the user to undo past this point. */
730 current_buffer
->undo_list
= Qnil
;
734 /* If cursor is on the minibuffer line,
735 show the user we have exited by putting it in column 0. */
736 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
739 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
740 XWINDOW (minibuf_window
)->cursor
.x
= 0;
741 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
742 update_frame (XFRAME (selected_frame
), 1, 1);
744 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
745 struct redisplay_interface
*rif
= FRAME_RIF (f
);
746 if (rif
&& rif
->flush_display
)
747 rif
->flush_display (f
);
751 /* Make minibuffer contents into a string. */
752 Fset_buffer (minibuffer
);
754 val
= Fminibuffer_contents ();
756 val
= Fminibuffer_contents_no_properties ();
758 /* VAL is the string of minibuffer text. */
760 last_minibuf_string
= val
;
762 /* Choose the string to add to the history. */
763 if (SCHARS (val
) != 0)
765 else if (STRINGP (defalt
))
770 /* Add the value to the appropriate history list, if any. */
771 if (!NILP (Vhistory_add_new_input
)
772 && SYMBOLP (Vminibuffer_history_variable
)
773 && !NILP (histstring
))
775 /* If the caller wanted to save the value read on a history list,
776 then do so if the value is not already the front of the list. */
779 /* If variable is unbound, make it nil. */
780 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
781 Fset (Vminibuffer_history_variable
, Qnil
);
783 histval
= Fsymbol_value (Vminibuffer_history_variable
);
785 /* The value of the history variable must be a cons or nil. Other
786 values are unacceptable. We silently ignore these values. */
790 /* Don't duplicate the most recent entry in the history. */
791 && (NILP (Fequal (histstring
, Fcar (histval
))))))
795 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
796 histval
= Fcons (histstring
, histval
);
797 Fset (Vminibuffer_history_variable
, histval
);
799 /* Truncate if requested. */
800 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
801 if (NILP (length
)) length
= Vhistory_length
;
802 if (INTEGERP (length
))
804 if (XINT (length
) <= 0)
805 Fset (Vminibuffer_history_variable
, Qnil
);
810 temp
= Fnthcdr (Fsub1 (length
), histval
);
811 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
817 /* If Lisp form desired instead of string, parse it. */
819 val
= string_to_object (val
, defalt
);
821 /* The appropriate frame will get selected
822 in set-window-configuration. */
824 return unbind_to (count
, val
);
827 /* Return a buffer to be used as the minibuffer at depth `depth'.
828 depth = 0 is the lowest allowed argument, and that is the value
829 used for nonrecursive minibuffer invocations */
832 get_minibuffer (depth
)
835 Lisp_Object tail
, num
, buf
;
837 extern Lisp_Object
nconc2 ();
839 XSETFASTINT (num
, depth
);
840 tail
= Fnthcdr (num
, Vminibuffer_list
);
843 tail
= Fcons (Qnil
, Qnil
);
844 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
847 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
849 sprintf (name
, " *Minibuf-%d*", depth
);
850 buf
= Fget_buffer_create (build_string (name
));
852 /* Although the buffer's name starts with a space, undo should be
854 Fbuffer_enable_undo (buf
);
860 int count
= SPECPDL_INDEX ();
861 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
862 have to empty the list, otherwise we end up with overlays that
863 think they belong to this buffer while the buffer doesn't know about
865 delete_all_overlays (XBUFFER (buf
));
866 reset_buffer (XBUFFER (buf
));
867 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
869 Fkill_all_local_variables ();
870 unbind_to (count
, Qnil
);
877 run_exit_minibuf_hook (data
)
880 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
881 && !NILP (Vrun_hooks
))
882 safe_run_hooks (Qminibuffer_exit_hook
);
887 /* This function is called on exiting minibuffer, whether normally or
888 not, and it restores the current window, buffer, etc. */
891 read_minibuf_unwind (data
)
894 Lisp_Object old_deactivate_mark
;
897 /* If this was a recursive minibuffer,
898 tie the minibuffer window back to the outer level minibuffer buffer. */
901 window
= minibuf_window
;
902 /* To keep things predictable, in case it matters, let's be in the
903 minibuffer when we reset the relevant variables. */
904 Fset_buffer (XWINDOW (window
)->buffer
);
906 /* Restore prompt, etc, from outer minibuffer level. */
907 minibuf_prompt
= Fcar (minibuf_save_list
);
908 minibuf_save_list
= Fcdr (minibuf_save_list
);
909 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
910 minibuf_save_list
= Fcdr (minibuf_save_list
);
911 Vhelp_form
= Fcar (minibuf_save_list
);
912 minibuf_save_list
= Fcdr (minibuf_save_list
);
913 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
914 minibuf_save_list
= Fcdr (minibuf_save_list
);
915 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
916 minibuf_save_list
= Fcdr (minibuf_save_list
);
917 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
918 minibuf_save_list
= Fcdr (minibuf_save_list
);
919 Voverriding_local_map
= Fcar (minibuf_save_list
);
920 minibuf_save_list
= Fcdr (minibuf_save_list
);
922 temp
= Fcar (minibuf_save_list
);
923 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
924 minibuf_window
= temp
;
926 minibuf_save_list
= Fcdr (minibuf_save_list
);
928 /* Erase the minibuffer we were using at this level. */
930 int count
= SPECPDL_INDEX ();
931 /* Prevent error in erase-buffer. */
932 specbind (Qinhibit_read_only
, Qt
);
933 specbind (Qinhibit_modification_hooks
, Qt
);
934 old_deactivate_mark
= Vdeactivate_mark
;
936 Vdeactivate_mark
= old_deactivate_mark
;
937 unbind_to (count
, Qnil
);
940 /* When we get to the outmost level, make sure we resize the
941 mini-window back to its normal size. */
942 if (minibuf_level
== 0)
943 resize_mini_window (XWINDOW (window
), 0);
945 /* Make sure minibuffer window is erased, not ignored. */
946 windows_or_buffers_changed
++;
947 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
948 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
953 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
954 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
955 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
956 DEFAULT-VALUE. It normally should be nil in new code, except when
957 HIST is a cons. It is discussed in more detail below.
958 Third arg KEYMAP is a keymap to use whilst reading;
959 if omitted or nil, the default is `minibuffer-local-map'.
960 If fourth arg READ is non-nil, then interpret the result as a Lisp object
961 and return that object:
962 in other words, do `(car (read-from-string INPUT-STRING))'
963 Fifth arg HIST, if non-nil, specifies a history list and optionally
964 the initial position in the list. It can be a symbol, which is the
965 history list variable to use, or it can be a cons cell
966 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
967 to use, and HISTPOS is the initial position for use by the minibuffer
968 history commands. For consistency, you should also specify that
969 element of the history as the value of INITIAL-CONTENTS. Positions
970 are counted starting from 1 at the beginning of the list.
971 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
972 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
973 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
975 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
976 the current input method and the setting of `enable-multibyte-characters'.
977 If the variable `minibuffer-allow-text-properties' is non-nil,
978 then the string which is returned includes whatever text properties
979 were present in the minibuffer. Otherwise the value has no text properties.
981 The remainder of this documentation string describes the
982 INITIAL-CONTENTS argument in more detail. It is only relevant when
983 studying existing code, or when HIST is a cons. If non-nil,
984 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
985 reading input. Normally, point is put at the end of that string.
986 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
987 input is STRING, but point is placed at _one-indexed_ position
988 POSITION in the minibuffer. Any integer value less than or equal to
989 one puts point at the beginning of the string. *Note* that this
990 behavior differs from the way such arguments are used in `completing-read'
991 and some related functions, which use zero-indexing for POSITION. */)
992 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
993 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
994 Lisp_Object inherit_input_method
;
996 Lisp_Object histvar
, histpos
, val
;
999 CHECK_STRING (prompt
);
1001 keymap
= Vminibuffer_local_map
;
1003 keymap
= get_keymap (keymap
, 1, 0);
1012 histvar
= Fcar_safe (hist
);
1013 histpos
= Fcdr_safe (hist
);
1016 histvar
= Qminibuffer_history
;
1018 XSETFASTINT (histpos
, 0);
1020 GCPRO1 (default_value
);
1021 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1023 histvar
, histpos
, default_value
,
1024 minibuffer_allow_text_properties
,
1025 !NILP (inherit_input_method
));
1030 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1031 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1032 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1033 is a string to insert in the minibuffer before reading.
1034 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1035 arguments are used as in `read-from-minibuffer'.) */)
1036 (prompt
, initial_contents
)
1037 Lisp_Object prompt
, initial_contents
;
1039 CHECK_STRING (prompt
);
1040 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1041 prompt
, Qnil
, 1, Qminibuffer_history
,
1042 make_number (0), Qnil
, 0, 0);
1045 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1046 doc
: /* Return value of Lisp expression read using the minibuffer.
1047 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1048 is a string to insert in the minibuffer before reading.
1049 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1050 arguments are used as in `read-from-minibuffer'.) */)
1051 (prompt
, initial_contents
)
1052 Lisp_Object prompt
, initial_contents
;
1054 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1055 prompt
, Qnil
, 1, Qread_expression_history
,
1056 make_number (0), Qnil
, 0, 0));
1059 /* Functions that use the minibuffer to read various things. */
1061 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1062 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1063 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1064 This argument has been superseded by DEFAULT-VALUE and should normally
1065 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1066 documentation string of that function for details.
1067 The third arg HISTORY, if non-nil, specifies a history list
1068 and optionally the initial position in the list.
1069 See `read-from-minibuffer' for details of HISTORY argument.
1070 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1071 for history commands, and as the value to return if the user enters
1073 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1074 the current input method and the setting of `enable-multibyte-characters'. */)
1075 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1076 Lisp_Object prompt
, initial_input
, history
, default_value
;
1077 Lisp_Object inherit_input_method
;
1080 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1081 Qnil
, history
, default_value
,
1082 inherit_input_method
);
1083 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1084 val
= default_value
;
1088 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1089 doc
: /* Read a string from the terminal, not allowing blanks.
1090 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1091 non-nil, it should be a string, which is used as initial input, with
1092 point positioned at the end, so that SPACE will accept the input.
1093 \(Actually, INITIAL can also be a cons of a string and an integer.
1094 Such values are treated as in `read-from-minibuffer', but are normally
1095 not useful in this function.)
1096 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1097 the current input method and the setting of`enable-multibyte-characters'. */)
1098 (prompt
, initial
, inherit_input_method
)
1099 Lisp_Object prompt
, initial
, inherit_input_method
;
1101 CHECK_STRING (prompt
);
1102 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1103 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1104 !NILP (inherit_input_method
));
1107 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1108 doc
: /* Read the name of a command and return as a symbol.
1109 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1110 (prompt
, default_value
)
1111 Lisp_Object prompt
, default_value
;
1113 Lisp_Object name
, default_string
;
1115 if (NILP (default_value
))
1116 default_string
= Qnil
;
1117 else if (SYMBOLP (default_value
))
1118 default_string
= SYMBOL_NAME (default_value
);
1120 default_string
= default_value
;
1122 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1123 Qnil
, Qnil
, default_string
, Qnil
);
1126 return Fintern (name
, Qnil
);
1130 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1131 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1132 Prompt with PROMPT. */)
1136 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1141 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1142 doc
: /* Read the name of a user variable and return it as a symbol.
1143 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1144 A user variable is one for which `user-variable-p' returns non-nil. */)
1145 (prompt
, default_value
)
1146 Lisp_Object prompt
, default_value
;
1148 Lisp_Object name
, default_string
;
1150 if (NILP (default_value
))
1151 default_string
= Qnil
;
1152 else if (SYMBOLP (default_value
))
1153 default_string
= SYMBOL_NAME (default_value
);
1155 default_string
= default_value
;
1157 name
= Fcompleting_read (prompt
, Vobarray
,
1158 Quser_variable_p
, Qt
,
1159 Qnil
, Qnil
, default_string
, Qnil
);
1162 return Fintern (name
, Qnil
);
1165 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1166 doc
: /* Read the name of a buffer and return as a string.
1168 Optional second arg DEF is value to return if user enters an empty line.
1169 If optional third arg REQUIRE-MATCH is non-nil,
1170 only existing buffer names are allowed.
1171 The argument PROMPT should be a string ending with a colon and a space. */)
1172 (prompt
, def
, require_match
)
1173 Lisp_Object prompt
, def
, require_match
;
1175 Lisp_Object args
[4];
1180 def
= XBUFFER (def
)->name
;
1182 if (NILP (Vread_buffer_function
))
1186 /* A default value was provided: we must change PROMPT,
1187 editing the default value in before the colon. To achieve
1188 this, we replace PROMPT with a substring that doesn't
1189 contain the terminal space and colon (if present). They
1190 are then added back using Fformat. */
1192 if (STRINGP (prompt
))
1196 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1198 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1201 prompt
= make_specified_string (s
, -1, len
,
1202 STRING_MULTIBYTE (prompt
));
1205 args
[0] = build_string ("%s (default %s): ");
1208 prompt
= Fformat (3, args
);
1211 return Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1212 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1217 args
[0] = Vread_buffer_function
;
1220 args
[3] = require_match
;
1221 return Ffuncall(4, args
);
1226 minibuf_conform_representation (string
, basis
)
1227 Lisp_Object string
, basis
;
1229 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1232 if (STRING_MULTIBYTE (string
))
1233 return Fstring_make_unibyte (string
);
1235 return Fstring_make_multibyte (string
);
1238 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1239 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1240 Test each possible completion specified by COLLECTION
1241 to see if it begins with STRING. The possible completions may be
1242 strings or symbols. Symbols are converted to strings before testing,
1244 All that match STRING are compared together; the longest initial sequence
1245 common to all these matches is the return value.
1246 If there is no match at all, the return value is nil.
1247 For a unique match which is exact, the return value is t.
1249 If COLLECTION is an alist, the keys (cars of elements) are the
1250 possible completions. If an element is not a cons cell, then the
1251 element itself is the possible completion.
1252 If COLLECTION is a hash-table, all the keys that are strings or symbols
1253 are the possible completions.
1254 If COLLECTION is an obarray, the names of all symbols in the obarray
1255 are the possible completions.
1257 COLLECTION can also be a function to do the completion itself.
1258 It receives three arguments: the values STRING, PREDICATE and nil.
1259 Whatever it returns becomes the value of `try-completion'.
1261 If optional third argument PREDICATE is non-nil,
1262 it is used to test each possible match.
1263 The match is a candidate only if PREDICATE returns non-nil.
1264 The argument given to PREDICATE is the alist element
1265 or the symbol from the obarray. If COLLECTION is a hash-table,
1266 predicate is called with two arguments: the key and the value.
1267 Additionally to this predicate, `completion-regexp-list'
1268 is used to further constrain the set of candidates. */)
1269 (string
, collection
, predicate
)
1270 Lisp_Object string
, collection
, predicate
;
1272 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1273 /* Size in bytes of BESTMATCH. */
1274 int bestmatchsize
= 0;
1275 /* These are in bytes, too. */
1276 int compare
, matchsize
;
1277 int type
= (HASH_TABLE_P (collection
) ? 3
1278 : VECTORP (collection
) ? 2
1279 : NILP (collection
) || (CONSP (collection
)
1280 && (!SYMBOLP (XCAR (collection
))
1281 || NILP (XCAR (collection
)))));
1282 int index
= 0, obsize
= 0;
1285 Lisp_Object bucket
, zero
, end
, tem
;
1286 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1288 CHECK_STRING (string
);
1290 return call3 (collection
, string
, predicate
, Qnil
);
1292 bestmatch
= bucket
= Qnil
;
1293 zero
= make_number (0);
1295 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1299 collection
= check_obarray (collection
);
1300 obsize
= XVECTOR (collection
)->size
;
1301 bucket
= XVECTOR (collection
)->contents
[index
];
1306 /* Get the next element of the alist, obarray, or hash-table. */
1307 /* Exit the loop if the elements are all used up. */
1308 /* elt gets the alist element or symbol.
1309 eltstring gets the name to check as a completion. */
1316 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1321 if (!EQ (bucket
, zero
))
1323 if (!SYMBOLP (bucket
))
1324 error ("Bad data in guts of obarray");
1327 if (XSYMBOL (bucket
)->next
)
1328 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1330 XSETFASTINT (bucket
, 0);
1332 else if (++index
>= obsize
)
1336 bucket
= XVECTOR (collection
)->contents
[index
];
1340 else /* if (type == 3) */
1342 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1343 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1345 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1348 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1351 /* Is this element a possible completion? */
1353 if (SYMBOLP (eltstring
))
1354 eltstring
= Fsymbol_name (eltstring
);
1356 if (STRINGP (eltstring
)
1357 && SCHARS (string
) <= SCHARS (eltstring
)
1358 && (tem
= Fcompare_strings (eltstring
, zero
,
1359 make_number (SCHARS (string
)),
1361 completion_ignore_case
? Qt
: Qnil
),
1365 Lisp_Object regexps
;
1367 /* Ignore this element if it fails to match all the regexps. */
1369 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1370 regexps
= XCDR (regexps
))
1372 if (bindcount
< 0) {
1373 bindcount
= SPECPDL_INDEX ();
1374 specbind (Qcase_fold_search
,
1375 completion_ignore_case
? Qt
: Qnil
);
1377 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1381 if (CONSP (regexps
))
1385 /* Ignore this element if there is a predicate
1386 and the predicate doesn't like it. */
1388 if (!NILP (predicate
))
1390 if (EQ (predicate
, Qcommandp
))
1391 tem
= Fcommandp (elt
, Qnil
);
1394 if (bindcount
>= 0) {
1395 unbind_to (bindcount
, Qnil
);
1398 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1400 ? call2 (predicate
, elt
,
1401 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1402 : call1 (predicate
, elt
);
1405 if (NILP (tem
)) continue;
1408 /* Update computation of how much all possible completions match */
1410 if (NILP (bestmatch
))
1413 bestmatch
= eltstring
;
1414 bestmatchsize
= SCHARS (eltstring
);
1418 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1419 tem
= Fcompare_strings (bestmatch
, zero
,
1420 make_number (compare
),
1422 make_number (compare
),
1423 completion_ignore_case
? Qt
: Qnil
);
1425 matchsize
= compare
;
1426 else if (XINT (tem
) < 0)
1427 matchsize
= - XINT (tem
) - 1;
1429 matchsize
= XINT (tem
) - 1;
1432 /* When can this happen ? -stef */
1433 matchsize
= compare
;
1434 if (completion_ignore_case
)
1436 /* If this is an exact match except for case,
1437 use it as the best match rather than one that is not an
1438 exact match. This way, we get the case pattern
1439 of the actual match. */
1440 if ((matchsize
== SCHARS (eltstring
)
1441 && matchsize
< SCHARS (bestmatch
))
1443 /* If there is more than one exact match ignoring case,
1444 and one of them is exact including case,
1446 /* If there is no exact match ignoring case,
1447 prefer a match that does not change the case
1449 ((matchsize
== SCHARS (eltstring
))
1451 (matchsize
== SCHARS (bestmatch
))
1452 && (tem
= Fcompare_strings (eltstring
, zero
,
1453 make_number (SCHARS (string
)),
1458 && (tem
= Fcompare_strings (bestmatch
, zero
,
1459 make_number (SCHARS (string
)),
1464 bestmatch
= eltstring
;
1466 if (bestmatchsize
!= SCHARS (eltstring
)
1467 || bestmatchsize
!= matchsize
)
1468 /* Don't count the same string multiple times. */
1470 bestmatchsize
= matchsize
;
1471 if (matchsize
<= SCHARS (string
)
1473 /* No need to look any further. */
1479 if (bindcount
>= 0) {
1480 unbind_to (bindcount
, Qnil
);
1484 if (NILP (bestmatch
))
1485 return Qnil
; /* No completions found */
1486 /* If we are ignoring case, and there is no exact match,
1487 and no additional text was supplied,
1488 don't change the case of what the user typed. */
1489 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1490 && SCHARS (bestmatch
) > bestmatchsize
)
1491 return minibuf_conform_representation (string
, bestmatch
);
1493 /* Return t if the supplied string is an exact match (counting case);
1494 it does not require any change to be made. */
1495 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1496 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1497 make_number (bestmatchsize
),
1498 string
, make_number (0),
1499 make_number (bestmatchsize
),
1504 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1505 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1506 return Fsubstring (bestmatch
, zero
, end
);
1509 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1510 doc
: /* Search for partial matches to STRING in COLLECTION.
1511 Test each of the possible completions specified by COLLECTION
1512 to see if it begins with STRING. The possible completions may be
1513 strings or symbols. Symbols are converted to strings before testing,
1515 The value is a list of all the possible completions that match STRING.
1517 If COLLECTION is an alist, the keys (cars of elements) are the
1518 possible completions. If an element is not a cons cell, then the
1519 element itself is the possible completion.
1520 If COLLECTION is a hash-table, all the keys that are strings or symbols
1521 are the possible completions.
1522 If COLLECTION is an obarray, the names of all symbols in the obarray
1523 are the possible completions.
1525 COLLECTION can also be a function to do the completion itself.
1526 It receives three arguments: the values STRING, PREDICATE and t.
1527 Whatever it returns becomes the value of `all-completions'.
1529 If optional third argument PREDICATE is non-nil,
1530 it is used to test each possible match.
1531 The match is a candidate only if PREDICATE returns non-nil.
1532 The argument given to PREDICATE is the alist element
1533 or the symbol from the obarray. If COLLECTION is a hash-table,
1534 predicate is called with two arguments: the key and the value.
1535 Additionally to this predicate, `completion-regexp-list'
1536 is used to further constrain the set of candidates.
1538 If the optional fourth argument HIDE-SPACES is non-nil,
1539 strings in COLLECTION that start with a space
1540 are ignored unless STRING itself starts with a space. */)
1541 (string
, collection
, predicate
, hide_spaces
)
1542 Lisp_Object string
, collection
, predicate
, hide_spaces
;
1544 Lisp_Object tail
, elt
, eltstring
;
1545 Lisp_Object allmatches
;
1546 int type
= HASH_TABLE_P (collection
) ? 3
1547 : VECTORP (collection
) ? 2
1548 : NILP (collection
) || (CONSP (collection
)
1549 && (!SYMBOLP (XCAR (collection
))
1550 || NILP (XCAR (collection
))));
1551 int index
= 0, obsize
= 0;
1553 Lisp_Object bucket
, tem
, zero
;
1554 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1556 CHECK_STRING (string
);
1558 return call3 (collection
, string
, predicate
, Qt
);
1559 allmatches
= bucket
= Qnil
;
1560 zero
= make_number (0);
1562 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1566 obsize
= XVECTOR (collection
)->size
;
1567 bucket
= XVECTOR (collection
)->contents
[index
];
1572 /* Get the next element of the alist, obarray, or hash-table. */
1573 /* Exit the loop if the elements are all used up. */
1574 /* elt gets the alist element or symbol.
1575 eltstring gets the name to check as a completion. */
1582 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1587 if (!EQ (bucket
, zero
))
1591 if (XSYMBOL (bucket
)->next
)
1592 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1594 XSETFASTINT (bucket
, 0);
1596 else if (++index
>= obsize
)
1600 bucket
= XVECTOR (collection
)->contents
[index
];
1604 else /* if (type == 3) */
1606 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1607 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1609 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1612 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1615 /* Is this element a possible completion? */
1617 if (SYMBOLP (eltstring
))
1618 eltstring
= Fsymbol_name (eltstring
);
1620 if (STRINGP (eltstring
)
1621 && SCHARS (string
) <= SCHARS (eltstring
)
1622 /* If HIDE_SPACES, reject alternatives that start with space
1623 unless the input starts with space. */
1624 && ((SBYTES (string
) > 0
1625 && SREF (string
, 0) == ' ')
1626 || SREF (eltstring
, 0) != ' '
1627 || NILP (hide_spaces
))
1628 && (tem
= Fcompare_strings (eltstring
, zero
,
1629 make_number (SCHARS (string
)),
1631 make_number (SCHARS (string
)),
1632 completion_ignore_case
? Qt
: Qnil
),
1636 Lisp_Object regexps
;
1638 XSETFASTINT (zero
, 0);
1640 /* Ignore this element if it fails to match all the regexps. */
1642 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1643 regexps
= XCDR (regexps
))
1645 if (bindcount
< 0) {
1646 bindcount
= SPECPDL_INDEX ();
1647 specbind (Qcase_fold_search
,
1648 completion_ignore_case
? Qt
: Qnil
);
1650 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1654 if (CONSP (regexps
))
1658 /* Ignore this element if there is a predicate
1659 and the predicate doesn't like it. */
1661 if (!NILP (predicate
))
1663 if (EQ (predicate
, Qcommandp
))
1664 tem
= Fcommandp (elt
, Qnil
);
1667 if (bindcount
>= 0) {
1668 unbind_to (bindcount
, Qnil
);
1671 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1673 ? call2 (predicate
, elt
,
1674 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1675 : call1 (predicate
, elt
);
1678 if (NILP (tem
)) continue;
1680 /* Ok => put it on the list. */
1681 allmatches
= Fcons (eltstring
, allmatches
);
1685 if (bindcount
>= 0) {
1686 unbind_to (bindcount
, Qnil
);
1690 return Fnreverse (allmatches
);
1693 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1694 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1695 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1696 Lisp_Object Vminibuffer_completing_file_name
;
1698 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1699 doc
: /* Read a string in the minibuffer, with completion.
1700 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1701 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1702 COLLECTION can also be a function to do the completion itself.
1703 PREDICATE limits completion to a subset of COLLECTION.
1704 See `try-completion' and `all-completions' for more details
1705 on completion, COLLECTION, and PREDICATE.
1707 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1708 the input is (or completes to) an element of COLLECTION or is null.
1709 If it is also not t, typing RET does not exit if it does non-null completion.
1710 If the input is null, `completing-read' returns DEF, or an empty string
1711 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1713 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1714 with point positioned at the end.
1715 If it is (STRING . POSITION), the initial input is STRING, but point
1716 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1717 that this is different from `read-from-minibuffer' and related
1718 functions, which use one-indexing for POSITION.) This feature is
1719 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1720 default value DEF instead. The user can yank the default value into
1721 the minibuffer easily using \\[next-history-element].
1723 HIST, if non-nil, specifies a history list and optionally the initial
1724 position in the list. It can be a symbol, which is the history list
1725 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1726 that case, HISTVAR is the history list variable to use, and HISTPOS
1727 is the initial position (the position in the list used by the
1728 minibuffer history commands). For consistency, you should also
1729 specify that element of the history as the value of
1730 INITIAL-INPUT. (This is the only case in which you should use
1731 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1732 1 at the beginning of the list. The variable `history-length'
1733 controls the maximum length of a history list.
1735 DEF, if non-nil, is the default value.
1737 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1738 the current input method and the setting of `enable-multibyte-characters'.
1740 Completion ignores case if the ambient value of
1741 `completion-ignore-case' is non-nil. */)
1742 (prompt
, collection
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1743 Lisp_Object prompt
, collection
, predicate
, require_match
, initial_input
;
1744 Lisp_Object hist
, def
, inherit_input_method
;
1746 Lisp_Object val
, histvar
, histpos
, position
;
1749 int count
= SPECPDL_INDEX ();
1750 struct gcpro gcpro1
;
1752 init
= initial_input
;
1755 specbind (Qminibuffer_completion_table
, collection
);
1756 specbind (Qminibuffer_completion_predicate
, predicate
);
1757 specbind (Qminibuffer_completion_confirm
,
1758 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1759 last_exact_completion
= Qnil
;
1766 position
= Fcdr (init
);
1769 CHECK_STRING (init
);
1770 if (!NILP (position
))
1772 CHECK_NUMBER (position
);
1773 /* Convert to distance from end of input. */
1774 pos
= XINT (position
) - SCHARS (init
);
1785 histvar
= Fcar_safe (hist
);
1786 histpos
= Fcdr_safe (hist
);
1789 histvar
= Qminibuffer_history
;
1791 XSETFASTINT (histpos
, 0);
1793 val
= read_minibuf (NILP (require_match
)
1794 ? (NILP (Vminibuffer_completing_file_name
)
1795 ? Vminibuffer_local_completion_map
1796 : Vminibuffer_local_filename_completion_map
)
1797 : (NILP (Vminibuffer_completing_file_name
)
1798 ? Vminibuffer_local_must_match_map
1799 : Vminibuffer_local_must_match_filename_map
),
1800 init
, prompt
, make_number (pos
), 0,
1801 histvar
, histpos
, def
, 0,
1802 !NILP (inherit_input_method
));
1804 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1807 RETURN_UNGCPRO (unbind_to (count
, val
));
1810 Lisp_Object
Fminibuffer_completion_help ();
1811 Lisp_Object
Fassoc_string ();
1813 /* Test whether TXT is an exact completion. */
1814 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1815 doc
: /* Return non-nil if STRING is a valid completion.
1816 Takes the same arguments as `all-completions' and `try-completion'.
1817 If COLLECTION is a function, it is called with three arguments:
1818 the values STRING, PREDICATE and `lambda'. */)
1819 (string
, collection
, predicate
)
1820 Lisp_Object string
, collection
, predicate
;
1822 Lisp_Object regexps
, tail
, tem
= Qnil
;
1825 CHECK_STRING (string
);
1827 if ((CONSP (collection
)
1828 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1829 || NILP (collection
))
1831 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1835 else if (VECTORP (collection
))
1837 /* Bypass intern-soft as that loses for nil. */
1838 tem
= oblookup (collection
,
1844 if (STRING_MULTIBYTE (string
))
1845 string
= Fstring_make_unibyte (string
);
1847 string
= Fstring_make_multibyte (string
);
1849 tem
= oblookup (collection
,
1855 if (completion_ignore_case
&& !SYMBOLP (tem
))
1857 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1859 tail
= XVECTOR (collection
)->contents
[i
];
1863 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1864 Fsymbol_name (tail
),
1865 make_number (0) , Qnil
, Qt
)),
1871 if (XSYMBOL (tail
)->next
== 0)
1873 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1881 else if (HASH_TABLE_P (collection
))
1883 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1884 i
= hash_lookup (h
, string
, NULL
);
1886 tem
= HASH_KEY (h
, i
);
1888 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1889 if (!NILP (HASH_HASH (h
, i
)) &&
1890 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1891 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1892 completion_ignore_case
? Qt
: Qnil
),
1895 tem
= HASH_KEY (h
, i
);
1902 return call3 (collection
, string
, predicate
, Qlambda
);
1904 /* Reject this element if it fails to match all the regexps. */
1905 if (CONSP (Vcompletion_regexp_list
))
1907 int count
= SPECPDL_INDEX ();
1908 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1909 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1910 regexps
= XCDR (regexps
))
1912 if (NILP (Fstring_match (XCAR (regexps
),
1913 SYMBOLP (tem
) ? string
: tem
,
1915 return unbind_to (count
, Qnil
);
1917 unbind_to (count
, Qnil
);
1920 /* Finally, check the predicate. */
1921 if (!NILP (predicate
))
1923 return HASH_TABLE_P (collection
)
1924 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1925 : call1 (predicate
, tem
);
1931 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1932 doc
: /* Perform completion on buffer names.
1933 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1934 `all-completions', otherwise invoke `test-completion'.
1936 The arguments STRING and PREDICATE are as in `try-completion',
1937 `all-completions', and `test-completion'. */)
1938 (string
, predicate
, flag
)
1939 Lisp_Object string
, predicate
, flag
;
1942 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1943 else if (EQ (flag
, Qt
))
1944 return Fall_completions (string
, Vbuffer_alist
, predicate
, Qt
);
1945 else /* assume `lambda' */
1946 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1950 * 0 no possible completion
1951 * 1 was already an exact and unique completion
1952 * 3 was already an exact completion
1953 * 4 completed to an exact completion
1954 * 5 some completion happened
1955 * 6 no completion happened
1960 Lisp_Object completion
, string
, tem
;
1963 struct gcpro gcpro1
, gcpro2
;
1965 completion
= Ftry_completion (Fminibuffer_completion_contents (),
1966 Vminibuffer_completion_table
,
1967 Vminibuffer_completion_predicate
);
1968 last
= last_exact_completion
;
1969 last_exact_completion
= Qnil
;
1971 GCPRO2 (completion
, last
);
1973 if (NILP (completion
))
1976 temp_echo_area_glyphs (build_string (" [No match]"));
1981 if (EQ (completion
, Qt
)) /* exact and unique match */
1987 string
= Fminibuffer_completion_contents ();
1989 /* COMPLETEDP should be true if some completion was done, which
1990 doesn't include simply changing the case of the entered string.
1991 However, for appearance, the string is rewritten if the case
1993 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1994 completedp
= !EQ (tem
, Qt
);
1996 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1998 /* Rewrite the user's input. */
2000 int prompt_end
= XINT (Fminibuffer_prompt_end ());
2001 /* Some completion happened */
2003 if (! NILP (Vminibuffer_completing_file_name
)
2004 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2006 && FETCH_CHAR (PT_BYTE
) == '/')
2008 del_range (prompt_end
, PT
+ 1);
2011 del_range (prompt_end
, PT
);
2013 Finsert (1, &completion
);
2016 /* The case of the string changed, but that's all. We're not
2017 sure whether this is a unique completion or not, so try again
2018 using the real case (this shouldn't recurse again, because
2019 the next time try-completion will return either `t' or the
2023 return do_completion ();
2027 /* It did find a match. Do we match some possibility exactly now? */
2028 tem
= Ftest_completion (Fminibuffer_contents (),
2029 Vminibuffer_completion_table
,
2030 Vminibuffer_completion_predicate
);
2033 /* not an exact match */
2037 else if (!NILP (Vcompletion_auto_help
))
2038 Fminibuffer_completion_help ();
2040 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
2043 else if (completedp
)
2048 /* If the last exact completion and this one were the same,
2049 it means we've already given a "Complete but not unique"
2050 message and the user's hit TAB again, so now we give him help. */
2051 last_exact_completion
= completion
;
2054 tem
= Fminibuffer_completion_contents ();
2055 if (!NILP (Fequal (tem
, last
)))
2056 Fminibuffer_completion_help ();
2062 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2064 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
2065 doc
: /* Like `assoc' but specifically for strings.
2066 Unibyte strings are converted to multibyte for comparison.
2067 And case is ignored if CASE-FOLD is non-nil.
2068 As opposed to `assoc', it will also match an entry consisting of a single
2069 string rather than a cons cell whose car is a string. */)
2070 (key
, list
, case_fold
)
2071 register Lisp_Object key
;
2072 Lisp_Object list
, case_fold
;
2074 register Lisp_Object tail
;
2076 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2078 register Lisp_Object elt
, tem
, thiscar
;
2080 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2081 if (!STRINGP (thiscar
))
2083 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2084 key
, make_number (0), Qnil
,
2093 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2094 doc
: /* Complete the minibuffer contents as far as possible.
2095 Return nil if there is no valid completion, else t.
2096 If no characters can be completed, display a list of possible completions.
2097 If you repeat this command after it displayed such a list,
2098 scroll the window of possible completions. */)
2102 Lisp_Object window
, tem
;
2104 /* If the previous command was not this,
2105 mark the completion buffer obsolete. */
2106 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2107 Vminibuf_scroll_window
= Qnil
;
2109 window
= Vminibuf_scroll_window
;
2110 /* If there's a fresh completion window with a live buffer,
2111 and this command is repeated, scroll that window. */
2112 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2113 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2115 struct buffer
*obuf
= current_buffer
;
2117 Fset_buffer (XWINDOW (window
)->buffer
);
2118 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2120 /* If end is in view, scroll up to the beginning. */
2121 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2123 /* Else scroll down one screen. */
2124 Fscroll_other_window (Qnil
);
2126 set_buffer_internal (obuf
);
2130 i
= do_completion ();
2138 Fgoto_char (make_number (ZV
));
2139 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2144 Fgoto_char (make_number (ZV
));
2145 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2152 /* Subroutines of Fminibuffer_complete_and_exit. */
2154 /* This one is called by internal_condition_case to do the real work. */
2157 complete_and_exit_1 ()
2159 return make_number (do_completion ());
2162 /* This one is called by internal_condition_case if an error happens.
2163 Pretend the current value is an exact match. */
2166 complete_and_exit_2 (ignore
)
2169 return make_number (1);
2172 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2174 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2175 Sminibuffer_complete_and_exit
, 0, 0, "",
2176 doc
: /* If the minibuffer contents is a valid completion then exit.
2177 Otherwise try to complete it. If completion leads to a valid completion,
2178 a repetition of this command will exit. */)
2182 Lisp_Object val
, tem
;
2184 /* Allow user to specify null string */
2185 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2188 val
= Fminibuffer_contents ();
2189 tem
= Ftest_completion (val
,
2190 Vminibuffer_completion_table
,
2191 Vminibuffer_completion_predicate
);
2194 if (completion_ignore_case
)
2195 { /* Fixup case of the field, if necessary. */
2197 = Ftry_completion (val
,
2198 Vminibuffer_completion_table
,
2199 Vminibuffer_completion_predicate
);
2201 /* If it weren't for this piece of paranoia, I'd replace
2202 the whole thing with a call to do_completion. */
2203 && EQ (Flength (val
), Flength (compl)))
2205 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2206 Finsert (1, &compl);
2212 /* Call do_completion, but ignore errors. */
2214 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2215 complete_and_exit_2
);
2225 if (!NILP (Vminibuffer_completion_confirm
))
2227 temp_echo_area_glyphs (build_string (" [Confirm]"));
2237 return Fexit_minibuffer ();
2241 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2243 doc
: /* Complete the minibuffer contents at most a single word.
2244 After one word is completed as much as possible, a space or hyphen
2245 is added, provided that matches some possible completion.
2246 Return nil if there is no valid completion, else t. */)
2249 Lisp_Object completion
, tem
, tem1
;
2250 register int i
, i_byte
;
2251 struct gcpro gcpro1
, gcpro2
;
2252 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2254 /* We keep calling Fbuffer_string rather than arrange for GC to
2255 hold onto a pointer to one of the strings thus made. */
2257 completion
= Ftry_completion (Fminibuffer_completion_contents (),
2258 Vminibuffer_completion_table
,
2259 Vminibuffer_completion_predicate
);
2260 if (NILP (completion
))
2263 temp_echo_area_glyphs (build_string (" [No match]"));
2266 if (EQ (completion
, Qt
))
2269 #if 0 /* How the below code used to look, for reference. */
2270 tem
= Fminibuffer_contents ();
2272 i
= ZV
- 1 - SCHARS (completion
);
2273 p
= SDATA (completion
);
2275 0 <= scmp (b
, p
, ZV
- 1))
2278 /* Set buffer to longest match of buffer tail and completion head. */
2279 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2281 del_range (1, i
+ 1);
2284 #else /* Rewritten code */
2286 int buffer_nchars
, completion_nchars
;
2288 CHECK_STRING (completion
);
2289 tem
= Fminibuffer_completion_contents ();
2290 GCPRO2 (completion
, tem
);
2291 /* If reading a file name,
2292 expand any $ENVVAR refs in the buffer and in TEM. */
2293 if (! NILP (Vminibuffer_completing_file_name
))
2295 Lisp_Object substituted
;
2296 substituted
= Fsubstitute_in_file_name (tem
);
2297 if (! EQ (substituted
, tem
))
2300 del_range (prompt_end_charpos
, PT
);
2304 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2305 completion_nchars
= SCHARS (completion
);
2306 i
= buffer_nchars
- completion_nchars
;
2309 (tem1
= Fcompare_strings (tem
, make_number (0),
2310 make_number (buffer_nchars
),
2311 completion
, make_number (0),
2312 make_number (buffer_nchars
),
2313 completion_ignore_case
? Qt
: Qnil
),
2318 /* Make buffer (before point) contain the longest match
2319 of TEM's tail and COMPLETION's head. */
2325 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2326 completion
, make_number (0),
2327 make_number (buffer_nchars
),
2328 completion_ignore_case
? Qt
: Qnil
);
2335 del_range (start_pos
, start_pos
+ buffer_nchars
);
2339 #endif /* Rewritten code */
2342 int prompt_end_bytepos
;
2343 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2344 i
= PT
- prompt_end_charpos
;
2345 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2348 /* If completion finds next char not unique,
2349 consider adding a space or a hyphen. */
2350 if (i
== SCHARS (completion
))
2352 GCPRO1 (completion
);
2353 tem
= Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2354 build_string (" ")),
2355 Vminibuffer_completion_table
,
2356 Vminibuffer_completion_predicate
);
2363 GCPRO1 (completion
);
2365 Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2366 build_string ("-")),
2367 Vminibuffer_completion_table
,
2368 Vminibuffer_completion_predicate
);
2376 /* Now find first word-break in the stuff found by completion.
2377 i gets index in string of where to stop completing. */
2380 int bytes
= SBYTES (completion
);
2381 register const unsigned char *completion_string
= SDATA (completion
);
2382 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2384 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2387 if (SYNTAX (c
) != Sword
)
2396 /* If got no characters, print help for user. */
2398 if (i
== PT
- prompt_end_charpos
)
2400 if (!NILP (Vcompletion_auto_help
))
2401 Fminibuffer_completion_help ();
2405 /* Otherwise insert in minibuffer the chars we got */
2407 if (! NILP (Vminibuffer_completing_file_name
)
2408 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2410 && FETCH_CHAR (PT_BYTE
) == '/')
2412 del_range (prompt_end_charpos
, PT
+ 1);
2415 del_range (prompt_end_charpos
, PT
);
2417 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2421 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2423 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2424 Each element may be just a symbol or string
2425 or may be a list of two strings to be printed as if concatenated.
2426 If it is a list of two strings, the first is the actual completion
2427 alternative, the second serves as annotation.
2428 `standard-output' must be a buffer.
2429 The actual completion alternatives, as inserted, are given `mouse-face'
2430 properties of `highlight'.
2431 At the end, this runs the normal hook `completion-setup-hook'.
2432 It can find the completion buffer in `standard-output'.
2433 The optional second arg COMMON-SUBSTRING is a string.
2434 It is used to put faces, `completions-first-difference' and
2435 `completions-common-part' on the completion buffer. The
2436 `completions-common-part' face is put on the common substring
2437 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
2438 and the current buffer is not the minibuffer, the faces are not put.
2439 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2440 during running `completion-setup-hook'. */)
2441 (completions
, common_substring
)
2442 Lisp_Object completions
;
2443 Lisp_Object common_substring
;
2445 Lisp_Object tail
, elt
;
2448 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2449 struct buffer
*old
= current_buffer
;
2452 /* Note that (when it matters) every variable
2453 points to a non-string that is pointed to by COMPLETIONS,
2454 except for ELT. ELT can be pointing to a string
2455 when terpri or Findent_to calls a change hook. */
2457 GCPRO3 (completions
, elt
, common_substring
);
2459 if (BUFFERP (Vstandard_output
))
2460 set_buffer_internal (XBUFFER (Vstandard_output
));
2462 if (NILP (completions
))
2463 write_string ("There are no possible completions of what you have typed.",
2467 write_string ("Possible completions are:", -1);
2468 for (tail
= completions
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2470 Lisp_Object tem
, string
;
2472 Lisp_Object startpos
, endpos
;
2478 elt
= SYMBOL_NAME (elt
);
2479 /* Compute the length of this element. */
2484 length
= SCHARS (tem
);
2486 tem
= Fcar (XCDR (elt
));
2488 length
+= SCHARS (tem
);
2493 length
= SCHARS (elt
);
2496 /* This does a bad job for narrower than usual windows.
2497 Sadly, the window it will appear in is not known
2498 until after the text has been made. */
2500 if (BUFFERP (Vstandard_output
))
2501 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2503 /* If the previous completion was very wide,
2504 or we have two on this line already,
2505 don't put another on the same line. */
2506 if (column
> 33 || first
2507 /* If this is really wide, don't put it second on a line. */
2508 || (column
> 0 && length
> 45))
2513 /* Otherwise advance to column 35. */
2516 if (BUFFERP (Vstandard_output
))
2518 tem
= Findent_to (make_number (35), make_number (2));
2520 column
= XINT (tem
);
2526 write_string (" ", -1);
2529 while (column
< 35);
2533 if (BUFFERP (Vstandard_output
))
2535 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2536 Fset_text_properties (startpos
, endpos
,
2537 Qnil
, Vstandard_output
);
2540 /* Output this element.
2541 If necessary, convert it to unibyte or to multibyte first. */
2543 string
= Fcar (elt
);
2546 if (NILP (current_buffer
->enable_multibyte_characters
)
2547 && STRING_MULTIBYTE (string
))
2548 string
= Fstring_make_unibyte (string
);
2549 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2550 && !STRING_MULTIBYTE (string
))
2551 string
= Fstring_make_multibyte (string
);
2553 if (BUFFERP (Vstandard_output
))
2555 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2557 Fprinc (string
, Qnil
);
2559 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2561 Fput_text_property (startpos
, endpos
,
2562 Qmouse_face
, intern ("highlight"),
2567 Fprinc (string
, Qnil
);
2570 /* Output the annotation for this element. */
2573 if (BUFFERP (Vstandard_output
))
2575 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2577 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2579 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2581 Fset_text_properties (startpos
, endpos
, Qnil
,
2586 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2591 /* Update COLUMN for what we have output. */
2594 /* If output is to a buffer, recompute COLUMN in a way
2595 that takes account of character widths. */
2596 if (BUFFERP (Vstandard_output
))
2598 tem
= Fcurrent_column ();
2599 column
= XINT (tem
);
2606 if (BUFFERP (Vstandard_output
))
2607 set_buffer_internal (old
);
2609 if (!NILP (Vrun_hooks
))
2611 int count1
= SPECPDL_INDEX ();
2613 specbind (intern ("completion-common-substring"), common_substring
);
2614 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2616 unbind_to (count1
, Qnil
);
2626 display_completion_list_1 (list
)
2629 return Fdisplay_completion_list (list
, Qnil
);
2632 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2634 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2637 Lisp_Object completions
;
2639 message ("Making completion list...");
2640 completions
= Fall_completions (Fminibuffer_completion_contents (),
2641 Vminibuffer_completion_table
,
2642 Vminibuffer_completion_predicate
,
2644 clear_message (1, 0);
2646 if (NILP (completions
))
2649 temp_echo_area_glyphs (build_string (" [No completions]"));
2653 /* Sort and remove duplicates. */
2654 Lisp_Object tmp
= completions
= Fsort (completions
, Qstring_lessp
);
2657 if (CONSP (XCDR (tmp
))
2658 && !NILP (Fequal (XCAR (tmp
), XCAR (XCDR (tmp
)))))
2659 XSETCDR (tmp
, XCDR (XCDR (tmp
)));
2663 internal_with_output_to_temp_buffer ("*Completions*",
2664 display_completion_list_1
,
2670 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2671 doc
: /* Terminate minibuffer input. */)
2674 if (INTEGERP (last_command_char
))
2675 internal_self_insert (XINT (last_command_char
), 0);
2679 return Fexit_minibuffer ();
2682 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2683 doc
: /* Terminate this minibuffer argument. */)
2686 /* If the command that uses this has made modifications in the minibuffer,
2687 we don't want them to cause deactivation of the mark in the original
2689 A better solution would be to make deactivate-mark buffer-local
2690 (or to turn it into a list of buffers, ...), but in the mean time,
2691 this should do the trick in most cases. */
2692 Vdeactivate_mark
= Qnil
;
2693 Fthrow (Qexit
, Qnil
);
2696 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2697 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2700 return make_number (minibuf_level
);
2703 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2704 doc
: /* Return the prompt string of the currently-active minibuffer.
2705 If no minibuffer is active, return nil. */)
2708 return Fcopy_sequence (minibuf_prompt
);
2712 /* Temporarily display STRING at the end of the current
2713 minibuffer contents. This is used to display things like
2714 "[No Match]" when the user requests a completion for a prefix
2715 that has no possible completions, and other quick, unobtrusive
2718 extern Lisp_Object Vminibuffer_message_timeout
;
2721 temp_echo_area_glyphs (string
)
2725 int osize_byte
= ZV_BYTE
;
2727 int opoint_byte
= PT_BYTE
;
2728 Lisp_Object oinhibit
;
2729 oinhibit
= Vinhibit_quit
;
2731 /* Clear out any old echo-area message to make way for our new thing. */
2734 SET_PT_BOTH (osize
, osize_byte
);
2735 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2736 SET_PT_BOTH (opoint
, opoint_byte
);
2739 if (NUMBERP (Vminibuffer_message_timeout
))
2740 sit_for (Vminibuffer_message_timeout
, 0, 2);
2744 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2745 SET_PT_BOTH (opoint
, opoint_byte
);
2746 if (!NILP (Vquit_flag
))
2749 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2751 Vinhibit_quit
= oinhibit
;
2754 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2756 doc
: /* Temporarily display STRING at the end of the minibuffer.
2757 The text is displayed for a period controlled by `minibuffer-message-timeout',
2758 or until the next input event arrives, whichever comes first. */)
2762 CHECK_STRING (string
);
2763 temp_echo_area_glyphs (string
);
2768 init_minibuf_once ()
2770 Vminibuffer_list
= Qnil
;
2771 staticpro (&Vminibuffer_list
);
2778 minibuf_prompt
= Qnil
;
2779 staticpro (&minibuf_prompt
);
2781 minibuf_save_list
= Qnil
;
2782 staticpro (&minibuf_save_list
);
2784 Qread_file_name_internal
= intern ("read-file-name-internal");
2785 staticpro (&Qread_file_name_internal
);
2787 Qminibuffer_default
= intern ("minibuffer-default");
2788 staticpro (&Qminibuffer_default
);
2789 Fset (Qminibuffer_default
, Qnil
);
2791 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2792 staticpro (&Qminibuffer_completion_table
);
2794 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2795 staticpro (&Qminibuffer_completion_confirm
);
2797 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2798 staticpro (&Qminibuffer_completion_predicate
);
2800 staticpro (&last_exact_completion
);
2801 last_exact_completion
= Qnil
;
2803 staticpro (&last_minibuf_string
);
2804 last_minibuf_string
= Qnil
;
2806 Quser_variable_p
= intern ("user-variable-p");
2807 staticpro (&Quser_variable_p
);
2809 Qminibuffer_history
= intern ("minibuffer-history");
2810 staticpro (&Qminibuffer_history
);
2812 Qbuffer_name_history
= intern ("buffer-name-history");
2813 staticpro (&Qbuffer_name_history
);
2814 Fset (Qbuffer_name_history
, Qnil
);
2816 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2817 staticpro (&Qminibuffer_setup_hook
);
2819 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2820 staticpro (&Qminibuffer_exit_hook
);
2822 Qhistory_length
= intern ("history-length");
2823 staticpro (&Qhistory_length
);
2825 Qcurrent_input_method
= intern ("current-input-method");
2826 staticpro (&Qcurrent_input_method
);
2828 Qactivate_input_method
= intern ("activate-input-method");
2829 staticpro (&Qactivate_input_method
);
2831 Qcase_fold_search
= intern ("case-fold-search");
2832 staticpro (&Qcase_fold_search
);
2834 Qread_expression_history
= intern ("read-expression-history");
2835 staticpro (&Qread_expression_history
);
2837 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2838 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2839 Vread_buffer_function
= Qnil
;
2841 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2842 doc
: /* Normal hook run just after entry to minibuffer. */);
2843 Vminibuffer_setup_hook
= Qnil
;
2845 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2846 doc
: /* Normal hook run just after exit from minibuffer. */);
2847 Vminibuffer_exit_hook
= Qnil
;
2849 DEFVAR_LISP ("history-length", &Vhistory_length
,
2850 doc
: /* *Maximum length for history lists before truncation takes place.
2851 A number means that length; t means infinite. Truncation takes place
2852 just after a new element is inserted. Setting the `history-length'
2853 property of a history variable overrides this default. */);
2854 XSETFASTINT (Vhistory_length
, 30);
2856 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2857 doc
: /* *Non-nil means to delete duplicates in history.
2858 If set to t when adding a new history element, all previous identical
2859 elements are deleted from the history list. */);
2860 history_delete_duplicates
= 0;
2862 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2863 doc
: /* *Non-nil means to add new elements in history.
2864 If set to nil, minibuffer reading functions don't add new elements to the
2865 history list, so it is possible to do this afterwards by calling
2866 `add-to-history' explicitly. */);
2867 Vhistory_add_new_input
= Qt
;
2869 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2870 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2871 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2872 see the doc string of `partial-completion-mode' for more details. */);
2873 Vcompletion_auto_help
= Qt
;
2875 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2876 doc
: /* Non-nil means don't consider case significant in completion.
2878 For file-name completion, the variable `read-file-name-completion-ignore-case'
2879 controls the behavior, rather than this variable. */);
2880 completion_ignore_case
= 0;
2882 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2883 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2884 This variable makes a difference whenever the minibuffer window is active. */);
2885 enable_recursive_minibuffers
= 0;
2887 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2888 doc
: /* Alist or obarray used for completion in the minibuffer.
2889 This becomes the ALIST argument to `try-completion' and `all-completions'.
2890 The value can also be a list of strings or a hash table.
2892 The value may alternatively be a function, which is given three arguments:
2893 STRING, the current buffer contents;
2894 PREDICATE, the predicate for filtering possible matches;
2895 CODE, which says what kind of things to do.
2896 CODE can be nil, t or `lambda':
2897 nil -- return the best completion of STRING, or nil if there is none.
2898 t -- return a list of all possible completions of STRING.
2899 lambda -- return t if STRING is a valid completion as it stands. */);
2900 Vminibuffer_completion_table
= Qnil
;
2902 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2903 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2904 Vminibuffer_completion_predicate
= Qnil
;
2906 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2907 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2908 Vminibuffer_completion_confirm
= Qnil
;
2910 DEFVAR_LISP ("minibuffer-completing-file-name",
2911 &Vminibuffer_completing_file_name
,
2912 doc
: /* Non-nil means completing file names. */);
2913 Vminibuffer_completing_file_name
= Qnil
;
2915 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2916 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2917 Vminibuffer_help_form
= Qnil
;
2919 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2920 doc
: /* History list symbol to add minibuffer values to.
2921 Each string of minibuffer input, as it appears on exit from the minibuffer,
2923 (set minibuffer-history-variable
2924 (cons STRING (symbol-value minibuffer-history-variable))) */);
2925 XSETFASTINT (Vminibuffer_history_variable
, 0);
2927 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2928 doc
: /* Current position of redoing in the history list. */);
2929 Vminibuffer_history_position
= Qnil
;
2931 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2932 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2933 Some uses of the echo area also raise that frame (since they use it too). */);
2934 minibuffer_auto_raise
= 0;
2936 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2937 doc
: /* List of regexps that should restrict possible completions.
2938 The basic completion functions only consider a completion acceptable
2939 if it matches all regular expressions in this list, with
2940 `case-fold-search' bound to the value of `completion-ignore-case'.
2941 See Info node `(elisp)Basic Completion', for a description of these
2943 Vcompletion_regexp_list
= Qnil
;
2945 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2946 &minibuffer_allow_text_properties
,
2947 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2948 This also affects `read-string', but it does not affect `read-minibuffer',
2949 `read-no-blanks-input', or any of the functions that do minibuffer input
2950 with completion; they always discard text properties. */);
2951 minibuffer_allow_text_properties
= 0;
2953 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2954 doc
: /* Text properties that are added to minibuffer prompts.
2955 These are in addition to the basic `field' property, and stickiness
2957 /* We use `intern' here instead of Qread_only to avoid
2958 initialization-order problems. */
2959 Vminibuffer_prompt_properties
2960 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2962 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
2963 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2964 Vread_expression_map
= Qnil
;
2966 defsubr (&Sset_minibuffer_window
);
2967 defsubr (&Sread_from_minibuffer
);
2968 defsubr (&Seval_minibuffer
);
2969 defsubr (&Sread_minibuffer
);
2970 defsubr (&Sread_string
);
2971 defsubr (&Sread_command
);
2972 defsubr (&Sread_variable
);
2973 defsubr (&Sinternal_complete_buffer
);
2974 defsubr (&Sread_buffer
);
2975 defsubr (&Sread_no_blanks_input
);
2976 defsubr (&Sminibuffer_depth
);
2977 defsubr (&Sminibuffer_prompt
);
2979 defsubr (&Sminibufferp
);
2980 defsubr (&Sminibuffer_prompt_end
);
2981 defsubr (&Sminibuffer_contents
);
2982 defsubr (&Sminibuffer_contents_no_properties
);
2983 defsubr (&Sminibuffer_completion_contents
);
2984 defsubr (&Sdelete_minibuffer_contents
);
2986 defsubr (&Stry_completion
);
2987 defsubr (&Sall_completions
);
2988 defsubr (&Stest_completion
);
2989 defsubr (&Sassoc_string
);
2990 defsubr (&Scompleting_read
);
2991 defsubr (&Sminibuffer_complete
);
2992 defsubr (&Sminibuffer_complete_word
);
2993 defsubr (&Sminibuffer_complete_and_exit
);
2994 defsubr (&Sdisplay_completion_list
);
2995 defsubr (&Sminibuffer_completion_help
);
2997 defsubr (&Sself_insert_and_exit
);
2998 defsubr (&Sexit_minibuffer
);
3000 defsubr (&Sminibuffer_message
);
3006 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
3007 "abort-recursive-edit");
3008 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
3010 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
3013 initial_define_key (Vminibuffer_local_ns_map
, ' ',
3015 initial_define_key (Vminibuffer_local_ns_map
, '\t',
3017 initial_define_key (Vminibuffer_local_ns_map
, '?',
3018 "self-insert-and-exit");
3020 initial_define_key (Vminibuffer_local_completion_map
, '\t',
3021 "minibuffer-complete");
3022 initial_define_key (Vminibuffer_local_completion_map
, ' ',
3023 "minibuffer-complete-word");
3024 initial_define_key (Vminibuffer_local_completion_map
, '?',
3025 "minibuffer-completion-help");
3027 Fdefine_key (Vminibuffer_local_filename_completion_map
,
3028 build_string (" "), Qnil
);
3030 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
3031 "minibuffer-complete-and-exit");
3032 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
3033 "minibuffer-complete-and-exit");
3035 Fdefine_key (Vminibuffer_local_must_match_filename_map
,
3036 build_string (" "), Qnil
);
3039 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
3040 (do not change this comment) */