1 /* Minibuffer input and completion.
2 Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03,04
3 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, 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 /* Fread_minibuffer leaves the input here as a string. */
66 Lisp_Object last_minibuf_string
;
68 /* Nonzero means let functions called when within a minibuffer
69 invoke recursive minibuffers (to read arguments, or whatever) */
71 int enable_recursive_minibuffers
;
73 /* Nonzero means don't ignore text properties
74 in Fread_from_minibuffer. */
76 int minibuffer_allow_text_properties
;
78 /* help-form is bound to this while in the minibuffer. */
80 Lisp_Object Vminibuffer_help_form
;
82 /* Variable which is the history list to add minibuffer values to. */
84 Lisp_Object Vminibuffer_history_variable
;
86 /* Current position in the history list (adjusted by M-n and M-p). */
88 Lisp_Object Vminibuffer_history_position
;
90 /* Text properties that are added to minibuffer prompts.
91 These are in addition to the basic `field' property, and stickiness
94 Lisp_Object Vminibuffer_prompt_properties
;
96 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
98 Lisp_Object Qread_file_name_internal
;
100 /* Normal hooks for entry to and exit from minibuffer. */
102 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
103 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
105 /* Function to call to read a buffer name. */
106 Lisp_Object Vread_buffer_function
;
108 /* Nonzero means completion ignores case. */
110 int completion_ignore_case
;
112 /* List of regexps that should restrict possible completions. */
114 Lisp_Object Vcompletion_regexp_list
;
116 /* Nonzero means raise the minibuffer frame when the minibuffer
119 int minibuffer_auto_raise
;
121 /* If last completion attempt reported "Complete but not unique"
122 then this is the string completed then; otherwise this is nil. */
124 static Lisp_Object last_exact_completion
;
126 extern Lisp_Object Voverriding_local_map
;
128 Lisp_Object Quser_variable_p
;
130 Lisp_Object Qminibuffer_default
;
132 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
134 Lisp_Object Qcase_fold_search
;
136 extern Lisp_Object Qmouse_face
;
138 extern Lisp_Object Qfield
;
140 /* Put minibuf on currently selected frame's minibuffer.
141 We do this whenever the user starts a new minibuffer
142 or when a minibuffer exits. */
145 choose_minibuf_frame ()
147 if (FRAMEP (selected_frame
)
148 && FRAME_LIVE_P (XFRAME (selected_frame
))
149 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
151 struct frame
*sf
= XFRAME (selected_frame
);
154 /* I don't think that any frames may validly have a null minibuffer
156 if (NILP (sf
->minibuffer_window
))
159 /* Under X, we come here with minibuf_window being the
160 minibuffer window of the unused termcap window created in
161 init_window_once. That window doesn't have a buffer. */
162 buffer
= XWINDOW (minibuf_window
)->buffer
;
163 if (BUFFERP (buffer
))
164 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
165 minibuf_window
= sf
->minibuffer_window
;
168 /* Make sure no other frame has a minibuffer as its selected window,
169 because the text would not be displayed in it, and that would be
170 confusing. Only allow the selected frame to do this,
171 and that only if the minibuffer is active. */
173 Lisp_Object tail
, frame
;
175 FOR_EACH_FRAME (tail
, frame
)
176 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
177 && !(EQ (frame
, selected_frame
)
178 && minibuf_level
> 0))
179 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
184 choose_minibuf_frame_1 (ignore
)
187 choose_minibuf_frame ();
191 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
192 Sset_minibuffer_window
, 1, 1, 0,
193 doc
: /* Specify which minibuffer window to use for the minibuffer.
194 This affects where the minibuffer is displayed if you put text in it
195 without invoking the usual minibuffer commands. */)
199 CHECK_WINDOW (window
);
200 if (! MINI_WINDOW_P (XWINDOW (window
)))
201 error ("Window is not a minibuffer window");
203 minibuf_window
= window
;
209 /* Actual minibuffer invocation. */
211 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
212 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
213 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
214 Lisp_Object
, Lisp_Object
,
216 Lisp_Object
, Lisp_Object
,
218 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
219 Lisp_Object
, Lisp_Object
,
221 Lisp_Object
, Lisp_Object
,
223 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
226 /* Read a Lisp object from VAL and return it. If VAL is an empty
227 string, and DEFALT is a string, read from DEFALT instead of VAL. */
230 string_to_object (val
, defalt
)
231 Lisp_Object val
, defalt
;
233 struct gcpro gcpro1
, gcpro2
;
234 Lisp_Object expr_and_pos
;
237 GCPRO2 (val
, defalt
);
239 if (STRINGP (val
) && SCHARS (val
) == 0
243 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
244 pos
= XINT (Fcdr (expr_and_pos
));
245 if (pos
!= SCHARS (val
))
247 /* Ignore trailing whitespace; any other trailing junk
250 pos
= string_char_to_byte (val
, pos
);
251 for (i
= pos
; i
< SBYTES (val
); i
++)
253 int c
= SREF (val
, i
);
254 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
255 error ("Trailing garbage following expression");
259 val
= Fcar (expr_and_pos
);
260 RETURN_UNGCPRO (val
);
264 /* Like read_minibuf but reading from stdin. This function is called
265 from read_minibuf to do the job if noninteractive. */
268 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
269 histvar
, histpos
, defalt
, allow_props
,
270 inherit_input_method
)
274 Lisp_Object backup_n
;
280 int inherit_input_method
;
286 fprintf (stdout
, "%s", SDATA (prompt
));
292 line
= (char *) xmalloc (size
* sizeof *line
);
293 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
294 && (len
= strlen (line
),
295 len
== size
- 1 && line
[len
- 1] != '\n'))
298 line
= (char *) xrealloc (line
, size
);
305 if (len
> 0 && line
[len
- 1] == '\n')
308 val
= build_string (line
);
314 error ("Error reading from stdin");
317 /* If Lisp form desired instead of string, parse it. */
319 val
= string_to_object (val
, defalt
);
324 DEFUN ("minibufferp", Fminibufferp
,
325 Sminibufferp
, 0, 1, 0,
326 doc
: /* Return t if BUFFER is a minibuffer.
327 No argument or nil as argument means use current buffer as BUFFER.
328 BUFFER can be a buffer or a buffer name. */)
335 buffer
= Fcurrent_buffer ();
336 else if (STRINGP (buffer
))
337 buffer
= Fget_buffer (buffer
);
339 CHECK_BUFFER (buffer
);
341 tem
= Fmemq (buffer
, Vminibuffer_list
);
342 return ! NILP (tem
) ? Qt
: Qnil
;
345 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
346 Sminibuffer_prompt_end
, 0, 0, 0,
347 doc
: /* Return the buffer position of the end of the minibuffer prompt.
348 Return (point-min) if current buffer is not a mini-buffer. */)
351 /* This function is written to be most efficient when there's a prompt. */
352 Lisp_Object beg
, end
, tem
;
353 beg
= make_number (BEGV
);
355 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
359 end
= Ffield_end (beg
, Qnil
, Qnil
);
361 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
367 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
368 Sminibuffer_contents
, 0, 0, 0,
369 doc
: /* Return the user input in a minibuffer as a string.
370 The current buffer must be a minibuffer. */)
373 int prompt_end
= XINT (Fminibuffer_prompt_end ());
374 return make_buffer_string (prompt_end
, ZV
, 1);
377 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
378 Sminibuffer_contents_no_properties
, 0, 0, 0,
379 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
380 The current buffer must be a minibuffer. */)
383 int prompt_end
= XINT (Fminibuffer_prompt_end ());
384 return make_buffer_string (prompt_end
, ZV
, 0);
387 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
388 Sdelete_minibuffer_contents
, 0, 0, 0,
389 doc
: /* Delete all user input in a minibuffer.
390 The current buffer must be a minibuffer. */)
393 int prompt_end
= XINT (Fminibuffer_prompt_end ());
395 del_range (prompt_end
, ZV
);
399 /* Get the text in the minibuffer before point.
400 That is what completion commands operate on. */
403 minibuffer_completion_contents ()
405 int prompt_end
= XINT (Fminibuffer_prompt_end ());
407 error ("Cannot do completion in the prompt");
408 return make_buffer_string (prompt_end
, PT
, 1);
411 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
412 putting point minus BACKUP_N bytes from the end of INITIAL,
413 prompting with PROMPT (a string), using history list HISTVAR
414 with initial position HISTPOS. INITIAL should be a string or a
415 cons of a string and an integer. BACKUP_N should be <= 0, or
416 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
417 ignored and replaced with an integer that puts point at one-indexed
418 position N in INITIAL, where N is the CDR of INITIAL, or at the
419 beginning of INITIAL if N <= 0.
421 Normally return the result as a string (the text that was read),
422 but if EXPFLAG is nonzero, read it and return the object read.
423 If HISTVAR is given, save the value read on that history only if it doesn't
424 match the front of that history list exactly. The value is pushed onto
425 the list as the string that was read.
427 DEFALT specifies the default value for the sake of history commands.
429 If ALLOW_PROPS is nonzero, we do not throw away text properties.
431 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
432 current input method. */
435 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
436 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
440 Lisp_Object backup_n
;
446 int inherit_input_method
;
449 int count
= SPECPDL_INDEX ();
450 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
451 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
452 Lisp_Object enable_multibyte
;
453 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
455 /* String to add to the history. */
456 Lisp_Object histstring
;
458 extern Lisp_Object Qfront_sticky
;
459 extern Lisp_Object Qrear_nonsticky
;
461 specbind (Qminibuffer_default
, defalt
);
463 single_kboard_state ();
464 #ifdef HAVE_X_WINDOWS
465 if (display_hourglass_p
)
473 backup_n
= Fcdr (initial
);
474 initial
= Fcar (initial
);
475 CHECK_STRING (initial
);
476 if (!NILP (backup_n
))
478 CHECK_NUMBER (backup_n
);
479 /* Convert to distance from end of input. */
480 if (XINT (backup_n
) < 1)
481 /* A number too small means the beginning of the string. */
482 pos
= - SCHARS (initial
);
484 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
488 CHECK_STRING (initial
);
491 ambient_dir
= current_buffer
->directory
;
493 enable_multibyte
= Qnil
;
495 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
496 store them away before we can GC. Don't need to protect
497 BACKUP_N because we use the value only if it is an integer. */
498 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
500 if (!STRINGP (prompt
))
501 prompt
= empty_string
;
503 if (!enable_recursive_minibuffers
504 && minibuf_level
> 0)
506 if (EQ (selected_window
, minibuf_window
))
507 error ("Command attempted to use minibuffer while in minibuffer");
509 /* If we're in another window, cancel the minibuffer that's active. */
511 build_string ("Command attempted to use minibuffer while in minibuffer"));
516 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
518 expflag
, histvar
, histpos
, defalt
,
519 allow_props
, inherit_input_method
);
521 return unbind_to (count
, val
);
524 /* Choose the minibuffer window and frame, and take action on them. */
526 choose_minibuf_frame ();
528 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
530 record_unwind_protect (Fset_window_configuration
,
531 Fcurrent_window_configuration (Qnil
));
533 /* If the minibuffer window is on a different frame, save that
534 frame's configuration too. */
535 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
536 if (!EQ (mini_frame
, selected_frame
))
537 record_unwind_protect (Fset_window_configuration
,
538 Fcurrent_window_configuration (mini_frame
));
540 /* If the minibuffer is on an iconified or invisible frame,
541 make it visible now. */
542 Fmake_frame_visible (mini_frame
);
544 if (minibuffer_auto_raise
)
545 Fraise_frame (mini_frame
);
547 /* We have to do this after saving the window configuration
548 since that is what restores the current buffer. */
550 /* Arrange to restore a number of minibuffer-related variables.
551 We could bind each variable separately, but that would use lots of
554 = Fcons (Voverriding_local_map
,
555 Fcons (minibuf_window
, minibuf_save_list
));
557 = Fcons (minibuf_prompt
,
558 Fcons (make_number (minibuf_prompt_width
),
560 Fcons (Vcurrent_prefix_arg
,
561 Fcons (Vminibuffer_history_position
,
562 Fcons (Vminibuffer_history_variable
,
563 minibuf_save_list
))))));
565 record_unwind_protect (read_minibuf_unwind
, Qnil
);
567 /* We are exiting the minibuffer one way or the other, so run the hook.
568 It should be run before unwinding the minibuf settings. Do it
569 separately from read_minibuf_unwind because we need to make sure that
570 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
571 signals an error. --Stef */
572 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
574 /* Now that we can restore all those variables, start changing them. */
576 minibuf_prompt_width
= 0;
577 minibuf_prompt
= Fcopy_sequence (prompt
);
578 Vminibuffer_history_position
= histpos
;
579 Vminibuffer_history_variable
= histvar
;
580 Vhelp_form
= Vminibuffer_help_form
;
582 if (inherit_input_method
)
584 /* `current-input-method' is buffer local. So, remember it in
585 INPUT_METHOD before changing the current buffer. */
586 input_method
= Fsymbol_value (Qcurrent_input_method
);
587 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
590 /* Switch to the minibuffer. */
592 minibuffer
= get_minibuffer (minibuf_level
);
593 Fset_buffer (minibuffer
);
595 /* The current buffer's default directory is usually the right thing
596 for our minibuffer here. However, if you're typing a command at
597 a minibuffer-only frame when minibuf_level is zero, then buf IS
598 the current_buffer, so reset_buffer leaves buf's default
599 directory unchanged. This is a bummer when you've just started
600 up Emacs and buf's default directory is Qnil. Here's a hack; can
601 you think of something better to do? Find another buffer with a
602 better directory, and use that one instead. */
603 if (STRINGP (ambient_dir
))
604 current_buffer
->directory
= ambient_dir
;
607 Lisp_Object buf_list
;
609 for (buf_list
= Vbuffer_alist
;
611 buf_list
= XCDR (buf_list
))
613 Lisp_Object other_buf
;
615 other_buf
= XCDR (XCAR (buf_list
));
616 if (STRINGP (XBUFFER (other_buf
)->directory
))
618 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
624 if (!EQ (mini_frame
, selected_frame
))
625 Fredirect_frame_focus (selected_frame
, mini_frame
);
627 Vminibuf_scroll_window
= selected_window
;
628 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
629 minibuf_selected_window
= selected_window
;
630 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
631 Fselect_window (minibuf_window
, Qnil
);
632 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
634 Fmake_local_variable (Qprint_escape_newlines
);
635 print_escape_newlines
= 1;
637 /* Erase the buffer. */
639 int count1
= SPECPDL_INDEX ();
640 specbind (Qinhibit_read_only
, Qt
);
641 specbind (Qinhibit_modification_hooks
, Qt
);
643 unbind_to (count1
, Qnil
);
646 if (!NILP (current_buffer
->enable_multibyte_characters
)
647 && ! STRING_MULTIBYTE (minibuf_prompt
))
648 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
650 /* Insert the prompt, record where it ends. */
651 Finsert (1, &minibuf_prompt
);
654 Fput_text_property (make_number (BEG
), make_number (PT
),
655 Qfront_sticky
, Qt
, Qnil
);
656 Fput_text_property (make_number (BEG
), make_number (PT
),
657 Qrear_nonsticky
, Qt
, Qnil
);
658 Fput_text_property (make_number (BEG
), make_number (PT
),
660 Fadd_text_properties (make_number (BEG
), make_number (PT
),
661 Vminibuffer_prompt_properties
, Qnil
);
664 minibuf_prompt_width
= (int) current_column (); /* iftc */
666 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
667 if (inherit_input_method
)
668 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
670 /* Put in the initial input. */
673 Finsert (1, &initial
);
674 Fforward_char (make_number (pos
));
677 clear_message (1, 1);
678 current_buffer
->keymap
= map
;
680 /* Turn on an input method stored in INPUT_METHOD if any. */
681 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
682 call1 (Qactivate_input_method
, input_method
);
684 /* Run our hook, but not if it is empty.
685 (run-hooks would do nothing if it is empty,
686 but it's important to save time here in the usual case.) */
687 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
688 && !NILP (Vrun_hooks
))
689 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
691 /* Don't allow the user to undo past this point. */
692 current_buffer
->undo_list
= Qnil
;
696 /* If cursor is on the minibuffer line,
697 show the user we have exited by putting it in column 0. */
698 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
701 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
702 XWINDOW (minibuf_window
)->cursor
.x
= 0;
703 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
704 update_frame (XFRAME (selected_frame
), 1, 1);
705 if (rif
&& rif
->flush_display
)
706 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
709 /* Make minibuffer contents into a string. */
710 Fset_buffer (minibuffer
);
712 val
= Fminibuffer_contents ();
714 val
= Fminibuffer_contents_no_properties ();
716 /* VAL is the string of minibuffer text. */
718 last_minibuf_string
= val
;
720 /* Choose the string to add to the history. */
721 if (SCHARS (val
) != 0)
723 else if (STRINGP (defalt
))
728 /* Add the value to the appropriate history list, if any. */
729 if (SYMBOLP (Vminibuffer_history_variable
)
730 && !NILP (histstring
))
732 /* If the caller wanted to save the value read on a history list,
733 then do so if the value is not already the front of the list. */
736 /* If variable is unbound, make it nil. */
737 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
738 Fset (Vminibuffer_history_variable
, Qnil
);
740 histval
= Fsymbol_value (Vminibuffer_history_variable
);
742 /* The value of the history variable must be a cons or nil. Other
743 values are unacceptable. We silently ignore these values. */
747 /* Don't duplicate the most recent entry in the history. */
748 && NILP (Fequal (histstring
, Fcar (histval
)))))
752 histval
= Fcons (histstring
, histval
);
753 Fset (Vminibuffer_history_variable
, histval
);
755 /* Truncate if requested. */
756 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
757 if (NILP (length
)) length
= Vhistory_length
;
758 if (INTEGERP (length
))
760 if (XINT (length
) <= 0)
761 Fset (Vminibuffer_history_variable
, Qnil
);
766 temp
= Fnthcdr (Fsub1 (length
), histval
);
767 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
773 /* If Lisp form desired instead of string, parse it. */
775 val
= string_to_object (val
, defalt
);
777 /* The appropriate frame will get selected
778 in set-window-configuration. */
780 return unbind_to (count
, val
);
783 /* Return a buffer to be used as the minibuffer at depth `depth'.
784 depth = 0 is the lowest allowed argument, and that is the value
785 used for nonrecursive minibuffer invocations */
788 get_minibuffer (depth
)
791 Lisp_Object tail
, num
, buf
;
793 extern Lisp_Object
nconc2 ();
795 XSETFASTINT (num
, depth
);
796 tail
= Fnthcdr (num
, Vminibuffer_list
);
799 tail
= Fcons (Qnil
, Qnil
);
800 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
803 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
805 sprintf (name
, " *Minibuf-%d*", depth
);
806 buf
= Fget_buffer_create (build_string (name
));
808 /* Although the buffer's name starts with a space, undo should be
810 Fbuffer_enable_undo (buf
);
816 int count
= SPECPDL_INDEX ();
817 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
818 have to empty the list, otherwise we end up with overlays that
819 think they belong to this buffer while the buffer doesn't know about
821 delete_all_overlays (XBUFFER (buf
));
822 reset_buffer (XBUFFER (buf
));
823 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
825 Fkill_all_local_variables ();
826 unbind_to (count
, Qnil
);
833 run_exit_minibuf_hook (data
)
836 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
837 && !NILP (Vrun_hooks
))
838 safe_run_hooks (Qminibuffer_exit_hook
);
843 /* This function is called on exiting minibuffer, whether normally or
844 not, and it restores the current window, buffer, etc. */
847 read_minibuf_unwind (data
)
850 Lisp_Object old_deactivate_mark
;
853 /* If this was a recursive minibuffer,
854 tie the minibuffer window back to the outer level minibuffer buffer. */
857 window
= minibuf_window
;
858 /* To keep things predictable, in case it matters, let's be in the
859 minibuffer when we reset the relevant variables. */
860 Fset_buffer (XWINDOW (window
)->buffer
);
862 /* Restore prompt, etc, from outer minibuffer level. */
863 minibuf_prompt
= Fcar (minibuf_save_list
);
864 minibuf_save_list
= Fcdr (minibuf_save_list
);
865 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
866 minibuf_save_list
= Fcdr (minibuf_save_list
);
867 Vhelp_form
= Fcar (minibuf_save_list
);
868 minibuf_save_list
= Fcdr (minibuf_save_list
);
869 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
870 minibuf_save_list
= Fcdr (minibuf_save_list
);
871 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
872 minibuf_save_list
= Fcdr (minibuf_save_list
);
873 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
874 minibuf_save_list
= Fcdr (minibuf_save_list
);
875 Voverriding_local_map
= Fcar (minibuf_save_list
);
876 minibuf_save_list
= Fcdr (minibuf_save_list
);
878 temp
= Fcar (minibuf_save_list
);
879 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
880 minibuf_window
= temp
;
882 minibuf_save_list
= Fcdr (minibuf_save_list
);
884 /* Erase the minibuffer we were using at this level. */
886 int count
= SPECPDL_INDEX ();
887 /* Prevent error in erase-buffer. */
888 specbind (Qinhibit_read_only
, Qt
);
889 specbind (Qinhibit_modification_hooks
, Qt
);
890 old_deactivate_mark
= Vdeactivate_mark
;
892 Vdeactivate_mark
= old_deactivate_mark
;
893 unbind_to (count
, Qnil
);
896 /* When we get to the outmost level, make sure we resize the
897 mini-window back to its normal size. */
898 if (minibuf_level
== 0)
899 resize_mini_window (XWINDOW (window
), 0);
901 /* Make sure minibuffer window is erased, not ignored. */
902 windows_or_buffers_changed
++;
903 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
904 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
909 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
910 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
911 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
912 DEFAULT-VALUE. It normally should be nil in new code, except when
913 HIST is a cons. It is discussed in more detail below.
914 Third arg KEYMAP is a keymap to use whilst reading;
915 if omitted or nil, the default is `minibuffer-local-map'.
916 If fourth arg READ is non-nil, then interpret the result as a Lisp object
917 and return that object:
918 in other words, do `(car (read-from-string INPUT-STRING))'
919 Fifth arg HIST, if non-nil, specifies a history list and optionally
920 the initial position in the list. It can be a symbol, which is the
921 history list variable to use, or it can be a cons cell
922 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
923 to use, and HISTPOS is the initial position for use by the minibuffer
924 history commands. For consistency, you should also specify that
925 element of the history as the value of INITIAL-CONTENTS. Positions
926 are counted starting from 1 at the beginning of the list.
927 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
928 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
929 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
931 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
932 the current input method and the setting of `enable-multibyte-characters'.
933 If the variable `minibuffer-allow-text-properties' is non-nil,
934 then the string which is returned includes whatever text properties
935 were present in the minibuffer. Otherwise the value has no text properties.
937 The remainder of this documentation string describes the
938 INITIAL-CONTENTS argument in more detail. It is only relevant when
939 studying existing code, or when HIST is a cons. If non-nil,
940 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
941 reading input. Normally, point is put at the end of that string.
942 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
943 input is STRING, but point is placed at _one-indexed_ position
944 POSITION in the minibuffer. Any integer value less than or equal to
945 one puts point at the beginning of the string. *Note* that this
946 behavior differs from the way such arguments are used in `completing-read'
947 and some related functions, which use zero-indexing for POSITION. */)
948 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
949 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
950 Lisp_Object inherit_input_method
;
952 Lisp_Object histvar
, histpos
, val
;
955 CHECK_STRING (prompt
);
957 keymap
= Vminibuffer_local_map
;
959 keymap
= get_keymap (keymap
, 1, 0);
968 histvar
= Fcar_safe (hist
);
969 histpos
= Fcdr_safe (hist
);
972 histvar
= Qminibuffer_history
;
974 XSETFASTINT (histpos
, 0);
976 GCPRO1 (default_value
);
977 val
= read_minibuf (keymap
, initial_contents
, prompt
,
979 histvar
, histpos
, default_value
,
980 minibuffer_allow_text_properties
,
981 !NILP (inherit_input_method
));
986 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
987 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
988 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
989 is a string to insert in the minibuffer before reading.
990 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
991 arguments are used as in `read-from-minibuffer') */)
992 (prompt
, initial_contents
)
993 Lisp_Object prompt
, initial_contents
;
995 CHECK_STRING (prompt
);
996 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
997 prompt
, Qnil
, 1, Qminibuffer_history
,
998 make_number (0), Qnil
, 0, 0);
1001 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1002 doc
: /* Return value of Lisp expression read using the minibuffer.
1003 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1004 is a string to insert in the minibuffer before reading.
1005 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1006 arguments are used as in `read-from-minibuffer') */)
1007 (prompt
, initial_contents
)
1008 Lisp_Object prompt
, initial_contents
;
1010 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1013 /* Functions that use the minibuffer to read various things. */
1015 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1016 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1017 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1018 This argument has been superseded by DEFAULT-VALUE and should normally
1019 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1020 documentation string of that function for details.
1021 The third arg HISTORY, if non-nil, specifies a history list
1022 and optionally the initial position in the list.
1023 See `read-from-minibuffer' for details of HISTORY argument.
1024 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1025 for history commands, and as the value to return if the user enters
1027 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1028 the current input method and the setting of `enable-multibyte-characters'. */)
1029 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1030 Lisp_Object prompt
, initial_input
, history
, default_value
;
1031 Lisp_Object inherit_input_method
;
1034 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1035 Qnil
, history
, default_value
,
1036 inherit_input_method
);
1037 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1038 val
= default_value
;
1042 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1043 doc
: /* Read a string from the terminal, not allowing blanks.
1044 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1045 non-nil, it should be a string, which is used as initial input, with
1046 point positioned at the end, so that SPACE will accept the input.
1047 \(Actually, INITIAL can also be a cons of a string and an integer.
1048 Such values are treated as in `read-from-minibuffer', but are normally
1049 not useful in this function.)
1050 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1051 the current input method and the setting of`enable-multibyte-characters'. */)
1052 (prompt
, initial
, inherit_input_method
)
1053 Lisp_Object prompt
, initial
, inherit_input_method
;
1055 CHECK_STRING (prompt
);
1056 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1057 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1058 !NILP (inherit_input_method
));
1061 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1062 doc
: /* Read the name of a command and return as a symbol.
1063 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1064 (prompt
, default_value
)
1065 Lisp_Object prompt
, default_value
;
1067 Lisp_Object name
, default_string
;
1069 if (NILP (default_value
))
1070 default_string
= Qnil
;
1071 else if (SYMBOLP (default_value
))
1072 default_string
= SYMBOL_NAME (default_value
);
1074 default_string
= default_value
;
1076 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1077 Qnil
, Qnil
, default_string
, Qnil
);
1080 return Fintern (name
, Qnil
);
1084 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1085 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1086 Prompt with PROMPT. */)
1090 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1095 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1096 doc
: /* Read the name of a user variable and return it as a symbol.
1097 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1098 A user variable is one for which `user-variable-p' returns non-nil. */)
1099 (prompt
, default_value
)
1100 Lisp_Object prompt
, default_value
;
1102 Lisp_Object name
, default_string
;
1104 if (NILP (default_value
))
1105 default_string
= Qnil
;
1106 else if (SYMBOLP (default_value
))
1107 default_string
= SYMBOL_NAME (default_value
);
1109 default_string
= default_value
;
1111 name
= Fcompleting_read (prompt
, Vobarray
,
1112 Quser_variable_p
, Qt
,
1113 Qnil
, Qnil
, default_string
, Qnil
);
1116 return Fintern (name
, Qnil
);
1119 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1120 doc
: /* Read the name of a buffer and return as a string.
1122 Optional second arg DEF is value to return if user enters an empty line.
1123 If optional third arg REQUIRE-MATCH is non-nil,
1124 only existing buffer names are allowed. */)
1125 (prompt
, def
, require_match
)
1126 Lisp_Object prompt
, def
, require_match
;
1128 Lisp_Object args
[4];
1131 def
= XBUFFER (def
)->name
;
1133 if (NILP (Vread_buffer_function
))
1137 args
[0] = build_string ("%s(default %s) ");
1140 prompt
= Fformat (3, args
);
1143 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1144 require_match
, Qnil
, Qbuffer_name_history
,
1149 args
[0] = Vread_buffer_function
;
1152 args
[3] = require_match
;
1153 return Ffuncall(4, args
);
1158 minibuf_conform_representation (string
, basis
)
1159 Lisp_Object string
, basis
;
1161 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1164 if (STRING_MULTIBYTE (string
))
1165 return Fstring_make_unibyte (string
);
1167 return Fstring_make_multibyte (string
);
1170 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1171 doc
: /* Return common substring of all completions of STRING in ALIST.
1172 Each car of each element of ALIST (or each element if it is not a cons cell)
1173 is tested to see if it begins with STRING.
1174 All that match are compared together; the longest initial sequence
1175 common to all matches is returned as a string.
1176 If there is no match at all, nil is returned.
1177 For a unique match which is exact, t is returned.
1179 If ALIST is a hash-table, all the string keys are the possible matches.
1180 If ALIST is an obarray, the names of all symbols in the obarray
1181 are the possible matches.
1183 ALIST can also be a function to do the completion itself.
1184 It receives three arguments: the values STRING, PREDICATE and nil.
1185 Whatever it returns becomes the value of `try-completion'.
1187 If optional third argument PREDICATE is non-nil,
1188 it is used to test each possible match.
1189 The match is a candidate only if PREDICATE returns non-nil.
1190 The argument given to PREDICATE is the alist element
1191 or the symbol from the obarray. If ALIST is a hash-table,
1192 predicate is called with two arguments: the key and the value.
1193 Additionally to this predicate, `completion-regexp-list'
1194 is used to further constrain the set of candidates. */)
1195 (string
, alist
, predicate
)
1196 Lisp_Object string
, alist
, predicate
;
1198 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1199 /* Size in bytes of BESTMATCH. */
1200 int bestmatchsize
= 0;
1201 /* These are in bytes, too. */
1202 int compare
, matchsize
;
1203 int type
= HASH_TABLE_P (alist
) ? 3
1204 : VECTORP (alist
) ? 2
1205 : NILP (alist
) || (CONSP (alist
)
1206 && (!SYMBOLP (XCAR (alist
))
1207 || NILP (XCAR (alist
))));
1208 int index
= 0, obsize
= 0;
1211 Lisp_Object bucket
, zero
, end
, tem
;
1212 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1214 CHECK_STRING (string
);
1216 return call3 (alist
, string
, predicate
, Qnil
);
1218 bestmatch
= bucket
= Qnil
;
1220 /* If ALIST is not a list, set TAIL just for gc pro. */
1224 obsize
= XVECTOR (alist
)->size
;
1225 bucket
= XVECTOR (alist
)->contents
[index
];
1230 /* Get the next element of the alist, obarray, or hash-table. */
1231 /* Exit the loop if the elements are all used up. */
1232 /* elt gets the alist element or symbol.
1233 eltstring gets the name to check as a completion. */
1240 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1245 if (XFASTINT (bucket
) != 0)
1248 eltstring
= Fsymbol_name (elt
);
1249 if (XSYMBOL (bucket
)->next
)
1250 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1252 XSETFASTINT (bucket
, 0);
1254 else if (++index
>= obsize
)
1258 bucket
= XVECTOR (alist
)->contents
[index
];
1262 else /* if (type == 3) */
1264 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1265 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1267 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1270 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1273 /* Is this element a possible completion? */
1275 if (STRINGP (eltstring
)
1276 && SCHARS (string
) <= SCHARS (eltstring
)
1277 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1278 make_number (SCHARS (string
)),
1279 string
, make_number (0), Qnil
,
1280 completion_ignore_case
? Qt
: Qnil
),
1284 Lisp_Object regexps
;
1286 XSETFASTINT (zero
, 0);
1288 /* Ignore this element if it fails to match all the regexps. */
1290 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1291 regexps
= XCDR (regexps
))
1293 if (bindcount
< 0) {
1294 bindcount
= SPECPDL_INDEX ();
1295 specbind (Qcase_fold_search
,
1296 completion_ignore_case
? Qt
: Qnil
);
1298 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1302 if (CONSP (regexps
))
1306 /* Ignore this element if there is a predicate
1307 and the predicate doesn't like it. */
1309 if (!NILP (predicate
))
1311 if (EQ (predicate
, Qcommandp
))
1312 tem
= Fcommandp (elt
, Qnil
);
1315 if (bindcount
>= 0) {
1316 unbind_to (bindcount
, Qnil
);
1319 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1321 ? call2 (predicate
, elt
,
1322 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1323 : call1 (predicate
, elt
);
1326 if (NILP (tem
)) continue;
1329 /* Update computation of how much all possible completions match */
1331 if (NILP (bestmatch
))
1334 bestmatch
= eltstring
;
1335 bestmatchsize
= SCHARS (eltstring
);
1339 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1340 tem
= Fcompare_strings (bestmatch
, make_number (0),
1341 make_number (compare
),
1342 eltstring
, make_number (0),
1343 make_number (compare
),
1344 completion_ignore_case
? Qt
: Qnil
);
1346 matchsize
= compare
;
1347 else if (XINT (tem
) < 0)
1348 matchsize
= - XINT (tem
) - 1;
1350 matchsize
= XINT (tem
) - 1;
1353 /* When can this happen ? -stef */
1354 matchsize
= compare
;
1355 if (completion_ignore_case
)
1357 /* If this is an exact match except for case,
1358 use it as the best match rather than one that is not an
1359 exact match. This way, we get the case pattern
1360 of the actual match. */
1361 if ((matchsize
== SCHARS (eltstring
)
1362 && matchsize
< SCHARS (bestmatch
))
1364 /* If there is more than one exact match ignoring case,
1365 and one of them is exact including case,
1367 /* If there is no exact match ignoring case,
1368 prefer a match that does not change the case
1370 ((matchsize
== SCHARS (eltstring
))
1372 (matchsize
== SCHARS (bestmatch
))
1373 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1374 make_number (SCHARS (string
)),
1375 string
, make_number (0),
1379 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1380 make_number (SCHARS (string
)),
1381 string
, make_number (0),
1385 bestmatch
= eltstring
;
1387 if (bestmatchsize
!= SCHARS (eltstring
)
1388 || bestmatchsize
!= matchsize
)
1389 /* Don't count the same string multiple times. */
1391 bestmatchsize
= matchsize
;
1392 if (matchsize
<= SCHARS (string
)
1394 /* No need to look any further. */
1400 if (bindcount
>= 0) {
1401 unbind_to (bindcount
, Qnil
);
1405 if (NILP (bestmatch
))
1406 return Qnil
; /* No completions found */
1407 /* If we are ignoring case, and there is no exact match,
1408 and no additional text was supplied,
1409 don't change the case of what the user typed. */
1410 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1411 && SCHARS (bestmatch
) > bestmatchsize
)
1412 return minibuf_conform_representation (string
, bestmatch
);
1414 /* Return t if the supplied string is an exact match (counting case);
1415 it does not require any change to be made. */
1416 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1417 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1418 make_number (bestmatchsize
),
1419 string
, make_number (0),
1420 make_number (bestmatchsize
),
1425 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1426 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1427 return Fsubstring (bestmatch
, zero
, end
);
1430 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1431 doc
: /* Search for partial matches to STRING in ALIST.
1432 Each car of each element of ALIST (or each element if it is not a cons cell)
1433 is tested to see if it begins with STRING.
1434 The value is a list of all the strings from ALIST that match.
1436 If ALIST is a hash-table, all the string keys are the possible matches.
1437 If ALIST is an obarray, the names of all symbols in the obarray
1438 are the possible matches.
1440 ALIST can also be a function to do the completion itself.
1441 It receives three arguments: the values STRING, PREDICATE and t.
1442 Whatever it returns becomes the value of `all-completions'.
1444 If optional third argument PREDICATE is non-nil,
1445 it is used to test each possible match.
1446 The match is a candidate only if PREDICATE returns non-nil.
1447 The argument given to PREDICATE is the alist element
1448 or the symbol from the obarray. If ALIST is a hash-table,
1449 predicate is called with two arguments: the key and the value.
1450 Additionally to this predicate, `completion-regexp-list'
1451 is used to further constrain the set of candidates.
1453 If the optional fourth argument HIDE-SPACES is non-nil,
1454 strings in ALIST that start with a space
1455 are ignored unless STRING itself starts with a space. */)
1456 (string
, alist
, predicate
, hide_spaces
)
1457 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1459 Lisp_Object tail
, elt
, eltstring
;
1460 Lisp_Object allmatches
;
1461 int type
= HASH_TABLE_P (alist
) ? 3
1462 : VECTORP (alist
) ? 2
1463 : NILP (alist
) || (CONSP (alist
)
1464 && (!SYMBOLP (XCAR (alist
))
1465 || NILP (XCAR (alist
))));
1466 int index
= 0, obsize
= 0;
1468 Lisp_Object bucket
, tem
;
1469 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1471 CHECK_STRING (string
);
1473 return call3 (alist
, string
, predicate
, Qt
);
1474 allmatches
= bucket
= Qnil
;
1476 /* If ALIST is not a list, set TAIL just for gc pro. */
1480 obsize
= XVECTOR (alist
)->size
;
1481 bucket
= XVECTOR (alist
)->contents
[index
];
1486 /* Get the next element of the alist, obarray, or hash-table. */
1487 /* Exit the loop if the elements are all used up. */
1488 /* elt gets the alist element or symbol.
1489 eltstring gets the name to check as a completion. */
1496 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1501 if (XFASTINT (bucket
) != 0)
1504 eltstring
= Fsymbol_name (elt
);
1505 if (XSYMBOL (bucket
)->next
)
1506 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1508 XSETFASTINT (bucket
, 0);
1510 else if (++index
>= obsize
)
1514 bucket
= XVECTOR (alist
)->contents
[index
];
1518 else /* if (type == 3) */
1520 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1521 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1523 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1526 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1529 /* Is this element a possible completion? */
1531 if (STRINGP (eltstring
)
1532 && SCHARS (string
) <= SCHARS (eltstring
)
1533 /* If HIDE_SPACES, reject alternatives that start with space
1534 unless the input starts with space. */
1535 && ((SBYTES (string
) > 0
1536 && SREF (string
, 0) == ' ')
1537 || SREF (eltstring
, 0) != ' '
1538 || NILP (hide_spaces
))
1539 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1540 make_number (SCHARS (string
)),
1541 string
, make_number (0),
1542 make_number (SCHARS (string
)),
1543 completion_ignore_case
? Qt
: Qnil
),
1547 Lisp_Object regexps
;
1549 XSETFASTINT (zero
, 0);
1551 /* Ignore this element if it fails to match all the regexps. */
1553 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1554 regexps
= XCDR (regexps
))
1556 if (bindcount
< 0) {
1557 bindcount
= SPECPDL_INDEX ();
1558 specbind (Qcase_fold_search
,
1559 completion_ignore_case
? Qt
: Qnil
);
1561 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1565 if (CONSP (regexps
))
1569 /* Ignore this element if there is a predicate
1570 and the predicate doesn't like it. */
1572 if (!NILP (predicate
))
1574 if (EQ (predicate
, Qcommandp
))
1575 tem
= Fcommandp (elt
, Qnil
);
1578 if (bindcount
>= 0) {
1579 unbind_to (bindcount
, Qnil
);
1582 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1584 ? call2 (predicate
, elt
,
1585 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1586 : call1 (predicate
, elt
);
1589 if (NILP (tem
)) continue;
1591 /* Ok => put it on the list. */
1592 allmatches
= Fcons (eltstring
, allmatches
);
1596 if (bindcount
>= 0) {
1597 unbind_to (bindcount
, Qnil
);
1601 return Fnreverse (allmatches
);
1604 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1605 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1606 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1607 Lisp_Object Vminibuffer_completing_file_name
;
1609 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1610 doc
: /* Read a string in the minibuffer, with completion.
1611 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1612 TABLE can be an list of strings, an alist, an obarray or a hash table.
1613 TABLE can also be a function to do the completion itself.
1614 PREDICATE limits completion to a subset of TABLE.
1615 See `try-completion' and `all-completions' for more details
1616 on completion, TABLE, and PREDICATE.
1618 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1619 the input is (or completes to) an element of TABLE or is null.
1620 If it is also not t, typing RET does not exit if it does non-null completion.
1621 If the input is null, `completing-read' returns DEF, or an empty string
1622 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1624 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1625 with point positioned at the end.
1626 If it is (STRING . POSITION), the initial input is STRING, but point
1627 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1628 that this is different from `read-from-minibuffer' and related
1629 functions, which use one-indexing for POSITION.) This feature is
1630 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1631 default value DEF instead. The user can yank the default value into
1632 the minibuffer easily using \\[next-history-element].
1634 HIST, if non-nil, specifies a history list and optionally the initial
1635 position in the list. It can be a symbol, which is the history list
1636 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1637 that case, HISTVAR is the history list variable to use, and HISTPOS
1638 is the initial position (the position in the list used by the
1639 minibuffer history commands). For consistency, you should also
1640 specify that element of the history as the value of
1641 INITIAL-INPUT. (This is the only case in which you should use
1642 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1643 1 at the beginning of the list. The variable `history-length'
1644 controls the maximum length of a history list.
1646 DEF, if non-nil, is the default value.
1648 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1649 the current input method and the setting of `enable-multibyte-characters'.
1651 Completion ignores case if the ambient value of
1652 `completion-ignore-case' is non-nil. */)
1653 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1654 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1655 Lisp_Object hist
, def
, inherit_input_method
;
1657 Lisp_Object val
, histvar
, histpos
, position
;
1660 int count
= SPECPDL_INDEX ();
1661 struct gcpro gcpro1
;
1663 init
= initial_input
;
1666 specbind (Qminibuffer_completion_table
, table
);
1667 specbind (Qminibuffer_completion_predicate
, predicate
);
1668 specbind (Qminibuffer_completion_confirm
,
1669 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1670 last_exact_completion
= Qnil
;
1677 position
= Fcdr (init
);
1680 CHECK_STRING (init
);
1681 if (!NILP (position
))
1683 CHECK_NUMBER (position
);
1684 /* Convert to distance from end of input. */
1685 pos
= XINT (position
) - SCHARS (init
);
1696 histvar
= Fcar_safe (hist
);
1697 histpos
= Fcdr_safe (hist
);
1700 histvar
= Qminibuffer_history
;
1702 XSETFASTINT (histpos
, 0);
1704 val
= read_minibuf (NILP (require_match
)
1705 ? Vminibuffer_local_completion_map
1706 : Vminibuffer_local_must_match_map
,
1707 init
, prompt
, make_number (pos
), 0,
1708 histvar
, histpos
, def
, 0,
1709 !NILP (inherit_input_method
));
1711 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1714 RETURN_UNGCPRO (unbind_to (count
, val
));
1717 Lisp_Object
Fminibuffer_completion_help ();
1718 Lisp_Object
Fassoc_string ();
1720 /* Test whether TXT is an exact completion. */
1721 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1722 doc
: /* Return non-nil if STRING is a valid completion.
1723 Takes the same arguments as `all-completions' and `try-completion'.
1724 If ALIST is a function, it is called with three arguments:
1725 the values STRING, PREDICATE and `lambda'. */)
1726 (string
, alist
, predicate
)
1727 Lisp_Object string
, alist
, predicate
;
1729 Lisp_Object regexps
, tail
, tem
= Qnil
;
1732 CHECK_STRING (string
);
1734 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1737 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1741 else if (VECTORP (alist
))
1743 /* Bypass intern-soft as that loses for nil. */
1744 tem
= oblookup (alist
,
1750 if (STRING_MULTIBYTE (string
))
1751 string
= Fstring_make_unibyte (string
);
1753 string
= Fstring_make_multibyte (string
);
1755 tem
= oblookup (alist
,
1761 if (completion_ignore_case
&& !SYMBOLP (tem
))
1763 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1765 tail
= XVECTOR (alist
)->contents
[i
];
1769 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1770 Fsymbol_name (tail
),
1771 make_number (0) , Qnil
, Qt
)),
1777 if (XSYMBOL (tail
)->next
== 0)
1779 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1787 else if (HASH_TABLE_P (alist
))
1789 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1790 i
= hash_lookup (h
, string
, NULL
);
1792 tem
= HASH_KEY (h
, i
);
1794 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1795 if (!NILP (HASH_HASH (h
, i
)) &&
1796 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1797 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1798 completion_ignore_case
? Qt
: Qnil
),
1801 tem
= HASH_KEY (h
, i
);
1808 return call3 (alist
, string
, predicate
, Qlambda
);
1810 /* Reject this element if it fails to match all the regexps. */
1811 if (CONSP (Vcompletion_regexp_list
))
1813 int count
= SPECPDL_INDEX ();
1814 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1815 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1816 regexps
= XCDR (regexps
))
1818 if (NILP (Fstring_match (XCAR (regexps
),
1819 SYMBOLP (tem
) ? string
: tem
,
1821 return unbind_to (count
, Qnil
);
1823 unbind_to (count
, Qnil
);
1826 /* Finally, check the predicate. */
1827 if (!NILP (predicate
))
1829 return HASH_TABLE_P (alist
)
1830 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1831 : call1 (predicate
, tem
);
1838 * 0 no possible completion
1839 * 1 was already an exact and unique completion
1840 * 3 was already an exact completion
1841 * 4 completed to an exact completion
1842 * 5 some completion happened
1843 * 6 no completion happened
1848 Lisp_Object completion
, string
, tem
;
1851 struct gcpro gcpro1
, gcpro2
;
1853 completion
= Ftry_completion (minibuffer_completion_contents (),
1854 Vminibuffer_completion_table
,
1855 Vminibuffer_completion_predicate
);
1856 last
= last_exact_completion
;
1857 last_exact_completion
= Qnil
;
1859 GCPRO2 (completion
, last
);
1861 if (NILP (completion
))
1864 temp_echo_area_glyphs (build_string (" [No match]"));
1869 if (EQ (completion
, Qt
)) /* exact and unique match */
1875 string
= minibuffer_completion_contents ();
1877 /* COMPLETEDP should be true if some completion was done, which
1878 doesn't include simply changing the case of the entered string.
1879 However, for appearance, the string is rewritten if the case
1881 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1882 completedp
= !EQ (tem
, Qt
);
1884 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1886 /* Rewrite the user's input. */
1888 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1889 /* Some completion happened */
1891 if (! NILP (Vminibuffer_completing_file_name
)
1892 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1894 && FETCH_CHAR (PT_BYTE
) == '/')
1896 del_range (prompt_end
, PT
+ 1);
1899 del_range (prompt_end
, PT
);
1901 Finsert (1, &completion
);
1904 /* The case of the string changed, but that's all. We're not
1905 sure whether this is a unique completion or not, so try again
1906 using the real case (this shouldn't recurse again, because
1907 the next time try-completion will return either `t' or the
1911 return do_completion ();
1915 /* It did find a match. Do we match some possibility exactly now? */
1916 tem
= Ftest_completion (Fminibuffer_contents (),
1917 Vminibuffer_completion_table
,
1918 Vminibuffer_completion_predicate
);
1921 /* not an exact match */
1925 else if (!NILP (Vcompletion_auto_help
))
1926 Fminibuffer_completion_help ();
1928 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1931 else if (completedp
)
1936 /* If the last exact completion and this one were the same,
1937 it means we've already given a "Complete but not unique"
1938 message and the user's hit TAB again, so now we give him help. */
1939 last_exact_completion
= completion
;
1942 tem
= minibuffer_completion_contents ();
1943 if (!NILP (Fequal (tem
, last
)))
1944 Fminibuffer_completion_help ();
1950 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1952 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1953 doc
: /* Like `assoc' but specifically for strings.
1954 Unibyte strings are converted to multibyte for comparison.
1955 And case is ignored if CASE-FOLD is non-nil.
1956 As opposed to `assoc', it will also match an entry consisting of a single
1957 string rather than a cons cell whose car is a string. */)
1958 (key
, list
, case_fold
)
1959 register Lisp_Object key
;
1960 Lisp_Object list
, case_fold
;
1962 register Lisp_Object tail
;
1964 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1966 register Lisp_Object elt
, tem
, thiscar
;
1968 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1969 if (!STRINGP (thiscar
))
1971 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1972 key
, make_number (0), Qnil
,
1981 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1982 doc
: /* Complete the minibuffer contents as far as possible.
1983 Return nil if there is no valid completion, else t.
1984 If no characters can be completed, display a list of possible completions.
1985 If you repeat this command after it displayed such a list,
1986 scroll the window of possible completions. */)
1990 Lisp_Object window
, tem
;
1992 /* If the previous command was not this,
1993 mark the completion buffer obsolete. */
1994 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1995 Vminibuf_scroll_window
= Qnil
;
1997 window
= Vminibuf_scroll_window
;
1998 /* If there's a fresh completion window with a live buffer,
1999 and this command is repeated, scroll that window. */
2000 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2001 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2003 struct buffer
*obuf
= current_buffer
;
2005 Fset_buffer (XWINDOW (window
)->buffer
);
2006 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2008 /* If end is in view, scroll up to the beginning. */
2009 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2011 /* Else scroll down one screen. */
2012 Fscroll_other_window (Qnil
);
2014 set_buffer_internal (obuf
);
2018 i
= do_completion ();
2026 Fgoto_char (make_number (ZV
));
2027 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2032 Fgoto_char (make_number (ZV
));
2033 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2040 /* Subroutines of Fminibuffer_complete_and_exit. */
2042 /* This one is called by internal_condition_case to do the real work. */
2045 complete_and_exit_1 ()
2047 return make_number (do_completion ());
2050 /* This one is called by internal_condition_case if an error happens.
2051 Pretend the current value is an exact match. */
2054 complete_and_exit_2 (ignore
)
2057 return make_number (1);
2060 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2061 Sminibuffer_complete_and_exit
, 0, 0, "",
2062 doc
: /* If the minibuffer contents is a valid completion then exit.
2063 Otherwise try to complete it. If completion leads to a valid completion,
2064 a repetition of this command will exit. */)
2070 /* Allow user to specify null string */
2071 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2074 if (!NILP (Ftest_completion (Fminibuffer_contents (),
2075 Vminibuffer_completion_table
,
2076 Vminibuffer_completion_predicate
)))
2079 /* Call do_completion, but ignore errors. */
2081 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2082 complete_and_exit_2
);
2092 if (!NILP (Vminibuffer_completion_confirm
))
2094 temp_echo_area_glyphs (build_string (" [Confirm]"));
2104 return Fthrow (Qexit
, Qnil
);
2108 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2110 doc
: /* Complete the minibuffer contents at most a single word.
2111 After one word is completed as much as possible, a space or hyphen
2112 is added, provided that matches some possible completion.
2113 Return nil if there is no valid completion, else t. */)
2116 Lisp_Object completion
, tem
, tem1
;
2117 register int i
, i_byte
;
2118 register const unsigned char *completion_string
;
2119 struct gcpro gcpro1
, gcpro2
;
2120 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2122 /* We keep calling Fbuffer_string rather than arrange for GC to
2123 hold onto a pointer to one of the strings thus made. */
2125 completion
= Ftry_completion (minibuffer_completion_contents (),
2126 Vminibuffer_completion_table
,
2127 Vminibuffer_completion_predicate
);
2128 if (NILP (completion
))
2131 temp_echo_area_glyphs (build_string (" [No match]"));
2134 if (EQ (completion
, Qt
))
2137 #if 0 /* How the below code used to look, for reference. */
2138 tem
= Fminibuffer_contents ();
2140 i
= ZV
- 1 - SCHARS (completion
);
2141 p
= SDATA (completion
);
2143 0 <= scmp (b
, p
, ZV
- 1))
2146 /* Set buffer to longest match of buffer tail and completion head. */
2147 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2149 del_range (1, i
+ 1);
2152 #else /* Rewritten code */
2154 int buffer_nchars
, completion_nchars
;
2156 CHECK_STRING (completion
);
2157 tem
= minibuffer_completion_contents ();
2158 GCPRO2 (completion
, tem
);
2159 /* If reading a file name,
2160 expand any $ENVVAR refs in the buffer and in TEM. */
2161 if (! NILP (Vminibuffer_completing_file_name
))
2163 Lisp_Object substituted
;
2164 substituted
= Fsubstitute_in_file_name (tem
);
2165 if (! EQ (substituted
, tem
))
2168 del_range (prompt_end_charpos
, PT
);
2172 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2173 completion_nchars
= SCHARS (completion
);
2174 i
= buffer_nchars
- completion_nchars
;
2177 (tem1
= Fcompare_strings (tem
, make_number (0),
2178 make_number (buffer_nchars
),
2179 completion
, make_number (0),
2180 make_number (buffer_nchars
),
2181 completion_ignore_case
? Qt
: Qnil
),
2186 /* Make buffer (before point) contain the longest match
2187 of TEM's tail and COMPLETION's head. */
2193 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2194 completion
, make_number (0),
2195 make_number (buffer_nchars
),
2196 completion_ignore_case
? Qt
: Qnil
);
2203 del_range (start_pos
, start_pos
+ buffer_nchars
);
2207 #endif /* Rewritten code */
2210 int prompt_end_bytepos
;
2211 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2212 i
= PT
- prompt_end_charpos
;
2213 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2216 /* If completion finds next char not unique,
2217 consider adding a space or a hyphen. */
2218 if (i
== SCHARS (completion
))
2220 GCPRO1 (completion
);
2221 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2222 build_string (" ")),
2223 Vminibuffer_completion_table
,
2224 Vminibuffer_completion_predicate
);
2231 GCPRO1 (completion
);
2233 Ftry_completion (concat2 (minibuffer_completion_contents (),
2234 build_string ("-")),
2235 Vminibuffer_completion_table
,
2236 Vminibuffer_completion_predicate
);
2244 /* Now find first word-break in the stuff found by completion.
2245 i gets index in string of where to stop completing. */
2248 int bytes
= SBYTES (completion
);
2249 completion_string
= SDATA (completion
);
2250 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2252 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2255 if (SYNTAX (c
) != Sword
)
2264 /* If got no characters, print help for user. */
2266 if (i
== PT
- prompt_end_charpos
)
2268 if (!NILP (Vcompletion_auto_help
))
2269 Fminibuffer_completion_help ();
2273 /* Otherwise insert in minibuffer the chars we got */
2275 if (! NILP (Vminibuffer_completing_file_name
)
2276 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2278 && FETCH_CHAR (PT_BYTE
) == '/')
2280 del_range (prompt_end_charpos
, PT
+ 1);
2283 del_range (prompt_end_charpos
, PT
);
2285 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2289 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2291 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2292 Each element may be just a symbol or string
2293 or may be a list of two strings to be printed as if concatenated.
2294 If it is a list of two strings, the first is the actual completion
2295 alternative, the second serves as annotation.
2296 `standard-output' must be a buffer.
2297 The actual completion alternatives, as inserted, are given `mouse-face'
2298 properties of `highlight'.
2299 At the end, this runs the normal hook `completion-setup-hook'.
2300 It can find the completion buffer in `standard-output'. */)
2302 Lisp_Object completions
;
2304 Lisp_Object tail
, elt
;
2307 struct gcpro gcpro1
, gcpro2
;
2308 struct buffer
*old
= current_buffer
;
2311 /* Note that (when it matters) every variable
2312 points to a non-string that is pointed to by COMPLETIONS,
2313 except for ELT. ELT can be pointing to a string
2314 when terpri or Findent_to calls a change hook. */
2316 GCPRO2 (completions
, elt
);
2318 if (BUFFERP (Vstandard_output
))
2319 set_buffer_internal (XBUFFER (Vstandard_output
));
2321 if (NILP (completions
))
2322 write_string ("There are no possible completions of what you have typed.",
2326 write_string ("Possible completions are:", -1);
2327 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2329 Lisp_Object tem
, string
;
2331 Lisp_Object startpos
, endpos
;
2337 elt
= SYMBOL_NAME (elt
);
2338 /* Compute the length of this element. */
2343 length
= SCHARS (tem
);
2345 tem
= Fcar (XCDR (elt
));
2347 length
+= SCHARS (tem
);
2352 length
= SCHARS (elt
);
2355 /* This does a bad job for narrower than usual windows.
2356 Sadly, the window it will appear in is not known
2357 until after the text has been made. */
2359 if (BUFFERP (Vstandard_output
))
2360 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2362 /* If the previous completion was very wide,
2363 or we have two on this line already,
2364 don't put another on the same line. */
2365 if (column
> 33 || first
2366 /* If this is really wide, don't put it second on a line. */
2367 || (column
> 0 && length
> 45))
2372 /* Otherwise advance to column 35. */
2375 if (BUFFERP (Vstandard_output
))
2377 tem
= Findent_to (make_number (35), make_number (2));
2379 column
= XINT (tem
);
2385 write_string (" ", -1);
2388 while (column
< 35);
2392 if (BUFFERP (Vstandard_output
))
2394 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2395 Fset_text_properties (startpos
, endpos
,
2396 Qnil
, Vstandard_output
);
2399 /* Output this element.
2400 If necessary, convert it to unibyte or to multibyte first. */
2402 string
= Fcar (elt
);
2405 if (NILP (current_buffer
->enable_multibyte_characters
)
2406 && STRING_MULTIBYTE (string
))
2407 string
= Fstring_make_unibyte (string
);
2408 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2409 && !STRING_MULTIBYTE (string
))
2410 string
= Fstring_make_multibyte (string
);
2412 if (BUFFERP (Vstandard_output
))
2414 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2416 Fprinc (string
, Qnil
);
2418 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2420 Fput_text_property (startpos
, endpos
,
2421 Qmouse_face
, intern ("highlight"),
2426 Fprinc (string
, Qnil
);
2429 /* Output the annotation for this element. */
2432 if (BUFFERP (Vstandard_output
))
2434 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2436 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2438 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2440 Fset_text_properties (startpos
, endpos
, Qnil
,
2445 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2450 /* Update COLUMN for what we have output. */
2453 /* If output is to a buffer, recompute COLUMN in a way
2454 that takes account of character widths. */
2455 if (BUFFERP (Vstandard_output
))
2457 tem
= Fcurrent_column ();
2458 column
= XINT (tem
);
2467 if (BUFFERP (Vstandard_output
))
2468 set_buffer_internal (old
);
2470 if (!NILP (Vrun_hooks
))
2471 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2476 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2478 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2481 Lisp_Object completions
;
2483 message ("Making completion list...");
2484 completions
= Fall_completions (minibuffer_completion_contents (),
2485 Vminibuffer_completion_table
,
2486 Vminibuffer_completion_predicate
,
2488 clear_message (1, 0);
2490 if (NILP (completions
))
2493 temp_echo_area_glyphs (build_string (" [No completions]"));
2496 internal_with_output_to_temp_buffer ("*Completions*",
2497 Fdisplay_completion_list
,
2498 Fsort (completions
, Qstring_lessp
));
2502 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2503 doc
: /* Terminate minibuffer input. */)
2506 if (INTEGERP (last_command_char
))
2507 internal_self_insert (XINT (last_command_char
), 0);
2511 return Fthrow (Qexit
, Qnil
);
2514 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2515 doc
: /* Terminate this minibuffer argument. */)
2518 return Fthrow (Qexit
, Qnil
);
2521 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2522 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2525 return make_number (minibuf_level
);
2528 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2529 doc
: /* Return the prompt string of the currently-active minibuffer.
2530 If no minibuffer is active, return nil. */)
2533 return Fcopy_sequence (minibuf_prompt
);
2537 /* Temporarily display STRING at the end of the current
2538 minibuffer contents. This is used to display things like
2539 "[No Match]" when the user requests a completion for a prefix
2540 that has no possible completions, and other quick, unobtrusive
2544 temp_echo_area_glyphs (string
)
2548 int osize_byte
= ZV_BYTE
;
2550 int opoint_byte
= PT_BYTE
;
2551 Lisp_Object oinhibit
;
2552 oinhibit
= Vinhibit_quit
;
2554 /* Clear out any old echo-area message to make way for our new thing. */
2557 SET_PT_BOTH (osize
, osize_byte
);
2558 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2559 SET_PT_BOTH (opoint
, opoint_byte
);
2561 Fsit_for (make_number (2), Qnil
, Qnil
);
2562 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2563 SET_PT_BOTH (opoint
, opoint_byte
);
2564 if (!NILP (Vquit_flag
))
2567 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2569 Vinhibit_quit
= oinhibit
;
2572 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2574 doc
: /* Temporarily display STRING at the end of the minibuffer.
2575 The text is displayed for two seconds,
2576 or until the next input event arrives, whichever comes first. */)
2580 CHECK_STRING (string
);
2581 temp_echo_area_glyphs (string
);
2586 init_minibuf_once ()
2588 Vminibuffer_list
= Qnil
;
2589 staticpro (&Vminibuffer_list
);
2596 minibuf_prompt
= Qnil
;
2597 staticpro (&minibuf_prompt
);
2599 minibuf_save_list
= Qnil
;
2600 staticpro (&minibuf_save_list
);
2602 Qread_file_name_internal
= intern ("read-file-name-internal");
2603 staticpro (&Qread_file_name_internal
);
2605 Qminibuffer_default
= intern ("minibuffer-default");
2606 staticpro (&Qminibuffer_default
);
2607 Fset (Qminibuffer_default
, Qnil
);
2609 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2610 staticpro (&Qminibuffer_completion_table
);
2612 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2613 staticpro (&Qminibuffer_completion_confirm
);
2615 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2616 staticpro (&Qminibuffer_completion_predicate
);
2618 staticpro (&last_exact_completion
);
2619 last_exact_completion
= Qnil
;
2621 staticpro (&last_minibuf_string
);
2622 last_minibuf_string
= Qnil
;
2624 Quser_variable_p
= intern ("user-variable-p");
2625 staticpro (&Quser_variable_p
);
2627 Qminibuffer_history
= intern ("minibuffer-history");
2628 staticpro (&Qminibuffer_history
);
2630 Qbuffer_name_history
= intern ("buffer-name-history");
2631 staticpro (&Qbuffer_name_history
);
2632 Fset (Qbuffer_name_history
, Qnil
);
2634 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2635 staticpro (&Qminibuffer_setup_hook
);
2637 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2638 staticpro (&Qminibuffer_exit_hook
);
2640 Qhistory_length
= intern ("history-length");
2641 staticpro (&Qhistory_length
);
2643 Qcurrent_input_method
= intern ("current-input-method");
2644 staticpro (&Qcurrent_input_method
);
2646 Qactivate_input_method
= intern ("activate-input-method");
2647 staticpro (&Qactivate_input_method
);
2649 Qcase_fold_search
= intern ("case-fold-search");
2650 staticpro (&Qcase_fold_search
);
2652 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2653 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2654 Vread_buffer_function
= Qnil
;
2656 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2657 doc
: /* Normal hook run just after entry to minibuffer. */);
2658 Vminibuffer_setup_hook
= Qnil
;
2660 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2661 doc
: /* Normal hook run just after exit from minibuffer. */);
2662 Vminibuffer_exit_hook
= Qnil
;
2664 DEFVAR_LISP ("history-length", &Vhistory_length
,
2665 doc
: /* *Maximum length for history lists before truncation takes place.
2666 A number means that length; t means infinite. Truncation takes place
2667 just after a new element is inserted. Setting the history-length
2668 property of a history variable overrides this default. */);
2669 XSETFASTINT (Vhistory_length
, 30);
2671 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2672 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2673 Vcompletion_auto_help
= Qt
;
2675 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2676 doc
: /* Non-nil means don't consider case significant in completion. */);
2677 completion_ignore_case
= 0;
2679 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2680 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2681 This variable makes a difference whenever the minibuffer window is active. */);
2682 enable_recursive_minibuffers
= 0;
2684 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2685 doc
: /* Alist or obarray used for completion in the minibuffer.
2686 This becomes the ALIST argument to `try-completion' and `all-completions'.
2687 The value can also be a list of strings or a hash table.
2689 The value may alternatively be a function, which is given three arguments:
2690 STRING, the current buffer contents;
2691 PREDICATE, the predicate for filtering possible matches;
2692 CODE, which says what kind of things to do.
2693 CODE can be nil, t or `lambda'.
2694 nil means to return the best completion of STRING, or nil if there is none.
2695 t means to return a list of all possible completions of STRING.
2696 `lambda' means to return t if STRING is a valid completion as it stands. */);
2697 Vminibuffer_completion_table
= Qnil
;
2699 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2700 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2701 Vminibuffer_completion_predicate
= Qnil
;
2703 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2704 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2705 Vminibuffer_completion_confirm
= Qnil
;
2707 DEFVAR_LISP ("minibuffer-completing-file-name",
2708 &Vminibuffer_completing_file_name
,
2709 doc
: /* Non-nil means completing file names. */);
2710 Vminibuffer_completing_file_name
= Qnil
;
2712 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2713 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2714 Vminibuffer_help_form
= Qnil
;
2716 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2717 doc
: /* History list symbol to add minibuffer values to.
2718 Each string of minibuffer input, as it appears on exit from the minibuffer,
2720 (set minibuffer-history-variable
2721 (cons STRING (symbol-value minibuffer-history-variable))) */);
2722 XSETFASTINT (Vminibuffer_history_variable
, 0);
2724 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2725 doc
: /* Current position of redoing in the history list. */);
2726 Vminibuffer_history_position
= Qnil
;
2728 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2729 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2730 Some uses of the echo area also raise that frame (since they use it too). */);
2731 minibuffer_auto_raise
= 0;
2733 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2734 doc
: /* List of regexps that should restrict possible completions.
2735 The basic completion functions only consider a completion acceptable
2736 if it matches all regular expressions in this list, with
2737 `case-fold-search' bound to the value of `completion-ignore-case'.
2738 See Info node `(elisp)Basic Completion', for a description of these
2740 Vcompletion_regexp_list
= Qnil
;
2742 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2743 &minibuffer_allow_text_properties
,
2744 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2745 This also affects `read-string', but it does not affect `read-minibuffer',
2746 `read-no-blanks-input', or any of the functions that do minibuffer input
2747 with completion; they always discard text properties. */);
2748 minibuffer_allow_text_properties
= 0;
2750 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2751 doc
: /* Text properties that are added to minibuffer prompts.
2752 These are in addition to the basic `field' property, and stickiness
2754 /* We use `intern' here instead of Qread_only to avoid
2755 initialization-order problems. */
2756 Vminibuffer_prompt_properties
2757 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2759 defsubr (&Sset_minibuffer_window
);
2760 defsubr (&Sread_from_minibuffer
);
2761 defsubr (&Seval_minibuffer
);
2762 defsubr (&Sread_minibuffer
);
2763 defsubr (&Sread_string
);
2764 defsubr (&Sread_command
);
2765 defsubr (&Sread_variable
);
2766 defsubr (&Sread_buffer
);
2767 defsubr (&Sread_no_blanks_input
);
2768 defsubr (&Sminibuffer_depth
);
2769 defsubr (&Sminibuffer_prompt
);
2771 defsubr (&Sminibufferp
);
2772 defsubr (&Sminibuffer_prompt_end
);
2773 defsubr (&Sminibuffer_contents
);
2774 defsubr (&Sminibuffer_contents_no_properties
);
2775 defsubr (&Sdelete_minibuffer_contents
);
2777 defsubr (&Stry_completion
);
2778 defsubr (&Sall_completions
);
2779 defsubr (&Stest_completion
);
2780 defsubr (&Sassoc_string
);
2781 defsubr (&Scompleting_read
);
2782 defsubr (&Sminibuffer_complete
);
2783 defsubr (&Sminibuffer_complete_word
);
2784 defsubr (&Sminibuffer_complete_and_exit
);
2785 defsubr (&Sdisplay_completion_list
);
2786 defsubr (&Sminibuffer_completion_help
);
2788 defsubr (&Sself_insert_and_exit
);
2789 defsubr (&Sexit_minibuffer
);
2791 defsubr (&Sminibuffer_message
);
2797 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2798 "abort-recursive-edit");
2799 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2801 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2804 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2806 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2808 initial_define_key (Vminibuffer_local_ns_map
, '?',
2809 "self-insert-and-exit");
2811 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2812 "minibuffer-complete");
2813 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2814 "minibuffer-complete-word");
2815 initial_define_key (Vminibuffer_local_completion_map
, '?',
2816 "minibuffer-completion-help");
2818 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2819 "minibuffer-complete-and-exit");
2820 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2821 "minibuffer-complete-and-exit");
2824 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2825 (do not change this comment) */