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"
37 #include "termhooks.h"
41 /* List of buffers for use as minibuffers.
42 The first element of the list is used for the outermost minibuffer
43 invocation, the next element is used for a recursive minibuffer
44 invocation, etc. The list is extended at the end as deeper
45 minibuffer recursions are encountered. */
47 Lisp_Object Vminibuffer_list
;
49 /* Data to remember during recursive minibuffer invocations */
51 Lisp_Object minibuf_save_list
;
53 /* Depth in minibuffer invocations. */
57 /* Nonzero means display completion help for invalid input. */
59 Lisp_Object Vcompletion_auto_help
;
61 /* The maximum length of a minibuffer history. */
63 Lisp_Object Qhistory_length
, Vhistory_length
;
65 /* No duplicates in history. */
67 int history_delete_duplicates
;
69 /* Fread_minibuffer leaves the input here as a string. */
71 Lisp_Object last_minibuf_string
;
73 /* Nonzero means let functions called when within a minibuffer
74 invoke recursive minibuffers (to read arguments, or whatever) */
76 int enable_recursive_minibuffers
;
78 /* Nonzero means don't ignore text properties
79 in Fread_from_minibuffer. */
81 int minibuffer_allow_text_properties
;
83 /* help-form is bound to this while in the minibuffer. */
85 Lisp_Object Vminibuffer_help_form
;
87 /* Variable which is the history list to add minibuffer values to. */
89 Lisp_Object Vminibuffer_history_variable
;
91 /* Current position in the history list (adjusted by M-n and M-p). */
93 Lisp_Object Vminibuffer_history_position
;
95 /* Text properties that are added to minibuffer prompts.
96 These are in addition to the basic `field' property, and stickiness
99 Lisp_Object Vminibuffer_prompt_properties
;
101 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
103 Lisp_Object Qread_file_name_internal
;
105 /* Normal hooks for entry to and exit from minibuffer. */
107 Lisp_Object Qminibuffer_setup_hook
, Vminibuffer_setup_hook
;
108 Lisp_Object Qminibuffer_exit_hook
, Vminibuffer_exit_hook
;
110 /* Function to call to read a buffer name. */
111 Lisp_Object Vread_buffer_function
;
113 /* Nonzero means completion ignores case. */
115 int completion_ignore_case
;
117 /* List of regexps that should restrict possible completions. */
119 Lisp_Object Vcompletion_regexp_list
;
121 /* Nonzero means raise the minibuffer frame when the minibuffer
124 int minibuffer_auto_raise
;
126 /* If last completion attempt reported "Complete but not unique"
127 then this is the string completed then; otherwise this is nil. */
129 static Lisp_Object last_exact_completion
;
131 extern Lisp_Object Voverriding_local_map
;
133 Lisp_Object Quser_variable_p
;
135 Lisp_Object Qminibuffer_default
;
137 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
139 Lisp_Object Qcase_fold_search
;
141 extern Lisp_Object Qmouse_face
;
143 extern Lisp_Object Qfield
;
145 /* Put minibuf on currently selected frame's minibuffer.
146 We do this whenever the user starts a new minibuffer
147 or when a minibuffer exits. */
150 choose_minibuf_frame ()
152 if (FRAMEP (selected_frame
)
153 && FRAME_LIVE_P (XFRAME (selected_frame
))
154 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
156 struct frame
*sf
= XFRAME (selected_frame
);
159 /* I don't think that any frames may validly have a null minibuffer
161 if (NILP (sf
->minibuffer_window
))
164 /* Under X, we come here with minibuf_window being the
165 minibuffer window of the unused termcap window created in
166 init_window_once. That window doesn't have a buffer. */
167 buffer
= XWINDOW (minibuf_window
)->buffer
;
168 if (BUFFERP (buffer
))
169 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
170 minibuf_window
= sf
->minibuffer_window
;
173 /* Make sure no other frame has a minibuffer as its selected window,
174 because the text would not be displayed in it, and that would be
175 confusing. Only allow the selected frame to do this,
176 and that only if the minibuffer is active. */
178 Lisp_Object tail
, frame
;
180 FOR_EACH_FRAME (tail
, frame
)
181 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
182 && !(EQ (frame
, selected_frame
)
183 && minibuf_level
> 0))
184 Fset_frame_selected_window (frame
, Fframe_first_window (frame
));
189 choose_minibuf_frame_1 (ignore
)
192 choose_minibuf_frame ();
196 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
197 Sset_minibuffer_window
, 1, 1, 0,
198 doc
: /* Specify which minibuffer window to use for the minibuffer.
199 This affects where the minibuffer is displayed if you put text in it
200 without invoking the usual minibuffer commands. */)
204 CHECK_WINDOW (window
);
205 if (! MINI_WINDOW_P (XWINDOW (window
)))
206 error ("Window is not a minibuffer window");
208 minibuf_window
= window
;
214 /* Actual minibuffer invocation. */
216 static Lisp_Object read_minibuf_unwind
P_ ((Lisp_Object
));
217 static Lisp_Object run_exit_minibuf_hook
P_ ((Lisp_Object
));
218 static Lisp_Object read_minibuf
P_ ((Lisp_Object
, Lisp_Object
,
219 Lisp_Object
, Lisp_Object
,
221 Lisp_Object
, Lisp_Object
,
223 static Lisp_Object read_minibuf_noninteractive
P_ ((Lisp_Object
, Lisp_Object
,
224 Lisp_Object
, Lisp_Object
,
226 Lisp_Object
, Lisp_Object
,
228 static Lisp_Object string_to_object
P_ ((Lisp_Object
, Lisp_Object
));
231 /* Read a Lisp object from VAL and return it. If VAL is an empty
232 string, and DEFALT is a string, read from DEFALT instead of VAL. */
235 string_to_object (val
, defalt
)
236 Lisp_Object val
, defalt
;
238 struct gcpro gcpro1
, gcpro2
;
239 Lisp_Object expr_and_pos
;
242 GCPRO2 (val
, defalt
);
244 if (STRINGP (val
) && SCHARS (val
) == 0
248 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
249 pos
= XINT (Fcdr (expr_and_pos
));
250 if (pos
!= SCHARS (val
))
252 /* Ignore trailing whitespace; any other trailing junk
255 pos
= string_char_to_byte (val
, pos
);
256 for (i
= pos
; i
< SBYTES (val
); i
++)
258 int c
= SREF (val
, i
);
259 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
260 error ("Trailing garbage following expression");
264 val
= Fcar (expr_and_pos
);
265 RETURN_UNGCPRO (val
);
269 /* Like read_minibuf but reading from stdin. This function is called
270 from read_minibuf to do the job if noninteractive. */
273 read_minibuf_noninteractive (map
, initial
, prompt
, backup_n
, expflag
,
274 histvar
, histpos
, defalt
, allow_props
,
275 inherit_input_method
)
279 Lisp_Object backup_n
;
285 int inherit_input_method
;
291 fprintf (stdout
, "%s", SDATA (prompt
));
297 line
= (char *) xmalloc (size
* sizeof *line
);
298 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
299 && (len
= strlen (line
),
300 len
== size
- 1 && line
[len
- 1] != '\n'))
303 line
= (char *) xrealloc (line
, size
);
310 if (len
> 0 && line
[len
- 1] == '\n')
313 val
= build_string (line
);
319 error ("Error reading from stdin");
322 /* If Lisp form desired instead of string, parse it. */
324 val
= string_to_object (val
, defalt
);
329 DEFUN ("minibufferp", Fminibufferp
,
330 Sminibufferp
, 0, 1, 0,
331 doc
: /* Return t if BUFFER is a minibuffer.
332 No argument or nil as argument means use current buffer as BUFFER.
333 BUFFER can be a buffer or a buffer name. */)
340 buffer
= Fcurrent_buffer ();
341 else if (STRINGP (buffer
))
342 buffer
= Fget_buffer (buffer
);
344 CHECK_BUFFER (buffer
);
346 tem
= Fmemq (buffer
, Vminibuffer_list
);
347 return ! NILP (tem
) ? Qt
: Qnil
;
350 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
351 Sminibuffer_prompt_end
, 0, 0, 0,
352 doc
: /* Return the buffer position of the end of the minibuffer prompt.
353 Return (point-min) if current buffer is not a mini-buffer. */)
356 /* This function is written to be most efficient when there's a prompt. */
357 Lisp_Object beg
, end
, tem
;
358 beg
= make_number (BEGV
);
360 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
364 end
= Ffield_end (beg
, Qnil
, Qnil
);
366 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
372 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
373 Sminibuffer_contents
, 0, 0, 0,
374 doc
: /* Return the user input in a minibuffer as a string.
375 The current buffer must be a minibuffer. */)
378 int prompt_end
= XINT (Fminibuffer_prompt_end ());
379 return make_buffer_string (prompt_end
, ZV
, 1);
382 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
383 Sminibuffer_contents_no_properties
, 0, 0, 0,
384 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
385 The current buffer must be a minibuffer. */)
388 int prompt_end
= XINT (Fminibuffer_prompt_end ());
389 return make_buffer_string (prompt_end
, ZV
, 0);
392 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
393 Sdelete_minibuffer_contents
, 0, 0, 0,
394 doc
: /* Delete all user input in a minibuffer.
395 The current buffer must be a minibuffer. */)
398 int prompt_end
= XINT (Fminibuffer_prompt_end ());
400 del_range (prompt_end
, ZV
);
404 /* Get the text in the minibuffer before point.
405 That is what completion commands operate on. */
408 minibuffer_completion_contents ()
410 int prompt_end
= XINT (Fminibuffer_prompt_end ());
412 error ("Cannot do completion in the prompt");
413 return make_buffer_string (prompt_end
, PT
, 1);
416 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
417 putting point minus BACKUP_N bytes from the end of INITIAL,
418 prompting with PROMPT (a string), using history list HISTVAR
419 with initial position HISTPOS. INITIAL should be a string or a
420 cons of a string and an integer. BACKUP_N should be <= 0, or
421 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
422 ignored and replaced with an integer that puts point at one-indexed
423 position N in INITIAL, where N is the CDR of INITIAL, or at the
424 beginning of INITIAL if N <= 0.
426 Normally return the result as a string (the text that was read),
427 but if EXPFLAG is nonzero, read it and return the object read.
428 If HISTVAR is given, save the value read on that history only if it doesn't
429 match the front of that history list exactly. The value is pushed onto
430 the list as the string that was read.
432 DEFALT specifies the default value for the sake of history commands.
434 If ALLOW_PROPS is nonzero, we do not throw away text properties.
436 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
437 current input method. */
440 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
441 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
)
445 Lisp_Object backup_n
;
451 int inherit_input_method
;
454 int count
= SPECPDL_INDEX ();
455 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
456 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
457 Lisp_Object enable_multibyte
;
458 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
460 /* String to add to the history. */
461 Lisp_Object histstring
;
463 extern Lisp_Object Qfront_sticky
;
464 extern Lisp_Object Qrear_nonsticky
;
466 specbind (Qminibuffer_default
, defalt
);
468 single_kboard_state ();
469 #ifdef HAVE_X_WINDOWS
470 if (display_hourglass_p
)
478 backup_n
= Fcdr (initial
);
479 initial
= Fcar (initial
);
480 CHECK_STRING (initial
);
481 if (!NILP (backup_n
))
483 CHECK_NUMBER (backup_n
);
484 /* Convert to distance from end of input. */
485 if (XINT (backup_n
) < 1)
486 /* A number too small means the beginning of the string. */
487 pos
= - SCHARS (initial
);
489 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
493 CHECK_STRING (initial
);
496 ambient_dir
= current_buffer
->directory
;
498 enable_multibyte
= Qnil
;
500 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
501 store them away before we can GC. Don't need to protect
502 BACKUP_N because we use the value only if it is an integer. */
503 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
505 if (!STRINGP (prompt
))
506 prompt
= empty_string
;
508 if (!enable_recursive_minibuffers
509 && minibuf_level
> 0)
511 if (EQ (selected_window
, minibuf_window
))
512 error ("Command attempted to use minibuffer while in minibuffer");
514 /* If we're in another window, cancel the minibuffer that's active. */
516 build_string ("Command attempted to use minibuffer while in minibuffer"));
521 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
523 expflag
, histvar
, histpos
, defalt
,
524 allow_props
, inherit_input_method
);
526 return unbind_to (count
, val
);
529 /* Choose the minibuffer window and frame, and take action on them. */
531 choose_minibuf_frame ();
533 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
535 record_unwind_protect (Fset_window_configuration
,
536 Fcurrent_window_configuration (Qnil
));
538 /* If the minibuffer window is on a different frame, save that
539 frame's configuration too. */
540 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
541 if (!EQ (mini_frame
, selected_frame
))
542 record_unwind_protect (Fset_window_configuration
,
543 Fcurrent_window_configuration (mini_frame
));
545 /* If the minibuffer is on an iconified or invisible frame,
546 make it visible now. */
547 Fmake_frame_visible (mini_frame
);
549 if (minibuffer_auto_raise
)
550 Fraise_frame (mini_frame
);
552 /* We have to do this after saving the window configuration
553 since that is what restores the current buffer. */
555 /* Arrange to restore a number of minibuffer-related variables.
556 We could bind each variable separately, but that would use lots of
559 = Fcons (Voverriding_local_map
,
560 Fcons (minibuf_window
, minibuf_save_list
));
562 = Fcons (minibuf_prompt
,
563 Fcons (make_number (minibuf_prompt_width
),
565 Fcons (Vcurrent_prefix_arg
,
566 Fcons (Vminibuffer_history_position
,
567 Fcons (Vminibuffer_history_variable
,
568 minibuf_save_list
))))));
570 record_unwind_protect (read_minibuf_unwind
, Qnil
);
572 /* We are exiting the minibuffer one way or the other, so run the hook.
573 It should be run before unwinding the minibuf settings. Do it
574 separately from read_minibuf_unwind because we need to make sure that
575 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
576 signals an error. --Stef */
577 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
579 /* Now that we can restore all those variables, start changing them. */
581 minibuf_prompt_width
= 0;
582 minibuf_prompt
= Fcopy_sequence (prompt
);
583 Vminibuffer_history_position
= histpos
;
584 Vminibuffer_history_variable
= histvar
;
585 Vhelp_form
= Vminibuffer_help_form
;
587 if (inherit_input_method
)
589 /* `current-input-method' is buffer local. So, remember it in
590 INPUT_METHOD before changing the current buffer. */
591 input_method
= Fsymbol_value (Qcurrent_input_method
);
592 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
595 /* Switch to the minibuffer. */
597 minibuffer
= get_minibuffer (minibuf_level
);
598 Fset_buffer (minibuffer
);
600 /* The current buffer's default directory is usually the right thing
601 for our minibuffer here. However, if you're typing a command at
602 a minibuffer-only frame when minibuf_level is zero, then buf IS
603 the current_buffer, so reset_buffer leaves buf's default
604 directory unchanged. This is a bummer when you've just started
605 up Emacs and buf's default directory is Qnil. Here's a hack; can
606 you think of something better to do? Find another buffer with a
607 better directory, and use that one instead. */
608 if (STRINGP (ambient_dir
))
609 current_buffer
->directory
= ambient_dir
;
612 Lisp_Object buf_list
;
614 for (buf_list
= Vbuffer_alist
;
616 buf_list
= XCDR (buf_list
))
618 Lisp_Object other_buf
;
620 other_buf
= XCDR (XCAR (buf_list
));
621 if (STRINGP (XBUFFER (other_buf
)->directory
))
623 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
629 if (!EQ (mini_frame
, selected_frame
))
630 Fredirect_frame_focus (selected_frame
, mini_frame
);
632 Vminibuf_scroll_window
= selected_window
;
633 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
634 minibuf_selected_window
= selected_window
;
635 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
636 Fselect_window (minibuf_window
, Qnil
);
637 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
639 Fmake_local_variable (Qprint_escape_newlines
);
640 print_escape_newlines
= 1;
642 /* Erase the buffer. */
644 int count1
= SPECPDL_INDEX ();
645 specbind (Qinhibit_read_only
, Qt
);
646 specbind (Qinhibit_modification_hooks
, Qt
);
648 unbind_to (count1
, Qnil
);
651 if (!NILP (current_buffer
->enable_multibyte_characters
)
652 && ! STRING_MULTIBYTE (minibuf_prompt
))
653 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
655 /* Insert the prompt, record where it ends. */
656 Finsert (1, &minibuf_prompt
);
659 Fput_text_property (make_number (BEG
), make_number (PT
),
660 Qfront_sticky
, Qt
, Qnil
);
661 Fput_text_property (make_number (BEG
), make_number (PT
),
662 Qrear_nonsticky
, Qt
, Qnil
);
663 Fput_text_property (make_number (BEG
), make_number (PT
),
665 Fadd_text_properties (make_number (BEG
), make_number (PT
),
666 Vminibuffer_prompt_properties
, Qnil
);
669 minibuf_prompt_width
= (int) current_column (); /* iftc */
671 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
672 if (inherit_input_method
)
673 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
675 /* Put in the initial input. */
678 Finsert (1, &initial
);
679 Fforward_char (make_number (pos
));
682 clear_message (1, 1);
683 current_buffer
->keymap
= map
;
685 /* Turn on an input method stored in INPUT_METHOD if any. */
686 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
687 call1 (Qactivate_input_method
, input_method
);
689 /* Run our hook, but not if it is empty.
690 (run-hooks would do nothing if it is empty,
691 but it's important to save time here in the usual case.) */
692 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
693 && !NILP (Vrun_hooks
))
694 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
696 /* Don't allow the user to undo past this point. */
697 current_buffer
->undo_list
= Qnil
;
701 /* If cursor is on the minibuffer line,
702 show the user we have exited by putting it in column 0. */
703 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
706 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
707 XWINDOW (minibuf_window
)->cursor
.x
= 0;
708 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
709 update_frame (XFRAME (selected_frame
), 1, 1);
711 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
712 struct redisplay_interface
*rif
= FRAME_RIF (f
);
713 if (rif
&& rif
->flush_display
)
714 rif
->flush_display (f
);
718 /* Make minibuffer contents into a string. */
719 Fset_buffer (minibuffer
);
721 val
= Fminibuffer_contents ();
723 val
= Fminibuffer_contents_no_properties ();
725 /* VAL is the string of minibuffer text. */
727 last_minibuf_string
= val
;
729 /* Choose the string to add to the history. */
730 if (SCHARS (val
) != 0)
732 else if (STRINGP (defalt
))
737 /* Add the value to the appropriate history list, if any. */
738 if (SYMBOLP (Vminibuffer_history_variable
)
739 && !NILP (histstring
))
741 /* If the caller wanted to save the value read on a history list,
742 then do so if the value is not already the front of the list. */
745 /* If variable is unbound, make it nil. */
746 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
747 Fset (Vminibuffer_history_variable
, Qnil
);
749 histval
= Fsymbol_value (Vminibuffer_history_variable
);
751 /* The value of the history variable must be a cons or nil. Other
752 values are unacceptable. We silently ignore these values. */
756 /* Don't duplicate the most recent entry in the history. */
757 && NILP (Fequal (histstring
, Fcar (histval
)))))
761 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
762 histval
= Fcons (histstring
, histval
);
763 Fset (Vminibuffer_history_variable
, histval
);
765 /* Truncate if requested. */
766 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
767 if (NILP (length
)) length
= Vhistory_length
;
768 if (INTEGERP (length
))
770 if (XINT (length
) <= 0)
771 Fset (Vminibuffer_history_variable
, Qnil
);
776 temp
= Fnthcdr (Fsub1 (length
), histval
);
777 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
783 /* If Lisp form desired instead of string, parse it. */
785 val
= string_to_object (val
, defalt
);
787 /* The appropriate frame will get selected
788 in set-window-configuration. */
790 return unbind_to (count
, val
);
793 /* Return a buffer to be used as the minibuffer at depth `depth'.
794 depth = 0 is the lowest allowed argument, and that is the value
795 used for nonrecursive minibuffer invocations */
798 get_minibuffer (depth
)
801 Lisp_Object tail
, num
, buf
;
803 extern Lisp_Object
nconc2 ();
805 XSETFASTINT (num
, depth
);
806 tail
= Fnthcdr (num
, Vminibuffer_list
);
809 tail
= Fcons (Qnil
, Qnil
);
810 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
813 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
815 sprintf (name
, " *Minibuf-%d*", depth
);
816 buf
= Fget_buffer_create (build_string (name
));
818 /* Although the buffer's name starts with a space, undo should be
820 Fbuffer_enable_undo (buf
);
826 int count
= SPECPDL_INDEX ();
827 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
828 have to empty the list, otherwise we end up with overlays that
829 think they belong to this buffer while the buffer doesn't know about
831 delete_all_overlays (XBUFFER (buf
));
832 reset_buffer (XBUFFER (buf
));
833 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
835 Fkill_all_local_variables ();
836 unbind_to (count
, Qnil
);
843 run_exit_minibuf_hook (data
)
846 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
847 && !NILP (Vrun_hooks
))
848 safe_run_hooks (Qminibuffer_exit_hook
);
853 /* This function is called on exiting minibuffer, whether normally or
854 not, and it restores the current window, buffer, etc. */
857 read_minibuf_unwind (data
)
860 Lisp_Object old_deactivate_mark
;
863 /* If this was a recursive minibuffer,
864 tie the minibuffer window back to the outer level minibuffer buffer. */
867 window
= minibuf_window
;
868 /* To keep things predictable, in case it matters, let's be in the
869 minibuffer when we reset the relevant variables. */
870 Fset_buffer (XWINDOW (window
)->buffer
);
872 /* Restore prompt, etc, from outer minibuffer level. */
873 minibuf_prompt
= Fcar (minibuf_save_list
);
874 minibuf_save_list
= Fcdr (minibuf_save_list
);
875 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
876 minibuf_save_list
= Fcdr (minibuf_save_list
);
877 Vhelp_form
= Fcar (minibuf_save_list
);
878 minibuf_save_list
= Fcdr (minibuf_save_list
);
879 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
880 minibuf_save_list
= Fcdr (minibuf_save_list
);
881 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
882 minibuf_save_list
= Fcdr (minibuf_save_list
);
883 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
884 minibuf_save_list
= Fcdr (minibuf_save_list
);
885 Voverriding_local_map
= Fcar (minibuf_save_list
);
886 minibuf_save_list
= Fcdr (minibuf_save_list
);
888 temp
= Fcar (minibuf_save_list
);
889 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
890 minibuf_window
= temp
;
892 minibuf_save_list
= Fcdr (minibuf_save_list
);
894 /* Erase the minibuffer we were using at this level. */
896 int count
= SPECPDL_INDEX ();
897 /* Prevent error in erase-buffer. */
898 specbind (Qinhibit_read_only
, Qt
);
899 specbind (Qinhibit_modification_hooks
, Qt
);
900 old_deactivate_mark
= Vdeactivate_mark
;
902 Vdeactivate_mark
= old_deactivate_mark
;
903 unbind_to (count
, Qnil
);
906 /* When we get to the outmost level, make sure we resize the
907 mini-window back to its normal size. */
908 if (minibuf_level
== 0)
909 resize_mini_window (XWINDOW (window
), 0);
911 /* Make sure minibuffer window is erased, not ignored. */
912 windows_or_buffers_changed
++;
913 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
914 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
919 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
920 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
921 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
922 DEFAULT-VALUE. It normally should be nil in new code, except when
923 HIST is a cons. It is discussed in more detail below.
924 Third arg KEYMAP is a keymap to use whilst reading;
925 if omitted or nil, the default is `minibuffer-local-map'.
926 If fourth arg READ is non-nil, then interpret the result as a Lisp object
927 and return that object:
928 in other words, do `(car (read-from-string INPUT-STRING))'
929 Fifth arg HIST, if non-nil, specifies a history list and optionally
930 the initial position in the list. It can be a symbol, which is the
931 history list variable to use, or it can be a cons cell
932 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
933 to use, and HISTPOS is the initial position for use by the minibuffer
934 history commands. For consistency, you should also specify that
935 element of the history as the value of INITIAL-CONTENTS. Positions
936 are counted starting from 1 at the beginning of the list.
937 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
938 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
939 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
941 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
942 the current input method and the setting of `enable-multibyte-characters'.
943 If the variable `minibuffer-allow-text-properties' is non-nil,
944 then the string which is returned includes whatever text properties
945 were present in the minibuffer. Otherwise the value has no text properties.
947 The remainder of this documentation string describes the
948 INITIAL-CONTENTS argument in more detail. It is only relevant when
949 studying existing code, or when HIST is a cons. If non-nil,
950 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
951 reading input. Normally, point is put at the end of that string.
952 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
953 input is STRING, but point is placed at _one-indexed_ position
954 POSITION in the minibuffer. Any integer value less than or equal to
955 one puts point at the beginning of the string. *Note* that this
956 behavior differs from the way such arguments are used in `completing-read'
957 and some related functions, which use zero-indexing for POSITION. */)
958 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
)
959 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
960 Lisp_Object inherit_input_method
;
962 Lisp_Object histvar
, histpos
, val
;
965 CHECK_STRING (prompt
);
967 keymap
= Vminibuffer_local_map
;
969 keymap
= get_keymap (keymap
, 1, 0);
978 histvar
= Fcar_safe (hist
);
979 histpos
= Fcdr_safe (hist
);
982 histvar
= Qminibuffer_history
;
984 XSETFASTINT (histpos
, 0);
986 GCPRO1 (default_value
);
987 val
= read_minibuf (keymap
, initial_contents
, prompt
,
989 histvar
, histpos
, default_value
,
990 minibuffer_allow_text_properties
,
991 !NILP (inherit_input_method
));
996 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
997 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
998 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
999 is a string to insert in the minibuffer before reading.
1000 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1001 arguments are used as in `read-from-minibuffer') */)
1002 (prompt
, initial_contents
)
1003 Lisp_Object prompt
, initial_contents
;
1005 CHECK_STRING (prompt
);
1006 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1007 prompt
, Qnil
, 1, Qminibuffer_history
,
1008 make_number (0), Qnil
, 0, 0);
1011 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1012 doc
: /* Return value of Lisp expression read using the minibuffer.
1013 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1014 is a string to insert in the minibuffer before reading.
1015 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1016 arguments are used as in `read-from-minibuffer') */)
1017 (prompt
, initial_contents
)
1018 Lisp_Object prompt
, initial_contents
;
1020 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1023 /* Functions that use the minibuffer to read various things. */
1025 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1026 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1027 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1028 This argument has been superseded by DEFAULT-VALUE and should normally
1029 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1030 documentation string of that function for details.
1031 The third arg HISTORY, if non-nil, specifies a history list
1032 and optionally the initial position in the list.
1033 See `read-from-minibuffer' for details of HISTORY argument.
1034 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1035 for history commands, and as the value to return if the user enters
1037 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1038 the current input method and the setting of `enable-multibyte-characters'. */)
1039 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1040 Lisp_Object prompt
, initial_input
, history
, default_value
;
1041 Lisp_Object inherit_input_method
;
1044 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1045 Qnil
, history
, default_value
,
1046 inherit_input_method
);
1047 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1048 val
= default_value
;
1052 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1053 doc
: /* Read a string from the terminal, not allowing blanks.
1054 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1055 non-nil, it should be a string, which is used as initial input, with
1056 point positioned at the end, so that SPACE will accept the input.
1057 \(Actually, INITIAL can also be a cons of a string and an integer.
1058 Such values are treated as in `read-from-minibuffer', but are normally
1059 not useful in this function.)
1060 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1061 the current input method and the setting of`enable-multibyte-characters'. */)
1062 (prompt
, initial
, inherit_input_method
)
1063 Lisp_Object prompt
, initial
, inherit_input_method
;
1065 CHECK_STRING (prompt
);
1066 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1067 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1068 !NILP (inherit_input_method
));
1071 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1072 doc
: /* Read the name of a command and return as a symbol.
1073 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1074 (prompt
, default_value
)
1075 Lisp_Object prompt
, default_value
;
1077 Lisp_Object name
, default_string
;
1079 if (NILP (default_value
))
1080 default_string
= Qnil
;
1081 else if (SYMBOLP (default_value
))
1082 default_string
= SYMBOL_NAME (default_value
);
1084 default_string
= default_value
;
1086 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1087 Qnil
, Qnil
, default_string
, Qnil
);
1090 return Fintern (name
, Qnil
);
1094 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1095 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1096 Prompt with PROMPT. */)
1100 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1105 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1106 doc
: /* Read the name of a user variable and return it as a symbol.
1107 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1108 A user variable is one for which `user-variable-p' returns non-nil. */)
1109 (prompt
, default_value
)
1110 Lisp_Object prompt
, default_value
;
1112 Lisp_Object name
, default_string
;
1114 if (NILP (default_value
))
1115 default_string
= Qnil
;
1116 else if (SYMBOLP (default_value
))
1117 default_string
= SYMBOL_NAME (default_value
);
1119 default_string
= default_value
;
1121 name
= Fcompleting_read (prompt
, Vobarray
,
1122 Quser_variable_p
, Qt
,
1123 Qnil
, Qnil
, default_string
, Qnil
);
1126 return Fintern (name
, Qnil
);
1129 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1130 doc
: /* Read the name of a buffer and return as a string.
1132 Optional second arg DEF is value to return if user enters an empty line.
1133 If optional third arg REQUIRE-MATCH is non-nil,
1134 only existing buffer names are allowed. */)
1135 (prompt
, def
, require_match
)
1136 Lisp_Object prompt
, def
, require_match
;
1138 Lisp_Object args
[4];
1141 def
= XBUFFER (def
)->name
;
1143 if (NILP (Vread_buffer_function
))
1147 args
[0] = build_string ("%s(default %s) ");
1150 prompt
= Fformat (3, args
);
1153 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1154 require_match
, Qnil
, Qbuffer_name_history
,
1159 args
[0] = Vread_buffer_function
;
1162 args
[3] = require_match
;
1163 return Ffuncall(4, args
);
1168 minibuf_conform_representation (string
, basis
)
1169 Lisp_Object string
, basis
;
1171 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1174 if (STRING_MULTIBYTE (string
))
1175 return Fstring_make_unibyte (string
);
1177 return Fstring_make_multibyte (string
);
1180 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1181 doc
: /* Return common substring of all completions of STRING in ALIST.
1182 Each car of each element of ALIST (or each element if it is not a cons cell)
1183 is tested to see if it begins with STRING.
1184 All that match are compared together; the longest initial sequence
1185 common to all matches is returned as a string.
1186 If there is no match at all, nil is returned.
1187 For a unique match which is exact, t is returned.
1189 If ALIST is a hash-table, all the string keys are the possible matches.
1190 If ALIST is an obarray, the names of all symbols in the obarray
1191 are the possible matches.
1193 ALIST can also be a function to do the completion itself.
1194 It receives three arguments: the values STRING, PREDICATE and nil.
1195 Whatever it returns becomes the value of `try-completion'.
1197 If optional third argument PREDICATE is non-nil,
1198 it is used to test each possible match.
1199 The match is a candidate only if PREDICATE returns non-nil.
1200 The argument given to PREDICATE is the alist element
1201 or the symbol from the obarray. If ALIST is a hash-table,
1202 predicate is called with two arguments: the key and the value.
1203 Additionally to this predicate, `completion-regexp-list'
1204 is used to further constrain the set of candidates. */)
1205 (string
, alist
, predicate
)
1206 Lisp_Object string
, alist
, predicate
;
1208 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1209 /* Size in bytes of BESTMATCH. */
1210 int bestmatchsize
= 0;
1211 /* These are in bytes, too. */
1212 int compare
, matchsize
;
1213 int type
= HASH_TABLE_P (alist
) ? 3
1214 : VECTORP (alist
) ? 2
1215 : NILP (alist
) || (CONSP (alist
)
1216 && (!SYMBOLP (XCAR (alist
))
1217 || NILP (XCAR (alist
))));
1218 int index
= 0, obsize
= 0;
1221 Lisp_Object bucket
, zero
, end
, tem
;
1222 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1224 CHECK_STRING (string
);
1226 return call3 (alist
, string
, predicate
, Qnil
);
1228 bestmatch
= bucket
= Qnil
;
1230 /* If ALIST is not a list, set TAIL just for gc pro. */
1234 obsize
= XVECTOR (alist
)->size
;
1235 bucket
= XVECTOR (alist
)->contents
[index
];
1240 /* Get the next element of the alist, obarray, or hash-table. */
1241 /* Exit the loop if the elements are all used up. */
1242 /* elt gets the alist element or symbol.
1243 eltstring gets the name to check as a completion. */
1250 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1255 if (XFASTINT (bucket
) != 0)
1258 eltstring
= Fsymbol_name (elt
);
1259 if (XSYMBOL (bucket
)->next
)
1260 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1262 XSETFASTINT (bucket
, 0);
1264 else if (++index
>= obsize
)
1268 bucket
= XVECTOR (alist
)->contents
[index
];
1272 else /* if (type == 3) */
1274 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1275 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1277 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1280 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1283 /* Is this element a possible completion? */
1285 if (STRINGP (eltstring
)
1286 && SCHARS (string
) <= SCHARS (eltstring
)
1287 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1288 make_number (SCHARS (string
)),
1289 string
, make_number (0), Qnil
,
1290 completion_ignore_case
? Qt
: Qnil
),
1294 Lisp_Object regexps
;
1296 XSETFASTINT (zero
, 0);
1298 /* Ignore this element if it fails to match all the regexps. */
1300 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1301 regexps
= XCDR (regexps
))
1303 if (bindcount
< 0) {
1304 bindcount
= SPECPDL_INDEX ();
1305 specbind (Qcase_fold_search
,
1306 completion_ignore_case
? Qt
: Qnil
);
1308 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1312 if (CONSP (regexps
))
1316 /* Ignore this element if there is a predicate
1317 and the predicate doesn't like it. */
1319 if (!NILP (predicate
))
1321 if (EQ (predicate
, Qcommandp
))
1322 tem
= Fcommandp (elt
, Qnil
);
1325 if (bindcount
>= 0) {
1326 unbind_to (bindcount
, Qnil
);
1329 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1331 ? call2 (predicate
, elt
,
1332 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1333 : call1 (predicate
, elt
);
1336 if (NILP (tem
)) continue;
1339 /* Update computation of how much all possible completions match */
1341 if (NILP (bestmatch
))
1344 bestmatch
= eltstring
;
1345 bestmatchsize
= SCHARS (eltstring
);
1349 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1350 tem
= Fcompare_strings (bestmatch
, make_number (0),
1351 make_number (compare
),
1352 eltstring
, make_number (0),
1353 make_number (compare
),
1354 completion_ignore_case
? Qt
: Qnil
);
1356 matchsize
= compare
;
1357 else if (XINT (tem
) < 0)
1358 matchsize
= - XINT (tem
) - 1;
1360 matchsize
= XINT (tem
) - 1;
1363 /* When can this happen ? -stef */
1364 matchsize
= compare
;
1365 if (completion_ignore_case
)
1367 /* If this is an exact match except for case,
1368 use it as the best match rather than one that is not an
1369 exact match. This way, we get the case pattern
1370 of the actual match. */
1371 if ((matchsize
== SCHARS (eltstring
)
1372 && matchsize
< SCHARS (bestmatch
))
1374 /* If there is more than one exact match ignoring case,
1375 and one of them is exact including case,
1377 /* If there is no exact match ignoring case,
1378 prefer a match that does not change the case
1380 ((matchsize
== SCHARS (eltstring
))
1382 (matchsize
== SCHARS (bestmatch
))
1383 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1384 make_number (SCHARS (string
)),
1385 string
, make_number (0),
1389 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1390 make_number (SCHARS (string
)),
1391 string
, make_number (0),
1395 bestmatch
= eltstring
;
1397 if (bestmatchsize
!= SCHARS (eltstring
)
1398 || bestmatchsize
!= matchsize
)
1399 /* Don't count the same string multiple times. */
1401 bestmatchsize
= matchsize
;
1402 if (matchsize
<= SCHARS (string
)
1404 /* No need to look any further. */
1410 if (bindcount
>= 0) {
1411 unbind_to (bindcount
, Qnil
);
1415 if (NILP (bestmatch
))
1416 return Qnil
; /* No completions found */
1417 /* If we are ignoring case, and there is no exact match,
1418 and no additional text was supplied,
1419 don't change the case of what the user typed. */
1420 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1421 && SCHARS (bestmatch
) > bestmatchsize
)
1422 return minibuf_conform_representation (string
, bestmatch
);
1424 /* Return t if the supplied string is an exact match (counting case);
1425 it does not require any change to be made. */
1426 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1427 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1428 make_number (bestmatchsize
),
1429 string
, make_number (0),
1430 make_number (bestmatchsize
),
1435 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1436 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1437 return Fsubstring (bestmatch
, zero
, end
);
1440 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1441 doc
: /* Search for partial matches to STRING in ALIST.
1442 Each car of each element of ALIST (or each element if it is not a cons cell)
1443 is tested to see if it begins with STRING.
1444 The value is a list of all the strings from ALIST that match.
1446 If ALIST is a hash-table, all the string keys are the possible matches.
1447 If ALIST is an obarray, the names of all symbols in the obarray
1448 are the possible matches.
1450 ALIST can also be a function to do the completion itself.
1451 It receives three arguments: the values STRING, PREDICATE and t.
1452 Whatever it returns becomes the value of `all-completions'.
1454 If optional third argument PREDICATE is non-nil,
1455 it is used to test each possible match.
1456 The match is a candidate only if PREDICATE returns non-nil.
1457 The argument given to PREDICATE is the alist element
1458 or the symbol from the obarray. If ALIST is a hash-table,
1459 predicate is called with two arguments: the key and the value.
1460 Additionally to this predicate, `completion-regexp-list'
1461 is used to further constrain the set of candidates.
1463 If the optional fourth argument HIDE-SPACES is non-nil,
1464 strings in ALIST that start with a space
1465 are ignored unless STRING itself starts with a space. */)
1466 (string
, alist
, predicate
, hide_spaces
)
1467 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1469 Lisp_Object tail
, elt
, eltstring
;
1470 Lisp_Object allmatches
;
1471 int type
= HASH_TABLE_P (alist
) ? 3
1472 : VECTORP (alist
) ? 2
1473 : NILP (alist
) || (CONSP (alist
)
1474 && (!SYMBOLP (XCAR (alist
))
1475 || NILP (XCAR (alist
))));
1476 int index
= 0, obsize
= 0;
1478 Lisp_Object bucket
, tem
;
1479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1481 CHECK_STRING (string
);
1483 return call3 (alist
, string
, predicate
, Qt
);
1484 allmatches
= bucket
= Qnil
;
1486 /* If ALIST is not a list, set TAIL just for gc pro. */
1490 obsize
= XVECTOR (alist
)->size
;
1491 bucket
= XVECTOR (alist
)->contents
[index
];
1496 /* Get the next element of the alist, obarray, or hash-table. */
1497 /* Exit the loop if the elements are all used up. */
1498 /* elt gets the alist element or symbol.
1499 eltstring gets the name to check as a completion. */
1506 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1511 if (XFASTINT (bucket
) != 0)
1514 eltstring
= Fsymbol_name (elt
);
1515 if (XSYMBOL (bucket
)->next
)
1516 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1518 XSETFASTINT (bucket
, 0);
1520 else if (++index
>= obsize
)
1524 bucket
= XVECTOR (alist
)->contents
[index
];
1528 else /* if (type == 3) */
1530 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1531 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1533 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1536 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1539 /* Is this element a possible completion? */
1541 if (STRINGP (eltstring
)
1542 && SCHARS (string
) <= SCHARS (eltstring
)
1543 /* If HIDE_SPACES, reject alternatives that start with space
1544 unless the input starts with space. */
1545 && ((SBYTES (string
) > 0
1546 && SREF (string
, 0) == ' ')
1547 || SREF (eltstring
, 0) != ' '
1548 || NILP (hide_spaces
))
1549 && (tem
= Fcompare_strings (eltstring
, make_number (0),
1550 make_number (SCHARS (string
)),
1551 string
, make_number (0),
1552 make_number (SCHARS (string
)),
1553 completion_ignore_case
? Qt
: Qnil
),
1557 Lisp_Object regexps
;
1559 XSETFASTINT (zero
, 0);
1561 /* Ignore this element if it fails to match all the regexps. */
1563 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1564 regexps
= XCDR (regexps
))
1566 if (bindcount
< 0) {
1567 bindcount
= SPECPDL_INDEX ();
1568 specbind (Qcase_fold_search
,
1569 completion_ignore_case
? Qt
: Qnil
);
1571 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1575 if (CONSP (regexps
))
1579 /* Ignore this element if there is a predicate
1580 and the predicate doesn't like it. */
1582 if (!NILP (predicate
))
1584 if (EQ (predicate
, Qcommandp
))
1585 tem
= Fcommandp (elt
, Qnil
);
1588 if (bindcount
>= 0) {
1589 unbind_to (bindcount
, Qnil
);
1592 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1594 ? call2 (predicate
, elt
,
1595 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1596 : call1 (predicate
, elt
);
1599 if (NILP (tem
)) continue;
1601 /* Ok => put it on the list. */
1602 allmatches
= Fcons (eltstring
, allmatches
);
1606 if (bindcount
>= 0) {
1607 unbind_to (bindcount
, Qnil
);
1611 return Fnreverse (allmatches
);
1614 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1615 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1616 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1617 Lisp_Object Vminibuffer_completing_file_name
;
1619 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1620 doc
: /* Read a string in the minibuffer, with completion.
1621 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1622 TABLE can be an list of strings, an alist, an obarray or a hash table.
1623 TABLE can also be a function to do the completion itself.
1624 PREDICATE limits completion to a subset of TABLE.
1625 See `try-completion' and `all-completions' for more details
1626 on completion, TABLE, and PREDICATE.
1628 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1629 the input is (or completes to) an element of TABLE or is null.
1630 If it is also not t, typing RET does not exit if it does non-null completion.
1631 If the input is null, `completing-read' returns DEF, or an empty string
1632 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1634 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1635 with point positioned at the end.
1636 If it is (STRING . POSITION), the initial input is STRING, but point
1637 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1638 that this is different from `read-from-minibuffer' and related
1639 functions, which use one-indexing for POSITION.) This feature is
1640 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1641 default value DEF instead. The user can yank the default value into
1642 the minibuffer easily using \\[next-history-element].
1644 HIST, if non-nil, specifies a history list and optionally the initial
1645 position in the list. It can be a symbol, which is the history list
1646 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1647 that case, HISTVAR is the history list variable to use, and HISTPOS
1648 is the initial position (the position in the list used by the
1649 minibuffer history commands). For consistency, you should also
1650 specify that element of the history as the value of
1651 INITIAL-INPUT. (This is the only case in which you should use
1652 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1653 1 at the beginning of the list. The variable `history-length'
1654 controls the maximum length of a history list.
1656 DEF, if non-nil, is the default value.
1658 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1659 the current input method and the setting of `enable-multibyte-characters'.
1661 Completion ignores case if the ambient value of
1662 `completion-ignore-case' is non-nil. */)
1663 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1664 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1665 Lisp_Object hist
, def
, inherit_input_method
;
1667 Lisp_Object val
, histvar
, histpos
, position
;
1670 int count
= SPECPDL_INDEX ();
1671 struct gcpro gcpro1
;
1673 init
= initial_input
;
1676 specbind (Qminibuffer_completion_table
, table
);
1677 specbind (Qminibuffer_completion_predicate
, predicate
);
1678 specbind (Qminibuffer_completion_confirm
,
1679 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1680 last_exact_completion
= Qnil
;
1687 position
= Fcdr (init
);
1690 CHECK_STRING (init
);
1691 if (!NILP (position
))
1693 CHECK_NUMBER (position
);
1694 /* Convert to distance from end of input. */
1695 pos
= XINT (position
) - SCHARS (init
);
1706 histvar
= Fcar_safe (hist
);
1707 histpos
= Fcdr_safe (hist
);
1710 histvar
= Qminibuffer_history
;
1712 XSETFASTINT (histpos
, 0);
1714 val
= read_minibuf (NILP (require_match
)
1715 ? Vminibuffer_local_completion_map
1716 : Vminibuffer_local_must_match_map
,
1717 init
, prompt
, make_number (pos
), 0,
1718 histvar
, histpos
, def
, 0,
1719 !NILP (inherit_input_method
));
1721 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1724 RETURN_UNGCPRO (unbind_to (count
, val
));
1727 Lisp_Object
Fminibuffer_completion_help ();
1728 Lisp_Object
Fassoc_string ();
1730 /* Test whether TXT is an exact completion. */
1731 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1732 doc
: /* Return non-nil if STRING is a valid completion.
1733 Takes the same arguments as `all-completions' and `try-completion'.
1734 If ALIST is a function, it is called with three arguments:
1735 the values STRING, PREDICATE and `lambda'. */)
1736 (string
, alist
, predicate
)
1737 Lisp_Object string
, alist
, predicate
;
1739 Lisp_Object regexps
, tail
, tem
= Qnil
;
1742 CHECK_STRING (string
);
1744 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1747 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1751 else if (VECTORP (alist
))
1753 /* Bypass intern-soft as that loses for nil. */
1754 tem
= oblookup (alist
,
1760 if (STRING_MULTIBYTE (string
))
1761 string
= Fstring_make_unibyte (string
);
1763 string
= Fstring_make_multibyte (string
);
1765 tem
= oblookup (alist
,
1771 if (completion_ignore_case
&& !SYMBOLP (tem
))
1773 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1775 tail
= XVECTOR (alist
)->contents
[i
];
1779 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1780 Fsymbol_name (tail
),
1781 make_number (0) , Qnil
, Qt
)),
1787 if (XSYMBOL (tail
)->next
== 0)
1789 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1797 else if (HASH_TABLE_P (alist
))
1799 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1800 i
= hash_lookup (h
, string
, NULL
);
1802 tem
= HASH_KEY (h
, i
);
1804 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1805 if (!NILP (HASH_HASH (h
, i
)) &&
1806 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1807 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1808 completion_ignore_case
? Qt
: Qnil
),
1811 tem
= HASH_KEY (h
, i
);
1818 return call3 (alist
, string
, predicate
, Qlambda
);
1820 /* Reject this element if it fails to match all the regexps. */
1821 if (CONSP (Vcompletion_regexp_list
))
1823 int count
= SPECPDL_INDEX ();
1824 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1825 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1826 regexps
= XCDR (regexps
))
1828 if (NILP (Fstring_match (XCAR (regexps
),
1829 SYMBOLP (tem
) ? string
: tem
,
1831 return unbind_to (count
, Qnil
);
1833 unbind_to (count
, Qnil
);
1836 /* Finally, check the predicate. */
1837 if (!NILP (predicate
))
1839 return HASH_TABLE_P (alist
)
1840 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1841 : call1 (predicate
, tem
);
1848 * 0 no possible completion
1849 * 1 was already an exact and unique completion
1850 * 3 was already an exact completion
1851 * 4 completed to an exact completion
1852 * 5 some completion happened
1853 * 6 no completion happened
1858 Lisp_Object completion
, string
, tem
;
1861 struct gcpro gcpro1
, gcpro2
;
1863 completion
= Ftry_completion (minibuffer_completion_contents (),
1864 Vminibuffer_completion_table
,
1865 Vminibuffer_completion_predicate
);
1866 last
= last_exact_completion
;
1867 last_exact_completion
= Qnil
;
1869 GCPRO2 (completion
, last
);
1871 if (NILP (completion
))
1874 temp_echo_area_glyphs (build_string (" [No match]"));
1879 if (EQ (completion
, Qt
)) /* exact and unique match */
1885 string
= minibuffer_completion_contents ();
1887 /* COMPLETEDP should be true if some completion was done, which
1888 doesn't include simply changing the case of the entered string.
1889 However, for appearance, the string is rewritten if the case
1891 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1892 completedp
= !EQ (tem
, Qt
);
1894 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1896 /* Rewrite the user's input. */
1898 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1899 /* Some completion happened */
1901 if (! NILP (Vminibuffer_completing_file_name
)
1902 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1904 && FETCH_CHAR (PT_BYTE
) == '/')
1906 del_range (prompt_end
, PT
+ 1);
1909 del_range (prompt_end
, PT
);
1911 Finsert (1, &completion
);
1914 /* The case of the string changed, but that's all. We're not
1915 sure whether this is a unique completion or not, so try again
1916 using the real case (this shouldn't recurse again, because
1917 the next time try-completion will return either `t' or the
1921 return do_completion ();
1925 /* It did find a match. Do we match some possibility exactly now? */
1926 tem
= Ftest_completion (Fminibuffer_contents (),
1927 Vminibuffer_completion_table
,
1928 Vminibuffer_completion_predicate
);
1931 /* not an exact match */
1935 else if (!NILP (Vcompletion_auto_help
))
1936 Fminibuffer_completion_help ();
1938 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1941 else if (completedp
)
1946 /* If the last exact completion and this one were the same,
1947 it means we've already given a "Complete but not unique"
1948 message and the user's hit TAB again, so now we give him help. */
1949 last_exact_completion
= completion
;
1952 tem
= minibuffer_completion_contents ();
1953 if (!NILP (Fequal (tem
, last
)))
1954 Fminibuffer_completion_help ();
1960 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1962 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1963 doc
: /* Like `assoc' but specifically for strings.
1964 Unibyte strings are converted to multibyte for comparison.
1965 And case is ignored if CASE-FOLD is non-nil.
1966 As opposed to `assoc', it will also match an entry consisting of a single
1967 string rather than a cons cell whose car is a string. */)
1968 (key
, list
, case_fold
)
1969 register Lisp_Object key
;
1970 Lisp_Object list
, case_fold
;
1972 register Lisp_Object tail
;
1974 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1976 register Lisp_Object elt
, tem
, thiscar
;
1978 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1979 if (!STRINGP (thiscar
))
1981 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1982 key
, make_number (0), Qnil
,
1991 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1992 doc
: /* Complete the minibuffer contents as far as possible.
1993 Return nil if there is no valid completion, else t.
1994 If no characters can be completed, display a list of possible completions.
1995 If you repeat this command after it displayed such a list,
1996 scroll the window of possible completions. */)
2000 Lisp_Object window
, tem
;
2002 /* If the previous command was not this,
2003 mark the completion buffer obsolete. */
2004 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2005 Vminibuf_scroll_window
= Qnil
;
2007 window
= Vminibuf_scroll_window
;
2008 /* If there's a fresh completion window with a live buffer,
2009 and this command is repeated, scroll that window. */
2010 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2011 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2013 struct buffer
*obuf
= current_buffer
;
2015 Fset_buffer (XWINDOW (window
)->buffer
);
2016 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2018 /* If end is in view, scroll up to the beginning. */
2019 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2021 /* Else scroll down one screen. */
2022 Fscroll_other_window (Qnil
);
2024 set_buffer_internal (obuf
);
2028 i
= do_completion ();
2036 Fgoto_char (make_number (ZV
));
2037 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2042 Fgoto_char (make_number (ZV
));
2043 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2050 /* Subroutines of Fminibuffer_complete_and_exit. */
2052 /* This one is called by internal_condition_case to do the real work. */
2055 complete_and_exit_1 ()
2057 return make_number (do_completion ());
2060 /* This one is called by internal_condition_case if an error happens.
2061 Pretend the current value is an exact match. */
2064 complete_and_exit_2 (ignore
)
2067 return make_number (1);
2070 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2071 Sminibuffer_complete_and_exit
, 0, 0, "",
2072 doc
: /* If the minibuffer contents is a valid completion then exit.
2073 Otherwise try to complete it. If completion leads to a valid completion,
2074 a repetition of this command will exit. */)
2080 /* Allow user to specify null string */
2081 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2084 if (!NILP (Ftest_completion (Fminibuffer_contents (),
2085 Vminibuffer_completion_table
,
2086 Vminibuffer_completion_predicate
)))
2089 /* Call do_completion, but ignore errors. */
2091 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2092 complete_and_exit_2
);
2102 if (!NILP (Vminibuffer_completion_confirm
))
2104 temp_echo_area_glyphs (build_string (" [Confirm]"));
2114 return Fthrow (Qexit
, Qnil
);
2118 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2120 doc
: /* Complete the minibuffer contents at most a single word.
2121 After one word is completed as much as possible, a space or hyphen
2122 is added, provided that matches some possible completion.
2123 Return nil if there is no valid completion, else t. */)
2126 Lisp_Object completion
, tem
, tem1
;
2127 register int i
, i_byte
;
2128 register const unsigned char *completion_string
;
2129 struct gcpro gcpro1
, gcpro2
;
2130 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2132 /* We keep calling Fbuffer_string rather than arrange for GC to
2133 hold onto a pointer to one of the strings thus made. */
2135 completion
= Ftry_completion (minibuffer_completion_contents (),
2136 Vminibuffer_completion_table
,
2137 Vminibuffer_completion_predicate
);
2138 if (NILP (completion
))
2141 temp_echo_area_glyphs (build_string (" [No match]"));
2144 if (EQ (completion
, Qt
))
2147 #if 0 /* How the below code used to look, for reference. */
2148 tem
= Fminibuffer_contents ();
2150 i
= ZV
- 1 - SCHARS (completion
);
2151 p
= SDATA (completion
);
2153 0 <= scmp (b
, p
, ZV
- 1))
2156 /* Set buffer to longest match of buffer tail and completion head. */
2157 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2159 del_range (1, i
+ 1);
2162 #else /* Rewritten code */
2164 int buffer_nchars
, completion_nchars
;
2166 CHECK_STRING (completion
);
2167 tem
= minibuffer_completion_contents ();
2168 GCPRO2 (completion
, tem
);
2169 /* If reading a file name,
2170 expand any $ENVVAR refs in the buffer and in TEM. */
2171 if (! NILP (Vminibuffer_completing_file_name
))
2173 Lisp_Object substituted
;
2174 substituted
= Fsubstitute_in_file_name (tem
);
2175 if (! EQ (substituted
, tem
))
2178 del_range (prompt_end_charpos
, PT
);
2182 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2183 completion_nchars
= SCHARS (completion
);
2184 i
= buffer_nchars
- completion_nchars
;
2187 (tem1
= Fcompare_strings (tem
, make_number (0),
2188 make_number (buffer_nchars
),
2189 completion
, make_number (0),
2190 make_number (buffer_nchars
),
2191 completion_ignore_case
? Qt
: Qnil
),
2196 /* Make buffer (before point) contain the longest match
2197 of TEM's tail and COMPLETION's head. */
2203 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2204 completion
, make_number (0),
2205 make_number (buffer_nchars
),
2206 completion_ignore_case
? Qt
: Qnil
);
2213 del_range (start_pos
, start_pos
+ buffer_nchars
);
2217 #endif /* Rewritten code */
2220 int prompt_end_bytepos
;
2221 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2222 i
= PT
- prompt_end_charpos
;
2223 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2226 /* If completion finds next char not unique,
2227 consider adding a space or a hyphen. */
2228 if (i
== SCHARS (completion
))
2230 GCPRO1 (completion
);
2231 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2232 build_string (" ")),
2233 Vminibuffer_completion_table
,
2234 Vminibuffer_completion_predicate
);
2241 GCPRO1 (completion
);
2243 Ftry_completion (concat2 (minibuffer_completion_contents (),
2244 build_string ("-")),
2245 Vminibuffer_completion_table
,
2246 Vminibuffer_completion_predicate
);
2254 /* Now find first word-break in the stuff found by completion.
2255 i gets index in string of where to stop completing. */
2258 int bytes
= SBYTES (completion
);
2259 completion_string
= SDATA (completion
);
2260 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2262 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2265 if (SYNTAX (c
) != Sword
)
2274 /* If got no characters, print help for user. */
2276 if (i
== PT
- prompt_end_charpos
)
2278 if (!NILP (Vcompletion_auto_help
))
2279 Fminibuffer_completion_help ();
2283 /* Otherwise insert in minibuffer the chars we got */
2285 if (! NILP (Vminibuffer_completing_file_name
)
2286 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2288 && FETCH_CHAR (PT_BYTE
) == '/')
2290 del_range (prompt_end_charpos
, PT
+ 1);
2293 del_range (prompt_end_charpos
, PT
);
2295 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2299 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2301 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2302 Each element may be just a symbol or string
2303 or may be a list of two strings to be printed as if concatenated.
2304 If it is a list of two strings, the first is the actual completion
2305 alternative, the second serves as annotation.
2306 `standard-output' must be a buffer.
2307 The actual completion alternatives, as inserted, are given `mouse-face'
2308 properties of `highlight'.
2309 At the end, this runs the normal hook `completion-setup-hook'.
2310 It can find the completion buffer in `standard-output'. */)
2312 Lisp_Object completions
;
2314 Lisp_Object tail
, elt
;
2317 struct gcpro gcpro1
, gcpro2
;
2318 struct buffer
*old
= current_buffer
;
2321 /* Note that (when it matters) every variable
2322 points to a non-string that is pointed to by COMPLETIONS,
2323 except for ELT. ELT can be pointing to a string
2324 when terpri or Findent_to calls a change hook. */
2326 GCPRO2 (completions
, elt
);
2328 if (BUFFERP (Vstandard_output
))
2329 set_buffer_internal (XBUFFER (Vstandard_output
));
2331 if (NILP (completions
))
2332 write_string ("There are no possible completions of what you have typed.",
2336 write_string ("Possible completions are:", -1);
2337 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2339 Lisp_Object tem
, string
;
2341 Lisp_Object startpos
, endpos
;
2347 elt
= SYMBOL_NAME (elt
);
2348 /* Compute the length of this element. */
2353 length
= SCHARS (tem
);
2355 tem
= Fcar (XCDR (elt
));
2357 length
+= SCHARS (tem
);
2362 length
= SCHARS (elt
);
2365 /* This does a bad job for narrower than usual windows.
2366 Sadly, the window it will appear in is not known
2367 until after the text has been made. */
2369 if (BUFFERP (Vstandard_output
))
2370 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2372 /* If the previous completion was very wide,
2373 or we have two on this line already,
2374 don't put another on the same line. */
2375 if (column
> 33 || first
2376 /* If this is really wide, don't put it second on a line. */
2377 || (column
> 0 && length
> 45))
2382 /* Otherwise advance to column 35. */
2385 if (BUFFERP (Vstandard_output
))
2387 tem
= Findent_to (make_number (35), make_number (2));
2389 column
= XINT (tem
);
2395 write_string (" ", -1);
2398 while (column
< 35);
2402 if (BUFFERP (Vstandard_output
))
2404 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2405 Fset_text_properties (startpos
, endpos
,
2406 Qnil
, Vstandard_output
);
2409 /* Output this element.
2410 If necessary, convert it to unibyte or to multibyte first. */
2412 string
= Fcar (elt
);
2415 if (NILP (current_buffer
->enable_multibyte_characters
)
2416 && STRING_MULTIBYTE (string
))
2417 string
= Fstring_make_unibyte (string
);
2418 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2419 && !STRING_MULTIBYTE (string
))
2420 string
= Fstring_make_multibyte (string
);
2422 if (BUFFERP (Vstandard_output
))
2424 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2426 Fprinc (string
, Qnil
);
2428 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2430 Fput_text_property (startpos
, endpos
,
2431 Qmouse_face
, intern ("highlight"),
2436 Fprinc (string
, Qnil
);
2439 /* Output the annotation for this element. */
2442 if (BUFFERP (Vstandard_output
))
2444 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2446 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2448 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2450 Fset_text_properties (startpos
, endpos
, Qnil
,
2455 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2460 /* Update COLUMN for what we have output. */
2463 /* If output is to a buffer, recompute COLUMN in a way
2464 that takes account of character widths. */
2465 if (BUFFERP (Vstandard_output
))
2467 tem
= Fcurrent_column ();
2468 column
= XINT (tem
);
2477 if (BUFFERP (Vstandard_output
))
2478 set_buffer_internal (old
);
2480 if (!NILP (Vrun_hooks
))
2481 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2486 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2488 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2491 Lisp_Object completions
;
2493 message ("Making completion list...");
2494 completions
= Fall_completions (minibuffer_completion_contents (),
2495 Vminibuffer_completion_table
,
2496 Vminibuffer_completion_predicate
,
2498 clear_message (1, 0);
2500 if (NILP (completions
))
2503 temp_echo_area_glyphs (build_string (" [No completions]"));
2506 internal_with_output_to_temp_buffer ("*Completions*",
2507 Fdisplay_completion_list
,
2508 Fsort (completions
, Qstring_lessp
));
2512 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2513 doc
: /* Terminate minibuffer input. */)
2516 if (INTEGERP (last_command_char
))
2517 internal_self_insert (XINT (last_command_char
), 0);
2521 return Fthrow (Qexit
, Qnil
);
2524 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2525 doc
: /* Terminate this minibuffer argument. */)
2528 return Fthrow (Qexit
, Qnil
);
2531 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2532 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2535 return make_number (minibuf_level
);
2538 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2539 doc
: /* Return the prompt string of the currently-active minibuffer.
2540 If no minibuffer is active, return nil. */)
2543 return Fcopy_sequence (minibuf_prompt
);
2547 /* Temporarily display STRING at the end of the current
2548 minibuffer contents. This is used to display things like
2549 "[No Match]" when the user requests a completion for a prefix
2550 that has no possible completions, and other quick, unobtrusive
2554 temp_echo_area_glyphs (string
)
2558 int osize_byte
= ZV_BYTE
;
2560 int opoint_byte
= PT_BYTE
;
2561 Lisp_Object oinhibit
;
2562 oinhibit
= Vinhibit_quit
;
2564 /* Clear out any old echo-area message to make way for our new thing. */
2567 SET_PT_BOTH (osize
, osize_byte
);
2568 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2569 SET_PT_BOTH (opoint
, opoint_byte
);
2571 Fsit_for (make_number (2), Qnil
, Qnil
);
2572 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2573 SET_PT_BOTH (opoint
, opoint_byte
);
2574 if (!NILP (Vquit_flag
))
2577 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2579 Vinhibit_quit
= oinhibit
;
2582 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2584 doc
: /* Temporarily display STRING at the end of the minibuffer.
2585 The text is displayed for two seconds,
2586 or until the next input event arrives, whichever comes first. */)
2590 CHECK_STRING (string
);
2591 temp_echo_area_glyphs (string
);
2596 init_minibuf_once ()
2598 Vminibuffer_list
= Qnil
;
2599 staticpro (&Vminibuffer_list
);
2606 minibuf_prompt
= Qnil
;
2607 staticpro (&minibuf_prompt
);
2609 minibuf_save_list
= Qnil
;
2610 staticpro (&minibuf_save_list
);
2612 Qread_file_name_internal
= intern ("read-file-name-internal");
2613 staticpro (&Qread_file_name_internal
);
2615 Qminibuffer_default
= intern ("minibuffer-default");
2616 staticpro (&Qminibuffer_default
);
2617 Fset (Qminibuffer_default
, Qnil
);
2619 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2620 staticpro (&Qminibuffer_completion_table
);
2622 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2623 staticpro (&Qminibuffer_completion_confirm
);
2625 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2626 staticpro (&Qminibuffer_completion_predicate
);
2628 staticpro (&last_exact_completion
);
2629 last_exact_completion
= Qnil
;
2631 staticpro (&last_minibuf_string
);
2632 last_minibuf_string
= Qnil
;
2634 Quser_variable_p
= intern ("user-variable-p");
2635 staticpro (&Quser_variable_p
);
2637 Qminibuffer_history
= intern ("minibuffer-history");
2638 staticpro (&Qminibuffer_history
);
2640 Qbuffer_name_history
= intern ("buffer-name-history");
2641 staticpro (&Qbuffer_name_history
);
2642 Fset (Qbuffer_name_history
, Qnil
);
2644 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2645 staticpro (&Qminibuffer_setup_hook
);
2647 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2648 staticpro (&Qminibuffer_exit_hook
);
2650 Qhistory_length
= intern ("history-length");
2651 staticpro (&Qhistory_length
);
2653 Qcurrent_input_method
= intern ("current-input-method");
2654 staticpro (&Qcurrent_input_method
);
2656 Qactivate_input_method
= intern ("activate-input-method");
2657 staticpro (&Qactivate_input_method
);
2659 Qcase_fold_search
= intern ("case-fold-search");
2660 staticpro (&Qcase_fold_search
);
2662 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2663 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2664 Vread_buffer_function
= Qnil
;
2666 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2667 doc
: /* Normal hook run just after entry to minibuffer. */);
2668 Vminibuffer_setup_hook
= Qnil
;
2670 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2671 doc
: /* Normal hook run just after exit from minibuffer. */);
2672 Vminibuffer_exit_hook
= Qnil
;
2674 DEFVAR_LISP ("history-length", &Vhistory_length
,
2675 doc
: /* *Maximum length for history lists before truncation takes place.
2676 A number means that length; t means infinite. Truncation takes place
2677 just after a new element is inserted. Setting the history-length
2678 property of a history variable overrides this default. */);
2679 XSETFASTINT (Vhistory_length
, 30);
2681 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2682 doc
: /* *Non-nil means to delete duplicates in history.
2683 If set to t when adding a new history element, all previous identical
2684 elements are deleted. */);
2685 history_delete_duplicates
= 0;
2687 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2688 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2689 Vcompletion_auto_help
= Qt
;
2691 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2692 doc
: /* Non-nil means don't consider case significant in completion.
2694 See also `read-file-name-completion-ignore-case' concerning case significance
2695 in completion when reading a file name. */);
2696 completion_ignore_case
= 0;
2698 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2699 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2700 This variable makes a difference whenever the minibuffer window is active. */);
2701 enable_recursive_minibuffers
= 0;
2703 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2704 doc
: /* Alist or obarray used for completion in the minibuffer.
2705 This becomes the ALIST argument to `try-completion' and `all-completions'.
2706 The value can also be a list of strings or a hash table.
2708 The value may alternatively be a function, which is given three arguments:
2709 STRING, the current buffer contents;
2710 PREDICATE, the predicate for filtering possible matches;
2711 CODE, which says what kind of things to do.
2712 CODE can be nil, t or `lambda'.
2713 nil means to return the best completion of STRING, or nil if there is none.
2714 t means to return a list of all possible completions of STRING.
2715 `lambda' means to return t if STRING is a valid completion as it stands. */);
2716 Vminibuffer_completion_table
= Qnil
;
2718 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2719 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2720 Vminibuffer_completion_predicate
= Qnil
;
2722 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2723 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2724 Vminibuffer_completion_confirm
= Qnil
;
2726 DEFVAR_LISP ("minibuffer-completing-file-name",
2727 &Vminibuffer_completing_file_name
,
2728 doc
: /* Non-nil means completing file names. */);
2729 Vminibuffer_completing_file_name
= Qnil
;
2731 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2732 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2733 Vminibuffer_help_form
= Qnil
;
2735 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2736 doc
: /* History list symbol to add minibuffer values to.
2737 Each string of minibuffer input, as it appears on exit from the minibuffer,
2739 (set minibuffer-history-variable
2740 (cons STRING (symbol-value minibuffer-history-variable))) */);
2741 XSETFASTINT (Vminibuffer_history_variable
, 0);
2743 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2744 doc
: /* Current position of redoing in the history list. */);
2745 Vminibuffer_history_position
= Qnil
;
2747 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2748 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2749 Some uses of the echo area also raise that frame (since they use it too). */);
2750 minibuffer_auto_raise
= 0;
2752 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2753 doc
: /* List of regexps that should restrict possible completions.
2754 The basic completion functions only consider a completion acceptable
2755 if it matches all regular expressions in this list, with
2756 `case-fold-search' bound to the value of `completion-ignore-case'.
2757 See Info node `(elisp)Basic Completion', for a description of these
2759 Vcompletion_regexp_list
= Qnil
;
2761 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2762 &minibuffer_allow_text_properties
,
2763 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2764 This also affects `read-string', but it does not affect `read-minibuffer',
2765 `read-no-blanks-input', or any of the functions that do minibuffer input
2766 with completion; they always discard text properties. */);
2767 minibuffer_allow_text_properties
= 0;
2769 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2770 doc
: /* Text properties that are added to minibuffer prompts.
2771 These are in addition to the basic `field' property, and stickiness
2773 /* We use `intern' here instead of Qread_only to avoid
2774 initialization-order problems. */
2775 Vminibuffer_prompt_properties
2776 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2778 defsubr (&Sset_minibuffer_window
);
2779 defsubr (&Sread_from_minibuffer
);
2780 defsubr (&Seval_minibuffer
);
2781 defsubr (&Sread_minibuffer
);
2782 defsubr (&Sread_string
);
2783 defsubr (&Sread_command
);
2784 defsubr (&Sread_variable
);
2785 defsubr (&Sread_buffer
);
2786 defsubr (&Sread_no_blanks_input
);
2787 defsubr (&Sminibuffer_depth
);
2788 defsubr (&Sminibuffer_prompt
);
2790 defsubr (&Sminibufferp
);
2791 defsubr (&Sminibuffer_prompt_end
);
2792 defsubr (&Sminibuffer_contents
);
2793 defsubr (&Sminibuffer_contents_no_properties
);
2794 defsubr (&Sdelete_minibuffer_contents
);
2796 defsubr (&Stry_completion
);
2797 defsubr (&Sall_completions
);
2798 defsubr (&Stest_completion
);
2799 defsubr (&Sassoc_string
);
2800 defsubr (&Scompleting_read
);
2801 defsubr (&Sminibuffer_complete
);
2802 defsubr (&Sminibuffer_complete_word
);
2803 defsubr (&Sminibuffer_complete_and_exit
);
2804 defsubr (&Sdisplay_completion_list
);
2805 defsubr (&Sminibuffer_completion_help
);
2807 defsubr (&Sself_insert_and_exit
);
2808 defsubr (&Sexit_minibuffer
);
2810 defsubr (&Sminibuffer_message
);
2816 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2817 "abort-recursive-edit");
2818 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2820 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2823 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2825 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2827 initial_define_key (Vminibuffer_local_ns_map
, '?',
2828 "self-insert-and-exit");
2830 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2831 "minibuffer-complete");
2832 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2833 "minibuffer-complete-word");
2834 initial_define_key (Vminibuffer_local_completion_map
, '?',
2835 "minibuffer-completion-help");
2837 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2838 "minibuffer-complete-and-exit");
2839 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2840 "minibuffer-complete-and-exit");
2843 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2844 (do not change this comment) */