1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005,
4 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
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 Vminibuffer_completion_table
, Qminibuffer_completion_table
;
140 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
141 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
142 Lisp_Object Vminibuffer_completing_file_name
;
144 Lisp_Object Quser_variable_p
;
146 Lisp_Object Qminibuffer_default
;
148 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
150 Lisp_Object Qcase_fold_search
;
152 Lisp_Object Qread_expression_history
;
154 extern Lisp_Object Voverriding_local_map
;
156 extern Lisp_Object Qmouse_face
;
158 extern Lisp_Object Qfield
;
160 /* Put minibuf on currently selected frame's minibuffer.
161 We do this whenever the user starts a new minibuffer
162 or when a minibuffer exits. */
165 choose_minibuf_frame ()
167 if (FRAMEP (selected_frame
)
168 && FRAME_LIVE_P (XFRAME (selected_frame
))
169 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
171 struct frame
*sf
= XFRAME (selected_frame
);
174 /* I don't think that any frames may validly have a null minibuffer
176 if (NILP (sf
->minibuffer_window
))
179 /* Under X, we come here with minibuf_window being the
180 minibuffer window of the unused termcap window created in
181 init_window_once. That window doesn't have a buffer. */
182 buffer
= XWINDOW (minibuf_window
)->buffer
;
183 if (BUFFERP (buffer
))
184 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
185 minibuf_window
= sf
->minibuffer_window
;
188 /* Make sure no other frame has a minibuffer as its selected window,
189 because the text would not be displayed in it, and that would be
190 confusing. Only allow the selected frame to do this,
191 and that only if the minibuffer is active. */
193 Lisp_Object tail
, frame
;
195 FOR_EACH_FRAME (tail
, frame
)
196 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
197 && !(EQ (frame
, selected_frame
)
198 && minibuf_level
> 0))
199 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
204 choose_minibuf_frame_1 (ignore
)
207 choose_minibuf_frame ();
211 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
212 Sset_minibuffer_window
, 1, 1, 0,
213 doc
: /* Specify which minibuffer window to use for the minibuffer.
214 This affects where the minibuffer is displayed if you put text in it
215 without invoking the usual minibuffer commands. */)
219 CHECK_WINDOW (window
);
220 if (! MINI_WINDOW_P (XWINDOW (window
)))
221 error ("Window is not a minibuffer window");
223 minibuf_window
= window
;
229 /* Actual minibuffer invocation. */
231 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
232 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
233 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
234 Lisp_Object
, Lisp_Object
,
236 Lisp_Object
, Lisp_Object
,
238 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
239 Lisp_Object
, Lisp_Object
,
241 Lisp_Object
, Lisp_Object
,
243 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
246 /* Read a Lisp object from VAL and return it. If VAL is an empty
247 string, and DEFALT is a string, read from DEFALT instead of VAL. */
250 string_to_object (val
, defalt
)
251 Lisp_Object val
, defalt
;
253 struct gcpro gcpro1
, gcpro2
;
254 Lisp_Object expr_and_pos
;
257 GCPRO2 (val
, defalt
);
259 if (STRINGP (val
) && SCHARS (val
) == 0
263 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
264 pos
= XINT (Fcdr (expr_and_pos
));
265 if (pos
!= SCHARS (val
))
267 /* Ignore trailing whitespace; any other trailing junk
270 pos
= string_char_to_byte (val
, pos
);
271 for (i
= pos
; i
< SBYTES (val
); i
++)
273 int c
= SREF (val
, i
);
274 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
275 error ("Trailing garbage following expression");
279 val
= Fcar (expr_and_pos
);
280 RETURN_UNGCPRO (val
);
284 /* Like read_minibuf but reading from stdin. This function is called
285 from read_minibuf to do the job if noninteractive. */
288 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
289 histvar
, histpos
, defalt
, allow_props
,
290 inherit_input_method
)
294 Lisp_Object backup_n
;
300 int inherit_input_method
;
306 fprintf (stdout
, "%s", SDATA (prompt
));
312 line
= (char *) xmalloc (size
* sizeof *line
);
313 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
314 && (len
= strlen (line
),
315 len
== size
- 1 && line
[len
- 1] != '\n'))
318 line
= (char *) xrealloc (line
, size
);
325 if (len
> 0 && line
[len
- 1] == '\n')
328 val
= build_string (line
);
334 error ("Error reading from stdin");
337 /* If Lisp form desired instead of string, parse it. */
339 val
= string_to_object (val
, defalt
);
344 DEFUN ("minibufferp", Fminibufferp
,
345 Sminibufferp
, 0, 1, 0,
346 doc
: /* Return t if BUFFER is a minibuffer.
347 No argument or nil as argument means use current buffer as BUFFER.
348 BUFFER can be a buffer or a buffer name. */)
355 buffer
= Fcurrent_buffer ();
356 else if (STRINGP (buffer
))
357 buffer
= Fget_buffer (buffer
);
359 CHECK_BUFFER (buffer
);
361 tem
= Fmemq (buffer
, Vminibuffer_list
);
362 return ! NILP (tem
) ? Qt
: Qnil
;
365 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
366 Sminibuffer_prompt_end
, 0, 0, 0,
367 doc
: /* Return the buffer position of the end of the minibuffer prompt.
368 Return (point-min) if current buffer is not a minibuffer. */)
371 /* This function is written to be most efficient when there's a prompt. */
372 Lisp_Object beg
, end
, tem
;
373 beg
= make_number (BEGV
);
375 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
379 end
= Ffield_end (beg
, Qnil
, Qnil
);
381 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
387 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
388 Sminibuffer_contents
, 0, 0, 0,
389 doc
: /* Return the user input in a minibuffer as a string.
390 If the current buffer is not a minibuffer, return its entire contents. */)
393 int prompt_end
= XINT (Fminibuffer_prompt_end ());
394 return make_buffer_string (prompt_end
, ZV
, 1);
397 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
398 Sminibuffer_contents_no_properties
, 0, 0, 0,
399 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
400 If the current buffer is not a minibuffer, return its entire contents. */)
403 int prompt_end
= XINT (Fminibuffer_prompt_end ());
404 return make_buffer_string (prompt_end
, ZV
, 0);
407 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
408 Sminibuffer_completion_contents
, 0, 0, 0,
409 doc
: /* Return the user input in a minibuffer before point as a string.
410 That is what completion commands operate on.
411 If the current buffer is not a minibuffer, return its entire contents. */)
414 int prompt_end
= XINT (Fminibuffer_prompt_end ());
416 error ("Cannot do completion in the prompt");
417 return make_buffer_string (prompt_end
, PT
, 1);
420 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
421 Sdelete_minibuffer_contents
, 0, 0, 0,
422 doc
: /* Delete all user input in a minibuffer.
423 If the current buffer is not a minibuffer, erase its entire contents. */)
426 int prompt_end
= XINT (Fminibuffer_prompt_end ());
428 del_range (prompt_end
, ZV
);
433 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
434 putting point minus BACKUP_N bytes from the end of INITIAL,
435 prompting with PROMPT (a string), using history list HISTVAR
436 with initial position HISTPOS. INITIAL should be a string or a
437 cons of a string and an integer. BACKUP_N should be <= 0, or
438 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
439 ignored and replaced with an integer that puts point at one-indexed
440 position N in INITIAL, where N is the CDR of INITIAL, or at the
441 beginning of INITIAL if N <= 0.
443 Normally return the result as a string (the text that was read),
444 but if EXPFLAG is nonzero, read it and return the object read.
445 If HISTVAR is given, save the value read on that history only if it doesn't
446 match the front of that history list exactly. The value is pushed onto
447 the list as the string that was read.
449 DEFALT specifies the default value for the sake of history commands.
451 If ALLOW_PROPS is nonzero, we do not throw away text properties.
453 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
454 current input method. */
457 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
458 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
462 Lisp_Object backup_n
;
468 int inherit_input_method
;
471 int count
= SPECPDL_INDEX ();
472 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
473 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
474 Lisp_Object enable_multibyte
;
475 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
476 /* String to add to the history. */
477 Lisp_Object histstring
;
479 Lisp_Object empty_minibuf
;
480 Lisp_Object dummy
, frame
;
482 extern Lisp_Object Qfront_sticky
;
483 extern Lisp_Object Qrear_nonsticky
;
485 specbind (Qminibuffer_default
, defalt
);
487 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
488 in previous recursive minibuffer, but was not set explicitly
489 to t for this invocation, so set it to nil in this minibuffer.
490 Save the old value now, before we change it. */
491 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
492 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
493 Vminibuffer_completing_file_name
= Qnil
;
495 #ifdef HAVE_X_WINDOWS
496 if (display_hourglass_p
)
504 backup_n
= Fcdr (initial
);
505 initial
= Fcar (initial
);
506 CHECK_STRING (initial
);
507 if (!NILP (backup_n
))
509 CHECK_NUMBER (backup_n
);
510 /* Convert to distance from end of input. */
511 if (XINT (backup_n
) < 1)
512 /* A number too small means the beginning of the string. */
513 pos
= - SCHARS (initial
);
515 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
519 CHECK_STRING (initial
);
522 ambient_dir
= current_buffer
->directory
;
524 enable_multibyte
= Qnil
;
526 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
527 store them away before we can GC. Don't need to protect
528 BACKUP_N because we use the value only if it is an integer. */
529 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
531 if (!STRINGP (prompt
))
532 prompt
= empty_unibyte_string
;
534 if (!enable_recursive_minibuffers
535 && minibuf_level
> 0)
537 if (EQ (selected_window
, minibuf_window
))
538 error ("Command attempted to use minibuffer while in minibuffer");
540 /* If we're in another window, cancel the minibuffer that's active. */
542 build_string ("Command attempted to use minibuffer while in minibuffer"));
545 if (noninteractive
&& NILP (Vexecuting_kbd_macro
))
547 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
549 expflag
, histvar
, histpos
, defalt
,
550 allow_props
, inherit_input_method
);
552 return unbind_to (count
, val
);
555 /* Choose the minibuffer window and frame, and take action on them. */
557 choose_minibuf_frame ();
559 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
561 record_unwind_protect (Fset_window_configuration
,
562 Fcurrent_window_configuration (Qnil
));
564 /* If the minibuffer window is on a different frame, save that
565 frame's configuration too. */
566 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
567 if (!EQ (mini_frame
, selected_frame
))
568 record_unwind_protect (Fset_window_configuration
,
569 Fcurrent_window_configuration (mini_frame
));
571 /* If the minibuffer is on an iconified or invisible frame,
572 make it visible now. */
573 Fmake_frame_visible (mini_frame
);
575 if (minibuffer_auto_raise
)
576 Fraise_frame (mini_frame
);
578 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
580 /* We have to do this after saving the window configuration
581 since that is what restores the current buffer. */
583 /* Arrange to restore a number of minibuffer-related variables.
584 We could bind each variable separately, but that would use lots of
587 = Fcons (Voverriding_local_map
,
588 Fcons (minibuf_window
,
591 = Fcons (minibuf_prompt
,
592 Fcons (make_number (minibuf_prompt_width
),
594 Fcons (Vcurrent_prefix_arg
,
595 Fcons (Vminibuffer_history_position
,
596 Fcons (Vminibuffer_history_variable
,
597 minibuf_save_list
))))));
599 record_unwind_protect (read_minibuf_unwind
, Qnil
);
601 /* We are exiting the minibuffer one way or the other, so run the hook.
602 It should be run before unwinding the minibuf settings. Do it
603 separately from read_minibuf_unwind because we need to make sure that
604 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
605 signals an error. --Stef */
606 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
608 /* Now that we can restore all those variables, start changing them. */
610 minibuf_prompt_width
= 0;
611 minibuf_prompt
= Fcopy_sequence (prompt
);
612 Vminibuffer_history_position
= histpos
;
613 Vminibuffer_history_variable
= histvar
;
614 Vhelp_form
= Vminibuffer_help_form
;
615 /* If this minibuffer is reading a file name, that doesn't mean
616 recursive ones are. But we cannot set it to nil, because
617 completion code still need to know the minibuffer is completing a
618 file name. So use `lambda' as intermediate value meaning
619 "t" in this minibuffer, but "nil" in next minibuffer. */
620 if (!NILP (Vminibuffer_completing_file_name
))
621 Vminibuffer_completing_file_name
= Qlambda
;
623 if (inherit_input_method
)
625 /* `current-input-method' is buffer local. So, remember it in
626 INPUT_METHOD before changing the current buffer. */
627 input_method
= Fsymbol_value (Qcurrent_input_method
);
628 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
631 /* Switch to the minibuffer. */
633 minibuffer
= get_minibuffer (minibuf_level
);
634 Fset_buffer (minibuffer
);
636 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
637 if (inherit_input_method
)
638 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
640 /* The current buffer's default directory is usually the right thing
641 for our minibuffer here. However, if you're typing a command at
642 a minibuffer-only frame when minibuf_level is zero, then buf IS
643 the current_buffer, so reset_buffer leaves buf's default
644 directory unchanged. This is a bummer when you've just started
645 up Emacs and buf's default directory is Qnil. Here's a hack; can
646 you think of something better to do? Find another buffer with a
647 better directory, and use that one instead. */
648 if (STRINGP (ambient_dir
))
649 current_buffer
->directory
= ambient_dir
;
652 Lisp_Object buf_list
;
654 for (buf_list
= Vbuffer_alist
;
656 buf_list
= XCDR (buf_list
))
658 Lisp_Object other_buf
;
660 other_buf
= XCDR (XCAR (buf_list
));
661 if (STRINGP (XBUFFER (other_buf
)->directory
))
663 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
669 if (!EQ (mini_frame
, selected_frame
))
670 Fredirect_frame_focus (selected_frame
, mini_frame
);
672 Vminibuf_scroll_window
= selected_window
;
673 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
674 minibuf_selected_window
= selected_window
;
676 /* Empty out the minibuffers of all frames other than the one
677 where we are going to display one now.
678 Set them to point to ` *Minibuf-0*', which is always empty. */
679 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
681 FOR_EACH_FRAME (dummy
, frame
)
683 Lisp_Object root_window
= Fframe_root_window (frame
);
684 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
686 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
687 && !NILP (Fwindow_minibuffer_p (mini_window
)))
688 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
691 /* Display this minibuffer in the proper window. */
692 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
693 Fselect_window (minibuf_window
, Qnil
);
694 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
696 Fmake_local_variable (Qprint_escape_newlines
);
697 print_escape_newlines
= 1;
699 /* Erase the buffer. */
701 int count1
= SPECPDL_INDEX ();
702 specbind (Qinhibit_read_only
, Qt
);
703 specbind (Qinhibit_modification_hooks
, Qt
);
706 if (!NILP (current_buffer
->enable_multibyte_characters
)
707 && ! STRING_MULTIBYTE (minibuf_prompt
))
708 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
710 /* Insert the prompt, record where it ends. */
711 Finsert (1, &minibuf_prompt
);
714 Fput_text_property (make_number (BEG
), make_number (PT
),
715 Qfront_sticky
, Qt
, Qnil
);
716 Fput_text_property (make_number (BEG
), make_number (PT
),
717 Qrear_nonsticky
, Qt
, Qnil
);
718 Fput_text_property (make_number (BEG
), make_number (PT
),
720 Fadd_text_properties (make_number (BEG
), make_number (PT
),
721 Vminibuffer_prompt_properties
, Qnil
);
723 unbind_to (count1
, Qnil
);
726 minibuf_prompt_width
= (int) current_column (); /* iftc */
728 /* Put in the initial input. */
731 Finsert (1, &initial
);
732 Fforward_char (make_number (pos
));
735 clear_message (1, 1);
736 current_buffer
->keymap
= map
;
738 /* Turn on an input method stored in INPUT_METHOD if any. */
739 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
740 call1 (Qactivate_input_method
, input_method
);
742 /* Run our hook, but not if it is empty.
743 (run-hooks would do nothing if it is empty,
744 but it's important to save time here in the usual case.) */
745 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
746 && !NILP (Vrun_hooks
))
747 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
749 /* Don't allow the user to undo past this point. */
750 current_buffer
->undo_list
= Qnil
;
754 /* If cursor is on the minibuffer line,
755 show the user we have exited by putting it in column 0. */
756 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
759 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
760 XWINDOW (minibuf_window
)->cursor
.x
= 0;
761 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
762 update_frame (XFRAME (selected_frame
), 1, 1);
764 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
765 struct redisplay_interface
*rif
= FRAME_RIF (f
);
766 if (rif
&& rif
->flush_display
)
767 rif
->flush_display (f
);
771 /* Make minibuffer contents into a string. */
772 Fset_buffer (minibuffer
);
774 val
= Fminibuffer_contents ();
776 val
= Fminibuffer_contents_no_properties ();
778 /* VAL is the string of minibuffer text. */
780 last_minibuf_string
= val
;
782 /* Choose the string to add to the history. */
783 if (SCHARS (val
) != 0)
785 else if (STRINGP (defalt
))
790 /* Add the value to the appropriate history list, if any. */
791 if (!NILP (Vhistory_add_new_input
)
792 && SYMBOLP (Vminibuffer_history_variable
)
793 && !NILP (histstring
))
795 /* If the caller wanted to save the value read on a history list,
796 then do so if the value is not already the front of the list. */
799 /* If variable is unbound, make it nil. */
800 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
801 Fset (Vminibuffer_history_variable
, Qnil
);
803 histval
= Fsymbol_value (Vminibuffer_history_variable
);
805 /* The value of the history variable must be a cons or nil. Other
806 values are unacceptable. We silently ignore these values. */
810 /* Don't duplicate the most recent entry in the history. */
811 && (NILP (Fequal (histstring
, Fcar (histval
))))))
815 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
816 histval
= Fcons (histstring
, histval
);
817 Fset (Vminibuffer_history_variable
, histval
);
819 /* Truncate if requested. */
820 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
821 if (NILP (length
)) length
= Vhistory_length
;
822 if (INTEGERP (length
))
824 if (XINT (length
) <= 0)
825 Fset (Vminibuffer_history_variable
, Qnil
);
830 temp
= Fnthcdr (Fsub1 (length
), histval
);
831 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
837 /* If Lisp form desired instead of string, parse it. */
839 val
= string_to_object (val
, defalt
);
841 /* The appropriate frame will get selected
842 in set-window-configuration. */
844 return unbind_to (count
, val
);
847 /* Return a buffer to be used as the minibuffer at depth `depth'.
848 depth = 0 is the lowest allowed argument, and that is the value
849 used for nonrecursive minibuffer invocations */
852 get_minibuffer (depth
)
855 Lisp_Object tail
, num
, buf
;
857 extern Lisp_Object
nconc2 ();
859 XSETFASTINT (num
, depth
);
860 tail
= Fnthcdr (num
, Vminibuffer_list
);
863 tail
= Fcons (Qnil
, Qnil
);
864 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
867 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
869 sprintf (name
, " *Minibuf-%d*", depth
);
870 buf
= Fget_buffer_create (build_string (name
));
872 /* Although the buffer's name starts with a space, undo should be
874 Fbuffer_enable_undo (buf
);
880 int count
= SPECPDL_INDEX ();
881 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
882 have to empty the list, otherwise we end up with overlays that
883 think they belong to this buffer while the buffer doesn't know about
885 delete_all_overlays (XBUFFER (buf
));
886 reset_buffer (XBUFFER (buf
));
887 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
889 Fkill_all_local_variables ();
890 unbind_to (count
, Qnil
);
897 run_exit_minibuf_hook (data
)
900 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
901 && !NILP (Vrun_hooks
))
902 safe_run_hooks (Qminibuffer_exit_hook
);
907 /* This function is called on exiting minibuffer, whether normally or
908 not, and it restores the current window, buffer, etc. */
911 read_minibuf_unwind (data
)
914 Lisp_Object old_deactivate_mark
;
917 /* If this was a recursive minibuffer,
918 tie the minibuffer window back to the outer level minibuffer buffer. */
921 window
= minibuf_window
;
922 /* To keep things predictable, in case it matters, let's be in the
923 minibuffer when we reset the relevant variables. */
924 Fset_buffer (XWINDOW (window
)->buffer
);
926 /* Restore prompt, etc, from outer minibuffer level. */
927 minibuf_prompt
= Fcar (minibuf_save_list
);
928 minibuf_save_list
= Fcdr (minibuf_save_list
);
929 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
930 minibuf_save_list
= Fcdr (minibuf_save_list
);
931 Vhelp_form
= Fcar (minibuf_save_list
);
932 minibuf_save_list
= Fcdr (minibuf_save_list
);
933 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
934 minibuf_save_list
= Fcdr (minibuf_save_list
);
935 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
936 minibuf_save_list
= Fcdr (minibuf_save_list
);
937 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
938 minibuf_save_list
= Fcdr (minibuf_save_list
);
939 Voverriding_local_map
= Fcar (minibuf_save_list
);
940 minibuf_save_list
= Fcdr (minibuf_save_list
);
942 temp
= Fcar (minibuf_save_list
);
943 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
944 minibuf_window
= temp
;
946 minibuf_save_list
= Fcdr (minibuf_save_list
);
948 /* Erase the minibuffer we were using at this level. */
950 int count
= SPECPDL_INDEX ();
951 /* Prevent error in erase-buffer. */
952 specbind (Qinhibit_read_only
, Qt
);
953 specbind (Qinhibit_modification_hooks
, Qt
);
954 old_deactivate_mark
= Vdeactivate_mark
;
956 Vdeactivate_mark
= old_deactivate_mark
;
957 unbind_to (count
, Qnil
);
960 /* When we get to the outmost level, make sure we resize the
961 mini-window back to its normal size. */
962 if (minibuf_level
== 0)
963 resize_mini_window (XWINDOW (window
), 0);
965 /* Make sure minibuffer window is erased, not ignored. */
966 windows_or_buffers_changed
++;
967 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
968 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
973 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
974 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
975 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
976 DEFAULT-VALUE. It normally should be nil in new code, except when
977 HIST is a cons. It is discussed in more detail below.
978 Third arg KEYMAP is a keymap to use whilst reading;
979 if omitted or nil, the default is `minibuffer-local-map'.
980 If fourth arg READ is non-nil, then interpret the result as a Lisp object
981 and return that object:
982 in other words, do `(car (read-from-string INPUT-STRING))'
983 Fifth arg HIST, if non-nil, specifies a history list and optionally
984 the initial position in the list. It can be a symbol, which is the
985 history list variable to use, or it can be a cons cell
986 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
987 to use, and HISTPOS is the initial position for use by the minibuffer
988 history commands. For consistency, you should also specify that
989 element of the history as the value of INITIAL-CONTENTS. Positions
990 are counted starting from 1 at the beginning of the list.
991 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
992 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
993 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
995 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
996 the current input method and the setting of `enable-multibyte-characters'.
997 If the variable `minibuffer-allow-text-properties' is non-nil,
998 then the string which is returned includes whatever text properties
999 were present in the minibuffer. Otherwise the value has no text properties.
1001 The remainder of this documentation string describes the
1002 INITIAL-CONTENTS argument in more detail. It is only relevant when
1003 studying existing code, or when HIST is a cons. If non-nil,
1004 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
1005 reading input. Normally, point is put at the end of that string.
1006 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
1007 input is STRING, but point is placed at _one-indexed_ position
1008 POSITION in the minibuffer. Any integer value less than or equal to
1009 one puts point at the beginning of the string. *Note* that this
1010 behavior differs from the way such arguments are used in `completing-read'
1011 and some related functions, which use zero-indexing for POSITION. */)
1012 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
1013 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
1014 Lisp_Object inherit_input_method
;
1016 Lisp_Object histvar
, histpos
, val
;
1017 struct gcpro gcpro1
;
1019 CHECK_STRING (prompt
);
1021 keymap
= Vminibuffer_local_map
;
1023 keymap
= get_keymap (keymap
, 1, 0);
1032 histvar
= Fcar_safe (hist
);
1033 histpos
= Fcdr_safe (hist
);
1036 histvar
= Qminibuffer_history
;
1038 XSETFASTINT (histpos
, 0);
1040 GCPRO1 (default_value
);
1041 val
= read_minibuf (keymap
, initial_contents
, prompt
,
1043 histvar
, histpos
, default_value
,
1044 minibuffer_allow_text_properties
,
1045 !NILP (inherit_input_method
));
1050 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1051 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1052 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1053 is a string to insert in the minibuffer before reading.
1054 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1055 arguments are used as in `read-from-minibuffer'.) */)
1056 (prompt
, initial_contents
)
1057 Lisp_Object prompt
, initial_contents
;
1059 CHECK_STRING (prompt
);
1060 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1061 prompt
, Qnil
, 1, Qminibuffer_history
,
1062 make_number (0), Qnil
, 0, 0);
1065 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1066 doc
: /* Return value of Lisp expression read using the minibuffer.
1067 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1068 is a string to insert in the minibuffer before reading.
1069 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1070 arguments are used as in `read-from-minibuffer'.) */)
1071 (prompt
, initial_contents
)
1072 Lisp_Object prompt
, initial_contents
;
1074 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
1075 prompt
, Qnil
, 1, Qread_expression_history
,
1076 make_number (0), Qnil
, 0, 0));
1079 /* Functions that use the minibuffer to read various things. */
1081 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1082 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1083 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1084 This argument has been superseded by DEFAULT-VALUE and should normally
1085 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1086 documentation string of that function for details.
1087 The third arg HISTORY, if non-nil, specifies a history list
1088 and optionally the initial position in the list.
1089 See `read-from-minibuffer' for details of HISTORY argument.
1090 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1091 for history commands, and as the value to return if the user enters
1093 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1094 the current input method and the setting of `enable-multibyte-characters'. */)
1095 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1096 Lisp_Object prompt
, initial_input
, history
, default_value
;
1097 Lisp_Object inherit_input_method
;
1100 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1101 Qnil
, history
, default_value
,
1102 inherit_input_method
);
1103 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1104 val
= default_value
;
1108 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1109 doc
: /* Read a string from the terminal, not allowing blanks.
1110 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1111 non-nil, it should be a string, which is used as initial input, with
1112 point positioned at the end, so that SPACE will accept the input.
1113 \(Actually, INITIAL can also be a cons of a string and an integer.
1114 Such values are treated as in `read-from-minibuffer', but are normally
1115 not useful in this function.)
1116 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1117 the current input method and the setting of`enable-multibyte-characters'. */)
1118 (prompt
, initial
, inherit_input_method
)
1119 Lisp_Object prompt
, initial
, inherit_input_method
;
1121 CHECK_STRING (prompt
);
1122 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1123 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1124 !NILP (inherit_input_method
));
1127 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1128 doc
: /* Read the name of a command and return as a symbol.
1129 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1130 (prompt
, default_value
)
1131 Lisp_Object prompt
, default_value
;
1133 Lisp_Object name
, default_string
;
1135 if (NILP (default_value
))
1136 default_string
= Qnil
;
1137 else if (SYMBOLP (default_value
))
1138 default_string
= SYMBOL_NAME (default_value
);
1140 default_string
= default_value
;
1142 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1143 Qnil
, Qnil
, default_string
, Qnil
);
1146 return Fintern (name
, Qnil
);
1150 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1151 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1152 Prompt with PROMPT. */)
1156 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1161 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1162 doc
: /* Read the name of a user variable and return it as a symbol.
1163 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1164 A user variable is one for which `user-variable-p' returns non-nil. */)
1165 (prompt
, default_value
)
1166 Lisp_Object prompt
, default_value
;
1168 Lisp_Object name
, default_string
;
1170 if (NILP (default_value
))
1171 default_string
= Qnil
;
1172 else if (SYMBOLP (default_value
))
1173 default_string
= SYMBOL_NAME (default_value
);
1175 default_string
= default_value
;
1177 name
= Fcompleting_read (prompt
, Vobarray
,
1178 Quser_variable_p
, Qt
,
1179 Qnil
, Qnil
, default_string
, Qnil
);
1182 return Fintern (name
, Qnil
);
1185 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1186 doc
: /* Read the name of a buffer and return as a string.
1188 Optional second arg DEF is value to return if user enters an empty line.
1189 If optional third arg REQUIRE-MATCH is non-nil,
1190 only existing buffer names are allowed.
1191 The argument PROMPT should be a string ending with a colon and a space. */)
1192 (prompt
, def
, require_match
)
1193 Lisp_Object prompt
, def
, require_match
;
1195 Lisp_Object args
[4];
1200 def
= XBUFFER (def
)->name
;
1202 if (NILP (Vread_buffer_function
))
1206 /* A default value was provided: we must change PROMPT,
1207 editing the default value in before the colon. To achieve
1208 this, we replace PROMPT with a substring that doesn't
1209 contain the terminal space and colon (if present). They
1210 are then added back using Fformat. */
1212 if (STRINGP (prompt
))
1216 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1218 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1221 prompt
= make_specified_string (s
, -1, len
,
1222 STRING_MULTIBYTE (prompt
));
1225 args
[0] = build_string ("%s (default %s): ");
1228 prompt
= Fformat (3, args
);
1231 return Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1232 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1237 args
[0] = Vread_buffer_function
;
1240 args
[3] = require_match
;
1241 return Ffuncall(4, args
);
1246 minibuf_conform_representation (string
, basis
)
1247 Lisp_Object string
, basis
;
1249 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1252 if (STRING_MULTIBYTE (string
))
1253 return Fstring_make_unibyte (string
);
1255 return Fstring_make_multibyte (string
);
1258 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1259 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1260 Test each possible completion specified by COLLECTION
1261 to see if it begins with STRING. The possible completions may be
1262 strings or symbols. Symbols are converted to strings before testing,
1264 All that match STRING are compared together; the longest initial sequence
1265 common to all these matches is the return value.
1266 If there is no match at all, the return value is nil.
1267 For a unique match which is exact, the return value is t.
1269 If COLLECTION is an alist, the keys (cars of elements) are the
1270 possible completions. If an element is not a cons cell, then the
1271 element itself is the possible completion.
1272 If COLLECTION is a hash-table, all the keys that are strings or symbols
1273 are the possible completions.
1274 If COLLECTION is an obarray, the names of all symbols in the obarray
1275 are the possible completions.
1277 COLLECTION can also be a function to do the completion itself.
1278 It receives three arguments: the values STRING, PREDICATE and nil.
1279 Whatever it returns becomes the value of `try-completion'.
1281 If optional third argument PREDICATE is non-nil,
1282 it is used to test each possible match.
1283 The match is a candidate only if PREDICATE returns non-nil.
1284 The argument given to PREDICATE is the alist element
1285 or the symbol from the obarray. If COLLECTION is a hash-table,
1286 predicate is called with two arguments: the key and the value.
1287 Additionally to this predicate, `completion-regexp-list'
1288 is used to further constrain the set of candidates. */)
1289 (string
, collection
, predicate
)
1290 Lisp_Object string
, collection
, predicate
;
1292 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1293 /* Size in bytes of BESTMATCH. */
1294 int bestmatchsize
= 0;
1295 /* These are in bytes, too. */
1296 int compare
, matchsize
;
1297 enum { function_table
, list_table
, obarray_table
, hash_table
}
1298 type
= (HASH_TABLE_P (collection
) ? hash_table
1299 : VECTORP (collection
) ? obarray_table
1300 : ((NILP (collection
)
1301 || (CONSP (collection
)
1302 && (!SYMBOLP (XCAR (collection
))
1303 || NILP (XCAR (collection
)))))
1304 ? list_table
: function_table
));
1305 int index
= 0, obsize
= 0;
1308 Lisp_Object bucket
, zero
, end
, tem
;
1309 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1311 CHECK_STRING (string
);
1312 if (type
== function_table
)
1313 return call3 (collection
, string
, predicate
, Qnil
);
1315 bestmatch
= bucket
= Qnil
;
1316 zero
= make_number (0);
1318 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1320 if (type
== obarray_table
)
1322 collection
= check_obarray (collection
);
1323 obsize
= XVECTOR (collection
)->size
;
1324 bucket
= XVECTOR (collection
)->contents
[index
];
1329 /* Get the next element of the alist, obarray, or hash-table. */
1330 /* Exit the loop if the elements are all used up. */
1331 /* elt gets the alist element or symbol.
1332 eltstring gets the name to check as a completion. */
1334 if (type
== list_table
)
1339 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1342 else if (type
== obarray_table
)
1344 if (!EQ (bucket
, zero
))
1346 if (!SYMBOLP (bucket
))
1347 error ("Bad data in guts of obarray");
1350 if (XSYMBOL (bucket
)->next
)
1351 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1353 XSETFASTINT (bucket
, 0);
1355 else if (++index
>= obsize
)
1359 bucket
= XVECTOR (collection
)->contents
[index
];
1363 else /* if (type == hash_table) */
1365 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1366 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1368 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1371 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1374 /* Is this element a possible completion? */
1376 if (SYMBOLP (eltstring
))
1377 eltstring
= Fsymbol_name (eltstring
);
1379 if (STRINGP (eltstring
)
1380 && SCHARS (string
) <= SCHARS (eltstring
)
1381 && (tem
= Fcompare_strings (eltstring
, zero
,
1382 make_number (SCHARS (string
)),
1384 completion_ignore_case
? Qt
: Qnil
),
1388 Lisp_Object regexps
;
1390 /* Ignore this element if it fails to match all the regexps. */
1392 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1393 regexps
= XCDR (regexps
))
1395 if (bindcount
< 0) {
1396 bindcount
= SPECPDL_INDEX ();
1397 specbind (Qcase_fold_search
,
1398 completion_ignore_case
? Qt
: Qnil
);
1400 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1404 if (CONSP (regexps
))
1408 /* Ignore this element if there is a predicate
1409 and the predicate doesn't like it. */
1411 if (!NILP (predicate
))
1413 if (EQ (predicate
, Qcommandp
))
1414 tem
= Fcommandp (elt
, Qnil
);
1419 unbind_to (bindcount
, Qnil
);
1422 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1423 tem
= (type
== hash_table
1424 ? call2 (predicate
, elt
,
1425 HASH_VALUE (XHASH_TABLE (collection
),
1427 : call1 (predicate
, elt
));
1430 if (NILP (tem
)) continue;
1433 /* Update computation of how much all possible completions match */
1435 if (NILP (bestmatch
))
1438 bestmatch
= eltstring
;
1439 bestmatchsize
= SCHARS (eltstring
);
1443 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1444 tem
= Fcompare_strings (bestmatch
, zero
,
1445 make_number (compare
),
1447 make_number (compare
),
1448 completion_ignore_case
? Qt
: Qnil
);
1450 matchsize
= compare
;
1451 else if (XINT (tem
) < 0)
1452 matchsize
= - XINT (tem
) - 1;
1454 matchsize
= XINT (tem
) - 1;
1457 /* When can this happen ? -stef */
1458 matchsize
= compare
;
1459 if (completion_ignore_case
)
1461 /* If this is an exact match except for case,
1462 use it as the best match rather than one that is not an
1463 exact match. This way, we get the case pattern
1464 of the actual match. */
1465 if ((matchsize
== SCHARS (eltstring
)
1466 && matchsize
< SCHARS (bestmatch
))
1468 /* If there is more than one exact match ignoring case,
1469 and one of them is exact including case,
1471 /* If there is no exact match ignoring case,
1472 prefer a match that does not change the case
1474 ((matchsize
== SCHARS (eltstring
))
1476 (matchsize
== SCHARS (bestmatch
))
1477 && (tem
= Fcompare_strings (eltstring
, zero
,
1478 make_number (SCHARS (string
)),
1483 && (tem
= Fcompare_strings (bestmatch
, zero
,
1484 make_number (SCHARS (string
)),
1489 bestmatch
= eltstring
;
1491 if (bestmatchsize
!= SCHARS (eltstring
)
1492 || bestmatchsize
!= matchsize
)
1493 /* Don't count the same string multiple times. */
1495 bestmatchsize
= matchsize
;
1496 if (matchsize
<= SCHARS (string
)
1497 /* If completion-ignore-case is non-nil, don't
1498 short-circuit because we want to find the best
1499 possible match *including* case differences. */
1500 && !completion_ignore_case
1502 /* No need to look any further. */
1508 if (bindcount
>= 0) {
1509 unbind_to (bindcount
, Qnil
);
1513 if (NILP (bestmatch
))
1514 return Qnil
; /* No completions found */
1515 /* If we are ignoring case, and there is no exact match,
1516 and no additional text was supplied,
1517 don't change the case of what the user typed. */
1518 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1519 && SCHARS (bestmatch
) > bestmatchsize
)
1520 return minibuf_conform_representation (string
, bestmatch
);
1522 /* Return t if the supplied string is an exact match (counting case);
1523 it does not require any change to be made. */
1524 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1525 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1526 make_number (bestmatchsize
),
1527 string
, make_number (0),
1528 make_number (bestmatchsize
),
1533 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1534 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1535 return Fsubstring (bestmatch
, zero
, end
);
1538 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1539 doc
: /* Search for partial matches to STRING in COLLECTION.
1540 Test each of the possible completions specified by COLLECTION
1541 to see if it begins with STRING. The possible completions may be
1542 strings or symbols. Symbols are converted to strings before testing,
1544 The value is a list of all the possible completions that match STRING.
1546 If COLLECTION is an alist, the keys (cars of elements) are the
1547 possible completions. If an element is not a cons cell, then the
1548 element itself is the possible completion.
1549 If COLLECTION is a hash-table, all the keys that are strings or symbols
1550 are the possible completions.
1551 If COLLECTION is an obarray, the names of all symbols in the obarray
1552 are the possible completions.
1554 COLLECTION can also be a function to do the completion itself.
1555 It receives three arguments: the values STRING, PREDICATE and t.
1556 Whatever it returns becomes the value of `all-completions'.
1558 If optional third argument PREDICATE is non-nil,
1559 it is used to test each possible match.
1560 The match is a candidate only if PREDICATE returns non-nil.
1561 The argument given to PREDICATE is the alist element
1562 or the symbol from the obarray. If COLLECTION is a hash-table,
1563 predicate is called with two arguments: the key and the value.
1564 Additionally to this predicate, `completion-regexp-list'
1565 is used to further constrain the set of candidates.
1567 If the optional fourth argument HIDE-SPACES is non-nil,
1568 strings in COLLECTION that start with a space
1569 are ignored unless STRING itself starts with a space. */)
1570 (string
, collection
, predicate
, hide_spaces
)
1571 Lisp_Object string
, collection
, predicate
, hide_spaces
;
1573 Lisp_Object tail
, elt
, eltstring
;
1574 Lisp_Object allmatches
;
1575 int type
= HASH_TABLE_P (collection
) ? 3
1576 : VECTORP (collection
) ? 2
1577 : NILP (collection
) || (CONSP (collection
)
1578 && (!SYMBOLP (XCAR (collection
))
1579 || NILP (XCAR (collection
))));
1580 int index
= 0, obsize
= 0;
1582 Lisp_Object bucket
, tem
, zero
;
1583 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1585 CHECK_STRING (string
);
1587 return call3 (collection
, string
, predicate
, Qt
);
1588 allmatches
= bucket
= Qnil
;
1589 zero
= make_number (0);
1591 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1595 obsize
= XVECTOR (collection
)->size
;
1596 bucket
= XVECTOR (collection
)->contents
[index
];
1601 /* Get the next element of the alist, obarray, or hash-table. */
1602 /* Exit the loop if the elements are all used up. */
1603 /* elt gets the alist element or symbol.
1604 eltstring gets the name to check as a completion. */
1611 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1616 if (!EQ (bucket
, zero
))
1620 if (XSYMBOL (bucket
)->next
)
1621 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1623 XSETFASTINT (bucket
, 0);
1625 else if (++index
>= obsize
)
1629 bucket
= XVECTOR (collection
)->contents
[index
];
1633 else /* if (type == 3) */
1635 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1636 && NILP (HASH_HASH (XHASH_TABLE (collection
), index
)))
1638 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1641 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), index
++);
1644 /* Is this element a possible completion? */
1646 if (SYMBOLP (eltstring
))
1647 eltstring
= Fsymbol_name (eltstring
);
1649 if (STRINGP (eltstring
)
1650 && SCHARS (string
) <= SCHARS (eltstring
)
1651 /* If HIDE_SPACES, reject alternatives that start with space
1652 unless the input starts with space. */
1653 && ((SBYTES (string
) > 0
1654 && SREF (string
, 0) == ' ')
1655 || SREF (eltstring
, 0) != ' '
1656 || NILP (hide_spaces
))
1657 && (tem
= Fcompare_strings (eltstring
, zero
,
1658 make_number (SCHARS (string
)),
1660 make_number (SCHARS (string
)),
1661 completion_ignore_case
? Qt
: Qnil
),
1665 Lisp_Object regexps
;
1667 XSETFASTINT (zero
, 0);
1669 /* Ignore this element if it fails to match all the regexps. */
1671 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1672 regexps
= XCDR (regexps
))
1674 if (bindcount
< 0) {
1675 bindcount
= SPECPDL_INDEX ();
1676 specbind (Qcase_fold_search
,
1677 completion_ignore_case
? Qt
: Qnil
);
1679 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1683 if (CONSP (regexps
))
1687 /* Ignore this element if there is a predicate
1688 and the predicate doesn't like it. */
1690 if (!NILP (predicate
))
1692 if (EQ (predicate
, Qcommandp
))
1693 tem
= Fcommandp (elt
, Qnil
);
1696 if (bindcount
>= 0) {
1697 unbind_to (bindcount
, Qnil
);
1700 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1702 ? call2 (predicate
, elt
,
1703 HASH_VALUE (XHASH_TABLE (collection
), index
- 1))
1704 : call1 (predicate
, elt
);
1707 if (NILP (tem
)) continue;
1709 /* Ok => put it on the list. */
1710 allmatches
= Fcons (eltstring
, allmatches
);
1714 if (bindcount
>= 0) {
1715 unbind_to (bindcount
, Qnil
);
1719 return Fnreverse (allmatches
);
1722 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1723 doc
: /* Read a string in the minibuffer, with completion.
1724 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1725 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1726 COLLECTION can also be a function to do the completion itself.
1727 PREDICATE limits completion to a subset of COLLECTION.
1728 See `try-completion' and `all-completions' for more details
1729 on completion, COLLECTION, and PREDICATE.
1731 REQUIRE-MATCH can take the following values:
1732 - t means that the user is not allowed to exit unless
1733 the input is (or completes to) an element of COLLECTION or is null.
1734 - nil means that the user can exit with any input.
1735 - `confirm-only' means that the user can exit with any input, but she will
1736 need to confirm her choice if the input is not an element of COLLECTION.
1737 - anything else behaves like t except that typing RET does not exit if it
1738 does non-null completion.
1740 If the input is null, `completing-read' returns DEF, or an empty string
1741 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1743 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1744 with point positioned at the end.
1745 If it is (STRING . POSITION), the initial input is STRING, but point
1746 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1747 that this is different from `read-from-minibuffer' and related
1748 functions, which use one-indexing for POSITION.) This feature is
1749 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1750 default value DEF instead. The user can yank the default value into
1751 the minibuffer easily using \\[next-history-element].
1753 HIST, if non-nil, specifies a history list and optionally the initial
1754 position in the list. It can be a symbol, which is the history list
1755 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1756 that case, HISTVAR is the history list variable to use, and HISTPOS
1757 is the initial position (the position in the list used by the
1758 minibuffer history commands). For consistency, you should also
1759 specify that element of the history as the value of
1760 INITIAL-INPUT. (This is the only case in which you should use
1761 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1762 1 at the beginning of the list. The variable `history-length'
1763 controls the maximum length of a history list.
1765 DEF, if non-nil, is the default value.
1767 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1768 the current input method and the setting of `enable-multibyte-characters'.
1770 Completion ignores case if the ambient value of
1771 `completion-ignore-case' is non-nil. */)
1772 (prompt
, collection
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1773 Lisp_Object prompt
, collection
, predicate
, require_match
, initial_input
;
1774 Lisp_Object hist
, def
, inherit_input_method
;
1776 Lisp_Object val
, histvar
, histpos
, position
;
1779 int count
= SPECPDL_INDEX ();
1780 struct gcpro gcpro1
;
1782 init
= initial_input
;
1785 specbind (Qminibuffer_completion_table
, collection
);
1786 specbind (Qminibuffer_completion_predicate
, predicate
);
1787 specbind (Qminibuffer_completion_confirm
,
1788 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1789 last_exact_completion
= Qnil
;
1796 position
= Fcdr (init
);
1799 CHECK_STRING (init
);
1800 if (!NILP (position
))
1802 CHECK_NUMBER (position
);
1803 /* Convert to distance from end of input. */
1804 pos
= XINT (position
) - SCHARS (init
);
1815 histvar
= Fcar_safe (hist
);
1816 histpos
= Fcdr_safe (hist
);
1819 histvar
= Qminibuffer_history
;
1821 XSETFASTINT (histpos
, 0);
1823 val
= read_minibuf (NILP (require_match
)
1824 ? (NILP (Vminibuffer_completing_file_name
)
1825 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1826 ? Vminibuffer_local_completion_map
1827 : Vminibuffer_local_filename_completion_map
)
1828 : (NILP (Vminibuffer_completing_file_name
)
1829 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1830 ? Vminibuffer_local_must_match_map
1831 : Vminibuffer_local_must_match_filename_map
),
1832 init
, prompt
, make_number (pos
), 0,
1833 histvar
, histpos
, def
, 0,
1834 !NILP (inherit_input_method
));
1836 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1839 RETURN_UNGCPRO (unbind_to (count
, val
));
1842 Lisp_Object
Fminibuffer_completion_help ();
1843 Lisp_Object
Fassoc_string ();
1845 /* Test whether TXT is an exact completion. */
1846 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1847 doc
: /* Return non-nil if STRING is a valid completion.
1848 Takes the same arguments as `all-completions' and `try-completion'.
1849 If COLLECTION is a function, it is called with three arguments:
1850 the values STRING, PREDICATE and `lambda'. */)
1851 (string
, collection
, predicate
)
1852 Lisp_Object string
, collection
, predicate
;
1854 Lisp_Object regexps
, tail
, tem
= Qnil
;
1857 CHECK_STRING (string
);
1859 if ((CONSP (collection
)
1860 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1861 || NILP (collection
))
1863 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1867 else if (VECTORP (collection
))
1869 /* Bypass intern-soft as that loses for nil. */
1870 tem
= oblookup (collection
,
1876 if (STRING_MULTIBYTE (string
))
1877 string
= Fstring_make_unibyte (string
);
1879 string
= Fstring_make_multibyte (string
);
1881 tem
= oblookup (collection
,
1887 if (completion_ignore_case
&& !SYMBOLP (tem
))
1889 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1891 tail
= XVECTOR (collection
)->contents
[i
];
1895 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1896 Fsymbol_name (tail
),
1897 make_number (0) , Qnil
, Qt
)),
1903 if (XSYMBOL (tail
)->next
== 0)
1905 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1913 else if (HASH_TABLE_P (collection
))
1915 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1916 i
= hash_lookup (h
, string
, NULL
);
1918 tem
= HASH_KEY (h
, i
);
1920 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1921 if (!NILP (HASH_HASH (h
, i
)) &&
1922 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1923 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1924 completion_ignore_case
? Qt
: Qnil
),
1927 tem
= HASH_KEY (h
, i
);
1934 return call3 (collection
, string
, predicate
, Qlambda
);
1936 /* Reject this element if it fails to match all the regexps. */
1937 if (CONSP (Vcompletion_regexp_list
))
1939 int count
= SPECPDL_INDEX ();
1940 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1941 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1942 regexps
= XCDR (regexps
))
1944 if (NILP (Fstring_match (XCAR (regexps
),
1945 SYMBOLP (tem
) ? string
: tem
,
1947 return unbind_to (count
, Qnil
);
1949 unbind_to (count
, Qnil
);
1952 /* Finally, check the predicate. */
1953 if (!NILP (predicate
))
1955 return HASH_TABLE_P (collection
)
1956 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1957 : call1 (predicate
, tem
);
1963 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1964 doc
: /* Perform completion on buffer names.
1965 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1966 `all-completions', otherwise invoke `test-completion'.
1968 The arguments STRING and PREDICATE are as in `try-completion',
1969 `all-completions', and `test-completion'. */)
1970 (string
, predicate
, flag
)
1971 Lisp_Object string
, predicate
, flag
;
1974 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1975 else if (EQ (flag
, Qt
))
1976 return Fall_completions (string
, Vbuffer_alist
, predicate
, Qt
);
1977 else /* assume `lambda' */
1978 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1982 * 0 no possible completion
1983 * 1 was already an exact and unique completion
1984 * 3 was already an exact completion
1985 * 4 completed to an exact completion
1986 * 5 some completion happened
1987 * 6 no completion happened
1992 Lisp_Object completion
, string
, tem
;
1995 struct gcpro gcpro1
, gcpro2
;
1997 completion
= Ftry_completion (Fminibuffer_completion_contents (),
1998 Vminibuffer_completion_table
,
1999 Vminibuffer_completion_predicate
);
2000 last
= last_exact_completion
;
2001 last_exact_completion
= Qnil
;
2003 GCPRO2 (completion
, last
);
2005 if (NILP (completion
))
2008 temp_echo_area_glyphs (build_string (" [No match]"));
2013 if (EQ (completion
, Qt
)) /* exact and unique match */
2019 string
= Fminibuffer_completion_contents ();
2021 /* COMPLETEDP should be true if some completion was done, which
2022 doesn't include simply changing the case of the entered string.
2023 However, for appearance, the string is rewritten if the case
2025 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
2026 completedp
= !EQ (tem
, Qt
);
2028 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
2030 /* Rewrite the user's input. */
2032 int prompt_end
= XINT (Fminibuffer_prompt_end ());
2033 /* Some completion happened */
2035 if (! NILP (Vminibuffer_completing_file_name
)
2036 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2038 && FETCH_CHAR (PT_BYTE
) == '/')
2040 del_range (prompt_end
, PT
+ 1);
2043 del_range (prompt_end
, PT
);
2045 Finsert (1, &completion
);
2048 /* The case of the string changed, but that's all. We're not
2049 sure whether this is a unique completion or not, so try again
2050 using the real case (this shouldn't recurse again, because
2051 the next time try-completion will return either `t' or the
2055 return do_completion ();
2059 /* It did find a match. Do we match some possibility exactly now? */
2060 tem
= Ftest_completion (Fminibuffer_contents (),
2061 Vminibuffer_completion_table
,
2062 Vminibuffer_completion_predicate
);
2065 /* not an exact match */
2069 else if (!NILP (Vcompletion_auto_help
))
2070 Fminibuffer_completion_help ();
2072 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
2075 else if (completedp
)
2080 /* If the last exact completion and this one were the same,
2081 it means we've already given a "Complete but not unique"
2082 message and the user's hit TAB again, so now we give him help. */
2083 last_exact_completion
= completion
;
2086 tem
= Fminibuffer_completion_contents ();
2087 if (!NILP (Fequal (tem
, last
)))
2088 Fminibuffer_completion_help ();
2094 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2096 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
2097 doc
: /* Like `assoc' but specifically for strings (and symbols).
2098 Symbols are converted to strings, and unibyte strings are converted to
2099 multibyte for comparison.
2100 Case is ignored if optional arg CASE-FOLD is non-nil.
2101 As opposed to `assoc', it will also match an entry consisting of a single
2102 string rather than a cons cell whose car is a string. */)
2103 (key
, list
, case_fold
)
2104 register Lisp_Object key
;
2105 Lisp_Object list
, case_fold
;
2107 register Lisp_Object tail
;
2110 key
= Fsymbol_name (key
);
2112 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2114 register Lisp_Object elt
, tem
, thiscar
;
2116 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2117 if (SYMBOLP (thiscar
))
2118 thiscar
= Fsymbol_name (thiscar
);
2119 else if (!STRINGP (thiscar
))
2121 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2122 key
, make_number (0), Qnil
,
2131 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2132 doc
: /* Complete the minibuffer contents as far as possible.
2133 Return nil if there is no valid completion, else t.
2134 If no characters can be completed, display a list of possible completions.
2135 If you repeat this command after it displayed such a list,
2136 scroll the window of possible completions. */)
2140 Lisp_Object window
, tem
;
2142 /* If the previous command was not this,
2143 mark the completion buffer obsolete. */
2144 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2145 Vminibuf_scroll_window
= Qnil
;
2147 window
= Vminibuf_scroll_window
;
2148 /* If there's a fresh completion window with a live buffer,
2149 and this command is repeated, scroll that window. */
2150 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2151 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2153 struct buffer
*obuf
= current_buffer
;
2155 Fset_buffer (XWINDOW (window
)->buffer
);
2156 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2158 /* If end is in view, scroll up to the beginning. */
2159 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2161 /* Else scroll down one screen. */
2162 Fscroll_other_window (Qnil
);
2164 set_buffer_internal (obuf
);
2168 i
= do_completion ();
2176 Fgoto_char (make_number (ZV
));
2177 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2182 Fgoto_char (make_number (ZV
));
2183 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2190 /* Subroutines of Fminibuffer_complete_and_exit. */
2192 /* This one is called by internal_condition_case to do the real work. */
2195 complete_and_exit_1 ()
2197 return make_number (do_completion ());
2200 /* This one is called by internal_condition_case if an error happens.
2201 Pretend the current value is an exact match. */
2204 complete_and_exit_2 (ignore
)
2207 return make_number (1);
2210 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2212 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2213 Sminibuffer_complete_and_exit
, 0, 0, "",
2214 doc
: /* If the minibuffer contents is a valid completion then exit.
2215 Otherwise try to complete it. If completion leads to a valid completion,
2216 a repetition of this command will exit. */)
2220 Lisp_Object val
, tem
;
2222 /* Allow user to specify null string */
2223 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2226 val
= Fminibuffer_contents ();
2227 tem
= Ftest_completion (val
,
2228 Vminibuffer_completion_table
,
2229 Vminibuffer_completion_predicate
);
2232 if (completion_ignore_case
)
2233 { /* Fixup case of the field, if necessary. */
2235 = Ftry_completion (val
,
2236 Vminibuffer_completion_table
,
2237 Vminibuffer_completion_predicate
);
2239 /* If it weren't for this piece of paranoia, I'd replace
2240 the whole thing with a call to do_completion. */
2241 && EQ (Flength (val
), Flength (compl)))
2243 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2244 Finsert (1, &compl);
2250 if (EQ (Vminibuffer_completion_confirm
, intern ("confirm-only")))
2251 { /* The user is permitted to exit with an input that's rejected
2252 by test-completion, but at the condition to confirm her choice. */
2253 if (EQ (current_kboard
->Vlast_command
, Vthis_command
))
2257 temp_echo_area_glyphs (build_string (" [Confirm]"));
2262 /* Call do_completion, but ignore errors. */
2264 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2265 complete_and_exit_2
);
2275 if (!NILP (Vminibuffer_completion_confirm
))
2277 temp_echo_area_glyphs (build_string (" [Confirm]"));
2287 return Fexit_minibuffer ();
2291 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2293 doc
: /* Complete the minibuffer contents at most a single word.
2294 After one word is completed as much as possible, a space or hyphen
2295 is added, provided that matches some possible completion.
2296 Return nil if there is no valid completion, else t. */)
2299 Lisp_Object completion
, tem
, tem1
;
2300 register int i
, i_byte
;
2301 struct gcpro gcpro1
, gcpro2
;
2302 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2304 /* We keep calling Fbuffer_string rather than arrange for GC to
2305 hold onto a pointer to one of the strings thus made. */
2307 completion
= Ftry_completion (Fminibuffer_completion_contents (),
2308 Vminibuffer_completion_table
,
2309 Vminibuffer_completion_predicate
);
2310 if (NILP (completion
))
2313 temp_echo_area_glyphs (build_string (" [No match]"));
2316 if (EQ (completion
, Qt
))
2319 #if 0 /* How the below code used to look, for reference. */
2320 tem
= Fminibuffer_contents ();
2322 i
= ZV
- 1 - SCHARS (completion
);
2323 p
= SDATA (completion
);
2325 0 <= scmp (b
, p
, ZV
- 1))
2328 /* Set buffer to longest match of buffer tail and completion head. */
2329 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2331 del_range (1, i
+ 1);
2334 #else /* Rewritten code */
2336 int buffer_nchars
, completion_nchars
;
2338 CHECK_STRING (completion
);
2339 tem
= Fminibuffer_completion_contents ();
2340 GCPRO2 (completion
, tem
);
2341 /* If reading a file name,
2342 expand any $ENVVAR refs in the buffer and in TEM. */
2343 if (! NILP (Vminibuffer_completing_file_name
))
2345 Lisp_Object substituted
;
2346 substituted
= Fsubstitute_in_file_name (tem
);
2347 if (! EQ (substituted
, tem
))
2350 del_range (prompt_end_charpos
, PT
);
2354 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2355 completion_nchars
= SCHARS (completion
);
2356 i
= buffer_nchars
- completion_nchars
;
2359 (tem1
= Fcompare_strings (tem
, make_number (0),
2360 make_number (buffer_nchars
),
2361 completion
, make_number (0),
2362 make_number (buffer_nchars
),
2363 completion_ignore_case
? Qt
: Qnil
),
2368 /* Make buffer (before point) contain the longest match
2369 of TEM's tail and COMPLETION's head. */
2375 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2376 completion
, make_number (0),
2377 make_number (buffer_nchars
),
2378 completion_ignore_case
? Qt
: Qnil
);
2385 del_range (start_pos
, start_pos
+ buffer_nchars
);
2389 #endif /* Rewritten code */
2392 int prompt_end_bytepos
;
2393 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2394 i
= PT
- prompt_end_charpos
;
2395 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2398 /* If completion finds next char not unique,
2399 consider adding a space or a hyphen. */
2400 if (i
== SCHARS (completion
))
2402 GCPRO1 (completion
);
2403 tem
= Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2404 build_string (" ")),
2405 Vminibuffer_completion_table
,
2406 Vminibuffer_completion_predicate
);
2413 GCPRO1 (completion
);
2415 Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2416 build_string ("-")),
2417 Vminibuffer_completion_table
,
2418 Vminibuffer_completion_predicate
);
2426 /* Now find first word-break in the stuff found by completion.
2427 i gets index in string of where to stop completing. */
2430 int bytes
= SBYTES (completion
);
2431 register const unsigned char *completion_string
= SDATA (completion
);
2432 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2434 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2437 if (SYNTAX (c
) != Sword
)
2446 /* If got no characters, print help for user. */
2448 if (i
== PT
- prompt_end_charpos
)
2450 if (!NILP (Vcompletion_auto_help
))
2451 Fminibuffer_completion_help ();
2455 /* Otherwise insert in minibuffer the chars we got */
2457 if (! NILP (Vminibuffer_completing_file_name
)
2458 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2460 && FETCH_CHAR (PT_BYTE
) == '/')
2462 del_range (prompt_end_charpos
, PT
+ 1);
2465 del_range (prompt_end_charpos
, PT
);
2467 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2471 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2473 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2474 Each element may be just a symbol or string
2475 or may be a list of two strings to be printed as if concatenated.
2476 If it is a list of two strings, the first is the actual completion
2477 alternative, the second serves as annotation.
2478 `standard-output' must be a buffer.
2479 The actual completion alternatives, as inserted, are given `mouse-face'
2480 properties of `highlight'.
2481 At the end, this runs the normal hook `completion-setup-hook'.
2482 It can find the completion buffer in `standard-output'.
2483 The optional second arg COMMON-SUBSTRING is a string.
2484 It is used to put faces, `completions-first-difference' and
2485 `completions-common-part' on the completion buffer. The
2486 `completions-common-part' face is put on the common substring
2487 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
2488 and the current buffer is not the minibuffer, the faces are not put.
2489 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2490 during running `completion-setup-hook'. */)
2491 (completions
, common_substring
)
2492 Lisp_Object completions
;
2493 Lisp_Object common_substring
;
2495 Lisp_Object tail
, elt
;
2498 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2499 struct buffer
*old
= current_buffer
;
2502 /* Note that (when it matters) every variable
2503 points to a non-string that is pointed to by COMPLETIONS,
2504 except for ELT. ELT can be pointing to a string
2505 when terpri or Findent_to calls a change hook. */
2507 GCPRO3 (completions
, elt
, common_substring
);
2509 if (BUFFERP (Vstandard_output
))
2510 set_buffer_internal (XBUFFER (Vstandard_output
));
2512 if (NILP (completions
))
2513 write_string ("There are no possible completions of what you have typed.",
2517 write_string ("Possible completions are:", -1);
2518 for (tail
= completions
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2520 Lisp_Object tem
, string
;
2522 Lisp_Object startpos
, endpos
;
2528 elt
= SYMBOL_NAME (elt
);
2529 /* Compute the length of this element. */
2534 length
= SCHARS (tem
);
2536 tem
= Fcar (XCDR (elt
));
2538 length
+= SCHARS (tem
);
2543 length
= SCHARS (elt
);
2546 /* This does a bad job for narrower than usual windows.
2547 Sadly, the window it will appear in is not known
2548 until after the text has been made. */
2550 if (BUFFERP (Vstandard_output
))
2551 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2553 /* If the previous completion was very wide,
2554 or we have two on this line already,
2555 don't put another on the same line. */
2556 if (column
> 33 || first
2557 /* If this is really wide, don't put it second on a line. */
2558 || (column
> 0 && length
> 45))
2563 /* Otherwise advance to column 35. */
2566 if (BUFFERP (Vstandard_output
))
2568 tem
= Findent_to (make_number (35), make_number (2));
2570 column
= XINT (tem
);
2576 write_string (" ", -1);
2579 while (column
< 35);
2583 if (BUFFERP (Vstandard_output
))
2585 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2586 Fset_text_properties (startpos
, endpos
,
2587 Qnil
, Vstandard_output
);
2590 /* Output this element.
2591 If necessary, convert it to unibyte or to multibyte first. */
2593 string
= Fcar (elt
);
2596 if (NILP (current_buffer
->enable_multibyte_characters
)
2597 && STRING_MULTIBYTE (string
))
2598 string
= Fstring_make_unibyte (string
);
2599 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2600 && !STRING_MULTIBYTE (string
))
2601 string
= Fstring_make_multibyte (string
);
2603 if (BUFFERP (Vstandard_output
))
2605 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2607 Fprinc (string
, Qnil
);
2609 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2611 Fput_text_property (startpos
, endpos
,
2612 Qmouse_face
, intern ("highlight"),
2617 Fprinc (string
, Qnil
);
2620 /* Output the annotation for this element. */
2623 if (BUFFERP (Vstandard_output
))
2625 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2627 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2629 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2631 Fset_text_properties (startpos
, endpos
, Qnil
,
2636 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2641 /* Update COLUMN for what we have output. */
2644 /* If output is to a buffer, recompute COLUMN in a way
2645 that takes account of character widths. */
2646 if (BUFFERP (Vstandard_output
))
2648 tem
= Fcurrent_column ();
2649 column
= XINT (tem
);
2656 if (BUFFERP (Vstandard_output
))
2657 set_buffer_internal (old
);
2659 if (!NILP (Vrun_hooks
))
2661 int count1
= SPECPDL_INDEX ();
2663 specbind (intern ("completion-common-substring"), common_substring
);
2664 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2666 unbind_to (count1
, Qnil
);
2676 display_completion_list_1 (list
)
2679 return Fdisplay_completion_list (list
, Qnil
);
2682 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2684 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2687 Lisp_Object completions
;
2689 message ("Making completion list...");
2690 completions
= Fall_completions (Fminibuffer_completion_contents (),
2691 Vminibuffer_completion_table
,
2692 Vminibuffer_completion_predicate
,
2694 clear_message (1, 0);
2696 if (NILP (completions
))
2699 temp_echo_area_glyphs (build_string (" [No completions]"));
2703 /* Sort and remove duplicates. */
2704 Lisp_Object tmp
= completions
= Fsort (completions
, Qstring_lessp
);
2707 if (CONSP (XCDR (tmp
))
2708 && !NILP (Fequal (XCAR (tmp
), XCAR (XCDR (tmp
)))))
2709 XSETCDR (tmp
, XCDR (XCDR (tmp
)));
2713 internal_with_output_to_temp_buffer ("*Completions*",
2714 display_completion_list_1
,
2720 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2721 doc
: /* Terminate minibuffer input. */)
2724 if (INTEGERP (last_command_char
))
2725 internal_self_insert (XINT (last_command_char
), 0);
2729 return Fexit_minibuffer ();
2732 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2733 doc
: /* Terminate this minibuffer argument. */)
2736 /* If the command that uses this has made modifications in the minibuffer,
2737 we don't want them to cause deactivation of the mark in the original
2739 A better solution would be to make deactivate-mark buffer-local
2740 (or to turn it into a list of buffers, ...), but in the mean time,
2741 this should do the trick in most cases. */
2742 Vdeactivate_mark
= Qnil
;
2743 Fthrow (Qexit
, Qnil
);
2746 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2747 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2750 return make_number (minibuf_level
);
2753 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2754 doc
: /* Return the prompt string of the currently-active minibuffer.
2755 If no minibuffer is active, return nil. */)
2758 return Fcopy_sequence (minibuf_prompt
);
2762 /* Temporarily display STRING at the end of the current
2763 minibuffer contents. This is used to display things like
2764 "[No Match]" when the user requests a completion for a prefix
2765 that has no possible completions, and other quick, unobtrusive
2768 extern Lisp_Object Vminibuffer_message_timeout
;
2771 temp_echo_area_glyphs (string
)
2775 int osize_byte
= ZV_BYTE
;
2777 int opoint_byte
= PT_BYTE
;
2778 Lisp_Object oinhibit
;
2779 oinhibit
= Vinhibit_quit
;
2781 /* Clear out any old echo-area message to make way for our new thing. */
2784 SET_PT_BOTH (osize
, osize_byte
);
2785 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2786 SET_PT_BOTH (opoint
, opoint_byte
);
2789 if (NUMBERP (Vminibuffer_message_timeout
))
2790 sit_for (Vminibuffer_message_timeout
, 0, 2);
2794 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2795 SET_PT_BOTH (opoint
, opoint_byte
);
2796 if (!NILP (Vquit_flag
))
2799 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2801 Vinhibit_quit
= oinhibit
;
2804 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2806 doc
: /* Temporarily display STRING at the end of the minibuffer.
2807 The text is displayed for a period controlled by `minibuffer-message-timeout',
2808 or until the next input event arrives, whichever comes first. */)
2812 CHECK_STRING (string
);
2813 temp_echo_area_glyphs (string
);
2818 init_minibuf_once ()
2820 Vminibuffer_list
= Qnil
;
2821 staticpro (&Vminibuffer_list
);
2828 minibuf_prompt
= Qnil
;
2829 staticpro (&minibuf_prompt
);
2831 minibuf_save_list
= Qnil
;
2832 staticpro (&minibuf_save_list
);
2834 Qread_file_name_internal
= intern ("read-file-name-internal");
2835 staticpro (&Qread_file_name_internal
);
2837 Qminibuffer_default
= intern ("minibuffer-default");
2838 staticpro (&Qminibuffer_default
);
2839 Fset (Qminibuffer_default
, Qnil
);
2841 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2842 staticpro (&Qminibuffer_completion_table
);
2844 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2845 staticpro (&Qminibuffer_completion_confirm
);
2847 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2848 staticpro (&Qminibuffer_completion_predicate
);
2850 staticpro (&last_exact_completion
);
2851 last_exact_completion
= Qnil
;
2853 staticpro (&last_minibuf_string
);
2854 last_minibuf_string
= Qnil
;
2856 Quser_variable_p
= intern ("user-variable-p");
2857 staticpro (&Quser_variable_p
);
2859 Qminibuffer_history
= intern ("minibuffer-history");
2860 staticpro (&Qminibuffer_history
);
2862 Qbuffer_name_history
= intern ("buffer-name-history");
2863 staticpro (&Qbuffer_name_history
);
2864 Fset (Qbuffer_name_history
, Qnil
);
2866 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2867 staticpro (&Qminibuffer_setup_hook
);
2869 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2870 staticpro (&Qminibuffer_exit_hook
);
2872 Qhistory_length
= intern ("history-length");
2873 staticpro (&Qhistory_length
);
2875 Qcurrent_input_method
= intern ("current-input-method");
2876 staticpro (&Qcurrent_input_method
);
2878 Qactivate_input_method
= intern ("activate-input-method");
2879 staticpro (&Qactivate_input_method
);
2881 Qcase_fold_search
= intern ("case-fold-search");
2882 staticpro (&Qcase_fold_search
);
2884 Qread_expression_history
= intern ("read-expression-history");
2885 staticpro (&Qread_expression_history
);
2887 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2888 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2889 Vread_buffer_function
= Qnil
;
2891 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2892 doc
: /* Normal hook run just after entry to minibuffer. */);
2893 Vminibuffer_setup_hook
= Qnil
;
2895 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2896 doc
: /* Normal hook run just after exit from minibuffer. */);
2897 Vminibuffer_exit_hook
= Qnil
;
2899 DEFVAR_LISP ("history-length", &Vhistory_length
,
2900 doc
: /* *Maximum length for history lists before truncation takes place.
2901 A number means that length; t means infinite. Truncation takes place
2902 just after a new element is inserted. Setting the `history-length'
2903 property of a history variable overrides this default. */);
2904 XSETFASTINT (Vhistory_length
, 30);
2906 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2907 doc
: /* *Non-nil means to delete duplicates in history.
2908 If set to t when adding a new history element, all previous identical
2909 elements are deleted from the history list. */);
2910 history_delete_duplicates
= 0;
2912 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input
,
2913 doc
: /* *Non-nil means to add new elements in history.
2914 If set to nil, minibuffer reading functions don't add new elements to the
2915 history list, so it is possible to do this afterwards by calling
2916 `add-to-history' explicitly. */);
2917 Vhistory_add_new_input
= Qt
;
2919 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2920 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2921 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2922 see the doc string of `partial-completion-mode' for more details. */);
2923 Vcompletion_auto_help
= Qt
;
2925 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2926 doc
: /* Non-nil means don't consider case significant in completion.
2928 For file-name completion, the variable `read-file-name-completion-ignore-case'
2929 controls the behavior, rather than this variable. */);
2930 completion_ignore_case
= 0;
2932 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2933 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2934 This variable makes a difference whenever the minibuffer window is active. */);
2935 enable_recursive_minibuffers
= 0;
2937 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2938 doc
: /* Alist or obarray used for completion in the minibuffer.
2939 This becomes the ALIST argument to `try-completion' and `all-completions'.
2940 The value can also be a list of strings or a hash table.
2942 The value may alternatively be a function, which is given three arguments:
2943 STRING, the current buffer contents;
2944 PREDICATE, the predicate for filtering possible matches;
2945 CODE, which says what kind of things to do.
2946 CODE can be nil, t or `lambda':
2947 nil -- return the best completion of STRING, or nil if there is none.
2948 t -- return a list of all possible completions of STRING.
2949 lambda -- return t if STRING is a valid completion as it stands. */);
2950 Vminibuffer_completion_table
= Qnil
;
2952 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2953 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2954 Vminibuffer_completion_predicate
= Qnil
;
2956 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2957 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2958 Vminibuffer_completion_confirm
= Qnil
;
2960 DEFVAR_LISP ("minibuffer-completing-file-name",
2961 &Vminibuffer_completing_file_name
,
2962 doc
: /* Non-nil and non-`lambda' means completing file names. */);
2963 Vminibuffer_completing_file_name
= Qnil
;
2965 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2966 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2967 Vminibuffer_help_form
= Qnil
;
2969 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2970 doc
: /* History list symbol to add minibuffer values to.
2971 Each string of minibuffer input, as it appears on exit from the minibuffer,
2973 (set minibuffer-history-variable
2974 (cons STRING (symbol-value minibuffer-history-variable))) */);
2975 XSETFASTINT (Vminibuffer_history_variable
, 0);
2977 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2978 doc
: /* Current position of redoing in the history list. */);
2979 Vminibuffer_history_position
= Qnil
;
2981 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2982 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2983 Some uses of the echo area also raise that frame (since they use it too). */);
2984 minibuffer_auto_raise
= 0;
2986 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2987 doc
: /* List of regexps that should restrict possible completions.
2988 The basic completion functions only consider a completion acceptable
2989 if it matches all regular expressions in this list, with
2990 `case-fold-search' bound to the value of `completion-ignore-case'.
2991 See Info node `(elisp)Basic Completion', for a description of these
2993 Vcompletion_regexp_list
= Qnil
;
2995 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2996 &minibuffer_allow_text_properties
,
2997 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2998 This also affects `read-string', but it does not affect `read-minibuffer',
2999 `read-no-blanks-input', or any of the functions that do minibuffer input
3000 with completion; they always discard text properties. */);
3001 minibuffer_allow_text_properties
= 0;
3003 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
3004 doc
: /* Text properties that are added to minibuffer prompts.
3005 These are in addition to the basic `field' property, and stickiness
3007 /* We use `intern' here instead of Qread_only to avoid
3008 initialization-order problems. */
3009 Vminibuffer_prompt_properties
3010 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
3012 DEFVAR_LISP ("read-expression-map", &Vread_expression_map
,
3013 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
3014 Vread_expression_map
= Qnil
;
3016 defsubr (&Sset_minibuffer_window
);
3017 defsubr (&Sread_from_minibuffer
);
3018 defsubr (&Seval_minibuffer
);
3019 defsubr (&Sread_minibuffer
);
3020 defsubr (&Sread_string
);
3021 defsubr (&Sread_command
);
3022 defsubr (&Sread_variable
);
3023 defsubr (&Sinternal_complete_buffer
);
3024 defsubr (&Sread_buffer
);
3025 defsubr (&Sread_no_blanks_input
);
3026 defsubr (&Sminibuffer_depth
);
3027 defsubr (&Sminibuffer_prompt
);
3029 defsubr (&Sminibufferp
);
3030 defsubr (&Sminibuffer_prompt_end
);
3031 defsubr (&Sminibuffer_contents
);
3032 defsubr (&Sminibuffer_contents_no_properties
);
3033 defsubr (&Sminibuffer_completion_contents
);
3034 defsubr (&Sdelete_minibuffer_contents
);
3036 defsubr (&Stry_completion
);
3037 defsubr (&Sall_completions
);
3038 defsubr (&Stest_completion
);
3039 defsubr (&Sassoc_string
);
3040 defsubr (&Scompleting_read
);
3041 defsubr (&Sminibuffer_complete
);
3042 defsubr (&Sminibuffer_complete_word
);
3043 defsubr (&Sminibuffer_complete_and_exit
);
3044 defsubr (&Sdisplay_completion_list
);
3045 defsubr (&Sminibuffer_completion_help
);
3047 defsubr (&Sself_insert_and_exit
);
3048 defsubr (&Sexit_minibuffer
);
3050 defsubr (&Sminibuffer_message
);
3056 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
3057 "abort-recursive-edit");
3058 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
3060 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
3063 initial_define_key (Vminibuffer_local_ns_map
, ' ',
3065 initial_define_key (Vminibuffer_local_ns_map
, '\t',
3067 initial_define_key (Vminibuffer_local_ns_map
, '?',
3068 "self-insert-and-exit");
3070 initial_define_key (Vminibuffer_local_completion_map
, '\t',
3071 "minibuffer-complete");
3072 initial_define_key (Vminibuffer_local_completion_map
, ' ',
3073 "minibuffer-complete-word");
3074 initial_define_key (Vminibuffer_local_completion_map
, '?',
3075 "minibuffer-completion-help");
3077 Fdefine_key (Vminibuffer_local_filename_completion_map
,
3078 build_string (" "), Qnil
);
3080 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
3081 "minibuffer-complete-and-exit");
3082 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
3083 "minibuffer-complete-and-exit");
3085 Fdefine_key (Vminibuffer_local_must_match_filename_map
,
3086 build_string (" "), Qnil
);
3089 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
3090 (do not change this comment) */