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"
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 Quser_variable_p
;
140 Lisp_Object Qminibuffer_default
;
142 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
144 Lisp_Object Qcase_fold_search
;
146 Lisp_Object Qread_expression_history
;
148 extern Lisp_Object Voverriding_local_map
;
150 extern Lisp_Object Qmouse_face
;
152 extern Lisp_Object Qfield
;
154 /* Put minibuf on currently selected frame's minibuffer.
155 We do this whenever the user starts a new minibuffer
156 or when a minibuffer exits. */
159 choose_minibuf_frame ()
161 if (FRAMEP (selected_frame
)
162 && FRAME_LIVE_P (XFRAME (selected_frame
))
163 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
165 struct frame
*sf
= XFRAME (selected_frame
);
168 /* I don't think that any frames may validly have a null minibuffer
170 if (NILP (sf
->minibuffer_window
))
173 /* Under X, we come here with minibuf_window being the
174 minibuffer window of the unused termcap window created in
175 init_window_once. That window doesn't have a buffer. */
176 buffer
= XWINDOW (minibuf_window
)->buffer
;
177 if (BUFFERP (buffer
))
178 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
179 minibuf_window
= sf
->minibuffer_window
;
182 /* Make sure no other frame has a minibuffer as its selected window,
183 because the text would not be displayed in it, and that would be
184 confusing. Only allow the selected frame to do this,
185 and that only if the minibuffer is active. */
187 Lisp_Object tail
, frame
;
189 FOR_EACH_FRAME (tail
, frame
)
190 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
191 && !(EQ (frame
, selected_frame
)
192 && minibuf_level
> 0))
193 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
198 choose_minibuf_frame_1 (ignore
)
201 choose_minibuf_frame ();
205 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
206 Sset_minibuffer_window
, 1, 1, 0,
207 doc
: /* Specify which minibuffer window to use for the minibuffer.
208 This affects where the minibuffer is displayed if you put text in it
209 without invoking the usual minibuffer commands. */)
213 CHECK_WINDOW (window
);
214 if (! MINI_WINDOW_P (XWINDOW (window
)))
215 error ("Window is not a minibuffer window");
217 minibuf_window
= window
;
223 /* Actual minibuffer invocation. */
225 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
226 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
227 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
228 Lisp_Object
, Lisp_Object
,
230 Lisp_Object
, Lisp_Object
,
232 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
233 Lisp_Object
, Lisp_Object
,
235 Lisp_Object
, Lisp_Object
,
237 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
240 /* Read a Lisp object from VAL and return it. If VAL is an empty
241 string, and DEFALT is a string, read from DEFALT instead of VAL. */
244 string_to_object (val
, defalt
)
245 Lisp_Object val
, defalt
;
247 struct gcpro gcpro1
, gcpro2
;
248 Lisp_Object expr_and_pos
;
251 GCPRO2 (val
, defalt
);
253 if (STRINGP (val
) && SCHARS (val
) == 0
257 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
258 pos
= XINT (Fcdr (expr_and_pos
));
259 if (pos
!= SCHARS (val
))
261 /* Ignore trailing whitespace; any other trailing junk
264 pos
= string_char_to_byte (val
, pos
);
265 for (i
= pos
; i
< SBYTES (val
); i
++)
267 int c
= SREF (val
, i
);
268 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
269 error ("Trailing garbage following expression");
273 val
= Fcar (expr_and_pos
);
274 RETURN_UNGCPRO (val
);
278 /* Like read_minibuf but reading from stdin. This function is called
279 from read_minibuf to do the job if noninteractive. */
282 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
283 histvar
, histpos
, defalt
, allow_props
,
284 inherit_input_method
)
288 Lisp_Object backup_n
;
294 int inherit_input_method
;
300 fprintf (stdout
, "%s", SDATA (prompt
));
306 line
= (char *) xmalloc (size
* sizeof *line
);
307 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
308 && (len
= strlen (line
),
309 len
== size
- 1 && line
[len
- 1] != '\n'))
312 line
= (char *) xrealloc (line
, size
);
319 if (len
> 0 && line
[len
- 1] == '\n')
322 val
= build_string (line
);
328 error ("Error reading from stdin");
331 /* If Lisp form desired instead of string, parse it. */
333 val
= string_to_object (val
, defalt
);
338 DEFUN ("minibufferp", Fminibufferp
,
339 Sminibufferp
, 0, 1, 0,
340 doc
: /* Return t if BUFFER is a minibuffer.
341 No argument or nil as argument means use current buffer as BUFFER.
342 BUFFER can be a buffer or a buffer name. */)
349 buffer
= Fcurrent_buffer ();
350 else if (STRINGP (buffer
))
351 buffer
= Fget_buffer (buffer
);
353 CHECK_BUFFER (buffer
);
355 tem
= Fmemq (buffer
, Vminibuffer_list
);
356 return ! NILP (tem
) ? Qt
: Qnil
;
359 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
360 Sminibuffer_prompt_end
, 0, 0, 0,
361 doc
: /* Return the buffer position of the end of the minibuffer prompt.
362 Return (point-min) if current buffer is not a minibuffer. */)
365 /* This function is written to be most efficient when there's a prompt. */
366 Lisp_Object beg
, end
, tem
;
367 beg
= make_number (BEGV
);
369 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
373 end
= Ffield_end (beg
, Qnil
, Qnil
);
375 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
381 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
382 Sminibuffer_contents
, 0, 0, 0,
383 doc
: /* Return the user input in a minibuffer as a string.
384 The current buffer must be a minibuffer. */)
387 int prompt_end
= XINT (Fminibuffer_prompt_end ());
388 return make_buffer_string (prompt_end
, ZV
, 1);
391 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
392 Sminibuffer_contents_no_properties
, 0, 0, 0,
393 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
394 The current buffer must be a minibuffer. */)
397 int prompt_end
= XINT (Fminibuffer_prompt_end ());
398 return make_buffer_string (prompt_end
, ZV
, 0);
401 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
402 Sminibuffer_completion_contents
, 0, 0, 0,
403 doc
: /* Return the user input in a minibuffer before point as a string.
404 That is what completion commands operate on.
405 The current buffer must be a minibuffer. */)
408 int prompt_end
= XINT (Fminibuffer_prompt_end ());
410 error ("Cannot do completion in the prompt");
411 return make_buffer_string (prompt_end
, PT
, 1);
414 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
415 Sdelete_minibuffer_contents
, 0, 0, 0,
416 doc
: /* Delete all user input in a minibuffer.
417 The current buffer must be a minibuffer. */)
420 int prompt_end
= XINT (Fminibuffer_prompt_end ());
422 del_range (prompt_end
, ZV
);
427 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
428 putting point minus BACKUP_N bytes from the end of INITIAL,
429 prompting with PROMPT (a string), using history list HISTVAR
430 with initial position HISTPOS. INITIAL should be a string or a
431 cons of a string and an integer. BACKUP_N should be <= 0, or
432 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
433 ignored and replaced with an integer that puts point at one-indexed
434 position N in INITIAL, where N is the CDR of INITIAL, or at the
435 beginning of INITIAL if N <= 0.
437 Normally return the result as a string (the text that was read),
438 but if EXPFLAG is nonzero, read it and return the object read.
439 If HISTVAR is given, save the value read on that history only if it doesn't
440 match the front of that history list exactly. The value is pushed onto
441 the list as the string that was read.
443 DEFALT specifies the default value for the sake of history commands.
445 If ALLOW_PROPS is nonzero, we do not throw away text properties.
447 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
448 current input method. */
451 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
452 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
456 Lisp_Object backup_n
;
462 int inherit_input_method
;
465 int count
= SPECPDL_INDEX ();
466 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
467 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
468 Lisp_Object enable_multibyte
;
469 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
471 /* String to add to the history. */
472 Lisp_Object histstring
;
474 Lisp_Object empty_minibuf
;
475 Lisp_Object dummy
, frame
;
477 extern Lisp_Object Qfront_sticky
;
478 extern Lisp_Object Qrear_nonsticky
;
480 specbind (Qminibuffer_default
, defalt
);
482 single_kboard_state ();
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 /* We have to do this after saving the window configuration
567 since that is what restores the current buffer. */
569 /* Arrange to restore a number of minibuffer-related variables.
570 We could bind each variable separately, but that would use lots of
573 = Fcons (Voverriding_local_map
,
574 Fcons (minibuf_window
, minibuf_save_list
));
576 = Fcons (minibuf_prompt
,
577 Fcons (make_number (minibuf_prompt_width
),
579 Fcons (Vcurrent_prefix_arg
,
580 Fcons (Vminibuffer_history_position
,
581 Fcons (Vminibuffer_history_variable
,
582 minibuf_save_list
))))));
584 record_unwind_protect (read_minibuf_unwind
, Qnil
);
586 /* We are exiting the minibuffer one way or the other, so run the hook.
587 It should be run before unwinding the minibuf settings. Do it
588 separately from read_minibuf_unwind because we need to make sure that
589 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
590 signals an error. --Stef */
591 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
593 /* Now that we can restore all those variables, start changing them. */
595 minibuf_prompt_width
= 0;
596 minibuf_prompt
= Fcopy_sequence (prompt
);
597 Vminibuffer_history_position
= histpos
;
598 Vminibuffer_history_variable
= histvar
;
599 Vhelp_form
= Vminibuffer_help_form
;
601 if (inherit_input_method
)
603 /* `current-input-method' is buffer local. So, remember it in
604 INPUT_METHOD before changing the current buffer. */
605 input_method
= Fsymbol_value (Qcurrent_input_method
);
606 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
609 /* Switch to the minibuffer. */
611 minibuffer
= get_minibuffer (minibuf_level
);
612 Fset_buffer (minibuffer
);
614 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
615 if (inherit_input_method
)
616 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
618 /* The current buffer's default directory is usually the right thing
619 for our minibuffer here. However, if you're typing a command at
620 a minibuffer-only frame when minibuf_level is zero, then buf IS
621 the current_buffer, so reset_buffer leaves buf's default
622 directory unchanged. This is a bummer when you've just started
623 up Emacs and buf's default directory is Qnil. Here's a hack; can
624 you think of something better to do? Find another buffer with a
625 better directory, and use that one instead. */
626 if (STRINGP (ambient_dir
))
627 current_buffer
->directory
= ambient_dir
;
630 Lisp_Object buf_list
;
632 for (buf_list
= Vbuffer_alist
;
634 buf_list
= XCDR (buf_list
))
636 Lisp_Object other_buf
;
638 other_buf
= XCDR (XCAR (buf_list
));
639 if (STRINGP (XBUFFER (other_buf
)->directory
))
641 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
647 if (!EQ (mini_frame
, selected_frame
))
648 Fredirect_frame_focus (selected_frame
, mini_frame
);
650 Vminibuf_scroll_window
= selected_window
;
651 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
652 minibuf_selected_window
= selected_window
;
654 /* Empty out the minibuffers of all frames other than the one
655 where we are going to display one now.
656 Set them to point to ` *Minibuf-0*', which is always empty. */
657 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
659 FOR_EACH_FRAME (dummy
, frame
)
661 Lisp_Object root_window
= Fframe_root_window (frame
);
662 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
664 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
665 && !NILP (Fwindow_minibuffer_p (mini_window
)))
666 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
669 /* Display this minibuffer in the proper window. */
670 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
671 Fselect_window (minibuf_window
, Qnil
);
672 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
674 Fmake_local_variable (Qprint_escape_newlines
);
675 print_escape_newlines
= 1;
677 /* Erase the buffer. */
679 int count1
= SPECPDL_INDEX ();
680 specbind (Qinhibit_read_only
, Qt
);
681 specbind (Qinhibit_modification_hooks
, Qt
);
683 unbind_to (count1
, Qnil
);
686 if (!NILP (current_buffer
->enable_multibyte_characters
)
687 && ! STRING_MULTIBYTE (minibuf_prompt
))
688 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
690 /* Insert the prompt, record where it ends. */
691 Finsert (1, &minibuf_prompt
);
694 Fput_text_property (make_number (BEG
), make_number (PT
),
695 Qfront_sticky
, Qt
, Qnil
);
696 Fput_text_property (make_number (BEG
), make_number (PT
),
697 Qrear_nonsticky
, Qt
, Qnil
);
698 Fput_text_property (make_number (BEG
), make_number (PT
),
700 Fadd_text_properties (make_number (BEG
), make_number (PT
),
701 Vminibuffer_prompt_properties
, Qnil
);
704 minibuf_prompt_width
= (int) current_column (); /* iftc */
706 /* Put in the initial input. */
709 Finsert (1, &initial
);
710 Fforward_char (make_number (pos
));
713 clear_message (1, 1);
714 current_buffer
->keymap
= map
;
716 /* Turn on an input method stored in INPUT_METHOD if any. */
717 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
718 call1 (Qactivate_input_method
, input_method
);
720 /* Run our hook, but not if it is empty.
721 (run-hooks would do nothing if it is empty,
722 but it's important to save time here in the usual case.) */
723 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
724 && !NILP (Vrun_hooks
))
725 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
727 /* Don't allow the user to undo past this point. */
728 current_buffer
->undo_list
= Qnil
;
732 /* If cursor is on the minibuffer line,
733 show the user we have exited by putting it in column 0. */
734 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
737 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
738 XWINDOW (minibuf_window
)->cursor
.x
= 0;
739 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
740 update_frame (XFRAME (selected_frame
), 1, 1);
741 if (rif
&& rif
->flush_display
)
742 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
745 /* Make minibuffer contents into a string. */
746 Fset_buffer (minibuffer
);
748 val
= Fminibuffer_contents ();
750 val
= Fminibuffer_contents_no_properties ();
752 /* VAL is the string of minibuffer text. */
754 last_minibuf_string
= val
;
756 /* Choose the string to add to the history. */
757 if (SCHARS (val
) != 0)
759 else if (STRINGP (defalt
))
764 /* Add the value to the appropriate history list, if any. */
765 if (!NILP (Vhistory_add_new_input
)
766 && SYMBOLP (Vminibuffer_history_variable
)
767 && !NILP (histstring
))
769 /* If the caller wanted to save the value read on a history list,
770 then do so if the value is not already the front of the list. */
773 /* If variable is unbound, make it nil. */
774 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
775 Fset (Vminibuffer_history_variable
, Qnil
);
777 histval
= Fsymbol_value (Vminibuffer_history_variable
);
779 /* The value of the history variable must be a cons or nil. Other
780 values are unacceptable. We silently ignore these values. */
784 /* Don't duplicate the most recent entry in the history. */
785 && (NILP (Fequal (histstring
, Fcar (histval
))))))
789 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
790 histval
= Fcons (histstring
, histval
);
791 Fset (Vminibuffer_history_variable
, histval
);
793 /* Truncate if requested. */
794 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
795 if (NILP (length
)) length
= Vhistory_length
;
796 if (INTEGERP (length
))
798 if (XINT (length
) <= 0)
799 Fset (Vminibuffer_history_variable
, Qnil
);
804 temp
= Fnthcdr (Fsub1 (length
), histval
);
805 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
811 /* If Lisp form desired instead of string, parse it. */
813 val
= string_to_object (val
, defalt
);
815 /* The appropriate frame will get selected
816 in set-window-configuration. */
818 return unbind_to (count
, val
);
821 /* Return a buffer to be used as the minibuffer at depth `depth'.
822 depth = 0 is the lowest allowed argument, and that is the value
823 used for nonrecursive minibuffer invocations */
826 get_minibuffer (depth
)
829 Lisp_Object tail
, num
, buf
;
831 extern Lisp_Object
nconc2 ();
833 XSETFASTINT (num
, depth
);
834 tail
= Fnthcdr (num
, Vminibuffer_list
);
837 tail
= Fcons (Qnil
, Qnil
);
838 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
841 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
843 sprintf (name
, " *Minibuf-%d*", depth
);
844 buf
= Fget_buffer_create (build_string (name
));
846 /* Although the buffer's name starts with a space, undo should be
848 Fbuffer_enable_undo (buf
);
854 int count
= SPECPDL_INDEX ();
855 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
856 have to empty the list, otherwise we end up with overlays that
857 think they belong to this buffer while the buffer doesn't know about
859 delete_all_overlays (XBUFFER (buf
));
860 reset_buffer (XBUFFER (buf
));
861 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
863 Fkill_all_local_variables ();
864 unbind_to (count
, Qnil
);
871 run_exit_minibuf_hook (data
)
874 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
875 && !NILP (Vrun_hooks
))
876 safe_run_hooks (Qminibuffer_exit_hook
);
881 /* This function is called on exiting minibuffer, whether normally or
882 not, and it restores the current window, buffer, etc. */
885 read_minibuf_unwind (data
)
888 Lisp_Object old_deactivate_mark
;
891 /* If this was a recursive minibuffer,
892 tie the minibuffer window back to the outer level minibuffer buffer. */
895 window
= minibuf_window
;
896 /* To keep things predictable, in case it matters, let's be in the
897 minibuffer when we reset the relevant variables. */
898 Fset_buffer (XWINDOW (window
)->buffer
);
900 /* Restore prompt, etc, from outer minibuffer level. */
901 minibuf_prompt
= Fcar (minibuf_save_list
);
902 minibuf_save_list
= Fcdr (minibuf_save_list
);
903 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
904 minibuf_save_list
= Fcdr (minibuf_save_list
);
905 Vhelp_form
= Fcar (minibuf_save_list
);
906 minibuf_save_list
= Fcdr (minibuf_save_list
);
907 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
908 minibuf_save_list
= Fcdr (minibuf_save_list
);
909 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
910 minibuf_save_list
= Fcdr (minibuf_save_list
);
911 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
912 minibuf_save_list
= Fcdr (minibuf_save_list
);
913 Voverriding_local_map
= Fcar (minibuf_save_list
);
914 minibuf_save_list
= Fcdr (minibuf_save_list
);
916 temp
= Fcar (minibuf_save_list
);
917 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
918 minibuf_window
= temp
;
920 minibuf_save_list
= Fcdr (minibuf_save_list
);
922 /* Erase the minibuffer we were using at this level. */
924 int count
= SPECPDL_INDEX ();
925 /* Prevent error in erase-buffer. */
926 specbind (Qinhibit_read_only
, Qt
);
927 specbind (Qinhibit_modification_hooks
, Qt
);
928 old_deactivate_mark
= Vdeactivate_mark
;
930 Vdeactivate_mark
= old_deactivate_mark
;
931 unbind_to (count
, Qnil
);
934 /* When we get to the outmost level, make sure we resize the
935 mini-window back to its normal size. */
936 if (minibuf_level
== 0)
937 resize_mini_window (XWINDOW (window
), 0);
939 /* Make sure minibuffer window is erased, not ignored. */
940 windows_or_buffers_changed
++;
941 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
942 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
947 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
948 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
949 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
950 DEFAULT-VALUE. It normally should be nil in new code, except when
951 HIST is a cons. It is discussed in more detail below.
952 Third arg KEYMAP is a keymap to use whilst reading;
953 if omitted or nil, the default is `minibuffer-local-map'.
954 If fourth arg READ is non-nil, then interpret the result as a Lisp object
955 and return that object:
956 in other words, do `(car (read-from-string INPUT-STRING))'
957 Fifth arg HIST, if non-nil, specifies a history list and optionally
958 the initial position in the list. It can be a symbol, which is the
959 history list variable to use, or it can be a cons cell
960 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
961 to use, and HISTPOS is the initial position for use by the minibuffer
962 history commands. For consistency, you should also specify that
963 element of the history as the value of INITIAL-CONTENTS. Positions
964 are counted starting from 1 at the beginning of the list.
965 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
966 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
967 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
969 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
970 the current input method and the setting of `enable-multibyte-characters'.
971 If the variable `minibuffer-allow-text-properties' is non-nil,
972 then the string which is returned includes whatever text properties
973 were present in the minibuffer. Otherwise the value has no text properties.
975 The remainder of this documentation string describes the
976 INITIAL-CONTENTS argument in more detail. It is only relevant when
977 studying existing code, or when HIST is a cons. If non-nil,
978 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
979 reading input. Normally, point is put at the end of that string.
980 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
981 input is STRING, but point is placed at _one-indexed_ position
982 POSITION in the minibuffer. Any integer value less than or equal to
983 one puts point at the beginning of the string. *Note* that this
984 behavior differs from the way such arguments are used in `completing-read'
985 and some related functions, which use zero-indexing for POSITION. */)
986 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
987 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
988 Lisp_Object inherit_input_method
;
990 Lisp_Object histvar
, histpos
, val
;
993 CHECK_STRING (prompt
);
995 keymap
= Vminibuffer_local_map
;
997 keymap
= get_keymap (keymap
, 1, 0);
1006 histvar
= Fcar_safe (hist
);
1007 histpos
= Fcdr_safe (hist
);
1010 histvar
= Qminibuffer_history
;
1012 XSETFASTINT (histpos
, 0);
1014 GCPRO1 (default_value
);
1015 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1017 histvar
, histpos
, default_value
,
1018 minibuffer_allow_text_properties
,
1019 !NILP (inherit_input_method
));
1024 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1025 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1026 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1027 is a string to insert in the minibuffer before reading.
1028 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1029 arguments are used as in `read-from-minibuffer'.) */)
1030 (prompt
, initial_contents
)
1031 Lisp_Object prompt
, initial_contents
;
1033 CHECK_STRING (prompt
);
1034 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1035 prompt
, Qnil
, 1, Qminibuffer_history
,
1036 make_number (0), Qnil
, 0, 0);
1039 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1040 doc
: /* Return value of Lisp expression read using the minibuffer.
1041 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1042 is a string to insert in the minibuffer before reading.
1043 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1044 arguments are used as in `read-from-minibuffer'.) */)
1045 (prompt
, initial_contents
)
1046 Lisp_Object prompt
, initial_contents
;
1048 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1049 prompt
, Qnil
, 1, Qread_expression_history
,
1050 make_number (0), Qnil
, 0, 0));
1053 /* Functions that use the minibuffer to read various things. */
1055 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1056 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1057 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1058 This argument has been superseded by DEFAULT-VALUE and should normally
1059 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1060 documentation string of that function for details.
1061 The third arg HISTORY, if non-nil, specifies a history list
1062 and optionally the initial position in the list.
1063 See `read-from-minibuffer' for details of HISTORY argument.
1064 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1065 for history commands, and as the value to return if the user enters
1067 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1068 the current input method and the setting of `enable-multibyte-characters'. */)
1069 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1070 Lisp_Object prompt
, initial_input
, history
, default_value
;
1071 Lisp_Object inherit_input_method
;
1074 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1075 Qnil
, history
, default_value
,
1076 inherit_input_method
);
1077 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1078 val
= default_value
;
1082 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1083 doc
: /* Read a string from the terminal, not allowing blanks.
1084 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1085 non-nil, it should be a string, which is used as initial input, with
1086 point positioned at the end, so that SPACE will accept the input.
1087 \(Actually, INITIAL can also be a cons of a string and an integer.
1088 Such values are treated as in `read-from-minibuffer', but are normally
1089 not useful in this function.)
1090 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1091 the current input method and the setting of`enable-multibyte-characters'. */)
1092 (prompt
, initial
, inherit_input_method
)
1093 Lisp_Object prompt
, initial
, inherit_input_method
;
1095 CHECK_STRING (prompt
);
1096 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1097 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1098 !NILP (inherit_input_method
));
1101 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1102 doc
: /* Read the name of a command and return as a symbol.
1103 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1104 (prompt
, default_value
)
1105 Lisp_Object prompt
, default_value
;
1107 Lisp_Object name
, default_string
;
1109 if (NILP (default_value
))
1110 default_string
= Qnil
;
1111 else if (SYMBOLP (default_value
))
1112 default_string
= SYMBOL_NAME (default_value
);
1114 default_string
= default_value
;
1116 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1117 Qnil
, Qnil
, default_string
, Qnil
);
1120 return Fintern (name
, Qnil
);
1124 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1125 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1126 Prompt with PROMPT. */)
1130 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1135 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1136 doc
: /* Read the name of a user variable and return it as a symbol.
1137 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1138 A user variable is one for which `user-variable-p' returns non-nil. */)
1139 (prompt
, default_value
)
1140 Lisp_Object prompt
, default_value
;
1142 Lisp_Object name
, default_string
;
1144 if (NILP (default_value
))
1145 default_string
= Qnil
;
1146 else if (SYMBOLP (default_value
))
1147 default_string
= SYMBOL_NAME (default_value
);
1149 default_string
= default_value
;
1151 name
= Fcompleting_read (prompt
, Vobarray
,
1152 Quser_variable_p
, Qt
,
1153 Qnil
, Qnil
, default_string
, Qnil
);
1156 return Fintern (name
, Qnil
);
1159 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1160 doc
: /* Read the name of a buffer and return as a string.
1162 Optional second arg DEF is value to return if user enters an empty line.
1163 If optional third arg REQUIRE-MATCH is non-nil,
1164 only existing buffer names are allowed.
1165 The argument PROMPT should be a string ending with a colon and a space. */)
1166 (prompt
, def
, require_match
)
1167 Lisp_Object prompt
, def
, require_match
;
1169 Lisp_Object args
[4];
1174 def
= XBUFFER (def
)->name
;
1176 if (NILP (Vread_buffer_function
))
1180 /* A default value was provided: we must change PROMPT,
1181 editing the default value in before the colon. To achieve
1182 this, we replace PROMPT with a substring that doesn't
1183 contain the terminal space and colon (if present). They
1184 are then added back using Fformat. */
1186 if (STRINGP (prompt
))
1190 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1192 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1195 prompt
= make_specified_string (s
, -1, len
,
1196 STRING_MULTIBYTE (prompt
));
1199 args
[0] = build_string ("%s (default %s): ");
1202 prompt
= Fformat (3, args
);
1205 return Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1206 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1211 args
[0] = Vread_buffer_function
;
1214 args
[3] = require_match
;
1215 return Ffuncall(4, args
);
1220 minibuf_conform_representation (string
, basis
)
1221 Lisp_Object string
, basis
;
1223 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1226 if (STRING_MULTIBYTE (string
))
1227 return Fstring_make_unibyte (string
);
1229 return Fstring_make_multibyte (string
);
1232 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1233 doc
: /* Return common substring of all completions of STRING in ALIST.
1234 Each car of each element of ALIST (or each element if it is not a cons cell)
1235 is tested to see if it begins with STRING. The possible matches may be
1236 strings or symbols. Symbols are converted to strings before testing,
1238 All that match are compared together; the longest initial sequence
1239 common to all matches is returned as a string.
1240 If there is no match at all, nil is returned.
1241 For a unique match which is exact, t is returned.
1243 If ALIST is a hash-table, all the string and symbol keys are the
1245 If ALIST is an obarray, the names of all symbols in the obarray
1246 are the possible matches.
1248 ALIST can also be a function to do the completion itself.
1249 It receives three arguments: the values STRING, PREDICATE and nil.
1250 Whatever it returns becomes the value of `try-completion'.
1252 If optional third argument PREDICATE is non-nil,
1253 it is used to test each possible match.
1254 The match is a candidate only if PREDICATE returns non-nil.
1255 The argument given to PREDICATE is the alist element
1256 or the symbol from the obarray. If ALIST is a hash-table,
1257 predicate is called with two arguments: the key and the value.
1258 Additionally to this predicate, `completion-regexp-list'
1259 is used to further constrain the set of candidates. */)
1260 (string
, alist
, predicate
)
1261 Lisp_Object string
, alist
, predicate
;
1263 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1264 /* Size in bytes of BESTMATCH. */
1265 int bestmatchsize
= 0;
1266 /* These are in bytes, too. */
1267 int compare
, matchsize
;
1268 int type
= (HASH_TABLE_P (alist
) ? 3
1269 : VECTORP (alist
) ? 2
1270 : NILP (alist
) || (CONSP (alist
)
1271 && (!SYMBOLP (XCAR (alist
))
1272 || NILP (XCAR (alist
)))));
1273 int index
= 0, obsize
= 0;
1276 Lisp_Object bucket
, zero
, end
, tem
;
1277 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1279 CHECK_STRING (string
);
1281 return call3 (alist
, string
, predicate
, Qnil
);
1283 bestmatch
= bucket
= Qnil
;
1284 zero
= make_number (0);
1286 /* If ALIST is not a list, set TAIL just for gc pro. */
1290 alist
= check_obarray (alist
);
1291 obsize
= XVECTOR (alist
)->size
;
1292 bucket
= XVECTOR (alist
)->contents
[index
];
1297 /* Get the next element of the alist, obarray, or hash-table. */
1298 /* Exit the loop if the elements are all used up. */
1299 /* elt gets the alist element or symbol.
1300 eltstring gets the name to check as a completion. */
1307 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1312 if (!EQ (bucket
, zero
))
1314 if (!SYMBOLP (bucket
))
1315 error ("Bad data in guts of obarray");
1318 if (XSYMBOL (bucket
)->next
)
1319 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1321 XSETFASTINT (bucket
, 0);
1323 else if (++index
>= obsize
)
1327 bucket
= XVECTOR (alist
)->contents
[index
];
1331 else /* if (type == 3) */
1333 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1334 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1336 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1339 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1342 /* Is this element a possible completion? */
1344 if (SYMBOLP (eltstring
))
1345 eltstring
= Fsymbol_name (eltstring
);
1347 if (STRINGP (eltstring
)
1348 && SCHARS (string
) <= SCHARS (eltstring
)
1349 && (tem
= Fcompare_strings (eltstring
, zero
,
1350 make_number (SCHARS (string
)),
1352 completion_ignore_case
? Qt
: Qnil
),
1356 Lisp_Object regexps
;
1358 /* Ignore this element if it fails to match all the regexps. */
1360 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1361 regexps
= XCDR (regexps
))
1363 if (bindcount
< 0) {
1364 bindcount
= SPECPDL_INDEX ();
1365 specbind (Qcase_fold_search
,
1366 completion_ignore_case
? Qt
: Qnil
);
1368 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1372 if (CONSP (regexps
))
1376 /* Ignore this element if there is a predicate
1377 and the predicate doesn't like it. */
1379 if (!NILP (predicate
))
1381 if (EQ (predicate
, Qcommandp
))
1382 tem
= Fcommandp (elt
, Qnil
);
1385 if (bindcount
>= 0) {
1386 unbind_to (bindcount
, Qnil
);
1389 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1391 ? call2 (predicate
, elt
,
1392 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1393 : call1 (predicate
, elt
);
1396 if (NILP (tem
)) continue;
1399 /* Update computation of how much all possible completions match */
1401 if (NILP (bestmatch
))
1404 bestmatch
= eltstring
;
1405 bestmatchsize
= SCHARS (eltstring
);
1409 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1410 tem
= Fcompare_strings (bestmatch
, zero
,
1411 make_number (compare
),
1413 make_number (compare
),
1414 completion_ignore_case
? Qt
: Qnil
);
1416 matchsize
= compare
;
1417 else if (XINT (tem
) < 0)
1418 matchsize
= - XINT (tem
) - 1;
1420 matchsize
= XINT (tem
) - 1;
1423 /* When can this happen ? -stef */
1424 matchsize
= compare
;
1425 if (completion_ignore_case
)
1427 /* If this is an exact match except for case,
1428 use it as the best match rather than one that is not an
1429 exact match. This way, we get the case pattern
1430 of the actual match. */
1431 if ((matchsize
== SCHARS (eltstring
)
1432 && matchsize
< SCHARS (bestmatch
))
1434 /* If there is more than one exact match ignoring case,
1435 and one of them is exact including case,
1437 /* If there is no exact match ignoring case,
1438 prefer a match that does not change the case
1440 ((matchsize
== SCHARS (eltstring
))
1442 (matchsize
== SCHARS (bestmatch
))
1443 && (tem
= Fcompare_strings (eltstring
, zero
,
1444 make_number (SCHARS (string
)),
1449 && (tem
= Fcompare_strings (bestmatch
, zero
,
1450 make_number (SCHARS (string
)),
1455 bestmatch
= eltstring
;
1457 if (bestmatchsize
!= SCHARS (eltstring
)
1458 || bestmatchsize
!= matchsize
)
1459 /* Don't count the same string multiple times. */
1461 bestmatchsize
= matchsize
;
1462 if (matchsize
<= SCHARS (string
)
1464 /* No need to look any further. */
1470 if (bindcount
>= 0) {
1471 unbind_to (bindcount
, Qnil
);
1475 if (NILP (bestmatch
))
1476 return Qnil
; /* No completions found */
1477 /* If we are ignoring case, and there is no exact match,
1478 and no additional text was supplied,
1479 don't change the case of what the user typed. */
1480 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1481 && SCHARS (bestmatch
) > bestmatchsize
)
1482 return minibuf_conform_representation (string
, bestmatch
);
1484 /* Return t if the supplied string is an exact match (counting case);
1485 it does not require any change to be made. */
1486 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1487 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1488 make_number (bestmatchsize
),
1489 string
, make_number (0),
1490 make_number (bestmatchsize
),
1495 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1496 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1497 return Fsubstring (bestmatch
, zero
, end
);
1500 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1501 doc
: /* Search for partial matches to STRING in ALIST.
1502 Each car of each element of ALIST (or each element if it is not a cons cell)
1503 is tested to see if it begins with STRING. The possible matches may be
1504 strings or symbols. Symbols are converted to strings before testing,
1506 The value is a list of all the strings from ALIST that match.
1508 If ALIST is a hash-table, all the string and symbol keys are the
1510 If ALIST is an obarray, the names of all symbols in the obarray
1511 are the possible matches.
1513 ALIST can also be a function to do the completion itself.
1514 It receives three arguments: the values STRING, PREDICATE and t.
1515 Whatever it returns becomes the value of `all-completions'.
1517 If optional third argument PREDICATE is non-nil,
1518 it is used to test each possible match.
1519 The match is a candidate only if PREDICATE returns non-nil.
1520 The argument given to PREDICATE is the alist element
1521 or the symbol from the obarray. If ALIST is a hash-table,
1522 predicate is called with two arguments: the key and the value.
1523 Additionally to this predicate, `completion-regexp-list'
1524 is used to further constrain the set of candidates.
1526 If the optional fourth argument HIDE-SPACES is non-nil,
1527 strings in ALIST that start with a space
1528 are ignored unless STRING itself starts with a space. */)
1529 (string
, alist
, predicate
, hide_spaces
)
1530 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1532 Lisp_Object tail
, elt
, eltstring
;
1533 Lisp_Object allmatches
;
1534 int type
= HASH_TABLE_P (alist
) ? 3
1535 : VECTORP (alist
) ? 2
1536 : NILP (alist
) || (CONSP (alist
)
1537 && (!SYMBOLP (XCAR (alist
))
1538 || NILP (XCAR (alist
))));
1539 int index
= 0, obsize
= 0;
1541 Lisp_Object bucket
, tem
, zero
;
1542 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1544 CHECK_STRING (string
);
1546 return call3 (alist
, string
, predicate
, Qt
);
1547 allmatches
= bucket
= Qnil
;
1548 zero
= make_number (0);
1550 /* If ALIST is not a list, set TAIL just for gc pro. */
1554 obsize
= XVECTOR (alist
)->size
;
1555 bucket
= XVECTOR (alist
)->contents
[index
];
1560 /* Get the next element of the alist, obarray, or hash-table. */
1561 /* Exit the loop if the elements are all used up. */
1562 /* elt gets the alist element or symbol.
1563 eltstring gets the name to check as a completion. */
1570 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1575 if (!EQ (bucket
, zero
))
1579 if (XSYMBOL (bucket
)->next
)
1580 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1582 XSETFASTINT (bucket
, 0);
1584 else if (++index
>= obsize
)
1588 bucket
= XVECTOR (alist
)->contents
[index
];
1592 else /* if (type == 3) */
1594 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1595 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1597 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1600 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1603 /* Is this element a possible completion? */
1605 if (SYMBOLP (eltstring
))
1606 eltstring
= Fsymbol_name (eltstring
);
1608 if (STRINGP (eltstring
)
1609 && SCHARS (string
) <= SCHARS (eltstring
)
1610 /* If HIDE_SPACES, reject alternatives that start with space
1611 unless the input starts with space. */
1612 && ((SBYTES (string
) > 0
1613 && SREF (string
, 0) == ' ')
1614 || SREF (eltstring
, 0) != ' '
1615 || NILP (hide_spaces
))
1616 && (tem
= Fcompare_strings (eltstring
, zero
,
1617 make_number (SCHARS (string
)),
1619 make_number (SCHARS (string
)),
1620 completion_ignore_case
? Qt
: Qnil
),
1624 Lisp_Object regexps
;
1626 XSETFASTINT (zero
, 0);
1628 /* Ignore this element if it fails to match all the regexps. */
1630 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1631 regexps
= XCDR (regexps
))
1633 if (bindcount
< 0) {
1634 bindcount
= SPECPDL_INDEX ();
1635 specbind (Qcase_fold_search
,
1636 completion_ignore_case
? Qt
: Qnil
);
1638 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1642 if (CONSP (regexps
))
1646 /* Ignore this element if there is a predicate
1647 and the predicate doesn't like it. */
1649 if (!NILP (predicate
))
1651 if (EQ (predicate
, Qcommandp
))
1652 tem
= Fcommandp (elt
, Qnil
);
1655 if (bindcount
>= 0) {
1656 unbind_to (bindcount
, Qnil
);
1659 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1661 ? call2 (predicate
, elt
,
1662 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1663 : call1 (predicate
, elt
);
1666 if (NILP (tem
)) continue;
1668 /* Ok => put it on the list. */
1669 allmatches
= Fcons (eltstring
, allmatches
);
1673 if (bindcount
>= 0) {
1674 unbind_to (bindcount
, Qnil
);
1678 return Fnreverse (allmatches
);
1681 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1682 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1683 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1684 Lisp_Object Vminibuffer_completing_file_name
;
1686 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1687 doc
: /* Read a string in the minibuffer, with completion.
1688 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1689 TABLE can be a list of strings, an alist, an obarray or a hash table.
1690 TABLE can also be a function to do the completion itself.
1691 PREDICATE limits completion to a subset of TABLE.
1692 See `try-completion' and `all-completions' for more details
1693 on completion, TABLE, and PREDICATE.
1695 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1696 the input is (or completes to) an element of TABLE or is null.
1697 If it is also not t, typing RET does not exit if it does non-null completion.
1698 If the input is null, `completing-read' returns DEF, or an empty string
1699 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1701 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1702 with point positioned at the end.
1703 If it is (STRING . POSITION), the initial input is STRING, but point
1704 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1705 that this is different from `read-from-minibuffer' and related
1706 functions, which use one-indexing for POSITION.) This feature is
1707 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1708 default value DEF instead. The user can yank the default value into
1709 the minibuffer easily using \\[next-history-element].
1711 HIST, if non-nil, specifies a history list and optionally the initial
1712 position in the list. It can be a symbol, which is the history list
1713 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1714 that case, HISTVAR is the history list variable to use, and HISTPOS
1715 is the initial position (the position in the list used by the
1716 minibuffer history commands). For consistency, you should also
1717 specify that element of the history as the value of
1718 INITIAL-INPUT. (This is the only case in which you should use
1719 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1720 1 at the beginning of the list. The variable `history-length'
1721 controls the maximum length of a history list.
1723 DEF, if non-nil, is the default value.
1725 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1726 the current input method and the setting of `enable-multibyte-characters'.
1728 Completion ignores case if the ambient value of
1729 `completion-ignore-case' is non-nil. */)
1730 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1731 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1732 Lisp_Object hist
, def
, inherit_input_method
;
1734 Lisp_Object val
, histvar
, histpos
, position
;
1737 int count
= SPECPDL_INDEX ();
1738 struct gcpro gcpro1
;
1740 init
= initial_input
;
1743 specbind (Qminibuffer_completion_table
, table
);
1744 specbind (Qminibuffer_completion_predicate
, predicate
);
1745 specbind (Qminibuffer_completion_confirm
,
1746 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1747 last_exact_completion
= Qnil
;
1754 position
= Fcdr (init
);
1757 CHECK_STRING (init
);
1758 if (!NILP (position
))
1760 CHECK_NUMBER (position
);
1761 /* Convert to distance from end of input. */
1762 pos
= XINT (position
) - SCHARS (init
);
1773 histvar
= Fcar_safe (hist
);
1774 histpos
= Fcdr_safe (hist
);
1777 histvar
= Qminibuffer_history
;
1779 XSETFASTINT (histpos
, 0);
1781 val
= read_minibuf (NILP (require_match
)
1782 ? (NILP (Vminibuffer_completing_file_name
)
1783 ? Vminibuffer_local_completion_map
1784 : Vminibuffer_local_filename_completion_map
)
1785 : (NILP (Vminibuffer_completing_file_name
)
1786 ? Vminibuffer_local_must_match_map
1787 : Vminibuffer_local_must_match_filename_map
),
1788 init
, prompt
, make_number (pos
), 0,
1789 histvar
, histpos
, def
, 0,
1790 !NILP (inherit_input_method
));
1792 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1795 RETURN_UNGCPRO (unbind_to (count
, val
));
1798 Lisp_Object
Fminibuffer_completion_help ();
1799 Lisp_Object
Fassoc_string ();
1801 /* Test whether TXT is an exact completion. */
1802 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1803 doc
: /* Return non-nil if STRING is a valid completion.
1804 Takes the same arguments as `all-completions' and `try-completion'.
1805 If ALIST is a function, it is called with three arguments:
1806 the values STRING, PREDICATE and `lambda'. */)
1807 (string
, alist
, predicate
)
1808 Lisp_Object string
, alist
, predicate
;
1810 Lisp_Object regexps
, tail
, tem
= Qnil
;
1813 CHECK_STRING (string
);
1815 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1818 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1822 else if (VECTORP (alist
))
1824 /* Bypass intern-soft as that loses for nil. */
1825 tem
= oblookup (alist
,
1831 if (STRING_MULTIBYTE (string
))
1832 string
= Fstring_make_unibyte (string
);
1834 string
= Fstring_make_multibyte (string
);
1836 tem
= oblookup (alist
,
1842 if (completion_ignore_case
&& !SYMBOLP (tem
))
1844 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1846 tail
= XVECTOR (alist
)->contents
[i
];
1850 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1851 Fsymbol_name (tail
),
1852 make_number (0) , Qnil
, Qt
)),
1858 if (XSYMBOL (tail
)->next
== 0)
1860 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1868 else if (HASH_TABLE_P (alist
))
1870 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1871 i
= hash_lookup (h
, string
, NULL
);
1873 tem
= HASH_KEY (h
, i
);
1875 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1876 if (!NILP (HASH_HASH (h
, i
)) &&
1877 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1878 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1879 completion_ignore_case
? Qt
: Qnil
),
1882 tem
= HASH_KEY (h
, i
);
1889 return call3 (alist
, string
, predicate
, Qlambda
);
1891 /* Reject this element if it fails to match all the regexps. */
1892 if (CONSP (Vcompletion_regexp_list
))
1894 int count
= SPECPDL_INDEX ();
1895 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1896 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1897 regexps
= XCDR (regexps
))
1899 if (NILP (Fstring_match (XCAR (regexps
),
1900 SYMBOLP (tem
) ? string
: tem
,
1902 return unbind_to (count
, Qnil
);
1904 unbind_to (count
, Qnil
);
1907 /* Finally, check the predicate. */
1908 if (!NILP (predicate
))
1910 return HASH_TABLE_P (alist
)
1911 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1912 : call1 (predicate
, tem
);
1918 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1919 doc
: /* Perform completion on buffer names.
1920 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1921 `all-completions', otherwise invoke `test-completion'.
1923 The arguments STRING and PREDICATE are as in `try-completion',
1924 `all-completions', and `test-completion'. */)
1925 (string
, predicate
, flag
)
1926 Lisp_Object string
, predicate
, flag
;
1929 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1930 else if (EQ (flag
, Qt
))
1931 return Fall_completions (string
, Vbuffer_alist
, predicate
, Qt
);
1932 else /* assume `lambda' */
1933 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1937 * 0 no possible completion
1938 * 1 was already an exact and unique completion
1939 * 3 was already an exact completion
1940 * 4 completed to an exact completion
1941 * 5 some completion happened
1942 * 6 no completion happened
1947 Lisp_Object completion
, string
, tem
;
1950 struct gcpro gcpro1
, gcpro2
;
1952 completion
= Ftry_completion (Fminibuffer_completion_contents (),
1953 Vminibuffer_completion_table
,
1954 Vminibuffer_completion_predicate
);
1955 last
= last_exact_completion
;
1956 last_exact_completion
= Qnil
;
1958 GCPRO2 (completion
, last
);
1960 if (NILP (completion
))
1963 temp_echo_area_glyphs (build_string (" [No match]"));
1968 if (EQ (completion
, Qt
)) /* exact and unique match */
1974 string
= Fminibuffer_completion_contents ();
1976 /* COMPLETEDP should be true if some completion was done, which
1977 doesn't include simply changing the case of the entered string.
1978 However, for appearance, the string is rewritten if the case
1980 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1981 completedp
= !EQ (tem
, Qt
);
1983 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1985 /* Rewrite the user's input. */
1987 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1988 /* Some completion happened */
1990 if (! NILP (Vminibuffer_completing_file_name
)
1991 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1993 && FETCH_CHAR (PT_BYTE
) == '/')
1995 del_range (prompt_end
, PT
+ 1);
1998 del_range (prompt_end
, PT
);
2000 Finsert (1, &completion
);
2003 /* The case of the string changed, but that's all. We're not
2004 sure whether this is a unique completion or not, so try again
2005 using the real case (this shouldn't recurse again, because
2006 the next time try-completion will return either `t' or the
2010 return do_completion ();
2014 /* It did find a match. Do we match some possibility exactly now? */
2015 tem
= Ftest_completion (Fminibuffer_contents (),
2016 Vminibuffer_completion_table
,
2017 Vminibuffer_completion_predicate
);
2020 /* not an exact match */
2024 else if (!NILP (Vcompletion_auto_help
))
2025 Fminibuffer_completion_help ();
2027 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
2030 else if (completedp
)
2035 /* If the last exact completion and this one were the same,
2036 it means we've already given a "Complete but not unique"
2037 message and the user's hit TAB again, so now we give him help. */
2038 last_exact_completion
= completion
;
2041 tem
= Fminibuffer_completion_contents ();
2042 if (!NILP (Fequal (tem
, last
)))
2043 Fminibuffer_completion_help ();
2049 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2051 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
2052 doc
: /* Like `assoc' but specifically for strings.
2053 Unibyte strings are converted to multibyte for comparison.
2054 And case is ignored if CASE-FOLD is non-nil.
2055 As opposed to `assoc', it will also match an entry consisting of a single
2056 string rather than a cons cell whose car is a string. */)
2057 (key
, list
, case_fold
)
2058 register Lisp_Object key
;
2059 Lisp_Object list
, case_fold
;
2061 register Lisp_Object tail
;
2063 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2065 register Lisp_Object elt
, tem
, thiscar
;
2067 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2068 if (!STRINGP (thiscar
))
2070 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2071 key
, make_number (0), Qnil
,
2080 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2081 doc
: /* Complete the minibuffer contents as far as possible.
2082 Return nil if there is no valid completion, else t.
2083 If no characters can be completed, display a list of possible completions.
2084 If you repeat this command after it displayed such a list,
2085 scroll the window of possible completions. */)
2089 Lisp_Object window
, tem
;
2091 /* If the previous command was not this,
2092 mark the completion buffer obsolete. */
2093 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2094 Vminibuf_scroll_window
= Qnil
;
2096 window
= Vminibuf_scroll_window
;
2097 /* If there's a fresh completion window with a live buffer,
2098 and this command is repeated, scroll that window. */
2099 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2100 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2102 struct buffer
*obuf
= current_buffer
;
2104 Fset_buffer (XWINDOW (window
)->buffer
);
2105 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2107 /* If end is in view, scroll up to the beginning. */
2108 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2110 /* Else scroll down one screen. */
2111 Fscroll_other_window (Qnil
);
2113 set_buffer_internal (obuf
);
2117 i
= do_completion ();
2125 Fgoto_char (make_number (ZV
));
2126 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2131 Fgoto_char (make_number (ZV
));
2132 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2139 /* Subroutines of Fminibuffer_complete_and_exit. */
2141 /* This one is called by internal_condition_case to do the real work. */
2144 complete_and_exit_1 ()
2146 return make_number (do_completion ());
2149 /* This one is called by internal_condition_case if an error happens.
2150 Pretend the current value is an exact match. */
2153 complete_and_exit_2 (ignore
)
2156 return make_number (1);
2159 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2161 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2162 Sminibuffer_complete_and_exit
, 0, 0, "",
2163 doc
: /* If the minibuffer contents is a valid completion then exit.
2164 Otherwise try to complete it. If completion leads to a valid completion,
2165 a repetition of this command will exit. */)
2169 Lisp_Object val
, tem
;
2171 /* Allow user to specify null string */
2172 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2175 val
= Fminibuffer_contents ();
2176 tem
= Ftest_completion (val
,
2177 Vminibuffer_completion_table
,
2178 Vminibuffer_completion_predicate
);
2181 if (completion_ignore_case
)
2182 { /* Fixup case of the field, if necessary. */
2184 = Ftry_completion (val
,
2185 Vminibuffer_completion_table
,
2186 Vminibuffer_completion_predicate
);
2188 /* If it weren't for this piece of paranoia, I'd replace
2189 the whole thing with a call to do_completion. */
2190 && EQ (Flength (val
), Flength (compl)))
2192 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2193 Finsert (1, &compl);
2199 /* Call do_completion, but ignore errors. */
2201 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2202 complete_and_exit_2
);
2212 if (!NILP (Vminibuffer_completion_confirm
))
2214 temp_echo_area_glyphs (build_string (" [Confirm]"));
2224 return Fexit_minibuffer ();
2228 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2230 doc
: /* Complete the minibuffer contents at most a single word.
2231 After one word is completed as much as possible, a space or hyphen
2232 is added, provided that matches some possible completion.
2233 Return nil if there is no valid completion, else t. */)
2236 Lisp_Object completion
, tem
, tem1
;
2237 register int i
, i_byte
;
2238 struct gcpro gcpro1
, gcpro2
;
2239 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2241 /* We keep calling Fbuffer_string rather than arrange for GC to
2242 hold onto a pointer to one of the strings thus made. */
2244 completion
= Ftry_completion (Fminibuffer_completion_contents (),
2245 Vminibuffer_completion_table
,
2246 Vminibuffer_completion_predicate
);
2247 if (NILP (completion
))
2250 temp_echo_area_glyphs (build_string (" [No match]"));
2253 if (EQ (completion
, Qt
))
2256 #if 0 /* How the below code used to look, for reference. */
2257 tem
= Fminibuffer_contents ();
2259 i
= ZV
- 1 - SCHARS (completion
);
2260 p
= SDATA (completion
);
2262 0 <= scmp (b
, p
, ZV
- 1))
2265 /* Set buffer to longest match of buffer tail and completion head. */
2266 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2268 del_range (1, i
+ 1);
2271 #else /* Rewritten code */
2273 int buffer_nchars
, completion_nchars
;
2275 CHECK_STRING (completion
);
2276 tem
= Fminibuffer_completion_contents ();
2277 GCPRO2 (completion
, tem
);
2278 /* If reading a file name,
2279 expand any $ENVVAR refs in the buffer and in TEM. */
2280 if (! NILP (Vminibuffer_completing_file_name
))
2282 Lisp_Object substituted
;
2283 substituted
= Fsubstitute_in_file_name (tem
);
2284 if (! EQ (substituted
, tem
))
2287 del_range (prompt_end_charpos
, PT
);
2291 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2292 completion_nchars
= SCHARS (completion
);
2293 i
= buffer_nchars
- completion_nchars
;
2296 (tem1
= Fcompare_strings (tem
, make_number (0),
2297 make_number (buffer_nchars
),
2298 completion
, make_number (0),
2299 make_number (buffer_nchars
),
2300 completion_ignore_case
? Qt
: Qnil
),
2305 /* Make buffer (before point) contain the longest match
2306 of TEM's tail and COMPLETION's head. */
2312 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2313 completion
, make_number (0),
2314 make_number (buffer_nchars
),
2315 completion_ignore_case
? Qt
: Qnil
);
2322 del_range (start_pos
, start_pos
+ buffer_nchars
);
2326 #endif /* Rewritten code */
2329 int prompt_end_bytepos
;
2330 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2331 i
= PT
- prompt_end_charpos
;
2332 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2335 /* If completion finds next char not unique,
2336 consider adding a space or a hyphen. */
2337 if (i
== SCHARS (completion
))
2339 GCPRO1 (completion
);
2340 tem
= Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2341 build_string (" ")),
2342 Vminibuffer_completion_table
,
2343 Vminibuffer_completion_predicate
);
2350 GCPRO1 (completion
);
2352 Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2353 build_string ("-")),
2354 Vminibuffer_completion_table
,
2355 Vminibuffer_completion_predicate
);
2363 /* Now find first word-break in the stuff found by completion.
2364 i gets index in string of where to stop completing. */
2367 int bytes
= SBYTES (completion
);
2368 register const unsigned char *completion_string
= SDATA (completion
);
2369 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2371 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2374 if (SYNTAX (c
) != Sword
)
2383 /* If got no characters, print help for user. */
2385 if (i
== PT
- prompt_end_charpos
)
2387 if (!NILP (Vcompletion_auto_help
))
2388 Fminibuffer_completion_help ();
2392 /* Otherwise insert in minibuffer the chars we got */
2394 if (! NILP (Vminibuffer_completing_file_name
)
2395 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2397 && FETCH_CHAR (PT_BYTE
) == '/')
2399 del_range (prompt_end_charpos
, PT
+ 1);
2402 del_range (prompt_end_charpos
, PT
);
2404 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2408 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2410 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2411 Each element may be just a symbol or string
2412 or may be a list of two strings to be printed as if concatenated.
2413 If it is a list of two strings, the first is the actual completion
2414 alternative, the second serves as annotation.
2415 `standard-output' must be a buffer.
2416 The actual completion alternatives, as inserted, are given `mouse-face'
2417 properties of `highlight'.
2418 At the end, this runs the normal hook `completion-setup-hook'.
2419 It can find the completion buffer in `standard-output'.
2420 The optional second arg COMMON-SUBSTRING is a string.
2421 It is used to put faces, `completions-first-difference' and
2422 `completions-common-part' on the completion buffer. The
2423 `completions-common-part' face is put on the common substring
2424 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
2425 and the current buffer is not the minibuffer, the faces are not put.
2426 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2427 during running `completion-setup-hook'. */)
2428 (completions
, common_substring
)
2429 Lisp_Object completions
;
2430 Lisp_Object common_substring
;
2432 Lisp_Object tail
, elt
;
2435 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2436 struct buffer
*old
= current_buffer
;
2439 /* Note that (when it matters) every variable
2440 points to a non-string that is pointed to by COMPLETIONS,
2441 except for ELT. ELT can be pointing to a string
2442 when terpri or Findent_to calls a change hook. */
2444 GCPRO3 (completions
, elt
, common_substring
);
2446 if (BUFFERP (Vstandard_output
))
2447 set_buffer_internal (XBUFFER (Vstandard_output
));
2449 if (NILP (completions
))
2450 write_string ("There are no possible completions of what you have typed.",
2454 write_string ("Possible completions are:", -1);
2455 for (tail
= completions
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2457 Lisp_Object tem
, string
;
2459 Lisp_Object startpos
, endpos
;
2465 elt
= SYMBOL_NAME (elt
);
2466 /* Compute the length of this element. */
2471 length
= SCHARS (tem
);
2473 tem
= Fcar (XCDR (elt
));
2475 length
+= SCHARS (tem
);
2480 length
= SCHARS (elt
);
2483 /* This does a bad job for narrower than usual windows.
2484 Sadly, the window it will appear in is not known
2485 until after the text has been made. */
2487 if (BUFFERP (Vstandard_output
))
2488 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2490 /* If the previous completion was very wide,
2491 or we have two on this line already,
2492 don't put another on the same line. */
2493 if (column
> 33 || first
2494 /* If this is really wide, don't put it second on a line. */
2495 || (column
> 0 && length
> 45))
2500 /* Otherwise advance to column 35. */
2503 if (BUFFERP (Vstandard_output
))
2505 tem
= Findent_to (make_number (35), make_number (2));
2507 column
= XINT (tem
);
2513 write_string (" ", -1);
2516 while (column
< 35);
2520 if (BUFFERP (Vstandard_output
))
2522 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2523 Fset_text_properties (startpos
, endpos
,
2524 Qnil
, Vstandard_output
);
2527 /* Output this element.
2528 If necessary, convert it to unibyte or to multibyte first. */
2530 string
= Fcar (elt
);
2533 if (NILP (current_buffer
->enable_multibyte_characters
)
2534 && STRING_MULTIBYTE (string
))
2535 string
= Fstring_make_unibyte (string
);
2536 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2537 && !STRING_MULTIBYTE (string
))
2538 string
= Fstring_make_multibyte (string
);
2540 if (BUFFERP (Vstandard_output
))
2542 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2544 Fprinc (string
, Qnil
);
2546 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2548 Fput_text_property (startpos
, endpos
,
2549 Qmouse_face
, intern ("highlight"),
2554 Fprinc (string
, Qnil
);
2557 /* Output the annotation for this element. */
2560 if (BUFFERP (Vstandard_output
))
2562 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2564 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2566 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2568 Fset_text_properties (startpos
, endpos
, Qnil
,
2573 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2578 /* Update COLUMN for what we have output. */
2581 /* If output is to a buffer, recompute COLUMN in a way
2582 that takes account of character widths. */
2583 if (BUFFERP (Vstandard_output
))
2585 tem
= Fcurrent_column ();
2586 column
= XINT (tem
);
2593 if (BUFFERP (Vstandard_output
))
2594 set_buffer_internal (old
);
2596 if (!NILP (Vrun_hooks
))
2598 int count1
= SPECPDL_INDEX ();
2600 specbind (intern ("completion-common-substring"), common_substring
);
2601 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2603 unbind_to (count1
, Qnil
);
2613 display_completion_list_1 (list
)
2616 return Fdisplay_completion_list (list
, Qnil
);
2619 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2621 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2624 Lisp_Object completions
;
2626 message ("Making completion list...");
2627 completions
= Fall_completions (Fminibuffer_completion_contents (),
2628 Vminibuffer_completion_table
,
2629 Vminibuffer_completion_predicate
,
2631 clear_message (1, 0);
2633 if (NILP (completions
))
2636 temp_echo_area_glyphs (build_string (" [No completions]"));
2640 /* Sort and remove duplicates. */
2641 Lisp_Object tmp
= completions
= Fsort (completions
, Qstring_lessp
);
2644 if (CONSP (XCDR (tmp
))
2645 && !NILP (Fequal (XCAR (tmp
), XCAR (XCDR (tmp
)))))
2646 XSETCDR (tmp
, XCDR (XCDR (tmp
)));
2650 internal_with_output_to_temp_buffer ("*Completions*",
2651 display_completion_list_1
,
2657 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2658 doc
: /* Terminate minibuffer input. */)
2661 if (INTEGERP (last_command_char
))
2662 internal_self_insert (XINT (last_command_char
), 0);
2666 return Fexit_minibuffer ();
2669 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2670 doc
: /* Terminate this minibuffer argument. */)
2673 /* If the command that uses this has made modifications in the minibuffer,
2674 we don't want them to cause deactivation of the mark in the original
2676 A better solution would be to make deactivate-mark buffer-local
2677 (or to turn it into a list of buffers, ...), but in the mean time,
2678 this should do the trick in most cases. */
2679 Vdeactivate_mark
= Qnil
;
2680 Fthrow (Qexit
, Qnil
);
2683 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2684 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2687 return make_number (minibuf_level
);
2690 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2691 doc
: /* Return the prompt string of the currently-active minibuffer.
2692 If no minibuffer is active, return nil. */)
2695 return Fcopy_sequence (minibuf_prompt
);
2699 /* Temporarily display STRING at the end of the current
2700 minibuffer contents. This is used to display things like
2701 "[No Match]" when the user requests a completion for a prefix
2702 that has no possible completions, and other quick, unobtrusive
2705 extern Lisp_Object Vminibuffer_message_timeout
;
2708 temp_echo_area_glyphs (string
)
2712 int osize_byte
= ZV_BYTE
;
2714 int opoint_byte
= PT_BYTE
;
2715 Lisp_Object oinhibit
;
2716 oinhibit
= Vinhibit_quit
;
2718 /* Clear out any old echo-area message to make way for our new thing. */
2721 SET_PT_BOTH (osize
, osize_byte
);
2722 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2723 SET_PT_BOTH (opoint
, opoint_byte
);
2726 if (NUMBERP (Vminibuffer_message_timeout
))
2727 sit_for (Vminibuffer_message_timeout
, 0, 2);
2731 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2732 SET_PT_BOTH (opoint
, opoint_byte
);
2733 if (!NILP (Vquit_flag
))
2736 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2738 Vinhibit_quit
= oinhibit
;
2741 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2743 doc
: /* Temporarily display STRING at the end of the minibuffer.
2744 The text is displayed for a period controlled by `minibuffer-message-timeout',
2745 or until the next input event arrives, whichever comes first. */)
2749 CHECK_STRING (string
);
2750 temp_echo_area_glyphs (string
);
2755 init_minibuf_once ()
2757 Vminibuffer_list
= Qnil
;
2758 staticpro (&Vminibuffer_list
);
2765 minibuf_prompt
= Qnil
;
2766 staticpro (&minibuf_prompt
);
2768 minibuf_save_list
= Qnil
;
2769 staticpro (&minibuf_save_list
);
2771 Qread_file_name_internal
= intern ("read-file-name-internal");
2772 staticpro (&Qread_file_name_internal
);
2774 Qminibuffer_default
= intern ("minibuffer-default");
2775 staticpro (&Qminibuffer_default
);
2776 Fset (Qminibuffer_default
, Qnil
);
2778 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2779 staticpro (&Qminibuffer_completion_table
);
2781 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2782 staticpro (&Qminibuffer_completion_confirm
);
2784 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2785 staticpro (&Qminibuffer_completion_predicate
);
2787 staticpro (&last_exact_completion
);
2788 last_exact_completion
= Qnil
;
2790 staticpro (&last_minibuf_string
);
2791 last_minibuf_string
= Qnil
;
2793 Quser_variable_p
= intern ("user-variable-p");
2794 staticpro (&Quser_variable_p
);
2796 Qminibuffer_history
= intern ("minibuffer-history");
2797 staticpro (&Qminibuffer_history
);
2799 Qbuffer_name_history
= intern ("buffer-name-history");
2800 staticpro (&Qbuffer_name_history
);
2801 Fset (Qbuffer_name_history
, Qnil
);
2803 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2804 staticpro (&Qminibuffer_setup_hook
);
2806 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2807 staticpro (&Qminibuffer_exit_hook
);
2809 Qhistory_length
= intern ("history-length");
2810 staticpro (&Qhistory_length
);
2812 Qcurrent_input_method
= intern ("current-input-method");
2813 staticpro (&Qcurrent_input_method
);
2815 Qactivate_input_method
= intern ("activate-input-method");
2816 staticpro (&Qactivate_input_method
);
2818 Qcase_fold_search
= intern ("case-fold-search");
2819 staticpro (&Qcase_fold_search
);
2821 Qread_expression_history
= intern ("read-expression-history");
2822 staticpro (&Qread_expression_history
);
2824 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2825 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2826 Vread_buffer_function
= Qnil
;
2828 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2829 doc
: /* Normal hook run just after entry to minibuffer. */);
2830 Vminibuffer_setup_hook
= Qnil
;
2832 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2833 doc
: /* Normal hook run just after exit from minibuffer. */);
2834 Vminibuffer_exit_hook
= Qnil
;
2836 DEFVAR_LISP ("history-length", &Vhistory_length
,
2837 doc
: /* *Maximum length for history lists before truncation takes place.
2838 A number means that length; t means infinite. Truncation takes place
2839 just after a new element is inserted. Setting the `history-length'
2840 property of a history variable overrides this default. */);
2841 XSETFASTINT (Vhistory_length
, 30);
2843 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2844 doc
: /* *Non-nil means to delete duplicates in history.
2845 If set to t when adding a new history element, all previous identical
2846 elements are deleted from the history list. */);
2847 history_delete_duplicates
= 0;
2849 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2850 doc
: /* *Non-nil means to add new elements in history.
2851 If set to nil, minibuffer reading functions don't add new elements to the
2852 history list, so it is possible to do this afterwards by calling
2853 `add-to-history' explicitly. */);
2854 Vhistory_add_new_input
= Qt
;
2856 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2857 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2858 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2859 see the doc string of `partial-completion-mode' for more details. */);
2860 Vcompletion_auto_help
= Qt
;
2862 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2863 doc
: /* Non-nil means don't consider case significant in completion.
2865 For file-name completion, the variable `read-file-name-completion-ignore-case'
2866 controls the behavior, rather than this variable. */);
2867 completion_ignore_case
= 0;
2869 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2870 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2871 This variable makes a difference whenever the minibuffer window is active. */);
2872 enable_recursive_minibuffers
= 0;
2874 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2875 doc
: /* Alist or obarray used for completion in the minibuffer.
2876 This becomes the ALIST argument to `try-completion' and `all-completions'.
2877 The value can also be a list of strings or a hash table.
2879 The value may alternatively be a function, which is given three arguments:
2880 STRING, the current buffer contents;
2881 PREDICATE, the predicate for filtering possible matches;
2882 CODE, which says what kind of things to do.
2883 CODE can be nil, t or `lambda':
2884 nil -- return the best completion of STRING, or nil if there is none.
2885 t -- return a list of all possible completions of STRING.
2886 lambda -- return t if STRING is a valid completion as it stands. */);
2887 Vminibuffer_completion_table
= Qnil
;
2889 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2890 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2891 Vminibuffer_completion_predicate
= Qnil
;
2893 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2894 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2895 Vminibuffer_completion_confirm
= Qnil
;
2897 DEFVAR_LISP ("minibuffer-completing-file-name",
2898 &Vminibuffer_completing_file_name
,
2899 doc
: /* Non-nil means completing file names. */);
2900 Vminibuffer_completing_file_name
= Qnil
;
2902 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2903 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2904 Vminibuffer_help_form
= Qnil
;
2906 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2907 doc
: /* History list symbol to add minibuffer values to.
2908 Each string of minibuffer input, as it appears on exit from the minibuffer,
2910 (set minibuffer-history-variable
2911 (cons STRING (symbol-value minibuffer-history-variable))) */);
2912 XSETFASTINT (Vminibuffer_history_variable
, 0);
2914 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2915 doc
: /* Current position of redoing in the history list. */);
2916 Vminibuffer_history_position
= Qnil
;
2918 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2919 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2920 Some uses of the echo area also raise that frame (since they use it too). */);
2921 minibuffer_auto_raise
= 0;
2923 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2924 doc
: /* List of regexps that should restrict possible completions.
2925 The basic completion functions only consider a completion acceptable
2926 if it matches all regular expressions in this list, with
2927 `case-fold-search' bound to the value of `completion-ignore-case'.
2928 See Info node `(elisp)Basic Completion', for a description of these
2930 Vcompletion_regexp_list
= Qnil
;
2932 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2933 &minibuffer_allow_text_properties
,
2934 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2935 This also affects `read-string', but it does not affect `read-minibuffer',
2936 `read-no-blanks-input', or any of the functions that do minibuffer input
2937 with completion; they always discard text properties. */);
2938 minibuffer_allow_text_properties
= 0;
2940 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2941 doc
: /* Text properties that are added to minibuffer prompts.
2942 These are in addition to the basic `field' property, and stickiness
2944 /* We use `intern' here instead of Qread_only to avoid
2945 initialization-order problems. */
2946 Vminibuffer_prompt_properties
2947 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2949 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
2950 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2951 Vread_expression_map
= Qnil
;
2953 defsubr (&Sset_minibuffer_window
);
2954 defsubr (&Sread_from_minibuffer
);
2955 defsubr (&Seval_minibuffer
);
2956 defsubr (&Sread_minibuffer
);
2957 defsubr (&Sread_string
);
2958 defsubr (&Sread_command
);
2959 defsubr (&Sread_variable
);
2960 defsubr (&Sinternal_complete_buffer
);
2961 defsubr (&Sread_buffer
);
2962 defsubr (&Sread_no_blanks_input
);
2963 defsubr (&Sminibuffer_depth
);
2964 defsubr (&Sminibuffer_prompt
);
2966 defsubr (&Sminibufferp
);
2967 defsubr (&Sminibuffer_prompt_end
);
2968 defsubr (&Sminibuffer_contents
);
2969 defsubr (&Sminibuffer_contents_no_properties
);
2970 defsubr (&Sminibuffer_completion_contents
);
2971 defsubr (&Sdelete_minibuffer_contents
);
2973 defsubr (&Stry_completion
);
2974 defsubr (&Sall_completions
);
2975 defsubr (&Stest_completion
);
2976 defsubr (&Sassoc_string
);
2977 defsubr (&Scompleting_read
);
2978 defsubr (&Sminibuffer_complete
);
2979 defsubr (&Sminibuffer_complete_word
);
2980 defsubr (&Sminibuffer_complete_and_exit
);
2981 defsubr (&Sdisplay_completion_list
);
2982 defsubr (&Sminibuffer_completion_help
);
2984 defsubr (&Sself_insert_and_exit
);
2985 defsubr (&Sexit_minibuffer
);
2987 defsubr (&Sminibuffer_message
);
2993 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2994 "abort-recursive-edit");
2995 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2997 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
3000 initial_define_key (Vminibuffer_local_ns_map
, ' ',
3002 initial_define_key (Vminibuffer_local_ns_map
, '\t',
3004 initial_define_key (Vminibuffer_local_ns_map
, '?',
3005 "self-insert-and-exit");
3007 initial_define_key (Vminibuffer_local_completion_map
, '\t',
3008 "minibuffer-complete");
3009 initial_define_key (Vminibuffer_local_completion_map
, ' ',
3010 "minibuffer-complete-word");
3011 initial_define_key (Vminibuffer_local_completion_map
, '?',
3012 "minibuffer-completion-help");
3014 Fdefine_key (Vminibuffer_local_filename_completion_map
,
3015 build_string (" "), Qnil
);
3017 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
3018 "minibuffer-complete-and-exit");
3019 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
3020 "minibuffer-complete-and-exit");
3022 Fdefine_key (Vminibuffer_local_must_match_filename_map
,
3023 build_string (" "), Qnil
);
3026 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
3027 (do not change this comment) */