1 /* Minibuffer input and completion.
2 Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03
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 read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
213 Lisp_Object
, Lisp_Object
,
215 Lisp_Object
, Lisp_Object
,
217 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
218 Lisp_Object
, Lisp_Object
,
220 Lisp_Object
, Lisp_Object
,
222 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
225 /* Read a Lisp object from VAL and return it. If VAL is an empty
226 string, and DEFALT is a string, read from DEFALT instead of VAL. */
229 string_to_object (val
, defalt
)
230 Lisp_Object val
, defalt
;
232 struct gcpro gcpro1
, gcpro2
;
233 Lisp_Object expr_and_pos
;
236 GCPRO2 (val
, defalt
);
238 if (STRINGP (val
) && SCHARS (val
) == 0
242 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
243 pos
= XINT (Fcdr (expr_and_pos
));
244 if (pos
!= SCHARS (val
))
246 /* Ignore trailing whitespace; any other trailing junk
249 pos
= string_char_to_byte (val
, pos
);
250 for (i
= pos
; i
< SBYTES (val
); i
++)
252 int c
= SREF (val
, i
);
253 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
254 error ("Trailing garbage following expression");
258 val
= Fcar (expr_and_pos
);
259 RETURN_UNGCPRO (val
);
263 /* Like read_minibuf but reading from stdin. This function is called
264 from read_minibuf to do the job if noninteractive. */
267 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
268 histvar
, histpos
, defalt
, allow_props
,
269 inherit_input_method
)
273 Lisp_Object backup_n
;
279 int inherit_input_method
;
285 fprintf (stdout
, "%s", SDATA (prompt
));
291 line
= (char *) xmalloc (size
* sizeof *line
);
292 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
293 && (len
= strlen (line
),
294 len
== size
- 1 && line
[len
- 1] != '\n'))
297 line
= (char *) xrealloc (line
, size
);
304 if (len
> 0 && line
[len
- 1] == '\n')
307 val
= build_string (line
);
313 error ("Error reading from stdin");
316 /* If Lisp form desired instead of string, parse it. */
318 val
= string_to_object (val
, defalt
);
323 DEFUN ("minibufferp", Fminibufferp
,
324 Sminibufferp
, 0, 1, 0,
325 doc
: /* Return t if BUFFER is a minibuffer.
326 No argument or nil as argument means use current buffer as BUFFER.
327 BUFFER can be a buffer or a buffer name. */)
334 buffer
= Fcurrent_buffer ();
335 else if (STRINGP (buffer
))
336 buffer
= Fget_buffer (buffer
);
338 CHECK_BUFFER (buffer
);
340 tem
= Fmemq (buffer
, Vminibuffer_list
);
341 return ! NILP (tem
) ? Qt
: Qnil
;
344 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
345 Sminibuffer_prompt_end
, 0, 0, 0,
346 doc
: /* Return the buffer position of the end of the minibuffer prompt.
347 Return (point-min) if current buffer is not a mini-buffer. */)
350 /* This function is written to be most efficient when there's a prompt. */
351 Lisp_Object beg
, end
, tem
;
352 beg
= make_number (BEGV
);
354 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
358 end
= Ffield_end (beg
, Qnil
, Qnil
);
360 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
366 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
367 Sminibuffer_contents
, 0, 0, 0,
368 doc
: /* Return the user input in a minibuffer as a string.
369 The current buffer must be a minibuffer. */)
372 int prompt_end
= XINT (Fminibuffer_prompt_end ());
373 return make_buffer_string (prompt_end
, ZV
, 1);
376 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
377 Sminibuffer_contents_no_properties
, 0, 0, 0,
378 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
379 The current buffer must be a minibuffer. */)
382 int prompt_end
= XINT (Fminibuffer_prompt_end ());
383 return make_buffer_string (prompt_end
, ZV
, 0);
386 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
387 Sdelete_minibuffer_contents
, 0, 0, 0,
388 doc
: /* Delete all user input in a minibuffer.
389 The current buffer must be a minibuffer. */)
392 int prompt_end
= XINT (Fminibuffer_prompt_end ());
394 del_range (prompt_end
, ZV
);
398 /* Get the text in the minibuffer before point.
399 That is what completion commands operate on. */
402 minibuffer_completion_contents ()
404 int prompt_end
= XINT (Fminibuffer_prompt_end ());
406 error ("Cannot do completion in the prompt");
407 return make_buffer_string (prompt_end
, PT
, 1);
410 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
411 putting point minus BACKUP_N bytes from the end of INITIAL,
412 prompting with PROMPT (a string), using history list HISTVAR
413 with initial position HISTPOS. INITIAL should be a string or a
414 cons of a string and an integer. BACKUP_N should be <= 0, or
415 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
416 ignored and replaced with an integer that puts point at one-indexed
417 position N in INITIAL, where N is the CDR of INITIAL, or at the
418 beginning of INITIAL if N <= 0.
420 Normally return the result as a string (the text that was read),
421 but if EXPFLAG is nonzero, read it and return the object read.
422 If HISTVAR is given, save the value read on that history only if it doesn't
423 match the front of that history list exactly. The value is pushed onto
424 the list as the string that was read.
426 DEFALT specifies the default value for the sake of history commands.
428 If ALLOW_PROPS is nonzero, we do not throw away text properties.
430 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
431 current input method. */
434 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
435 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
439 Lisp_Object backup_n
;
445 int inherit_input_method
;
448 int count
= SPECPDL_INDEX ();
449 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
450 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
451 Lisp_Object enable_multibyte
;
452 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
454 /* String to add to the history. */
455 Lisp_Object histstring
;
457 extern Lisp_Object Qfront_sticky
;
458 extern Lisp_Object Qrear_nonsticky
;
460 specbind (Qminibuffer_default
, defalt
);
462 single_kboard_state ();
463 #ifdef HAVE_X_WINDOWS
464 if (display_hourglass_p
)
472 backup_n
= Fcdr (initial
);
473 initial
= Fcar (initial
);
474 CHECK_STRING (initial
);
475 if (!NILP (backup_n
))
477 CHECK_NUMBER (backup_n
);
478 /* Convert to distance from end of input. */
479 if (XINT (backup_n
) < 1)
480 /* A number too small means the beginning of the string. */
481 pos
= - SCHARS (initial
);
483 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
487 CHECK_STRING (initial
);
490 ambient_dir
= current_buffer
->directory
;
492 enable_multibyte
= Qnil
;
494 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
495 store them away before we can GC. Don't need to protect
496 BACKUP_N because we use the value only if it is an integer. */
497 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
499 if (!STRINGP (prompt
))
500 prompt
= empty_string
;
502 if (!enable_recursive_minibuffers
503 && minibuf_level
> 0)
505 if (EQ (selected_window
, minibuf_window
))
506 error ("Command attempted to use minibuffer while in minibuffer");
508 /* If we're in another window, cancel the minibuffer that's active. */
510 build_string ("Command attempted to use minibuffer while in minibuffer"));
515 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
517 expflag
, histvar
, histpos
, defalt
,
518 allow_props
, inherit_input_method
);
520 return unbind_to (count
, val
);
523 /* Choose the minibuffer window and frame, and take action on them. */
525 choose_minibuf_frame ();
527 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
529 record_unwind_protect (Fset_window_configuration
,
530 Fcurrent_window_configuration (Qnil
));
532 /* If the minibuffer window is on a different frame, save that
533 frame's configuration too. */
534 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
535 if (!EQ (mini_frame
, selected_frame
))
536 record_unwind_protect (Fset_window_configuration
,
537 Fcurrent_window_configuration (mini_frame
));
539 /* If the minibuffer is on an iconified or invisible frame,
540 make it visible now. */
541 Fmake_frame_visible (mini_frame
);
543 if (minibuffer_auto_raise
)
544 Fraise_frame (mini_frame
);
546 /* We have to do this after saving the window configuration
547 since that is what restores the current buffer. */
549 /* Arrange to restore a number of minibuffer-related variables.
550 We could bind each variable separately, but that would use lots of
553 = Fcons (Voverriding_local_map
,
554 Fcons (minibuf_window
, minibuf_save_list
));
556 = Fcons (minibuf_prompt
,
557 Fcons (make_number (minibuf_prompt_width
),
559 Fcons (Vcurrent_prefix_arg
,
560 Fcons (Vminibuffer_history_position
,
561 Fcons (Vminibuffer_history_variable
,
562 minibuf_save_list
))))));
564 record_unwind_protect (read_minibuf_unwind
, Qnil
);
567 /* Now that we can restore all those variables, start changing them. */
569 minibuf_prompt_width
= 0;
570 minibuf_prompt
= Fcopy_sequence (prompt
);
571 Vminibuffer_history_position
= histpos
;
572 Vminibuffer_history_variable
= histvar
;
573 Vhelp_form
= Vminibuffer_help_form
;
575 if (inherit_input_method
)
577 /* `current-input-method' is buffer local. So, remember it in
578 INPUT_METHOD before changing the current buffer. */
579 input_method
= Fsymbol_value (Qcurrent_input_method
);
580 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
583 /* Switch to the minibuffer. */
585 minibuffer
= get_minibuffer (minibuf_level
);
586 Fset_buffer (minibuffer
);
588 /* The current buffer's default directory is usually the right thing
589 for our minibuffer here. However, if you're typing a command at
590 a minibuffer-only frame when minibuf_level is zero, then buf IS
591 the current_buffer, so reset_buffer leaves buf's default
592 directory unchanged. This is a bummer when you've just started
593 up Emacs and buf's default directory is Qnil. Here's a hack; can
594 you think of something better to do? Find another buffer with a
595 better directory, and use that one instead. */
596 if (STRINGP (ambient_dir
))
597 current_buffer
->directory
= ambient_dir
;
600 Lisp_Object buf_list
;
602 for (buf_list
= Vbuffer_alist
;
604 buf_list
= XCDR (buf_list
))
606 Lisp_Object other_buf
;
608 other_buf
= XCDR (XCAR (buf_list
));
609 if (STRINGP (XBUFFER (other_buf
)->directory
))
611 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
617 if (!EQ (mini_frame
, selected_frame
))
618 Fredirect_frame_focus (selected_frame
, mini_frame
);
620 Vminibuf_scroll_window
= selected_window
;
621 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
622 minibuf_selected_window
= selected_window
;
623 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
624 Fselect_window (minibuf_window
, Qnil
);
625 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
627 Fmake_local_variable (Qprint_escape_newlines
);
628 print_escape_newlines
= 1;
630 /* Erase the buffer. */
632 int count1
= SPECPDL_INDEX ();
633 specbind (Qinhibit_read_only
, Qt
);
634 specbind (Qinhibit_modification_hooks
, Qt
);
636 unbind_to (count1
, Qnil
);
639 if (!NILP (current_buffer
->enable_multibyte_characters
)
640 && ! STRING_MULTIBYTE (minibuf_prompt
))
641 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
643 /* Insert the prompt, record where it ends. */
644 Finsert (1, &minibuf_prompt
);
647 Fput_text_property (make_number (BEG
), make_number (PT
),
648 Qfront_sticky
, Qt
, Qnil
);
649 Fput_text_property (make_number (BEG
), make_number (PT
),
650 Qrear_nonsticky
, Qt
, Qnil
);
651 Fput_text_property (make_number (BEG
), make_number (PT
),
653 Fadd_text_properties (make_number (BEG
), make_number (PT
),
654 Vminibuffer_prompt_properties
, Qnil
);
657 minibuf_prompt_width
= (int) current_column (); /* iftc */
659 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
660 if (inherit_input_method
)
661 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
663 /* Put in the initial input. */
666 Finsert (1, &initial
);
667 Fforward_char (make_number (pos
));
670 clear_message (1, 1);
671 current_buffer
->keymap
= map
;
673 /* Turn on an input method stored in INPUT_METHOD if any. */
674 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
675 call1 (Qactivate_input_method
, input_method
);
677 /* Run our hook, but not if it is empty.
678 (run-hooks would do nothing if it is empty,
679 but it's important to save time here in the usual case.) */
680 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
681 && !NILP (Vrun_hooks
))
682 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
684 /* Don't allow the user to undo past this point. */
685 current_buffer
->undo_list
= Qnil
;
689 /* If cursor is on the minibuffer line,
690 show the user we have exited by putting it in column 0. */
691 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
694 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
695 XWINDOW (minibuf_window
)->cursor
.x
= 0;
696 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
697 update_frame (XFRAME (selected_frame
), 1, 1);
698 if (rif
&& rif
->flush_display
)
699 rif
->flush_display (XFRAME (XWINDOW (minibuf_window
)->frame
));
702 /* Make minibuffer contents into a string. */
703 Fset_buffer (minibuffer
);
705 val
= Fminibuffer_contents ();
707 val
= Fminibuffer_contents_no_properties ();
709 /* VAL is the string of minibuffer text. */
711 last_minibuf_string
= val
;
713 /* Choose the string to add to the history. */
714 if (SCHARS (val
) != 0)
716 else if (STRINGP (defalt
))
721 /* Add the value to the appropriate history list, if any. */
722 if (SYMBOLP (Vminibuffer_history_variable
)
723 && !NILP (histstring
))
725 /* If the caller wanted to save the value read on a history list,
726 then do so if the value is not already the front of the list. */
729 /* If variable is unbound, make it nil. */
730 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
731 Fset (Vminibuffer_history_variable
, Qnil
);
733 histval
= Fsymbol_value (Vminibuffer_history_variable
);
735 /* The value of the history variable must be a cons or nil. Other
736 values are unacceptable. We silently ignore these values. */
740 /* Don't duplicate the most recent entry in the history. */
741 && NILP (Fequal (histstring
, Fcar (histval
)))))
745 histval
= Fcons (histstring
, histval
);
746 Fset (Vminibuffer_history_variable
, histval
);
748 /* Truncate if requested. */
749 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
750 if (NILP (length
)) length
= Vhistory_length
;
751 if (INTEGERP (length
))
753 if (XINT (length
) <= 0)
754 Fset (Vminibuffer_history_variable
, Qnil
);
759 temp
= Fnthcdr (Fsub1 (length
), histval
);
760 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
766 /* If Lisp form desired instead of string, parse it. */
768 val
= string_to_object (val
, defalt
);
770 /* The appropriate frame will get selected
771 in set-window-configuration. */
773 return unbind_to (count
, val
);
776 /* Return a buffer to be used as the minibuffer at depth `depth'.
777 depth = 0 is the lowest allowed argument, and that is the value
778 used for nonrecursive minibuffer invocations */
781 get_minibuffer (depth
)
784 Lisp_Object tail
, num
, buf
;
786 extern Lisp_Object
nconc2 ();
788 XSETFASTINT (num
, depth
);
789 tail
= Fnthcdr (num
, Vminibuffer_list
);
792 tail
= Fcons (Qnil
, Qnil
);
793 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
796 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
798 sprintf (name
, " *Minibuf-%d*", depth
);
799 buf
= Fget_buffer_create (build_string (name
));
801 /* Although the buffer's name starts with a space, undo should be
803 Fbuffer_enable_undo (buf
);
809 int count
= SPECPDL_INDEX ();
810 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
811 have to empty the list, otherwise we end up with overlays that
812 think they belong to this buffer while the buffer doesn't know about
814 delete_all_overlays (XBUFFER (buf
));
815 reset_buffer (XBUFFER (buf
));
816 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
818 Fkill_all_local_variables ();
819 unbind_to (count
, Qnil
);
825 /* This function is called on exiting minibuffer, whether normally or
826 not, and it restores the current window, buffer, etc. */
829 read_minibuf_unwind (data
)
832 Lisp_Object old_deactivate_mark
;
835 /* We are exiting the minibuffer one way or the other,
837 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
838 && !NILP (Vrun_hooks
))
839 safe_run_hooks (Qminibuffer_exit_hook
);
841 /* If this was a recursive minibuffer,
842 tie the minibuffer window back to the outer level minibuffer buffer. */
845 window
= minibuf_window
;
846 /* To keep things predictable, in case it matters, let's be in the
847 minibuffer when we reset the relevant variables. */
848 Fset_buffer (XWINDOW (window
)->buffer
);
850 /* Restore prompt, etc, from outer minibuffer level. */
851 minibuf_prompt
= Fcar (minibuf_save_list
);
852 minibuf_save_list
= Fcdr (minibuf_save_list
);
853 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
854 minibuf_save_list
= Fcdr (minibuf_save_list
);
855 Vhelp_form
= Fcar (minibuf_save_list
);
856 minibuf_save_list
= Fcdr (minibuf_save_list
);
857 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
858 minibuf_save_list
= Fcdr (minibuf_save_list
);
859 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
860 minibuf_save_list
= Fcdr (minibuf_save_list
);
861 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
862 minibuf_save_list
= Fcdr (minibuf_save_list
);
863 Voverriding_local_map
= Fcar (minibuf_save_list
);
864 minibuf_save_list
= Fcdr (minibuf_save_list
);
866 temp
= Fcar (minibuf_save_list
);
867 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
868 minibuf_window
= temp
;
870 minibuf_save_list
= Fcdr (minibuf_save_list
);
872 /* Erase the minibuffer we were using at this level. */
874 int count
= SPECPDL_INDEX ();
875 /* Prevent error in erase-buffer. */
876 specbind (Qinhibit_read_only
, Qt
);
877 specbind (Qinhibit_modification_hooks
, Qt
);
878 old_deactivate_mark
= Vdeactivate_mark
;
880 Vdeactivate_mark
= old_deactivate_mark
;
881 unbind_to (count
, Qnil
);
884 /* When we get to the outmost level, make sure we resize the
885 mini-window back to its normal size. */
886 if (minibuf_level
== 0)
887 resize_mini_window (XWINDOW (window
), 0);
889 /* Make sure minibuffer window is erased, not ignored. */
890 windows_or_buffers_changed
++;
891 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
892 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
897 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
898 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
899 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
900 DEFAULT-VALUE. It normally should be nil in new code, except when
901 HIST is a cons. It is discussed in more detail below.
902 Third arg KEYMAP is a keymap to use whilst reading;
903 if omitted or nil, the default is `minibuffer-local-map'.
904 If fourth arg READ is non-nil, then interpret the result as a Lisp object
905 and return that object:
906 in other words, do `(car (read-from-string INPUT-STRING))'
907 Fifth arg HIST, if non-nil, specifies a history list and optionally
908 the initial position in the list. It can be a symbol, which is the
909 history list variable to use, or it can be a cons cell
910 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
911 to use, and HISTPOS is the initial position for use by the minibuffer
912 history commands. For consistency, you should also specify that
913 element of the history as the value of INITIAL-CONTENTS. Positions
914 are counted starting from 1 at the beginning of the list.
915 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
916 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
917 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
919 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
920 the current input method and the setting of `enable-multibyte-characters'.
921 If the variable `minibuffer-allow-text-properties' is non-nil,
922 then the string which is returned includes whatever text properties
923 were present in the minibuffer. Otherwise the value has no text properties.
925 The remainder of this documentation string describes the
926 INITIAL-CONTENTS argument in more detail. It is only relevant when
927 studying existing code, or when HIST is a cons. If non-nil,
928 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
929 reading input. Normally, point is put at the end of that string.
930 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
931 input is STRING, but point is placed at _one-indexed_ position
932 POSITION in the minibuffer. Any integer value less than or equal to
933 one puts point at the beginning of the string. *Note* that this
934 behavior differs from the way such arguments are used in `completing-read'
935 and some related functions, which use zero-indexing for POSITION. */)
936 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
937 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
938 Lisp_Object inherit_input_method
;
940 Lisp_Object histvar
, histpos
, val
;
943 CHECK_STRING (prompt
);
945 keymap
= Vminibuffer_local_map
;
947 keymap
= get_keymap (keymap
, 1, 0);
956 histvar
= Fcar_safe (hist
);
957 histpos
= Fcdr_safe (hist
);
960 histvar
= Qminibuffer_history
;
962 XSETFASTINT (histpos
, 0);
964 GCPRO1 (default_value
);
965 val
= read_minibuf (keymap
, initial_contents
, prompt
,
967 histvar
, histpos
, default_value
,
968 minibuffer_allow_text_properties
,
969 !NILP (inherit_input_method
));
974 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
975 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
976 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
977 is a string to insert in the minibuffer before reading.
978 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
979 arguments are used as in `read-from-minibuffer') */)
980 (prompt
, initial_contents
)
981 Lisp_Object prompt
, initial_contents
;
983 CHECK_STRING (prompt
);
984 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
985 prompt
, Qnil
, 1, Qminibuffer_history
,
986 make_number (0), Qnil
, 0, 0);
989 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
990 doc
: /* Return value of Lisp expression read using the minibuffer.
991 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
992 is a string to insert in the minibuffer before reading.
993 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
994 arguments are used as in `read-from-minibuffer') */)
995 (prompt
, initial_contents
)
996 Lisp_Object prompt
, initial_contents
;
998 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1001 /* Functions that use the minibuffer to read various things. */
1003 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1004 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1005 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1006 This argument has been superseded by DEFAULT-VALUE and should normally
1007 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1008 documentation string of that function for details.
1009 The third arg HISTORY, if non-nil, specifies a history list
1010 and optionally the initial position in the list.
1011 See `read-from-minibuffer' for details of HISTORY argument.
1012 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1013 for history commands, and as the value to return if the user enters
1015 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1016 the current input method and the setting of `enable-multibyte-characters'. */)
1017 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1018 Lisp_Object prompt
, initial_input
, history
, default_value
;
1019 Lisp_Object inherit_input_method
;
1022 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1023 Qnil
, history
, default_value
,
1024 inherit_input_method
);
1025 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1026 val
= default_value
;
1030 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1031 doc
: /* Read a string from the terminal, not allowing blanks.
1032 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1033 non-nil, it should be a string, which is used as initial input, with
1034 point positioned at the end, so that SPACE will accept the input.
1035 \(Actually, INITIAL can also be a cons of a string and an integer.
1036 Such values are treated as in `read-from-minibuffer', but are normally
1037 not useful in this function.)
1038 Third 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
, inherit_input_method
)
1041 Lisp_Object prompt
, initial
, inherit_input_method
;
1043 CHECK_STRING (prompt
);
1044 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1045 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1046 !NILP (inherit_input_method
));
1049 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1050 doc
: /* Read the name of a command and return as a symbol.
1051 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1052 (prompt
, default_value
)
1053 Lisp_Object prompt
, default_value
;
1055 Lisp_Object name
, default_string
;
1057 if (NILP (default_value
))
1058 default_string
= Qnil
;
1059 else if (SYMBOLP (default_value
))
1060 default_string
= SYMBOL_NAME (default_value
);
1062 default_string
= default_value
;
1064 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1065 Qnil
, Qnil
, default_string
, Qnil
);
1068 return Fintern (name
, Qnil
);
1072 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1073 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1074 Prompt with PROMPT. */)
1078 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1083 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1084 doc
: /* Read the name of a user variable and return it as a symbol.
1085 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1086 A user variable is one for which `user-variable-p' returns non-nil. */)
1087 (prompt
, default_value
)
1088 Lisp_Object prompt
, default_value
;
1090 Lisp_Object name
, default_string
;
1092 if (NILP (default_value
))
1093 default_string
= Qnil
;
1094 else if (SYMBOLP (default_value
))
1095 default_string
= SYMBOL_NAME (default_value
);
1097 default_string
= default_value
;
1099 name
= Fcompleting_read (prompt
, Vobarray
,
1100 Quser_variable_p
, Qt
,
1101 Qnil
, Qnil
, default_string
, Qnil
);
1104 return Fintern (name
, Qnil
);
1107 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1108 doc
: /* Read the name of a buffer and return as a string.
1110 Optional second arg DEF is value to return if user enters an empty line.
1111 If optional third arg REQUIRE-MATCH is non-nil,
1112 only existing buffer names are allowed. */)
1113 (prompt
, def
, require_match
)
1114 Lisp_Object prompt
, def
, require_match
;
1116 Lisp_Object args
[4];
1119 def
= XBUFFER (def
)->name
;
1121 if (NILP (Vread_buffer_function
))
1125 args
[0] = build_string ("%s(default %s) ");
1128 prompt
= Fformat (3, args
);
1131 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1132 require_match
, Qnil
, Qbuffer_name_history
,
1137 args
[0] = Vread_buffer_function
;
1140 args
[3] = require_match
;
1141 return Ffuncall(4, args
);
1146 minibuf_conform_representation (string
, basis
)
1147 Lisp_Object string
, basis
;
1149 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1152 if (STRING_MULTIBYTE (string
))
1153 return Fstring_make_unibyte (string
);
1155 return Fstring_make_multibyte (string
);
1158 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1159 doc
: /* Return common substring of all completions of STRING in ALIST.
1160 Each car of each element of ALIST (or each element if it is not a cons cell)
1161 is tested to see if it begins with STRING.
1162 All that match are compared together; the longest initial sequence
1163 common to all matches is returned as a string.
1164 If there is no match at all, nil is returned.
1165 For a unique match which is exact, t is returned.
1167 If ALIST is a hash-table, all the string keys are the possible matches.
1168 If ALIST is an obarray, the names of all symbols in the obarray
1169 are the possible matches.
1171 ALIST can also be a function to do the completion itself.
1172 It receives three arguments: the values STRING, PREDICATE and nil.
1173 Whatever it returns becomes the value of `try-completion'.
1175 If optional third argument PREDICATE is non-nil,
1176 it is used to test each possible match.
1177 The match is a candidate only if PREDICATE returns non-nil.
1178 The argument given to PREDICATE is the alist element
1179 or the symbol from the obarray. If ALIST is a hash-table,
1180 predicate is called with two arguments: the key and the value.
1181 Additionally to this predicate, `completion-regexp-list'
1182 is used to further constrain the set of candidates. */)
1183 (string
, alist
, predicate
)
1184 Lisp_Object string
, alist
, predicate
;
1186 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1187 /* Size in bytes of BESTMATCH. */
1188 int bestmatchsize
= 0;
1189 /* These are in bytes, too. */
1190 int compare
, matchsize
;
1191 int type
= HASH_TABLE_P (alist
) ? 3
1192 : VECTORP (alist
) ? 2
1193 : NILP (alist
) || (CONSP (alist
)
1194 && (!SYMBOLP (XCAR (alist
))
1195 || NILP (XCAR (alist
))));
1196 int index
= 0, obsize
= 0;
1198 Lisp_Object bucket
, zero
, end
, tem
;
1199 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1201 CHECK_STRING (string
);
1203 return call3 (alist
, string
, predicate
, Qnil
);
1205 bestmatch
= bucket
= Qnil
;
1207 /* If ALIST is not a list, set TAIL just for gc pro. */
1211 obsize
= XVECTOR (alist
)->size
;
1212 bucket
= XVECTOR (alist
)->contents
[index
];
1217 /* Get the next element of the alist, obarray, or hash-table. */
1218 /* Exit the loop if the elements are all used up. */
1219 /* elt gets the alist element or symbol.
1220 eltstring gets the name to check as a completion. */
1227 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1232 if (XFASTINT (bucket
) != 0)
1235 eltstring
= Fsymbol_name (elt
);
1236 if (XSYMBOL (bucket
)->next
)
1237 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1239 XSETFASTINT (bucket
, 0);
1241 else if (++index
>= obsize
)
1245 bucket
= XVECTOR (alist
)->contents
[index
];
1249 else /* if (type == 3) */
1251 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1252 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1254 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1257 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1260 /* Is this element a possible completion? */
1262 if (STRINGP (eltstring
)
1263 && SCHARS (string
) <= SCHARS (eltstring
)
1264 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1265 make_number (SCHARS (string
)),
1266 string
, make_number (0), Qnil
,
1267 completion_ignore_case
? Qt
: Qnil
),
1271 Lisp_Object regexps
;
1273 XSETFASTINT (zero
, 0);
1275 /* Ignore this element if it fails to match all the regexps. */
1277 int count
= SPECPDL_INDEX ();
1278 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1279 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1280 regexps
= XCDR (regexps
))
1282 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1286 unbind_to (count
, Qnil
);
1287 if (CONSP (regexps
))
1291 /* Ignore this element if there is a predicate
1292 and the predicate doesn't like it. */
1294 if (!NILP (predicate
))
1296 if (EQ (predicate
, Qcommandp
))
1297 tem
= Fcommandp (elt
, Qnil
);
1300 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1302 ? call2 (predicate
, elt
,
1303 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1304 : call1 (predicate
, elt
);
1307 if (NILP (tem
)) continue;
1310 /* Update computation of how much all possible completions match */
1312 if (NILP (bestmatch
))
1315 bestmatch
= eltstring
;
1316 bestmatchsize
= SCHARS (eltstring
);
1320 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1321 tem
= Fcompare_strings (bestmatch
, make_number (0),
1322 make_number (compare
),
1323 eltstring
, make_number (0),
1324 make_number (compare
),
1325 completion_ignore_case
? Qt
: Qnil
);
1327 matchsize
= compare
;
1328 else if (XINT (tem
) < 0)
1329 matchsize
= - XINT (tem
) - 1;
1331 matchsize
= XINT (tem
) - 1;
1334 /* When can this happen ? -stef */
1335 matchsize
= compare
;
1336 if (completion_ignore_case
)
1338 /* If this is an exact match except for case,
1339 use it as the best match rather than one that is not an
1340 exact match. This way, we get the case pattern
1341 of the actual match. */
1342 if ((matchsize
== SCHARS (eltstring
)
1343 && matchsize
< SCHARS (bestmatch
))
1345 /* If there is more than one exact match ignoring case,
1346 and one of them is exact including case,
1348 /* If there is no exact match ignoring case,
1349 prefer a match that does not change the case
1351 ((matchsize
== SCHARS (eltstring
))
1353 (matchsize
== SCHARS (bestmatch
))
1354 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1355 make_number (SCHARS (string
)),
1356 string
, make_number (0),
1360 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1361 make_number (SCHARS (string
)),
1362 string
, make_number (0),
1366 bestmatch
= eltstring
;
1368 if (bestmatchsize
!= SCHARS (eltstring
)
1369 || bestmatchsize
!= matchsize
)
1370 /* Don't count the same string multiple times. */
1372 bestmatchsize
= matchsize
;
1373 if (matchsize
<= SCHARS (string
)
1375 /* No need to look any further. */
1381 if (NILP (bestmatch
))
1382 return Qnil
; /* No completions found */
1383 /* If we are ignoring case, and there is no exact match,
1384 and no additional text was supplied,
1385 don't change the case of what the user typed. */
1386 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1387 && SCHARS (bestmatch
) > bestmatchsize
)
1388 return minibuf_conform_representation (string
, bestmatch
);
1390 /* Return t if the supplied string is an exact match (counting case);
1391 it does not require any change to be made. */
1392 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1393 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1394 make_number (bestmatchsize
),
1395 string
, make_number (0),
1396 make_number (bestmatchsize
),
1401 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1402 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1403 return Fsubstring (bestmatch
, zero
, end
);
1406 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1407 doc
: /* Search for partial matches to STRING in ALIST.
1408 Each car of each element of ALIST (or each element if it is not a cons cell)
1409 is tested to see if it begins with STRING.
1410 The value is a list of all the strings from ALIST that match.
1412 If ALIST is a hash-table, all the string keys are the possible matches.
1413 If ALIST is an obarray, the names of all symbols in the obarray
1414 are the possible matches.
1416 ALIST can also be a function to do the completion itself.
1417 It receives three arguments: the values STRING, PREDICATE and t.
1418 Whatever it returns becomes the value of `all-completions'.
1420 If optional third argument PREDICATE is non-nil,
1421 it is used to test each possible match.
1422 The match is a candidate only if PREDICATE returns non-nil.
1423 The argument given to PREDICATE is the alist element
1424 or the symbol from the obarray. If ALIST is a hash-table,
1425 predicate is called with two arguments: the key and the value.
1426 Additionally to this predicate, `completion-regexp-list'
1427 is used to further constrain the set of candidates.
1429 If the optional fourth argument HIDE-SPACES is non-nil,
1430 strings in ALIST that start with a space
1431 are ignored unless STRING itself starts with a space. */)
1432 (string
, alist
, predicate
, hide_spaces
)
1433 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1435 Lisp_Object tail
, elt
, eltstring
;
1436 Lisp_Object allmatches
;
1437 int type
= HASH_TABLE_P (alist
) ? 3
1438 : VECTORP (alist
) ? 2
1439 : NILP (alist
) || (CONSP (alist
)
1440 && (!SYMBOLP (XCAR (alist
))
1441 || NILP (XCAR (alist
))));
1442 int index
= 0, obsize
= 0;
1443 Lisp_Object bucket
, tem
;
1444 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1446 CHECK_STRING (string
);
1448 return call3 (alist
, string
, predicate
, Qt
);
1449 allmatches
= bucket
= Qnil
;
1451 /* If ALIST is not a list, set TAIL just for gc pro. */
1455 obsize
= XVECTOR (alist
)->size
;
1456 bucket
= XVECTOR (alist
)->contents
[index
];
1461 /* Get the next element of the alist, obarray, or hash-table. */
1462 /* Exit the loop if the elements are all used up. */
1463 /* elt gets the alist element or symbol.
1464 eltstring gets the name to check as a completion. */
1471 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1476 if (XFASTINT (bucket
) != 0)
1479 eltstring
= Fsymbol_name (elt
);
1480 if (XSYMBOL (bucket
)->next
)
1481 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1483 XSETFASTINT (bucket
, 0);
1485 else if (++index
>= obsize
)
1489 bucket
= XVECTOR (alist
)->contents
[index
];
1493 else /* if (type == 3) */
1495 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1496 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1498 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1501 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1504 /* Is this element a possible completion? */
1506 if (STRINGP (eltstring
)
1507 && SCHARS (string
) <= SCHARS (eltstring
)
1508 /* If HIDE_SPACES, reject alternatives that start with space
1509 unless the input starts with space. */
1510 && ((SBYTES (string
) > 0
1511 && SREF (string
, 0) == ' ')
1512 || SREF (eltstring
, 0) != ' '
1513 || NILP (hide_spaces
))
1514 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1515 make_number (SCHARS (string
)),
1516 string
, make_number (0),
1517 make_number (SCHARS (string
)),
1518 completion_ignore_case
? Qt
: Qnil
),
1522 Lisp_Object regexps
;
1524 XSETFASTINT (zero
, 0);
1526 /* Ignore this element if it fails to match all the regexps. */
1528 int count
= SPECPDL_INDEX ();
1529 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1530 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1531 regexps
= XCDR (regexps
))
1533 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1537 unbind_to (count
, Qnil
);
1538 if (CONSP (regexps
))
1542 /* Ignore this element if there is a predicate
1543 and the predicate doesn't like it. */
1545 if (!NILP (predicate
))
1547 if (EQ (predicate
, Qcommandp
))
1548 tem
= Fcommandp (elt
, Qnil
);
1551 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1553 ? call2 (predicate
, elt
,
1554 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1555 : call1 (predicate
, elt
);
1558 if (NILP (tem
)) continue;
1560 /* Ok => put it on the list. */
1561 allmatches
= Fcons (eltstring
, allmatches
);
1565 return Fnreverse (allmatches
);
1568 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1569 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1570 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1571 Lisp_Object Vminibuffer_completing_file_name
;
1573 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1574 doc
: /* Read a string in the minibuffer, with completion.
1575 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1576 TABLE can be an list of strings, an alist, an obarray or a hash table.
1577 TABLE can also be a function to do the completion itself.
1578 PREDICATE limits completion to a subset of TABLE.
1579 See `try-completion' and `all-completions' for more details
1580 on completion, TABLE, and PREDICATE.
1582 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1583 the input is (or completes to) an element of TABLE or is null.
1584 If it is also not t, typing RET does not exit if it does non-null completion.
1585 If the input is null, `completing-read' returns DEF, or an empty string
1586 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1588 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1589 with point positioned at the end.
1590 If it is (STRING . POSITION), the initial input is STRING, but point
1591 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1592 that this is different from `read-from-minibuffer' and related
1593 functions, which use one-indexing for POSITION.) This feature is
1594 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1595 default value DEF instead. The user can yank the default value into
1596 the minibuffer easily using \\[next-history-element].
1598 HIST, if non-nil, specifies a history list and optionally the initial
1599 position in the list. It can be a symbol, which is the history list
1600 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1601 that case, HISTVAR is the history list variable to use, and HISTPOS
1602 is the initial position (the position in the list used by the
1603 minibuffer history commands). For consistency, you should also
1604 specify that element of the history as the value of
1605 INITIAL-CONTENTS. (This is the only case in which you should use
1606 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1607 1 at the beginning of the list. The variable `history-length'
1608 controls the maximum length of a history list.
1610 DEF, if non-nil, is the default value.
1612 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1613 the current input method and the setting of `enable-multibyte-characters'.
1615 Completion ignores case if the ambient value of
1616 `completion-ignore-case' is non-nil. */)
1617 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1618 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1619 Lisp_Object hist
, def
, inherit_input_method
;
1621 Lisp_Object val
, histvar
, histpos
, position
;
1624 int count
= SPECPDL_INDEX ();
1625 struct gcpro gcpro1
;
1627 init
= initial_input
;
1630 specbind (Qminibuffer_completion_table
, table
);
1631 specbind (Qminibuffer_completion_predicate
, predicate
);
1632 specbind (Qminibuffer_completion_confirm
,
1633 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1634 last_exact_completion
= Qnil
;
1641 position
= Fcdr (init
);
1644 CHECK_STRING (init
);
1645 if (!NILP (position
))
1647 CHECK_NUMBER (position
);
1648 /* Convert to distance from end of input. */
1649 pos
= XINT (position
) - SCHARS (init
);
1660 histvar
= Fcar_safe (hist
);
1661 histpos
= Fcdr_safe (hist
);
1664 histvar
= Qminibuffer_history
;
1666 XSETFASTINT (histpos
, 0);
1668 val
= read_minibuf (NILP (require_match
)
1669 ? Vminibuffer_local_completion_map
1670 : Vminibuffer_local_must_match_map
,
1671 init
, prompt
, make_number (pos
), 0,
1672 histvar
, histpos
, def
, 0,
1673 !NILP (inherit_input_method
));
1675 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1678 RETURN_UNGCPRO (unbind_to (count
, val
));
1681 Lisp_Object
Fminibuffer_completion_help ();
1682 Lisp_Object
Fassoc_string ();
1684 /* Test whether TXT is an exact completion. */
1685 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1686 doc
: /* Return non-nil if STRING is a valid completion.
1687 Takes the same arguments as `all-completions' and `try-completion'.
1688 If ALIST is a function, it is called with three arguments:
1689 the values STRING, PREDICATE and `lambda'. */)
1690 (string
, alist
, predicate
)
1691 Lisp_Object string
, alist
, predicate
;
1693 Lisp_Object regexps
, tail
, tem
= Qnil
;
1696 CHECK_STRING (string
);
1698 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1701 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1705 else if (VECTORP (alist
))
1707 /* Bypass intern-soft as that loses for nil. */
1708 tem
= oblookup (alist
,
1714 if (STRING_MULTIBYTE (string
))
1715 string
= Fstring_make_unibyte (string
);
1717 string
= Fstring_make_multibyte (string
);
1719 tem
= oblookup (alist
,
1725 if (completion_ignore_case
&& !SYMBOLP (tem
))
1727 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1729 tail
= XVECTOR (alist
)->contents
[i
];
1733 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1734 Fsymbol_name (tail
),
1735 make_number (0) , Qnil
, Qt
)),
1741 if (XSYMBOL (tail
)->next
== 0)
1743 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1751 else if (HASH_TABLE_P (alist
))
1753 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1754 i
= hash_lookup (h
, string
, NULL
);
1756 tem
= HASH_KEY (h
, i
);
1758 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1759 if (!NILP (HASH_HASH (h
, i
)) &&
1760 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1761 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1762 completion_ignore_case
? Qt
: Qnil
),
1765 tem
= HASH_KEY (h
, i
);
1772 return call3 (alist
, string
, predicate
, Qlambda
);
1774 /* Reject this element if it fails to match all the regexps. */
1776 int count
= SPECPDL_INDEX ();
1777 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1778 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1779 regexps
= XCDR (regexps
))
1781 if (NILP (Fstring_match (XCAR (regexps
),
1782 SYMBOLP (tem
) ? string
: tem
,
1784 return unbind_to (count
, Qnil
);
1786 unbind_to (count
, Qnil
);
1789 /* Finally, check the predicate. */
1790 if (!NILP (predicate
))
1792 return HASH_TABLE_P (alist
)
1793 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1794 : call1 (predicate
, tem
);
1801 * 0 no possible completion
1802 * 1 was already an exact and unique completion
1803 * 3 was already an exact completion
1804 * 4 completed to an exact completion
1805 * 5 some completion happened
1806 * 6 no completion happened
1811 Lisp_Object completion
, string
, tem
;
1814 struct gcpro gcpro1
, gcpro2
;
1816 completion
= Ftry_completion (minibuffer_completion_contents (),
1817 Vminibuffer_completion_table
,
1818 Vminibuffer_completion_predicate
);
1819 last
= last_exact_completion
;
1820 last_exact_completion
= Qnil
;
1822 GCPRO2 (completion
, last
);
1824 if (NILP (completion
))
1827 temp_echo_area_glyphs (build_string (" [No match]"));
1832 if (EQ (completion
, Qt
)) /* exact and unique match */
1838 string
= minibuffer_completion_contents ();
1840 /* COMPLETEDP should be true if some completion was done, which
1841 doesn't include simply changing the case of the entered string.
1842 However, for appearance, the string is rewritten if the case
1844 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1845 completedp
= !EQ (tem
, Qt
);
1847 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1849 /* Rewrite the user's input. */
1851 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1852 /* Some completion happened */
1854 if (! NILP (Vminibuffer_completing_file_name
)
1855 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1857 && FETCH_CHAR (PT_BYTE
) == '/')
1859 del_range (prompt_end
, PT
+ 1);
1862 del_range (prompt_end
, PT
);
1864 Finsert (1, &completion
);
1867 /* The case of the string changed, but that's all. We're not
1868 sure whether this is a unique completion or not, so try again
1869 using the real case (this shouldn't recurse again, because
1870 the next time try-completion will return either `t' or the
1874 return do_completion ();
1878 /* It did find a match. Do we match some possibility exactly now? */
1879 tem
= Ftest_completion (Fminibuffer_contents (),
1880 Vminibuffer_completion_table
,
1881 Vminibuffer_completion_predicate
);
1884 /* not an exact match */
1888 else if (!NILP (Vcompletion_auto_help
))
1889 Fminibuffer_completion_help ();
1891 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1894 else if (completedp
)
1899 /* If the last exact completion and this one were the same,
1900 it means we've already given a "Complete but not unique"
1901 message and the user's hit TAB again, so now we give him help. */
1902 last_exact_completion
= completion
;
1905 tem
= minibuffer_completion_contents ();
1906 if (!NILP (Fequal (tem
, last
)))
1907 Fminibuffer_completion_help ();
1913 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1915 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1916 doc
: /* Like `assoc' but specifically for strings.
1917 Unibyte strings are converted to multibyte for comparison.
1918 And case is ignored if CASE-FOLD is non-nil.
1919 As opposed to `assoc', it will also match an entry consisting of a single
1920 string rather than a cons cell whose car is a string. */)
1921 (key
, list
, case_fold
)
1922 register Lisp_Object key
;
1923 Lisp_Object list
, case_fold
;
1925 register Lisp_Object tail
;
1927 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1929 register Lisp_Object elt
, tem
, thiscar
;
1931 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1932 if (!STRINGP (thiscar
))
1934 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1935 key
, make_number (0), Qnil
,
1944 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1945 doc
: /* Complete the minibuffer contents as far as possible.
1946 Return nil if there is no valid completion, else t.
1947 If no characters can be completed, display a list of possible completions.
1948 If you repeat this command after it displayed such a list,
1949 scroll the window of possible completions. */)
1953 Lisp_Object window
, tem
;
1955 /* If the previous command was not this,
1956 mark the completion buffer obsolete. */
1957 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
1958 Vminibuf_scroll_window
= Qnil
;
1960 window
= Vminibuf_scroll_window
;
1961 /* If there's a fresh completion window with a live buffer,
1962 and this command is repeated, scroll that window. */
1963 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
1964 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
1966 struct buffer
*obuf
= current_buffer
;
1968 Fset_buffer (XWINDOW (window
)->buffer
);
1969 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
1971 /* If end is in view, scroll up to the beginning. */
1972 Fset_window_start (window
, make_number (BEGV
), Qnil
);
1974 /* Else scroll down one screen. */
1975 Fscroll_other_window (Qnil
);
1977 set_buffer_internal (obuf
);
1981 i
= do_completion ();
1989 Fgoto_char (make_number (ZV
));
1990 temp_echo_area_glyphs (build_string (" [Sole completion]"));
1995 Fgoto_char (make_number (ZV
));
1996 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2003 /* Subroutines of Fminibuffer_complete_and_exit. */
2005 /* This one is called by internal_condition_case to do the real work. */
2008 complete_and_exit_1 ()
2010 return make_number (do_completion ());
2013 /* This one is called by internal_condition_case if an error happens.
2014 Pretend the current value is an exact match. */
2017 complete_and_exit_2 (ignore
)
2020 return make_number (1);
2023 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2024 Sminibuffer_complete_and_exit
, 0, 0, "",
2025 doc
: /* If the minibuffer contents is a valid completion then exit.
2026 Otherwise try to complete it. If completion leads to a valid completion,
2027 a repetition of this command will exit. */)
2033 /* Allow user to specify null string */
2034 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2037 if (!NILP (Ftest_completion (Fminibuffer_contents (),
2038 Vminibuffer_completion_table
,
2039 Vminibuffer_completion_predicate
)))
2042 /* Call do_completion, but ignore errors. */
2044 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2045 complete_and_exit_2
);
2055 if (!NILP (Vminibuffer_completion_confirm
))
2057 temp_echo_area_glyphs (build_string (" [Confirm]"));
2067 return Fthrow (Qexit
, Qnil
);
2071 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2073 doc
: /* Complete the minibuffer contents at most a single word.
2074 After one word is completed as much as possible, a space or hyphen
2075 is added, provided that matches some possible completion.
2076 Return nil if there is no valid completion, else t. */)
2079 Lisp_Object completion
, tem
, tem1
;
2080 register int i
, i_byte
;
2081 register const unsigned char *completion_string
;
2082 struct gcpro gcpro1
, gcpro2
;
2083 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2085 /* We keep calling Fbuffer_string rather than arrange for GC to
2086 hold onto a pointer to one of the strings thus made. */
2088 completion
= Ftry_completion (minibuffer_completion_contents (),
2089 Vminibuffer_completion_table
,
2090 Vminibuffer_completion_predicate
);
2091 if (NILP (completion
))
2094 temp_echo_area_glyphs (build_string (" [No match]"));
2097 if (EQ (completion
, Qt
))
2100 #if 0 /* How the below code used to look, for reference. */
2101 tem
= Fminibuffer_contents ();
2103 i
= ZV
- 1 - SCHARS (completion
);
2104 p
= SDATA (completion
);
2106 0 <= scmp (b
, p
, ZV
- 1))
2109 /* Set buffer to longest match of buffer tail and completion head. */
2110 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2112 del_range (1, i
+ 1);
2115 #else /* Rewritten code */
2117 int buffer_nchars
, completion_nchars
;
2119 CHECK_STRING (completion
);
2120 tem
= minibuffer_completion_contents ();
2121 GCPRO2 (completion
, tem
);
2122 /* If reading a file name,
2123 expand any $ENVVAR refs in the buffer and in TEM. */
2124 if (! NILP (Vminibuffer_completing_file_name
))
2126 Lisp_Object substituted
;
2127 substituted
= Fsubstitute_in_file_name (tem
);
2128 if (! EQ (substituted
, tem
))
2131 del_range (prompt_end_charpos
, PT
);
2135 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2136 completion_nchars
= SCHARS (completion
);
2137 i
= buffer_nchars
- completion_nchars
;
2140 (tem1
= Fcompare_strings (tem
, make_number (0),
2141 make_number (buffer_nchars
),
2142 completion
, make_number (0),
2143 make_number (buffer_nchars
),
2144 completion_ignore_case
? Qt
: Qnil
),
2149 /* Make buffer (before point) contain the longest match
2150 of TEM's tail and COMPLETION's head. */
2156 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2157 completion
, make_number (0),
2158 make_number (buffer_nchars
),
2159 completion_ignore_case
? Qt
: Qnil
);
2166 del_range (start_pos
, start_pos
+ buffer_nchars
);
2170 #endif /* Rewritten code */
2173 int prompt_end_bytepos
;
2174 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2175 i
= PT
- prompt_end_charpos
;
2176 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2179 /* If completion finds next char not unique,
2180 consider adding a space or a hyphen. */
2181 if (i
== SCHARS (completion
))
2183 GCPRO1 (completion
);
2184 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2185 build_string (" ")),
2186 Vminibuffer_completion_table
,
2187 Vminibuffer_completion_predicate
);
2194 GCPRO1 (completion
);
2196 Ftry_completion (concat2 (minibuffer_completion_contents (),
2197 build_string ("-")),
2198 Vminibuffer_completion_table
,
2199 Vminibuffer_completion_predicate
);
2207 /* Now find first word-break in the stuff found by completion.
2208 i gets index in string of where to stop completing. */
2211 int bytes
= SBYTES (completion
);
2212 completion_string
= SDATA (completion
);
2213 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2215 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2218 if (SYNTAX (c
) != Sword
)
2227 /* If got no characters, print help for user. */
2229 if (i
== PT
- prompt_end_charpos
)
2231 if (!NILP (Vcompletion_auto_help
))
2232 Fminibuffer_completion_help ();
2236 /* Otherwise insert in minibuffer the chars we got */
2238 if (! NILP (Vminibuffer_completing_file_name
)
2239 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2241 && FETCH_CHAR (PT_BYTE
) == '/')
2243 del_range (prompt_end_charpos
, PT
+ 1);
2246 del_range (prompt_end_charpos
, PT
);
2248 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2252 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2254 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2255 Each element may be just a symbol or string
2256 or may be a list of two strings to be printed as if concatenated.
2257 If it is a list of two strings, the first is the actual completion
2258 alternative, the second serves as annotation.
2259 `standard-output' must be a buffer.
2260 The actual completion alternatives, as inserted, are given `mouse-face'
2261 properties of `highlight'.
2262 At the end, this runs the normal hook `completion-setup-hook'.
2263 It can find the completion buffer in `standard-output'. */)
2265 Lisp_Object completions
;
2267 Lisp_Object tail
, elt
;
2270 struct gcpro gcpro1
, gcpro2
;
2271 struct buffer
*old
= current_buffer
;
2274 /* Note that (when it matters) every variable
2275 points to a non-string that is pointed to by COMPLETIONS,
2276 except for ELT. ELT can be pointing to a string
2277 when terpri or Findent_to calls a change hook. */
2279 GCPRO2 (completions
, elt
);
2281 if (BUFFERP (Vstandard_output
))
2282 set_buffer_internal (XBUFFER (Vstandard_output
));
2284 if (NILP (completions
))
2285 write_string ("There are no possible completions of what you have typed.",
2289 write_string ("Possible completions are:", -1);
2290 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2292 Lisp_Object tem
, string
;
2294 Lisp_Object startpos
, endpos
;
2300 elt
= SYMBOL_NAME (elt
);
2301 /* Compute the length of this element. */
2306 length
= SCHARS (tem
);
2308 tem
= Fcar (XCDR (elt
));
2310 length
+= SCHARS (tem
);
2315 length
= SCHARS (elt
);
2318 /* This does a bad job for narrower than usual windows.
2319 Sadly, the window it will appear in is not known
2320 until after the text has been made. */
2322 if (BUFFERP (Vstandard_output
))
2323 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2325 /* If the previous completion was very wide,
2326 or we have two on this line already,
2327 don't put another on the same line. */
2328 if (column
> 33 || first
2329 /* If this is really wide, don't put it second on a line. */
2330 || (column
> 0 && length
> 45))
2335 /* Otherwise advance to column 35. */
2338 if (BUFFERP (Vstandard_output
))
2340 tem
= Findent_to (make_number (35), make_number (2));
2342 column
= XINT (tem
);
2348 write_string (" ", -1);
2351 while (column
< 35);
2355 if (BUFFERP (Vstandard_output
))
2357 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2358 Fset_text_properties (startpos
, endpos
,
2359 Qnil
, Vstandard_output
);
2362 /* Output this element.
2363 If necessary, convert it to unibyte or to multibyte first. */
2365 string
= Fcar (elt
);
2368 if (NILP (current_buffer
->enable_multibyte_characters
)
2369 && STRING_MULTIBYTE (string
))
2370 string
= Fstring_make_unibyte (string
);
2371 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2372 && !STRING_MULTIBYTE (string
))
2373 string
= Fstring_make_multibyte (string
);
2375 if (BUFFERP (Vstandard_output
))
2377 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2379 Fprinc (string
, Qnil
);
2381 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2383 Fput_text_property (startpos
, endpos
,
2384 Qmouse_face
, intern ("highlight"),
2389 Fprinc (string
, Qnil
);
2392 /* Output the annotation for this element. */
2395 if (BUFFERP (Vstandard_output
))
2397 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2399 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2401 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2403 Fset_text_properties (startpos
, endpos
, Qnil
,
2408 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2413 /* Update COLUMN for what we have output. */
2416 /* If output is to a buffer, recompute COLUMN in a way
2417 that takes account of character widths. */
2418 if (BUFFERP (Vstandard_output
))
2420 tem
= Fcurrent_column ();
2421 column
= XINT (tem
);
2430 if (BUFFERP (Vstandard_output
))
2431 set_buffer_internal (old
);
2433 if (!NILP (Vrun_hooks
))
2434 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2439 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2441 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2444 Lisp_Object completions
;
2446 message ("Making completion list...");
2447 completions
= Fall_completions (minibuffer_completion_contents (),
2448 Vminibuffer_completion_table
,
2449 Vminibuffer_completion_predicate
,
2451 clear_message (1, 0);
2453 if (NILP (completions
))
2456 temp_echo_area_glyphs (build_string (" [No completions]"));
2459 internal_with_output_to_temp_buffer ("*Completions*",
2460 Fdisplay_completion_list
,
2461 Fsort (completions
, Qstring_lessp
));
2465 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2466 doc
: /* Terminate minibuffer input. */)
2469 if (INTEGERP (last_command_char
))
2470 internal_self_insert (XINT (last_command_char
), 0);
2474 return Fthrow (Qexit
, Qnil
);
2477 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2478 doc
: /* Terminate this minibuffer argument. */)
2481 return Fthrow (Qexit
, Qnil
);
2484 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2485 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2488 return make_number (minibuf_level
);
2491 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2492 doc
: /* Return the prompt string of the currently-active minibuffer.
2493 If no minibuffer is active, return nil. */)
2496 return Fcopy_sequence (minibuf_prompt
);
2500 /* Temporarily display STRING at the end of the current
2501 minibuffer contents. This is used to display things like
2502 "[No Match]" when the user requests a completion for a prefix
2503 that has no possible completions, and other quick, unobtrusive
2507 temp_echo_area_glyphs (string
)
2511 int osize_byte
= ZV_BYTE
;
2513 int opoint_byte
= PT_BYTE
;
2514 Lisp_Object oinhibit
;
2515 oinhibit
= Vinhibit_quit
;
2517 /* Clear out any old echo-area message to make way for our new thing. */
2520 SET_PT_BOTH (osize
, osize_byte
);
2521 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2522 SET_PT_BOTH (opoint
, opoint_byte
);
2524 Fsit_for (make_number (2), Qnil
, Qnil
);
2525 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2526 SET_PT_BOTH (opoint
, opoint_byte
);
2527 if (!NILP (Vquit_flag
))
2530 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2532 Vinhibit_quit
= oinhibit
;
2535 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2537 doc
: /* Temporarily display STRING at the end of the minibuffer.
2538 The text is displayed for two seconds,
2539 or until the next input event arrives, whichever comes first. */)
2543 CHECK_STRING (string
);
2544 temp_echo_area_glyphs (string
);
2549 init_minibuf_once ()
2551 Vminibuffer_list
= Qnil
;
2552 staticpro (&Vminibuffer_list
);
2559 minibuf_prompt
= Qnil
;
2560 staticpro (&minibuf_prompt
);
2562 minibuf_save_list
= Qnil
;
2563 staticpro (&minibuf_save_list
);
2565 Qread_file_name_internal
= intern ("read-file-name-internal");
2566 staticpro (&Qread_file_name_internal
);
2568 Qminibuffer_default
= intern ("minibuffer-default");
2569 staticpro (&Qminibuffer_default
);
2570 Fset (Qminibuffer_default
, Qnil
);
2572 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2573 staticpro (&Qminibuffer_completion_table
);
2575 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2576 staticpro (&Qminibuffer_completion_confirm
);
2578 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2579 staticpro (&Qminibuffer_completion_predicate
);
2581 staticpro (&last_exact_completion
);
2582 last_exact_completion
= Qnil
;
2584 staticpro (&last_minibuf_string
);
2585 last_minibuf_string
= Qnil
;
2587 Quser_variable_p
= intern ("user-variable-p");
2588 staticpro (&Quser_variable_p
);
2590 Qminibuffer_history
= intern ("minibuffer-history");
2591 staticpro (&Qminibuffer_history
);
2593 Qbuffer_name_history
= intern ("buffer-name-history");
2594 staticpro (&Qbuffer_name_history
);
2595 Fset (Qbuffer_name_history
, Qnil
);
2597 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2598 staticpro (&Qminibuffer_setup_hook
);
2600 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2601 staticpro (&Qminibuffer_exit_hook
);
2603 Qhistory_length
= intern ("history-length");
2604 staticpro (&Qhistory_length
);
2606 Qcurrent_input_method
= intern ("current-input-method");
2607 staticpro (&Qcurrent_input_method
);
2609 Qactivate_input_method
= intern ("activate-input-method");
2610 staticpro (&Qactivate_input_method
);
2612 Qcase_fold_search
= intern ("case-fold-search");
2613 staticpro (&Qcase_fold_search
);
2615 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2616 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2617 Vread_buffer_function
= Qnil
;
2619 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2620 doc
: /* Normal hook run just after entry to minibuffer. */);
2621 Vminibuffer_setup_hook
= Qnil
;
2623 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2624 doc
: /* Normal hook run just after exit from minibuffer. */);
2625 Vminibuffer_exit_hook
= Qnil
;
2627 DEFVAR_LISP ("history-length", &Vhistory_length
,
2628 doc
: /* *Maximum length for history lists before truncation takes place.
2629 A number means that length; t means infinite. Truncation takes place
2630 just after a new element is inserted. Setting the history-length
2631 property of a history variable overrides this default. */);
2632 XSETFASTINT (Vhistory_length
, 30);
2634 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2635 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2636 Vcompletion_auto_help
= Qt
;
2638 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2639 doc
: /* Non-nil means don't consider case significant in completion. */);
2640 completion_ignore_case
= 0;
2642 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2643 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2644 This variable makes a difference whenever the minibuffer window is active. */);
2645 enable_recursive_minibuffers
= 0;
2647 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2648 doc
: /* Alist or obarray used for completion in the minibuffer.
2649 This becomes the ALIST argument to `try-completion' and `all-completions'.
2650 The value can also be a list of strings or a hash table.
2652 The value may alternatively be a function, which is given three arguments:
2653 STRING, the current buffer contents;
2654 PREDICATE, the predicate for filtering possible matches;
2655 CODE, which says what kind of things to do.
2656 CODE can be nil, t or `lambda'.
2657 nil means to return the best completion of STRING, or nil if there is none.
2658 t means to return a list of all possible completions of STRING.
2659 `lambda' means to return t if STRING is a valid completion as it stands. */);
2660 Vminibuffer_completion_table
= Qnil
;
2662 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2663 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2664 Vminibuffer_completion_predicate
= Qnil
;
2666 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2667 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2668 Vminibuffer_completion_confirm
= Qnil
;
2670 DEFVAR_LISP ("minibuffer-completing-file-name",
2671 &Vminibuffer_completing_file_name
,
2672 doc
: /* Non-nil means completing file names. */);
2673 Vminibuffer_completing_file_name
= Qnil
;
2675 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2676 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2677 Vminibuffer_help_form
= Qnil
;
2679 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2680 doc
: /* History list symbol to add minibuffer values to.
2681 Each string of minibuffer input, as it appears on exit from the minibuffer,
2683 (set minibuffer-history-variable
2684 (cons STRING (symbol-value minibuffer-history-variable))) */);
2685 XSETFASTINT (Vminibuffer_history_variable
, 0);
2687 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2688 doc
: /* Current position of redoing in the history list. */);
2689 Vminibuffer_history_position
= Qnil
;
2691 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2692 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2693 Some uses of the echo area also raise that frame (since they use it too). */);
2694 minibuffer_auto_raise
= 0;
2696 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2697 doc
: /* List of regexps that should restrict possible completions.
2698 The basic completion functions only consider a completion acceptable
2699 if it matches all regular expressions in this list, with
2700 `case-fold-search' bound to the value of `completion-ignore-case'.
2701 See Info node `(elisp)Basic Completion', for a description of these
2703 Vcompletion_regexp_list
= Qnil
;
2705 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2706 &minibuffer_allow_text_properties
,
2707 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2708 This also affects `read-string', but it does not affect `read-minibuffer',
2709 `read-no-blanks-input', or any of the functions that do minibuffer input
2710 with completion; they always discard text properties. */);
2711 minibuffer_allow_text_properties
= 0;
2713 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2714 doc
: /* Text properties that are added to minibuffer prompts.
2715 These are in addition to the basic `field' property, and stickiness
2717 /* We use `intern' here instead of Qread_only to avoid
2718 initialization-order problems. */
2719 Vminibuffer_prompt_properties
2720 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2722 defsubr (&Sset_minibuffer_window
);
2723 defsubr (&Sread_from_minibuffer
);
2724 defsubr (&Seval_minibuffer
);
2725 defsubr (&Sread_minibuffer
);
2726 defsubr (&Sread_string
);
2727 defsubr (&Sread_command
);
2728 defsubr (&Sread_variable
);
2729 defsubr (&Sread_buffer
);
2730 defsubr (&Sread_no_blanks_input
);
2731 defsubr (&Sminibuffer_depth
);
2732 defsubr (&Sminibuffer_prompt
);
2734 defsubr (&Sminibufferp
);
2735 defsubr (&Sminibuffer_prompt_end
);
2736 defsubr (&Sminibuffer_contents
);
2737 defsubr (&Sminibuffer_contents_no_properties
);
2738 defsubr (&Sdelete_minibuffer_contents
);
2740 defsubr (&Stry_completion
);
2741 defsubr (&Sall_completions
);
2742 defsubr (&Stest_completion
);
2743 defsubr (&Sassoc_string
);
2744 defsubr (&Scompleting_read
);
2745 defsubr (&Sminibuffer_complete
);
2746 defsubr (&Sminibuffer_complete_word
);
2747 defsubr (&Sminibuffer_complete_and_exit
);
2748 defsubr (&Sdisplay_completion_list
);
2749 defsubr (&Sminibuffer_completion_help
);
2751 defsubr (&Sself_insert_and_exit
);
2752 defsubr (&Sexit_minibuffer
);
2754 defsubr (&Sminibuffer_message
);
2760 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2761 "abort-recursive-edit");
2762 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2764 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2767 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2769 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2771 initial_define_key (Vminibuffer_local_ns_map
, '?',
2772 "self-insert-and-exit");
2774 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2775 "minibuffer-complete");
2776 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2777 "minibuffer-complete-word");
2778 initial_define_key (Vminibuffer_local_completion_map
, '?',
2779 "minibuffer-completion-help");
2781 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2782 "minibuffer-complete-and-exit");
2783 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2784 "minibuffer-complete-and-exit");
2787 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2788 (do not change this comment) */