1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
30 #include "dispextern.h"
35 #include "intervals.h"
40 /* List of buffers for use as minibuffers.
41 The first element of the list is used for the outermost minibuffer
42 invocation, the next element is used for a recursive minibuffer
43 invocation, etc. The list is extended at the end as deeper
44 minibuffer recursions are encountered. */
46 Lisp_Object Vminibuffer_list
;
48 /* Data to remember during recursive minibuffer invocations */
50 Lisp_Object minibuf_save_list
;
52 /* Depth in minibuffer invocations. */
56 /* Nonzero means display completion help for invalid input. */
58 Lisp_Object Vcompletion_auto_help
;
60 /* The maximum length of a minibuffer history. */
62 Lisp_Object Qhistory_length
, Vhistory_length
;
64 /* No duplicates in history. */
66 int history_delete_duplicates
;
68 /* Fread_minibuffer leaves the input here as a string. */
70 Lisp_Object last_minibuf_string
;
72 /* Nonzero means let functions called when within a minibuffer
73 invoke recursive minibuffers (to read arguments, or whatever) */
75 int enable_recursive_minibuffers
;
77 /* Nonzero means don't ignore text properties
78 in Fread_from_minibuffer. */
80 int minibuffer_allow_text_properties
;
82 /* help-form is bound to this while in the minibuffer. */
84 Lisp_Object Vminibuffer_help_form
;
86 /* Variable which is the history list to add minibuffer values to. */
88 Lisp_Object Vminibuffer_history_variable
;
90 /* Current position in the history list (adjusted by M-n and M-p). */
92 Lisp_Object Vminibuffer_history_position
;
94 /* Text properties that are added to minibuffer prompts.
95 These are in addition to the basic `field' property, and stickiness
98 Lisp_Object Vminibuffer_prompt_properties
;
100 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
102 Lisp_Object Qread_file_name_internal
;
104 /* Normal hooks for entry to and exit from minibuffer. */
106 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
107 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
109 /* Function to call to read a buffer name. */
110 Lisp_Object Vread_buffer_function
;
112 /* Nonzero means completion ignores case. */
114 int completion_ignore_case
;
116 /* List of regexps that should restrict possible completions. */
118 Lisp_Object Vcompletion_regexp_list
;
120 /* Nonzero means raise the minibuffer frame when the minibuffer
123 int minibuffer_auto_raise
;
125 /* If last completion attempt reported "Complete but not unique"
126 then this is the string completed then; otherwise this is nil. */
128 static Lisp_Object last_exact_completion
;
130 extern Lisp_Object Voverriding_local_map
;
132 Lisp_Object Quser_variable_p
;
134 Lisp_Object Qminibuffer_default
;
136 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
138 Lisp_Object Qcase_fold_search
;
140 extern Lisp_Object Qmouse_face
;
142 extern Lisp_Object Qfield
;
144 /* Put minibuf on currently selected frame's minibuffer.
145 We do this whenever the user starts a new minibuffer
146 or when a minibuffer exits. */
149 choose_minibuf_frame ()
151 if (FRAMEP (selected_frame
)
152 && FRAME_LIVE_P (XFRAME (selected_frame
))
153 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
155 struct frame
*sf
= XFRAME (selected_frame
);
158 /* I don't think that any frames may validly have a null minibuffer
160 if (NILP (sf
->minibuffer_window
))
163 /* Under X, we come here with minibuf_window being the
164 minibuffer window of the unused termcap window created in
165 init_window_once. That window doesn't have a buffer. */
166 buffer
= XWINDOW (minibuf_window
)->buffer
;
167 if (BUFFERP (buffer
))
168 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
169 minibuf_window
= sf
->minibuffer_window
;
172 /* Make sure no other frame has a minibuffer as its selected window,
173 because the text would not be displayed in it, and that would be
174 confusing. Only allow the selected frame to do this,
175 and that only if the minibuffer is active. */
177 Lisp_Object tail
, frame
;
179 FOR_EACH_FRAME (tail
, frame
)
180 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
181 && !(EQ (frame
, selected_frame
)
182 && minibuf_level
> 0))
183 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
188 choose_minibuf_frame_1 (ignore
)
191 choose_minibuf_frame ();
195 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
196 Sset_minibuffer_window
, 1, 1, 0,
197 doc
: /* Specify which minibuffer window to use for the minibuffer.
198 This affects where the minibuffer is displayed if you put text in it
199 without invoking the usual minibuffer commands. */)
203 CHECK_WINDOW (window
);
204 if (! MINI_WINDOW_P (XWINDOW (window
)))
205 error ("Window is not a minibuffer window");
207 minibuf_window
= window
;
213 /* Actual minibuffer invocation. */
215 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
216 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
217 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
218 Lisp_Object
, Lisp_Object
,
220 Lisp_Object
, Lisp_Object
,
222 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
223 Lisp_Object
, Lisp_Object
,
225 Lisp_Object
, Lisp_Object
,
227 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
230 /* Read a Lisp object from VAL and return it. If VAL is an empty
231 string, and DEFALT is a string, read from DEFALT instead of VAL. */
234 string_to_object (val
, defalt
)
235 Lisp_Object val
, defalt
;
237 struct gcpro gcpro1
, gcpro2
;
238 Lisp_Object expr_and_pos
;
241 GCPRO2 (val
, defalt
);
243 if (STRINGP (val
) && SCHARS (val
) == 0
247 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
248 pos
= XINT (Fcdr (expr_and_pos
));
249 if (pos
!= SCHARS (val
))
251 /* Ignore trailing whitespace; any other trailing junk
254 pos
= string_char_to_byte (val
, pos
);
255 for (i
= pos
; i
< SBYTES (val
); i
++)
257 int c
= SREF (val
, i
);
258 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
259 error ("Trailing garbage following expression");
263 val
= Fcar (expr_and_pos
);
264 RETURN_UNGCPRO (val
);
268 /* Like read_minibuf but reading from stdin. This function is called
269 from read_minibuf to do the job if noninteractive. */
272 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
273 histvar
, histpos
, defalt
, allow_props
,
274 inherit_input_method
)
278 Lisp_Object backup_n
;
284 int inherit_input_method
;
290 fprintf (stdout
, "%s", SDATA (prompt
));
296 line
= (char *) xmalloc (size
* sizeof *line
);
297 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
298 && (len
= strlen (line
),
299 len
== size
- 1 && line
[len
- 1] != '\n'))
302 line
= (char *) xrealloc (line
, size
);
309 if (len
> 0 && line
[len
- 1] == '\n')
312 val
= build_string (line
);
318 error ("Error reading from stdin");
321 /* If Lisp form desired instead of string, parse it. */
323 val
= string_to_object (val
, defalt
);
328 DEFUN ("minibufferp", Fminibufferp
,
329 Sminibufferp
, 0, 1, 0,
330 doc
: /* Return t if BUFFER is a minibuffer.
331 No argument or nil as argument means use current buffer as BUFFER.
332 BUFFER can be a buffer or a buffer name. */)
339 buffer
= Fcurrent_buffer ();
340 else if (STRINGP (buffer
))
341 buffer
= Fget_buffer (buffer
);
343 CHECK_BUFFER (buffer
);
345 tem
= Fmemq (buffer
, Vminibuffer_list
);
346 return ! NILP (tem
) ? Qt
: Qnil
;
349 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
350 Sminibuffer_prompt_end
, 0, 0, 0,
351 doc
: /* Return the buffer position of the end of the minibuffer prompt.
352 Return (point-min) if current buffer is not a minibuffer. */)
355 /* This function is written to be most efficient when there's a prompt. */
356 Lisp_Object beg
, end
, tem
;
357 beg
= make_number (BEGV
);
359 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
363 end
= Ffield_end (beg
, Qnil
, Qnil
);
365 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
371 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
372 Sminibuffer_contents
, 0, 0, 0,
373 doc
: /* Return the user input in a minibuffer as a string.
374 The current buffer must be a minibuffer. */)
377 int prompt_end
= XINT (Fminibuffer_prompt_end ());
378 return make_buffer_string (prompt_end
, ZV
, 1);
381 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
382 Sminibuffer_contents_no_properties
, 0, 0, 0,
383 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
384 The current buffer must be a minibuffer. */)
387 int prompt_end
= XINT (Fminibuffer_prompt_end ());
388 return make_buffer_string (prompt_end
, ZV
, 0);
391 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
392 Sdelete_minibuffer_contents
, 0, 0, 0,
393 doc
: /* Delete all user input in a minibuffer.
394 The current buffer must be a minibuffer. */)
397 int prompt_end
= XINT (Fminibuffer_prompt_end ());
399 del_range (prompt_end
, ZV
);
403 /* Get the text in the minibuffer before point.
404 That is what completion commands operate on. */
407 minibuffer_completion_contents ()
409 int prompt_end
= XINT (Fminibuffer_prompt_end ());
411 error ("Cannot do completion in the prompt");
412 return make_buffer_string (prompt_end
, PT
, 1);
415 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
416 putting point minus BACKUP_N bytes from the end of INITIAL,
417 prompting with PROMPT (a string), using history list HISTVAR
418 with initial position HISTPOS. INITIAL should be a string or a
419 cons of a string and an integer. BACKUP_N should be <= 0, or
420 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
421 ignored and replaced with an integer that puts point at one-indexed
422 position N in INITIAL, where N is the CDR of INITIAL, or at the
423 beginning of INITIAL if N <= 0.
425 Normally return the result as a string (the text that was read),
426 but if EXPFLAG is nonzero, read it and return the object read.
427 If HISTVAR is given, save the value read on that history only if it doesn't
428 match the front of that history list exactly. The value is pushed onto
429 the list as the string that was read.
431 DEFALT specifies the default value for the sake of history commands.
433 If ALLOW_PROPS is nonzero, we do not throw away text properties.
435 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
436 current input method. */
439 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
440 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
,
445 Lisp_Object backup_n
;
451 int inherit_input_method
;
455 int count
= SPECPDL_INDEX ();
456 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
457 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
458 Lisp_Object enable_multibyte
;
459 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
461 /* String to add to the history. */
462 Lisp_Object histstring
;
464 extern Lisp_Object Qfront_sticky
;
465 extern Lisp_Object Qrear_nonsticky
;
467 specbind (Qminibuffer_default
, defalt
);
469 single_kboard_state ();
470 #ifdef HAVE_X_WINDOWS
471 if (display_hourglass_p
)
479 backup_n
= Fcdr (initial
);
480 initial
= Fcar (initial
);
481 CHECK_STRING (initial
);
482 if (!NILP (backup_n
))
484 CHECK_NUMBER (backup_n
);
485 /* Convert to distance from end of input. */
486 if (XINT (backup_n
) < 1)
487 /* A number too small means the beginning of the string. */
488 pos
= - SCHARS (initial
);
490 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
494 CHECK_STRING (initial
);
497 ambient_dir
= current_buffer
->directory
;
499 enable_multibyte
= Qnil
;
501 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
502 store them away before we can GC. Don't need to protect
503 BACKUP_N because we use the value only if it is an integer. */
504 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
506 if (!STRINGP (prompt
))
507 prompt
= empty_string
;
509 if (!enable_recursive_minibuffers
510 && minibuf_level
> 0)
512 if (EQ (selected_window
, minibuf_window
))
513 error ("Command attempted to use minibuffer while in minibuffer");
515 /* If we're in another window, cancel the minibuffer that's active. */
517 build_string ("Command attempted to use minibuffer while in minibuffer"));
522 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
524 expflag
, histvar
, histpos
, defalt
,
525 allow_props
, inherit_input_method
);
527 return unbind_to (count
, val
);
530 /* Choose the minibuffer window and frame, and take action on them. */
532 choose_minibuf_frame ();
534 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
536 record_unwind_protect (Fset_window_configuration
,
537 Fcurrent_window_configuration (Qnil
));
539 /* If the minibuffer window is on a different frame, save that
540 frame's configuration too. */
541 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
542 if (!EQ (mini_frame
, selected_frame
))
543 record_unwind_protect (Fset_window_configuration
,
544 Fcurrent_window_configuration (mini_frame
));
546 /* If the minibuffer is on an iconified or invisible frame,
547 make it visible now. */
548 Fmake_frame_visible (mini_frame
);
550 if (minibuffer_auto_raise
)
551 Fraise_frame (mini_frame
);
553 /* We have to do this after saving the window configuration
554 since that is what restores the current buffer. */
556 /* Arrange to restore a number of minibuffer-related variables.
557 We could bind each variable separately, but that would use lots of
560 = Fcons (Voverriding_local_map
,
561 Fcons (minibuf_window
, minibuf_save_list
));
563 = Fcons (minibuf_prompt
,
564 Fcons (make_number (minibuf_prompt_width
),
566 Fcons (Vcurrent_prefix_arg
,
567 Fcons (Vminibuffer_history_position
,
568 Fcons (Vminibuffer_history_variable
,
569 minibuf_save_list
))))));
571 record_unwind_protect (read_minibuf_unwind
, Qnil
);
573 /* We are exiting the minibuffer one way or the other, so run the hook.
574 It should be run before unwinding the minibuf settings. Do it
575 separately from read_minibuf_unwind because we need to make sure that
576 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
577 signals an error. --Stef */
578 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
580 /* Now that we can restore all those variables, start changing them. */
582 minibuf_prompt_width
= 0;
583 minibuf_prompt
= Fcopy_sequence (prompt
);
584 Vminibuffer_history_position
= histpos
;
585 Vminibuffer_history_variable
= histvar
;
586 Vhelp_form
= Vminibuffer_help_form
;
588 if (inherit_input_method
)
590 /* `current-input-method' is buffer local. So, remember it in
591 INPUT_METHOD before changing the current buffer. */
592 input_method
= Fsymbol_value (Qcurrent_input_method
);
593 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
596 /* Switch to the minibuffer. */
598 minibuffer
= get_minibuffer (minibuf_level
);
599 Fset_buffer (minibuffer
);
601 /* The current buffer's default directory is usually the right thing
602 for our minibuffer here. However, if you're typing a command at
603 a minibuffer-only frame when minibuf_level is zero, then buf IS
604 the current_buffer, so reset_buffer leaves buf's default
605 directory unchanged. This is a bummer when you've just started
606 up Emacs and buf's default directory is Qnil. Here's a hack; can
607 you think of something better to do? Find another buffer with a
608 better directory, and use that one instead. */
609 if (STRINGP (ambient_dir
))
610 current_buffer
->directory
= ambient_dir
;
613 Lisp_Object buf_list
;
615 for (buf_list
= Vbuffer_alist
;
617 buf_list
= XCDR (buf_list
))
619 Lisp_Object other_buf
;
621 other_buf
= XCDR (XCAR (buf_list
));
622 if (STRINGP (XBUFFER (other_buf
)->directory
))
624 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
630 if (!EQ (mini_frame
, selected_frame
))
631 Fredirect_frame_focus (selected_frame
, mini_frame
);
633 Vminibuf_scroll_window
= selected_window
;
634 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
635 minibuf_selected_window
= selected_window
;
636 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
637 Fselect_window (minibuf_window
, Qnil
);
638 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
640 Fmake_local_variable (Qprint_escape_newlines
);
641 print_escape_newlines
= 1;
643 /* Erase the buffer. */
645 int count1
= SPECPDL_INDEX ();
646 specbind (Qinhibit_read_only
, Qt
);
647 specbind (Qinhibit_modification_hooks
, Qt
);
649 unbind_to (count1
, Qnil
);
652 if (!NILP (current_buffer
->enable_multibyte_characters
)
653 && ! STRING_MULTIBYTE (minibuf_prompt
))
654 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
656 /* Insert the prompt, record where it ends. */
657 Finsert (1, &minibuf_prompt
);
660 Fput_text_property (make_number (BEG
), make_number (PT
),
661 Qfront_sticky
, Qt
, Qnil
);
662 Fput_text_property (make_number (BEG
), make_number (PT
),
663 Qrear_nonsticky
, Qt
, Qnil
);
664 Fput_text_property (make_number (BEG
), make_number (PT
),
666 Fadd_text_properties (make_number (BEG
), make_number (PT
),
667 Vminibuffer_prompt_properties
, Qnil
);
670 minibuf_prompt_width
= (int) current_column (); /* iftc */
672 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
673 if (inherit_input_method
)
674 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
676 /* Put in the initial input. */
679 Finsert (1, &initial
);
680 Fforward_char (make_number (pos
));
683 clear_message (1, 1);
684 current_buffer
->keymap
= map
;
686 /* Turn on an input method stored in INPUT_METHOD if any. */
687 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
688 call1 (Qactivate_input_method
, input_method
);
690 /* Run our hook, but not if it is empty.
691 (run-hooks would do nothing if it is empty,
692 but it's important to save time here in the usual case.) */
693 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
694 && !NILP (Vrun_hooks
))
695 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
697 /* Don't allow the user to undo past this point. */
698 current_buffer
->undo_list
= Qnil
;
702 /* If cursor is on the minibuffer line,
703 show the user we have exited by putting it in column 0. */
704 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
707 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
708 XWINDOW (minibuf_window
)->cursor
.x
= 0;
709 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
710 update_frame (XFRAME (selected_frame
), 1, 1);
711 if (rif
&& rif
->flush_display
)
712 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
715 /* Make minibuffer contents into a string. */
716 Fset_buffer (minibuffer
);
718 val
= Fminibuffer_contents ();
720 val
= Fminibuffer_contents_no_properties ();
722 /* VAL is the string of minibuffer text. */
724 last_minibuf_string
= val
;
726 /* Choose the string to add to the history. */
727 if (SCHARS (val
) != 0 || keep_all
)
729 else if (STRINGP (defalt
))
734 /* Add the value to the appropriate history list, if any. */
735 if (SYMBOLP (Vminibuffer_history_variable
)
736 && !NILP (histstring
))
738 /* If the caller wanted to save the value read on a history list,
739 then do so if the value is not already the front of the list. */
742 /* If variable is unbound, make it nil. */
743 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
744 Fset (Vminibuffer_history_variable
, Qnil
);
746 histval
= Fsymbol_value (Vminibuffer_history_variable
);
748 /* The value of the history variable must be a cons or nil. Other
749 values are unacceptable. We silently ignore these values. */
753 /* Don't duplicate the most recent entry in the history. */
755 || NILP (Fequal (histstring
, Fcar (histval
))))))
759 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
760 histval
= Fcons (histstring
, histval
);
761 Fset (Vminibuffer_history_variable
, histval
);
763 /* Truncate if requested. */
764 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
765 if (NILP (length
)) length
= Vhistory_length
;
766 if (INTEGERP (length
))
768 if (XINT (length
) <= 0)
769 Fset (Vminibuffer_history_variable
, Qnil
);
774 temp
= Fnthcdr (Fsub1 (length
), histval
);
775 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
781 /* If Lisp form desired instead of string, parse it. */
783 val
= string_to_object (val
, defalt
);
785 /* The appropriate frame will get selected
786 in set-window-configuration. */
788 return unbind_to (count
, val
);
791 /* Return a buffer to be used as the minibuffer at depth `depth'.
792 depth = 0 is the lowest allowed argument, and that is the value
793 used for nonrecursive minibuffer invocations */
796 get_minibuffer (depth
)
799 Lisp_Object tail
, num
, buf
;
801 extern Lisp_Object
nconc2 ();
803 XSETFASTINT (num
, depth
);
804 tail
= Fnthcdr (num
, Vminibuffer_list
);
807 tail
= Fcons (Qnil
, Qnil
);
808 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
811 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
813 sprintf (name
, " *Minibuf-%d*", depth
);
814 buf
= Fget_buffer_create (build_string (name
));
816 /* Although the buffer's name starts with a space, undo should be
818 Fbuffer_enable_undo (buf
);
824 int count
= SPECPDL_INDEX ();
825 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
826 have to empty the list, otherwise we end up with overlays that
827 think they belong to this buffer while the buffer doesn't know about
829 delete_all_overlays (XBUFFER (buf
));
830 reset_buffer (XBUFFER (buf
));
831 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
833 Fkill_all_local_variables ();
834 unbind_to (count
, Qnil
);
841 run_exit_minibuf_hook (data
)
844 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
845 && !NILP (Vrun_hooks
))
846 safe_run_hooks (Qminibuffer_exit_hook
);
851 /* This function is called on exiting minibuffer, whether normally or
852 not, and it restores the current window, buffer, etc. */
855 read_minibuf_unwind (data
)
858 Lisp_Object old_deactivate_mark
;
861 /* If this was a recursive minibuffer,
862 tie the minibuffer window back to the outer level minibuffer buffer. */
865 window
= minibuf_window
;
866 /* To keep things predictable, in case it matters, let's be in the
867 minibuffer when we reset the relevant variables. */
868 Fset_buffer (XWINDOW (window
)->buffer
);
870 /* Restore prompt, etc, from outer minibuffer level. */
871 minibuf_prompt
= Fcar (minibuf_save_list
);
872 minibuf_save_list
= Fcdr (minibuf_save_list
);
873 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
874 minibuf_save_list
= Fcdr (minibuf_save_list
);
875 Vhelp_form
= Fcar (minibuf_save_list
);
876 minibuf_save_list
= Fcdr (minibuf_save_list
);
877 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
878 minibuf_save_list
= Fcdr (minibuf_save_list
);
879 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
880 minibuf_save_list
= Fcdr (minibuf_save_list
);
881 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
882 minibuf_save_list
= Fcdr (minibuf_save_list
);
883 Voverriding_local_map
= Fcar (minibuf_save_list
);
884 minibuf_save_list
= Fcdr (minibuf_save_list
);
886 temp
= Fcar (minibuf_save_list
);
887 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
888 minibuf_window
= temp
;
890 minibuf_save_list
= Fcdr (minibuf_save_list
);
892 /* Erase the minibuffer we were using at this level. */
894 int count
= SPECPDL_INDEX ();
895 /* Prevent error in erase-buffer. */
896 specbind (Qinhibit_read_only
, Qt
);
897 specbind (Qinhibit_modification_hooks
, Qt
);
898 old_deactivate_mark
= Vdeactivate_mark
;
900 Vdeactivate_mark
= old_deactivate_mark
;
901 unbind_to (count
, Qnil
);
904 /* When we get to the outmost level, make sure we resize the
905 mini-window back to its normal size. */
906 if (minibuf_level
== 0)
907 resize_mini_window (XWINDOW (window
), 0);
909 /* Make sure minibuffer window is erased, not ignored. */
910 windows_or_buffers_changed
++;
911 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
912 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
917 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 8, 0,
918 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
919 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
920 DEFAULT-VALUE. It normally should be nil in new code, except when
921 HIST is a cons. It is discussed in more detail below.
922 Third arg KEYMAP is a keymap to use whilst reading;
923 if omitted or nil, the default is `minibuffer-local-map'.
924 If fourth arg READ is non-nil, then interpret the result as a Lisp object
925 and return that object:
926 in other words, do `(car (read-from-string INPUT-STRING))'
927 Fifth arg HIST, if non-nil, specifies a history list and optionally
928 the initial position in the list. It can be a symbol, which is the
929 history list variable to use, or it can be a cons cell
930 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
931 to use, and HISTPOS is the initial position for use by the minibuffer
932 history commands. For consistency, you should also specify that
933 element of the history as the value of INITIAL-CONTENTS. Positions
934 are counted starting from 1 at the beginning of the list.
935 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
936 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
937 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
939 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
940 the current input method and the setting of `enable-multibyte-characters'.
941 Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
942 even empty or duplicate inputs.
943 If the variable `minibuffer-allow-text-properties' is non-nil,
944 then the string which is returned includes whatever text properties
945 were present in the minibuffer. Otherwise the value has no text properties.
947 The remainder of this documentation string describes the
948 INITIAL-CONTENTS argument in more detail. It is only relevant when
949 studying existing code, or when HIST is a cons. If non-nil,
950 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
951 reading input. Normally, point is put at the end of that string.
952 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
953 input is STRING, but point is placed at _one-indexed_ position
954 POSITION in the minibuffer. Any integer value less than or equal to
955 one puts point at the beginning of the string. *Note* that this
956 behavior differs from the way such arguments are used in `completing-read'
957 and some related functions, which use zero-indexing for POSITION. */)
958 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
, keep_all
)
959 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
960 Lisp_Object inherit_input_method
, keep_all
;
962 Lisp_Object histvar
, histpos
, val
;
965 CHECK_STRING (prompt
);
967 keymap
= Vminibuffer_local_map
;
969 keymap
= get_keymap (keymap
, 1, 0);
978 histvar
= Fcar_safe (hist
);
979 histpos
= Fcdr_safe (hist
);
982 histvar
= Qminibuffer_history
;
984 XSETFASTINT (histpos
, 0);
986 GCPRO1 (default_value
);
987 val
= read_minibuf (keymap
, initial_contents
, prompt
,
989 histvar
, histpos
, default_value
,
990 minibuffer_allow_text_properties
,
991 !NILP (inherit_input_method
),
997 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
998 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
999 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1000 is a string to insert in the minibuffer before reading.
1001 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1002 arguments are used as in `read-from-minibuffer') */)
1003 (prompt
, initial_contents
)
1004 Lisp_Object prompt
, initial_contents
;
1006 CHECK_STRING (prompt
);
1007 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1008 prompt
, Qnil
, 1, Qminibuffer_history
,
1009 make_number (0), Qnil
, 0, 0, 0);
1012 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1013 doc
: /* Return value of Lisp expression read using the minibuffer.
1014 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1015 is a string to insert in the minibuffer before reading.
1016 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1017 arguments are used as in `read-from-minibuffer'.) */)
1018 (prompt
, initial_contents
)
1019 Lisp_Object prompt
, initial_contents
;
1021 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1024 /* Functions that use the minibuffer to read various things. */
1026 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1027 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1028 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1029 This argument has been superseded by DEFAULT-VALUE and should normally
1030 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1031 documentation string of that function for details.
1032 The third arg HISTORY, if non-nil, specifies a history list
1033 and optionally the initial position in the list.
1034 See `read-from-minibuffer' for details of HISTORY argument.
1035 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1036 for history commands, and as the value to return if the user enters
1038 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1039 the current input method and the setting of `enable-multibyte-characters'. */)
1040 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1041 Lisp_Object prompt
, initial_input
, history
, default_value
;
1042 Lisp_Object inherit_input_method
;
1045 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1046 Qnil
, history
, default_value
,
1047 inherit_input_method
, Qnil
);
1048 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1049 val
= default_value
;
1053 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1054 doc
: /* Read a string from the terminal, not allowing blanks.
1055 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1056 non-nil, it should be a string, which is used as initial input, with
1057 point positioned at the end, so that SPACE will accept the input.
1058 \(Actually, INITIAL can also be a cons of a string and an integer.
1059 Such values are treated as in `read-from-minibuffer', but are normally
1060 not useful in this function.)
1061 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1062 the current input method and the setting of`enable-multibyte-characters'. */)
1063 (prompt
, initial
, inherit_input_method
)
1064 Lisp_Object prompt
, initial
, inherit_input_method
;
1066 CHECK_STRING (prompt
);
1067 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1068 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1069 !NILP (inherit_input_method
), 0);
1072 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1073 doc
: /* Read the name of a command and return as a symbol.
1074 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1075 (prompt
, default_value
)
1076 Lisp_Object prompt
, default_value
;
1078 Lisp_Object name
, default_string
;
1080 if (NILP (default_value
))
1081 default_string
= Qnil
;
1082 else if (SYMBOLP (default_value
))
1083 default_string
= SYMBOL_NAME (default_value
);
1085 default_string
= default_value
;
1087 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1088 Qnil
, Qnil
, default_string
, Qnil
);
1091 return Fintern (name
, Qnil
);
1095 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1096 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1097 Prompt with PROMPT. */)
1101 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1106 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1107 doc
: /* Read the name of a user variable and return it as a symbol.
1108 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1109 A user variable is one for which `user-variable-p' returns non-nil. */)
1110 (prompt
, default_value
)
1111 Lisp_Object prompt
, default_value
;
1113 Lisp_Object name
, default_string
;
1115 if (NILP (default_value
))
1116 default_string
= Qnil
;
1117 else if (SYMBOLP (default_value
))
1118 default_string
= SYMBOL_NAME (default_value
);
1120 default_string
= default_value
;
1122 name
= Fcompleting_read (prompt
, Vobarray
,
1123 Quser_variable_p
, Qt
,
1124 Qnil
, Qnil
, default_string
, Qnil
);
1127 return Fintern (name
, Qnil
);
1130 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1131 doc
: /* Read the name of a buffer and return as a string.
1133 Optional second arg DEF is value to return if user enters an empty line.
1134 If optional third arg REQUIRE-MATCH is non-nil,
1135 only existing buffer names are allowed.
1136 The argument PROMPT should be a string ending with a colon and a space. */)
1137 (prompt
, def
, require_match
)
1138 Lisp_Object prompt
, def
, require_match
;
1140 Lisp_Object args
[4];
1145 def
= XBUFFER (def
)->name
;
1147 if (NILP (Vread_buffer_function
))
1151 /* A default value was provided: we must change PROMPT,
1152 editing the default value in before the colon. To achieve
1153 this, we replace PROMPT with a substring that doesn't
1154 contain the terminal space and colon (if present). They
1155 are then added back using Fformat. */
1157 if (STRINGP (prompt
))
1161 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1163 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1166 prompt
= make_specified_string (s
, -1, len
,
1167 STRING_MULTIBYTE (prompt
));
1170 args
[0] = build_string ("%s (default %s): ");
1173 prompt
= Fformat (3, args
);
1176 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1177 require_match
, Qnil
, Qbuffer_name_history
,
1182 args
[0] = Vread_buffer_function
;
1185 args
[3] = require_match
;
1186 return Ffuncall(4, args
);
1191 minibuf_conform_representation (string
, basis
)
1192 Lisp_Object string
, basis
;
1194 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1197 if (STRING_MULTIBYTE (string
))
1198 return Fstring_make_unibyte (string
);
1200 return Fstring_make_multibyte (string
);
1203 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1204 doc
: /* Return common substring of all completions of STRING in ALIST.
1205 Each car of each element of ALIST (or each element if it is not a cons cell)
1206 is tested to see if it begins with STRING. The possible matches may be
1207 strings or symbols. Symbols are converted to strings before testing,
1209 All that match are compared together; the longest initial sequence
1210 common to all matches is returned as a string.
1211 If there is no match at all, nil is returned.
1212 For a unique match which is exact, t is returned.
1214 If ALIST is a hash-table, all the string and symbol keys are the
1216 If ALIST is an obarray, the names of all symbols in the obarray
1217 are the possible matches.
1219 ALIST can also be a function to do the completion itself.
1220 It receives three arguments: the values STRING, PREDICATE and nil.
1221 Whatever it returns becomes the value of `try-completion'.
1223 If optional third argument PREDICATE is non-nil,
1224 it is used to test each possible match.
1225 The match is a candidate only if PREDICATE returns non-nil.
1226 The argument given to PREDICATE is the alist element
1227 or the symbol from the obarray. If ALIST is a hash-table,
1228 predicate is called with two arguments: the key and the value.
1229 Additionally to this predicate, `completion-regexp-list'
1230 is used to further constrain the set of candidates. */)
1231 (string
, alist
, predicate
)
1232 Lisp_Object string
, alist
, predicate
;
1234 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1235 /* Size in bytes of BESTMATCH. */
1236 int bestmatchsize
= 0;
1237 /* These are in bytes, too. */
1238 int compare
, matchsize
;
1239 int type
= HASH_TABLE_P (alist
) ? 3
1240 : VECTORP (alist
) ? 2
1241 : NILP (alist
) || (CONSP (alist
)
1242 && (!SYMBOLP (XCAR (alist
))
1243 || NILP (XCAR (alist
))));
1244 int index
= 0, obsize
= 0;
1247 Lisp_Object bucket
, zero
, end
, tem
;
1248 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1250 CHECK_STRING (string
);
1252 return call3 (alist
, string
, predicate
, Qnil
);
1254 bestmatch
= bucket
= Qnil
;
1255 zero
= make_number (0);
1257 /* If ALIST is not a list, set TAIL just for gc pro. */
1261 obsize
= XVECTOR (alist
)->size
;
1262 bucket
= XVECTOR (alist
)->contents
[index
];
1267 /* Get the next element of the alist, obarray, or hash-table. */
1268 /* Exit the loop if the elements are all used up. */
1269 /* elt gets the alist element or symbol.
1270 eltstring gets the name to check as a completion. */
1277 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1282 if (!EQ (bucket
, zero
))
1286 if (XSYMBOL (bucket
)->next
)
1287 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1289 XSETFASTINT (bucket
, 0);
1291 else if (++index
>= obsize
)
1295 bucket
= XVECTOR (alist
)->contents
[index
];
1299 else /* if (type == 3) */
1301 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1302 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1304 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1307 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1310 /* Is this element a possible completion? */
1312 if (SYMBOLP (eltstring
))
1313 eltstring
= Fsymbol_name (eltstring
);
1315 if (STRINGP (eltstring
)
1316 && SCHARS (string
) <= SCHARS (eltstring
)
1317 && (tem
= Fcompare_strings (eltstring
, zero
,
1318 make_number (SCHARS (string
)),
1320 completion_ignore_case
? Qt
: Qnil
),
1324 Lisp_Object regexps
;
1326 /* Ignore this element if it fails to match all the regexps. */
1328 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1329 regexps
= XCDR (regexps
))
1331 if (bindcount
< 0) {
1332 bindcount
= SPECPDL_INDEX ();
1333 specbind (Qcase_fold_search
,
1334 completion_ignore_case
? Qt
: Qnil
);
1336 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1340 if (CONSP (regexps
))
1344 /* Ignore this element if there is a predicate
1345 and the predicate doesn't like it. */
1347 if (!NILP (predicate
))
1349 if (EQ (predicate
, Qcommandp
))
1350 tem
= Fcommandp (elt
, Qnil
);
1353 if (bindcount
>= 0) {
1354 unbind_to (bindcount
, Qnil
);
1357 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1359 ? call2 (predicate
, elt
,
1360 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1361 : call1 (predicate
, elt
);
1364 if (NILP (tem
)) continue;
1367 /* Update computation of how much all possible completions match */
1369 if (NILP (bestmatch
))
1372 bestmatch
= eltstring
;
1373 bestmatchsize
= SCHARS (eltstring
);
1377 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1378 tem
= Fcompare_strings (bestmatch
, zero
,
1379 make_number (compare
),
1381 make_number (compare
),
1382 completion_ignore_case
? Qt
: Qnil
);
1384 matchsize
= compare
;
1385 else if (XINT (tem
) < 0)
1386 matchsize
= - XINT (tem
) - 1;
1388 matchsize
= XINT (tem
) - 1;
1391 /* When can this happen ? -stef */
1392 matchsize
= compare
;
1393 if (completion_ignore_case
)
1395 /* If this is an exact match except for case,
1396 use it as the best match rather than one that is not an
1397 exact match. This way, we get the case pattern
1398 of the actual match. */
1399 if ((matchsize
== SCHARS (eltstring
)
1400 && matchsize
< SCHARS (bestmatch
))
1402 /* If there is more than one exact match ignoring case,
1403 and one of them is exact including case,
1405 /* If there is no exact match ignoring case,
1406 prefer a match that does not change the case
1408 ((matchsize
== SCHARS (eltstring
))
1410 (matchsize
== SCHARS (bestmatch
))
1411 && (tem
= Fcompare_strings (eltstring
, zero
,
1412 make_number (SCHARS (string
)),
1417 && (tem
= Fcompare_strings (bestmatch
, zero
,
1418 make_number (SCHARS (string
)),
1423 bestmatch
= eltstring
;
1425 if (bestmatchsize
!= SCHARS (eltstring
)
1426 || bestmatchsize
!= matchsize
)
1427 /* Don't count the same string multiple times. */
1429 bestmatchsize
= matchsize
;
1430 if (matchsize
<= SCHARS (string
)
1432 /* No need to look any further. */
1438 if (bindcount
>= 0) {
1439 unbind_to (bindcount
, Qnil
);
1443 if (NILP (bestmatch
))
1444 return Qnil
; /* No completions found */
1445 /* If we are ignoring case, and there is no exact match,
1446 and no additional text was supplied,
1447 don't change the case of what the user typed. */
1448 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1449 && SCHARS (bestmatch
) > bestmatchsize
)
1450 return minibuf_conform_representation (string
, bestmatch
);
1452 /* Return t if the supplied string is an exact match (counting case);
1453 it does not require any change to be made. */
1454 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1455 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1456 make_number (bestmatchsize
),
1457 string
, make_number (0),
1458 make_number (bestmatchsize
),
1463 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1464 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1465 return Fsubstring (bestmatch
, zero
, end
);
1468 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1469 doc
: /* Search for partial matches to STRING in ALIST.
1470 Each car of each element of ALIST (or each element if it is not a cons cell)
1471 is tested to see if it begins with STRING. The possible matches may be
1472 strings or symbols. Symbols are converted to strings before testing,
1474 The value is a list of all the strings from ALIST that match.
1476 If ALIST is a hash-table, all the string and symbol keys are the
1478 If ALIST is an obarray, the names of all symbols in the obarray
1479 are the possible matches.
1481 ALIST can also be a function to do the completion itself.
1482 It receives three arguments: the values STRING, PREDICATE and t.
1483 Whatever it returns becomes the value of `all-completions'.
1485 If optional third argument PREDICATE is non-nil,
1486 it is used to test each possible match.
1487 The match is a candidate only if PREDICATE returns non-nil.
1488 The argument given to PREDICATE is the alist element
1489 or the symbol from the obarray. If ALIST is a hash-table,
1490 predicate is called with two arguments: the key and the value.
1491 Additionally to this predicate, `completion-regexp-list'
1492 is used to further constrain the set of candidates.
1494 If the optional fourth argument HIDE-SPACES is non-nil,
1495 strings in ALIST that start with a space
1496 are ignored unless STRING itself starts with a space. */)
1497 (string
, alist
, predicate
, hide_spaces
)
1498 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1500 Lisp_Object tail
, elt
, eltstring
;
1501 Lisp_Object allmatches
;
1502 int type
= HASH_TABLE_P (alist
) ? 3
1503 : VECTORP (alist
) ? 2
1504 : NILP (alist
) || (CONSP (alist
)
1505 && (!SYMBOLP (XCAR (alist
))
1506 || NILP (XCAR (alist
))));
1507 int index
= 0, obsize
= 0;
1509 Lisp_Object bucket
, tem
, zero
;
1510 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1512 CHECK_STRING (string
);
1514 return call3 (alist
, string
, predicate
, Qt
);
1515 allmatches
= bucket
= Qnil
;
1516 zero
= make_number (0);
1518 /* If ALIST is not a list, set TAIL just for gc pro. */
1522 obsize
= XVECTOR (alist
)->size
;
1523 bucket
= XVECTOR (alist
)->contents
[index
];
1528 /* Get the next element of the alist, obarray, or hash-table. */
1529 /* Exit the loop if the elements are all used up. */
1530 /* elt gets the alist element or symbol.
1531 eltstring gets the name to check as a completion. */
1538 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1543 if (!EQ (bucket
, zero
))
1547 if (XSYMBOL (bucket
)->next
)
1548 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1550 XSETFASTINT (bucket
, 0);
1552 else if (++index
>= obsize
)
1556 bucket
= XVECTOR (alist
)->contents
[index
];
1560 else /* if (type == 3) */
1562 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1563 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1565 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1568 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1571 /* Is this element a possible completion? */
1573 if (SYMBOLP (eltstring
))
1574 eltstring
= Fsymbol_name (eltstring
);
1576 if (STRINGP (eltstring
)
1577 && SCHARS (string
) <= SCHARS (eltstring
)
1578 /* If HIDE_SPACES, reject alternatives that start with space
1579 unless the input starts with space. */
1580 && ((SBYTES (string
) > 0
1581 && SREF (string
, 0) == ' ')
1582 || SREF (eltstring
, 0) != ' '
1583 || NILP (hide_spaces
))
1584 && (tem
= Fcompare_strings (eltstring
, zero
,
1585 make_number (SCHARS (string
)),
1587 make_number (SCHARS (string
)),
1588 completion_ignore_case
? Qt
: Qnil
),
1592 Lisp_Object regexps
;
1594 XSETFASTINT (zero
, 0);
1596 /* Ignore this element if it fails to match all the regexps. */
1598 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1599 regexps
= XCDR (regexps
))
1601 if (bindcount
< 0) {
1602 bindcount
= SPECPDL_INDEX ();
1603 specbind (Qcase_fold_search
,
1604 completion_ignore_case
? Qt
: Qnil
);
1606 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1610 if (CONSP (regexps
))
1614 /* Ignore this element if there is a predicate
1615 and the predicate doesn't like it. */
1617 if (!NILP (predicate
))
1619 if (EQ (predicate
, Qcommandp
))
1620 tem
= Fcommandp (elt
, Qnil
);
1623 if (bindcount
>= 0) {
1624 unbind_to (bindcount
, Qnil
);
1627 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1629 ? call2 (predicate
, elt
,
1630 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1631 : call1 (predicate
, elt
);
1634 if (NILP (tem
)) continue;
1636 /* Ok => put it on the list. */
1637 allmatches
= Fcons (eltstring
, allmatches
);
1641 if (bindcount
>= 0) {
1642 unbind_to (bindcount
, Qnil
);
1646 return Fnreverse (allmatches
);
1649 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1650 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1651 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1652 Lisp_Object Vminibuffer_completing_file_name
;
1654 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1655 doc
: /* Read a string in the minibuffer, with completion.
1656 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1657 TABLE can be an list of strings, an alist, an obarray or a hash table.
1658 TABLE can also be a function to do the completion itself.
1659 PREDICATE limits completion to a subset of TABLE.
1660 See `try-completion' and `all-completions' for more details
1661 on completion, TABLE, and PREDICATE.
1663 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1664 the input is (or completes to) an element of TABLE or is null.
1665 If it is also not t, typing RET does not exit if it does non-null completion.
1666 If the input is null, `completing-read' returns DEF, or an empty string
1667 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1669 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1670 with point positioned at the end.
1671 If it is (STRING . POSITION), the initial input is STRING, but point
1672 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1673 that this is different from `read-from-minibuffer' and related
1674 functions, which use one-indexing for POSITION.) This feature is
1675 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1676 default value DEF instead. The user can yank the default value into
1677 the minibuffer easily using \\[next-history-element].
1679 HIST, if non-nil, specifies a history list and optionally the initial
1680 position in the list. It can be a symbol, which is the history list
1681 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1682 that case, HISTVAR is the history list variable to use, and HISTPOS
1683 is the initial position (the position in the list used by the
1684 minibuffer history commands). For consistency, you should also
1685 specify that element of the history as the value of
1686 INITIAL-INPUT. (This is the only case in which you should use
1687 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1688 1 at the beginning of the list. The variable `history-length'
1689 controls the maximum length of a history list.
1691 DEF, if non-nil, is the default value.
1693 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1694 the current input method and the setting of `enable-multibyte-characters'.
1696 Completion ignores case if the ambient value of
1697 `completion-ignore-case' is non-nil. */)
1698 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1699 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1700 Lisp_Object hist
, def
, inherit_input_method
;
1702 Lisp_Object val
, histvar
, histpos
, position
;
1705 int count
= SPECPDL_INDEX ();
1706 struct gcpro gcpro1
;
1708 init
= initial_input
;
1711 specbind (Qminibuffer_completion_table
, table
);
1712 specbind (Qminibuffer_completion_predicate
, predicate
);
1713 specbind (Qminibuffer_completion_confirm
,
1714 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1715 last_exact_completion
= Qnil
;
1722 position
= Fcdr (init
);
1725 CHECK_STRING (init
);
1726 if (!NILP (position
))
1728 CHECK_NUMBER (position
);
1729 /* Convert to distance from end of input. */
1730 pos
= XINT (position
) - SCHARS (init
);
1741 histvar
= Fcar_safe (hist
);
1742 histpos
= Fcdr_safe (hist
);
1745 histvar
= Qminibuffer_history
;
1747 XSETFASTINT (histpos
, 0);
1749 val
= read_minibuf (NILP (require_match
)
1750 ? Vminibuffer_local_completion_map
1751 : Vminibuffer_local_must_match_map
,
1752 init
, prompt
, make_number (pos
), 0,
1753 histvar
, histpos
, def
, 0,
1754 !NILP (inherit_input_method
), 0);
1756 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1759 RETURN_UNGCPRO (unbind_to (count
, val
));
1762 Lisp_Object
Fminibuffer_completion_help ();
1763 Lisp_Object
Fassoc_string ();
1765 /* Test whether TXT is an exact completion. */
1766 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1767 doc
: /* Return non-nil if STRING is a valid completion.
1768 Takes the same arguments as `all-completions' and `try-completion'.
1769 If ALIST is a function, it is called with three arguments:
1770 the values STRING, PREDICATE and `lambda'. */)
1771 (string
, alist
, predicate
)
1772 Lisp_Object string
, alist
, predicate
;
1774 Lisp_Object regexps
, tail
, tem
= Qnil
;
1777 CHECK_STRING (string
);
1779 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1782 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1786 else if (VECTORP (alist
))
1788 /* Bypass intern-soft as that loses for nil. */
1789 tem
= oblookup (alist
,
1795 if (STRING_MULTIBYTE (string
))
1796 string
= Fstring_make_unibyte (string
);
1798 string
= Fstring_make_multibyte (string
);
1800 tem
= oblookup (alist
,
1806 if (completion_ignore_case
&& !SYMBOLP (tem
))
1808 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1810 tail
= XVECTOR (alist
)->contents
[i
];
1814 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1815 Fsymbol_name (tail
),
1816 make_number (0) , Qnil
, Qt
)),
1822 if (XSYMBOL (tail
)->next
== 0)
1824 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1832 else if (HASH_TABLE_P (alist
))
1834 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1835 i
= hash_lookup (h
, string
, NULL
);
1837 tem
= HASH_KEY (h
, i
);
1839 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1840 if (!NILP (HASH_HASH (h
, i
)) &&
1841 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1842 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1843 completion_ignore_case
? Qt
: Qnil
),
1846 tem
= HASH_KEY (h
, i
);
1853 return call3 (alist
, string
, predicate
, Qlambda
);
1855 /* Reject this element if it fails to match all the regexps. */
1856 if (CONSP (Vcompletion_regexp_list
))
1858 int count
= SPECPDL_INDEX ();
1859 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1860 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1861 regexps
= XCDR (regexps
))
1863 if (NILP (Fstring_match (XCAR (regexps
),
1864 SYMBOLP (tem
) ? string
: tem
,
1866 return unbind_to (count
, Qnil
);
1868 unbind_to (count
, Qnil
);
1871 /* Finally, check the predicate. */
1872 if (!NILP (predicate
))
1874 return HASH_TABLE_P (alist
)
1875 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1876 : call1 (predicate
, tem
);
1883 * 0 no possible completion
1884 * 1 was already an exact and unique completion
1885 * 3 was already an exact completion
1886 * 4 completed to an exact completion
1887 * 5 some completion happened
1888 * 6 no completion happened
1893 Lisp_Object completion
, string
, tem
;
1896 struct gcpro gcpro1
, gcpro2
;
1898 completion
= Ftry_completion (minibuffer_completion_contents (),
1899 Vminibuffer_completion_table
,
1900 Vminibuffer_completion_predicate
);
1901 last
= last_exact_completion
;
1902 last_exact_completion
= Qnil
;
1904 GCPRO2 (completion
, last
);
1906 if (NILP (completion
))
1909 temp_echo_area_glyphs (build_string (" [No match]"));
1914 if (EQ (completion
, Qt
)) /* exact and unique match */
1920 string
= minibuffer_completion_contents ();
1922 /* COMPLETEDP should be true if some completion was done, which
1923 doesn't include simply changing the case of the entered string.
1924 However, for appearance, the string is rewritten if the case
1926 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1927 completedp
= !EQ (tem
, Qt
);
1929 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1931 /* Rewrite the user's input. */
1933 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1934 /* Some completion happened */
1936 if (! NILP (Vminibuffer_completing_file_name
)
1937 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1939 && FETCH_CHAR (PT_BYTE
) == '/')
1941 del_range (prompt_end
, PT
+ 1);
1944 del_range (prompt_end
, PT
);
1946 Finsert (1, &completion
);
1949 /* The case of the string changed, but that's all. We're not
1950 sure whether this is a unique completion or not, so try again
1951 using the real case (this shouldn't recurse again, because
1952 the next time try-completion will return either `t' or the
1956 return do_completion ();
1960 /* It did find a match. Do we match some possibility exactly now? */
1961 tem
= Ftest_completion (Fminibuffer_contents (),
1962 Vminibuffer_completion_table
,
1963 Vminibuffer_completion_predicate
);
1966 /* not an exact match */
1970 else if (!NILP (Vcompletion_auto_help
))
1971 Fminibuffer_completion_help ();
1973 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1976 else if (completedp
)
1981 /* If the last exact completion and this one were the same,
1982 it means we've already given a "Complete but not unique"
1983 message and the user's hit TAB again, so now we give him help. */
1984 last_exact_completion
= completion
;
1987 tem
= minibuffer_completion_contents ();
1988 if (!NILP (Fequal (tem
, last
)))
1989 Fminibuffer_completion_help ();
1995 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1997 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1998 doc
: /* Like `assoc' but specifically for strings.
1999 Unibyte strings are converted to multibyte for comparison.
2000 And case is ignored if CASE-FOLD is non-nil.
2001 As opposed to `assoc', it will also match an entry consisting of a single
2002 string rather than a cons cell whose car is a string. */)
2003 (key
, list
, case_fold
)
2004 register Lisp_Object key
;
2005 Lisp_Object list
, case_fold
;
2007 register Lisp_Object tail
;
2009 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2011 register Lisp_Object elt
, tem
, thiscar
;
2013 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2014 if (!STRINGP (thiscar
))
2016 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2017 key
, make_number (0), Qnil
,
2026 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2027 doc
: /* Complete the minibuffer contents as far as possible.
2028 Return nil if there is no valid completion, else t.
2029 If no characters can be completed, display a list of possible completions.
2030 If you repeat this command after it displayed such a list,
2031 scroll the window of possible completions. */)
2035 Lisp_Object window
, tem
;
2037 /* If the previous command was not this,
2038 mark the completion buffer obsolete. */
2039 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2040 Vminibuf_scroll_window
= Qnil
;
2042 window
= Vminibuf_scroll_window
;
2043 /* If there's a fresh completion window with a live buffer,
2044 and this command is repeated, scroll that window. */
2045 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2046 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2048 struct buffer
*obuf
= current_buffer
;
2050 Fset_buffer (XWINDOW (window
)->buffer
);
2051 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2053 /* If end is in view, scroll up to the beginning. */
2054 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2056 /* Else scroll down one screen. */
2057 Fscroll_other_window (Qnil
);
2059 set_buffer_internal (obuf
);
2063 i
= do_completion ();
2071 Fgoto_char (make_number (ZV
));
2072 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2077 Fgoto_char (make_number (ZV
));
2078 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2085 /* Subroutines of Fminibuffer_complete_and_exit. */
2087 /* This one is called by internal_condition_case to do the real work. */
2090 complete_and_exit_1 ()
2092 return make_number (do_completion ());
2095 /* This one is called by internal_condition_case if an error happens.
2096 Pretend the current value is an exact match. */
2099 complete_and_exit_2 (ignore
)
2102 return make_number (1);
2105 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2107 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2108 Sminibuffer_complete_and_exit
, 0, 0, "",
2109 doc
: /* If the minibuffer contents is a valid completion then exit.
2110 Otherwise try to complete it. If completion leads to a valid completion,
2111 a repetition of this command will exit. */)
2117 /* Allow user to specify null string */
2118 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2121 val
= Fminibuffer_contents ();
2122 if (!NILP (Ftest_completion (val
,
2123 Vminibuffer_completion_table
,
2124 Vminibuffer_completion_predicate
)))
2126 if (completion_ignore_case
)
2127 { /* Fixup case of the field, if necessary. */
2129 = Ftry_completion (val
,
2130 Vminibuffer_completion_table
,
2131 Vminibuffer_completion_predicate
);
2133 /* If it weren't for this piece of paranoia, I'd replace
2134 the whole thing with a call to do_completion. */
2135 && EQ (Flength (val
), Flength (compl)))
2137 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2138 Finsert (1, &compl);
2144 /* Call do_completion, but ignore errors. */
2146 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2147 complete_and_exit_2
);
2157 if (!NILP (Vminibuffer_completion_confirm
))
2159 temp_echo_area_glyphs (build_string (" [Confirm]"));
2169 return Fexit_minibuffer ();
2173 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2175 doc
: /* Complete the minibuffer contents at most a single word.
2176 After one word is completed as much as possible, a space or hyphen
2177 is added, provided that matches some possible completion.
2178 Return nil if there is no valid completion, else t. */)
2181 Lisp_Object completion
, tem
, tem1
;
2182 register int i
, i_byte
;
2183 struct gcpro gcpro1
, gcpro2
;
2184 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2186 /* We keep calling Fbuffer_string rather than arrange for GC to
2187 hold onto a pointer to one of the strings thus made. */
2189 completion
= Ftry_completion (minibuffer_completion_contents (),
2190 Vminibuffer_completion_table
,
2191 Vminibuffer_completion_predicate
);
2192 if (NILP (completion
))
2195 temp_echo_area_glyphs (build_string (" [No match]"));
2198 if (EQ (completion
, Qt
))
2201 #if 0 /* How the below code used to look, for reference. */
2202 tem
= Fminibuffer_contents ();
2204 i
= ZV
- 1 - SCHARS (completion
);
2205 p
= SDATA (completion
);
2207 0 <= scmp (b
, p
, ZV
- 1))
2210 /* Set buffer to longest match of buffer tail and completion head. */
2211 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2213 del_range (1, i
+ 1);
2216 #else /* Rewritten code */
2218 int buffer_nchars
, completion_nchars
;
2220 CHECK_STRING (completion
);
2221 tem
= minibuffer_completion_contents ();
2222 GCPRO2 (completion
, tem
);
2223 /* If reading a file name,
2224 expand any $ENVVAR refs in the buffer and in TEM. */
2225 if (! NILP (Vminibuffer_completing_file_name
))
2227 Lisp_Object substituted
;
2228 substituted
= Fsubstitute_in_file_name (tem
);
2229 if (! EQ (substituted
, tem
))
2232 del_range (prompt_end_charpos
, PT
);
2236 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2237 completion_nchars
= SCHARS (completion
);
2238 i
= buffer_nchars
- completion_nchars
;
2241 (tem1
= Fcompare_strings (tem
, make_number (0),
2242 make_number (buffer_nchars
),
2243 completion
, make_number (0),
2244 make_number (buffer_nchars
),
2245 completion_ignore_case
? Qt
: Qnil
),
2250 /* Make buffer (before point) contain the longest match
2251 of TEM's tail and COMPLETION's head. */
2257 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2258 completion
, make_number (0),
2259 make_number (buffer_nchars
),
2260 completion_ignore_case
? Qt
: Qnil
);
2267 del_range (start_pos
, start_pos
+ buffer_nchars
);
2271 #endif /* Rewritten code */
2274 int prompt_end_bytepos
;
2275 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2276 i
= PT
- prompt_end_charpos
;
2277 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2280 /* If completion finds next char not unique,
2281 consider adding a space or a hyphen. */
2282 if (i
== SCHARS (completion
))
2284 GCPRO1 (completion
);
2285 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2286 build_string (" ")),
2287 Vminibuffer_completion_table
,
2288 Vminibuffer_completion_predicate
);
2295 GCPRO1 (completion
);
2297 Ftry_completion (concat2 (minibuffer_completion_contents (),
2298 build_string ("-")),
2299 Vminibuffer_completion_table
,
2300 Vminibuffer_completion_predicate
);
2308 /* Now find first word-break in the stuff found by completion.
2309 i gets index in string of where to stop completing. */
2312 int bytes
= SBYTES (completion
);
2313 register const unsigned char *completion_string
= SDATA (completion
);
2314 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2316 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2319 if (SYNTAX (c
) != Sword
)
2328 /* If got no characters, print help for user. */
2330 if (i
== PT
- prompt_end_charpos
)
2332 if (!NILP (Vcompletion_auto_help
))
2333 Fminibuffer_completion_help ();
2337 /* Otherwise insert in minibuffer the chars we got */
2339 if (! NILP (Vminibuffer_completing_file_name
)
2340 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2342 && FETCH_CHAR (PT_BYTE
) == '/')
2344 del_range (prompt_end_charpos
, PT
+ 1);
2347 del_range (prompt_end_charpos
, PT
);
2349 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2353 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2355 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2356 Each element may be just a symbol or string
2357 or may be a list of two strings to be printed as if concatenated.
2358 If it is a list of two strings, the first is the actual completion
2359 alternative, the second serves as annotation.
2360 `standard-output' must be a buffer.
2361 The actual completion alternatives, as inserted, are given `mouse-face'
2362 properties of `highlight'.
2363 At the end, this runs the normal hook `completion-setup-hook'.
2364 It can find the completion buffer in `standard-output'.
2365 The optional second arg COMMON-SUBSTRING is a string.
2366 It is used to put faces, `completions-first-difference' and
2367 `completions-common-part' on the completion buffer. The
2368 `completions-common-part' face is put on the common substring
2369 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil,
2370 the faces are not put.
2371 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2372 during running `completion-setup-hook'. */)
2373 (completions
, common_substring
)
2374 Lisp_Object completions
;
2375 Lisp_Object common_substring
;
2377 Lisp_Object tail
, elt
;
2380 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2381 struct buffer
*old
= current_buffer
;
2384 /* Note that (when it matters) every variable
2385 points to a non-string that is pointed to by COMPLETIONS,
2386 except for ELT. ELT can be pointing to a string
2387 when terpri or Findent_to calls a change hook. */
2389 GCPRO3 (completions
, elt
, common_substring
);
2391 if (BUFFERP (Vstandard_output
))
2392 set_buffer_internal (XBUFFER (Vstandard_output
));
2394 if (NILP (completions
))
2395 write_string ("There are no possible completions of what you have typed.",
2399 write_string ("Possible completions are:", -1);
2400 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2402 Lisp_Object tem
, string
;
2404 Lisp_Object startpos
, endpos
;
2410 elt
= SYMBOL_NAME (elt
);
2411 /* Compute the length of this element. */
2416 length
= SCHARS (tem
);
2418 tem
= Fcar (XCDR (elt
));
2420 length
+= SCHARS (tem
);
2425 length
= SCHARS (elt
);
2428 /* This does a bad job for narrower than usual windows.
2429 Sadly, the window it will appear in is not known
2430 until after the text has been made. */
2432 if (BUFFERP (Vstandard_output
))
2433 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2435 /* If the previous completion was very wide,
2436 or we have two on this line already,
2437 don't put another on the same line. */
2438 if (column
> 33 || first
2439 /* If this is really wide, don't put it second on a line. */
2440 || (column
> 0 && length
> 45))
2445 /* Otherwise advance to column 35. */
2448 if (BUFFERP (Vstandard_output
))
2450 tem
= Findent_to (make_number (35), make_number (2));
2452 column
= XINT (tem
);
2458 write_string (" ", -1);
2461 while (column
< 35);
2465 if (BUFFERP (Vstandard_output
))
2467 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2468 Fset_text_properties (startpos
, endpos
,
2469 Qnil
, Vstandard_output
);
2472 /* Output this element.
2473 If necessary, convert it to unibyte or to multibyte first. */
2475 string
= Fcar (elt
);
2478 if (NILP (current_buffer
->enable_multibyte_characters
)
2479 && STRING_MULTIBYTE (string
))
2480 string
= Fstring_make_unibyte (string
);
2481 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2482 && !STRING_MULTIBYTE (string
))
2483 string
= Fstring_make_multibyte (string
);
2485 if (BUFFERP (Vstandard_output
))
2487 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2489 Fprinc (string
, Qnil
);
2491 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2493 Fput_text_property (startpos
, endpos
,
2494 Qmouse_face
, intern ("highlight"),
2499 Fprinc (string
, Qnil
);
2502 /* Output the annotation for this element. */
2505 if (BUFFERP (Vstandard_output
))
2507 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2509 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2511 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2513 Fset_text_properties (startpos
, endpos
, Qnil
,
2518 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2523 /* Update COLUMN for what we have output. */
2526 /* If output is to a buffer, recompute COLUMN in a way
2527 that takes account of character widths. */
2528 if (BUFFERP (Vstandard_output
))
2530 tem
= Fcurrent_column ();
2531 column
= XINT (tem
);
2538 if (BUFFERP (Vstandard_output
))
2539 set_buffer_internal (old
);
2541 if (!NILP (Vrun_hooks
))
2543 int count1
= SPECPDL_INDEX ();
2545 specbind (intern ("completion-common-substring"), common_substring
);
2546 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2548 unbind_to (count1
, Qnil
);
2558 display_completion_list_1 (list
)
2561 return Fdisplay_completion_list (list
, Qnil
);
2564 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2566 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2569 Lisp_Object completions
;
2571 message ("Making completion list...");
2572 completions
= Fall_completions (minibuffer_completion_contents (),
2573 Vminibuffer_completion_table
,
2574 Vminibuffer_completion_predicate
,
2576 clear_message (1, 0);
2578 if (NILP (completions
))
2581 temp_echo_area_glyphs (build_string (" [No completions]"));
2584 internal_with_output_to_temp_buffer ("*Completions*",
2585 display_completion_list_1
,
2586 Fsort (completions
, Qstring_lessp
));
2590 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2591 doc
: /* Terminate minibuffer input. */)
2594 if (INTEGERP (last_command_char
))
2595 internal_self_insert (XINT (last_command_char
), 0);
2599 return Fexit_minibuffer ();
2602 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2603 doc
: /* Terminate this minibuffer argument. */)
2606 /* If the command that uses this has made modifications in the minibuffer,
2607 we don't want them to cause deactivation of the mark in the original
2609 A better solution would be to make deactivate-mark buffer-local
2610 (or to turn it into a list of buffers, ...), but in the mean time,
2611 this should do the trick in most cases. */
2612 Vdeactivate_mark
= Qnil
;
2613 Fthrow (Qexit
, Qnil
);
2616 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2617 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2620 return make_number (minibuf_level
);
2623 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2624 doc
: /* Return the prompt string of the currently-active minibuffer.
2625 If no minibuffer is active, return nil. */)
2628 return Fcopy_sequence (minibuf_prompt
);
2632 /* Temporarily display STRING at the end of the current
2633 minibuffer contents. This is used to display things like
2634 "[No Match]" when the user requests a completion for a prefix
2635 that has no possible completions, and other quick, unobtrusive
2639 temp_echo_area_glyphs (string
)
2643 int osize_byte
= ZV_BYTE
;
2645 int opoint_byte
= PT_BYTE
;
2646 Lisp_Object oinhibit
;
2647 oinhibit
= Vinhibit_quit
;
2649 /* Clear out any old echo-area message to make way for our new thing. */
2652 SET_PT_BOTH (osize
, osize_byte
);
2653 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2654 SET_PT_BOTH (opoint
, opoint_byte
);
2656 Fsit_for (make_number (2), Qnil
, Qnil
);
2657 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2658 SET_PT_BOTH (opoint
, opoint_byte
);
2659 if (!NILP (Vquit_flag
))
2662 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2664 Vinhibit_quit
= oinhibit
;
2667 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2669 doc
: /* Temporarily display STRING at the end of the minibuffer.
2670 The text is displayed for two seconds,
2671 or until the next input event arrives, whichever comes first. */)
2675 CHECK_STRING (string
);
2676 temp_echo_area_glyphs (string
);
2681 init_minibuf_once ()
2683 Vminibuffer_list
= Qnil
;
2684 staticpro (&Vminibuffer_list
);
2691 minibuf_prompt
= Qnil
;
2692 staticpro (&minibuf_prompt
);
2694 minibuf_save_list
= Qnil
;
2695 staticpro (&minibuf_save_list
);
2697 Qread_file_name_internal
= intern ("read-file-name-internal");
2698 staticpro (&Qread_file_name_internal
);
2700 Qminibuffer_default
= intern ("minibuffer-default");
2701 staticpro (&Qminibuffer_default
);
2702 Fset (Qminibuffer_default
, Qnil
);
2704 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2705 staticpro (&Qminibuffer_completion_table
);
2707 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2708 staticpro (&Qminibuffer_completion_confirm
);
2710 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2711 staticpro (&Qminibuffer_completion_predicate
);
2713 staticpro (&last_exact_completion
);
2714 last_exact_completion
= Qnil
;
2716 staticpro (&last_minibuf_string
);
2717 last_minibuf_string
= Qnil
;
2719 Quser_variable_p
= intern ("user-variable-p");
2720 staticpro (&Quser_variable_p
);
2722 Qminibuffer_history
= intern ("minibuffer-history");
2723 staticpro (&Qminibuffer_history
);
2725 Qbuffer_name_history
= intern ("buffer-name-history");
2726 staticpro (&Qbuffer_name_history
);
2727 Fset (Qbuffer_name_history
, Qnil
);
2729 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2730 staticpro (&Qminibuffer_setup_hook
);
2732 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2733 staticpro (&Qminibuffer_exit_hook
);
2735 Qhistory_length
= intern ("history-length");
2736 staticpro (&Qhistory_length
);
2738 Qcurrent_input_method
= intern ("current-input-method");
2739 staticpro (&Qcurrent_input_method
);
2741 Qactivate_input_method
= intern ("activate-input-method");
2742 staticpro (&Qactivate_input_method
);
2744 Qcase_fold_search
= intern ("case-fold-search");
2745 staticpro (&Qcase_fold_search
);
2747 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2748 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2749 Vread_buffer_function
= Qnil
;
2751 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2752 doc
: /* Normal hook run just after entry to minibuffer. */);
2753 Vminibuffer_setup_hook
= Qnil
;
2755 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2756 doc
: /* Normal hook run just after exit from minibuffer. */);
2757 Vminibuffer_exit_hook
= Qnil
;
2759 DEFVAR_LISP ("history-length", &Vhistory_length
,
2760 doc
: /* *Maximum length for history lists before truncation takes place.
2761 A number means that length; t means infinite. Truncation takes place
2762 just after a new element is inserted. Setting the history-length
2763 property of a history variable overrides this default. */);
2764 XSETFASTINT (Vhistory_length
, 30);
2766 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2767 doc
: /* *Non-nil means to delete duplicates in history.
2768 If set to t when adding a new history element, all previous identical
2769 elements are deleted. */);
2770 history_delete_duplicates
= 0;
2772 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2773 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2774 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2775 see the doc string of `partial-completion-mode' for more details. */);
2776 Vcompletion_auto_help
= Qt
;
2778 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2779 doc
: /* Non-nil means don't consider case significant in completion.
2781 For file-name completion, the variable `read-file-name-completion-ignore-case'
2782 controls the behavior, rather than this variable. */);
2783 completion_ignore_case
= 0;
2785 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2786 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2787 This variable makes a difference whenever the minibuffer window is active. */);
2788 enable_recursive_minibuffers
= 0;
2790 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2791 doc
: /* Alist or obarray used for completion in the minibuffer.
2792 This becomes the ALIST argument to `try-completion' and `all-completions'.
2793 The value can also be a list of strings or a hash table.
2795 The value may alternatively be a function, which is given three arguments:
2796 STRING, the current buffer contents;
2797 PREDICATE, the predicate for filtering possible matches;
2798 CODE, which says what kind of things to do.
2799 CODE can be nil, t or `lambda'.
2800 nil means to return the best completion of STRING, or nil if there is none.
2801 t means to return a list of all possible completions of STRING.
2802 `lambda' means to return t if STRING is a valid completion as it stands. */);
2803 Vminibuffer_completion_table
= Qnil
;
2805 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2806 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2807 Vminibuffer_completion_predicate
= Qnil
;
2809 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2810 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2811 Vminibuffer_completion_confirm
= Qnil
;
2813 DEFVAR_LISP ("minibuffer-completing-file-name",
2814 &Vminibuffer_completing_file_name
,
2815 doc
: /* Non-nil means completing file names. */);
2816 Vminibuffer_completing_file_name
= Qnil
;
2818 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2819 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2820 Vminibuffer_help_form
= Qnil
;
2822 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2823 doc
: /* History list symbol to add minibuffer values to.
2824 Each string of minibuffer input, as it appears on exit from the minibuffer,
2826 (set minibuffer-history-variable
2827 (cons STRING (symbol-value minibuffer-history-variable))) */);
2828 XSETFASTINT (Vminibuffer_history_variable
, 0);
2830 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2831 doc
: /* Current position of redoing in the history list. */);
2832 Vminibuffer_history_position
= Qnil
;
2834 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2835 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2836 Some uses of the echo area also raise that frame (since they use it too). */);
2837 minibuffer_auto_raise
= 0;
2839 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2840 doc
: /* List of regexps that should restrict possible completions.
2841 The basic completion functions only consider a completion acceptable
2842 if it matches all regular expressions in this list, with
2843 `case-fold-search' bound to the value of `completion-ignore-case'.
2844 See Info node `(elisp)Basic Completion', for a description of these
2846 Vcompletion_regexp_list
= Qnil
;
2848 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2849 &minibuffer_allow_text_properties
,
2850 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2851 This also affects `read-string', but it does not affect `read-minibuffer',
2852 `read-no-blanks-input', or any of the functions that do minibuffer input
2853 with completion; they always discard text properties. */);
2854 minibuffer_allow_text_properties
= 0;
2856 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2857 doc
: /* Text properties that are added to minibuffer prompts.
2858 These are in addition to the basic `field' property, and stickiness
2860 /* We use `intern' here instead of Qread_only to avoid
2861 initialization-order problems. */
2862 Vminibuffer_prompt_properties
2863 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2865 defsubr (&Sset_minibuffer_window
);
2866 defsubr (&Sread_from_minibuffer
);
2867 defsubr (&Seval_minibuffer
);
2868 defsubr (&Sread_minibuffer
);
2869 defsubr (&Sread_string
);
2870 defsubr (&Sread_command
);
2871 defsubr (&Sread_variable
);
2872 defsubr (&Sread_buffer
);
2873 defsubr (&Sread_no_blanks_input
);
2874 defsubr (&Sminibuffer_depth
);
2875 defsubr (&Sminibuffer_prompt
);
2877 defsubr (&Sminibufferp
);
2878 defsubr (&Sminibuffer_prompt_end
);
2879 defsubr (&Sminibuffer_contents
);
2880 defsubr (&Sminibuffer_contents_no_properties
);
2881 defsubr (&Sdelete_minibuffer_contents
);
2883 defsubr (&Stry_completion
);
2884 defsubr (&Sall_completions
);
2885 defsubr (&Stest_completion
);
2886 defsubr (&Sassoc_string
);
2887 defsubr (&Scompleting_read
);
2888 defsubr (&Sminibuffer_complete
);
2889 defsubr (&Sminibuffer_complete_word
);
2890 defsubr (&Sminibuffer_complete_and_exit
);
2891 defsubr (&Sdisplay_completion_list
);
2892 defsubr (&Sminibuffer_completion_help
);
2894 defsubr (&Sself_insert_and_exit
);
2895 defsubr (&Sexit_minibuffer
);
2897 defsubr (&Sminibuffer_message
);
2903 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2904 "abort-recursive-edit");
2905 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2907 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2910 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2912 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2914 initial_define_key (Vminibuffer_local_ns_map
, '?',
2915 "self-insert-and-exit");
2917 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2918 "minibuffer-complete");
2919 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2920 "minibuffer-complete-word");
2921 initial_define_key (Vminibuffer_local_completion_map
, '?',
2922 "minibuffer-completion-help");
2924 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2925 "minibuffer-complete-and-exit");
2926 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2927 "minibuffer-complete-and-exit");
2930 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2931 (do not change this comment) */