1 /* Minibuffer input and completion.
2 Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03,04,05
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., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, 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
,
446 Lisp_Object backup_n
;
452 int inherit_input_method
;
456 int count
= SPECPDL_INDEX ();
457 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
458 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
459 Lisp_Object enable_multibyte
;
460 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
462 /* String to add to the history. */
463 Lisp_Object histstring
;
465 extern Lisp_Object Qfront_sticky
;
466 extern Lisp_Object Qrear_nonsticky
;
468 specbind (Qminibuffer_default
, defalt
);
470 single_kboard_state ();
471 #ifdef HAVE_X_WINDOWS
472 if (display_hourglass_p
)
480 backup_n
= Fcdr (initial
);
481 initial
= Fcar (initial
);
482 CHECK_STRING (initial
);
483 if (!NILP (backup_n
))
485 CHECK_NUMBER (backup_n
);
486 /* Convert to distance from end of input. */
487 if (XINT (backup_n
) < 1)
488 /* A number too small means the beginning of the string. */
489 pos
= - SCHARS (initial
);
491 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
495 CHECK_STRING (initial
);
498 ambient_dir
= current_buffer
->directory
;
500 enable_multibyte
= Qnil
;
502 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
503 store them away before we can GC. Don't need to protect
504 BACKUP_N because we use the value only if it is an integer. */
505 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
507 if (!STRINGP (prompt
))
508 prompt
= empty_string
;
510 if (!enable_recursive_minibuffers
511 && minibuf_level
> 0)
513 if (EQ (selected_window
, minibuf_window
))
514 error ("Command attempted to use minibuffer while in minibuffer");
516 /* If we're in another window, cancel the minibuffer that's active. */
518 build_string ("Command attempted to use minibuffer while in minibuffer"));
523 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
525 expflag
, histvar
, histpos
, defalt
,
526 allow_props
, inherit_input_method
);
528 return unbind_to (count
, val
);
531 /* Choose the minibuffer window and frame, and take action on them. */
533 choose_minibuf_frame ();
535 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
537 record_unwind_protect (Fset_window_configuration
,
538 Fcurrent_window_configuration (Qnil
));
540 /* If the minibuffer window is on a different frame, save that
541 frame's configuration too. */
542 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
543 if (!EQ (mini_frame
, selected_frame
))
544 record_unwind_protect (Fset_window_configuration
,
545 Fcurrent_window_configuration (mini_frame
));
547 /* If the minibuffer is on an iconified or invisible frame,
548 make it visible now. */
549 Fmake_frame_visible (mini_frame
);
551 if (minibuffer_auto_raise
)
552 Fraise_frame (mini_frame
);
554 /* We have to do this after saving the window configuration
555 since that is what restores the current buffer. */
557 /* Arrange to restore a number of minibuffer-related variables.
558 We could bind each variable separately, but that would use lots of
561 = Fcons (Voverriding_local_map
,
562 Fcons (minibuf_window
, minibuf_save_list
));
564 = Fcons (minibuf_prompt
,
565 Fcons (make_number (minibuf_prompt_width
),
567 Fcons (Vcurrent_prefix_arg
,
568 Fcons (Vminibuffer_history_position
,
569 Fcons (Vminibuffer_history_variable
,
570 minibuf_save_list
))))));
572 record_unwind_protect (read_minibuf_unwind
, Qnil
);
574 /* We are exiting the minibuffer one way or the other, so run the hook.
575 It should be run before unwinding the minibuf settings. Do it
576 separately from read_minibuf_unwind because we need to make sure that
577 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
578 signals an error. --Stef */
579 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
581 /* Now that we can restore all those variables, start changing them. */
583 minibuf_prompt_width
= 0;
584 minibuf_prompt
= Fcopy_sequence (prompt
);
585 Vminibuffer_history_position
= histpos
;
586 Vminibuffer_history_variable
= histvar
;
587 Vhelp_form
= Vminibuffer_help_form
;
589 if (inherit_input_method
)
591 /* `current-input-method' is buffer local. So, remember it in
592 INPUT_METHOD before changing the current buffer. */
593 input_method
= Fsymbol_value (Qcurrent_input_method
);
594 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
597 /* Switch to the minibuffer. */
599 minibuffer
= get_minibuffer (minibuf_level
);
600 Fset_buffer (minibuffer
);
602 /* The current buffer's default directory is usually the right thing
603 for our minibuffer here. However, if you're typing a command at
604 a minibuffer-only frame when minibuf_level is zero, then buf IS
605 the current_buffer, so reset_buffer leaves buf's default
606 directory unchanged. This is a bummer when you've just started
607 up Emacs and buf's default directory is Qnil. Here's a hack; can
608 you think of something better to do? Find another buffer with a
609 better directory, and use that one instead. */
610 if (STRINGP (ambient_dir
))
611 current_buffer
->directory
= ambient_dir
;
614 Lisp_Object buf_list
;
616 for (buf_list
= Vbuffer_alist
;
618 buf_list
= XCDR (buf_list
))
620 Lisp_Object other_buf
;
622 other_buf
= XCDR (XCAR (buf_list
));
623 if (STRINGP (XBUFFER (other_buf
)->directory
))
625 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
631 if (!EQ (mini_frame
, selected_frame
))
632 Fredirect_frame_focus (selected_frame
, mini_frame
);
634 Vminibuf_scroll_window
= selected_window
;
635 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
636 minibuf_selected_window
= selected_window
;
637 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
638 Fselect_window (minibuf_window
, Qnil
);
639 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
641 Fmake_local_variable (Qprint_escape_newlines
);
642 print_escape_newlines
= 1;
644 /* Erase the buffer. */
646 int count1
= SPECPDL_INDEX ();
647 specbind (Qinhibit_read_only
, Qt
);
648 specbind (Qinhibit_modification_hooks
, Qt
);
650 unbind_to (count1
, Qnil
);
653 if (!NILP (current_buffer
->enable_multibyte_characters
)
654 && ! STRING_MULTIBYTE (minibuf_prompt
))
655 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
657 /* Insert the prompt, record where it ends. */
658 Finsert (1, &minibuf_prompt
);
661 Fput_text_property (make_number (BEG
), make_number (PT
),
662 Qfront_sticky
, Qt
, Qnil
);
663 Fput_text_property (make_number (BEG
), make_number (PT
),
664 Qrear_nonsticky
, Qt
, Qnil
);
665 Fput_text_property (make_number (BEG
), make_number (PT
),
667 Fadd_text_properties (make_number (BEG
), make_number (PT
),
668 Vminibuffer_prompt_properties
, Qnil
);
671 minibuf_prompt_width
= (int) current_column (); /* iftc */
673 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
674 if (inherit_input_method
)
675 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
677 /* Put in the initial input. */
680 Finsert (1, &initial
);
681 Fforward_char (make_number (pos
));
684 clear_message (1, 1);
685 current_buffer
->keymap
= map
;
687 /* Turn on an input method stored in INPUT_METHOD if any. */
688 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
689 call1 (Qactivate_input_method
, input_method
);
691 /* Run our hook, but not if it is empty.
692 (run-hooks would do nothing if it is empty,
693 but it's important to save time here in the usual case.) */
694 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
695 && !NILP (Vrun_hooks
))
696 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
698 /* Don't allow the user to undo past this point. */
699 current_buffer
->undo_list
= Qnil
;
703 /* If cursor is on the minibuffer line,
704 show the user we have exited by putting it in column 0. */
705 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
708 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
709 XWINDOW (minibuf_window
)->cursor
.x
= 0;
710 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
711 update_frame (XFRAME (selected_frame
), 1, 1);
713 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
714 struct redisplay_interface
*rif
= FRAME_RIF (f
);
715 if (rif
&& rif
->flush_display
)
716 rif
->flush_display (f
);
720 /* Make minibuffer contents into a string. */
721 Fset_buffer (minibuffer
);
723 val
= Fminibuffer_contents ();
725 val
= Fminibuffer_contents_no_properties ();
727 /* VAL is the string of minibuffer text. */
729 last_minibuf_string
= val
;
731 /* Choose the string to add to the history. */
732 if (SCHARS (val
) != 0 || keep_all
)
734 else if (STRINGP (defalt
))
739 /* Add the value to the appropriate history list, if any. */
740 if (SYMBOLP (Vminibuffer_history_variable
)
741 && !NILP (histstring
))
743 /* If the caller wanted to save the value read on a history list,
744 then do so if the value is not already the front of the list. */
747 /* If variable is unbound, make it nil. */
748 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
749 Fset (Vminibuffer_history_variable
, Qnil
);
751 histval
= Fsymbol_value (Vminibuffer_history_variable
);
753 /* The value of the history variable must be a cons or nil. Other
754 values are unacceptable. We silently ignore these values. */
758 /* Don't duplicate the most recent entry in the history. */
760 || NILP (Fequal (histstring
, Fcar (histval
))))))
764 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
765 histval
= Fcons (histstring
, histval
);
766 Fset (Vminibuffer_history_variable
, histval
);
768 /* Truncate if requested. */
769 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
770 if (NILP (length
)) length
= Vhistory_length
;
771 if (INTEGERP (length
))
773 if (XINT (length
) <= 0)
774 Fset (Vminibuffer_history_variable
, Qnil
);
779 temp
= Fnthcdr (Fsub1 (length
), histval
);
780 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
786 /* If Lisp form desired instead of string, parse it. */
788 val
= string_to_object (val
, defalt
);
790 /* The appropriate frame will get selected
791 in set-window-configuration. */
793 return unbind_to (count
, val
);
796 /* Return a buffer to be used as the minibuffer at depth `depth'.
797 depth = 0 is the lowest allowed argument, and that is the value
798 used for nonrecursive minibuffer invocations */
801 get_minibuffer (depth
)
804 Lisp_Object tail
, num
, buf
;
806 extern Lisp_Object
nconc2 ();
808 XSETFASTINT (num
, depth
);
809 tail
= Fnthcdr (num
, Vminibuffer_list
);
812 tail
= Fcons (Qnil
, Qnil
);
813 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
816 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
818 sprintf (name
, " *Minibuf-%d*", depth
);
819 buf
= Fget_buffer_create (build_string (name
));
821 /* Although the buffer's name starts with a space, undo should be
823 Fbuffer_enable_undo (buf
);
829 int count
= SPECPDL_INDEX ();
830 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
831 have to empty the list, otherwise we end up with overlays that
832 think they belong to this buffer while the buffer doesn't know about
834 delete_all_overlays (XBUFFER (buf
));
835 reset_buffer (XBUFFER (buf
));
836 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
838 Fkill_all_local_variables ();
839 unbind_to (count
, Qnil
);
846 run_exit_minibuf_hook (data
)
849 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
850 && !NILP (Vrun_hooks
))
851 safe_run_hooks (Qminibuffer_exit_hook
);
856 /* This function is called on exiting minibuffer, whether normally or
857 not, and it restores the current window, buffer, etc. */
860 read_minibuf_unwind (data
)
863 Lisp_Object old_deactivate_mark
;
866 /* If this was a recursive minibuffer,
867 tie the minibuffer window back to the outer level minibuffer buffer. */
870 window
= minibuf_window
;
871 /* To keep things predictable, in case it matters, let's be in the
872 minibuffer when we reset the relevant variables. */
873 Fset_buffer (XWINDOW (window
)->buffer
);
875 /* Restore prompt, etc, from outer minibuffer level. */
876 minibuf_prompt
= Fcar (minibuf_save_list
);
877 minibuf_save_list
= Fcdr (minibuf_save_list
);
878 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
879 minibuf_save_list
= Fcdr (minibuf_save_list
);
880 Vhelp_form
= Fcar (minibuf_save_list
);
881 minibuf_save_list
= Fcdr (minibuf_save_list
);
882 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
883 minibuf_save_list
= Fcdr (minibuf_save_list
);
884 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
885 minibuf_save_list
= Fcdr (minibuf_save_list
);
886 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
887 minibuf_save_list
= Fcdr (minibuf_save_list
);
888 Voverriding_local_map
= Fcar (minibuf_save_list
);
889 minibuf_save_list
= Fcdr (minibuf_save_list
);
891 temp
= Fcar (minibuf_save_list
);
892 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
893 minibuf_window
= temp
;
895 minibuf_save_list
= Fcdr (minibuf_save_list
);
897 /* Erase the minibuffer we were using at this level. */
899 int count
= SPECPDL_INDEX ();
900 /* Prevent error in erase-buffer. */
901 specbind (Qinhibit_read_only
, Qt
);
902 specbind (Qinhibit_modification_hooks
, Qt
);
903 old_deactivate_mark
= Vdeactivate_mark
;
905 Vdeactivate_mark
= old_deactivate_mark
;
906 unbind_to (count
, Qnil
);
909 /* When we get to the outmost level, make sure we resize the
910 mini-window back to its normal size. */
911 if (minibuf_level
== 0)
912 resize_mini_window (XWINDOW (window
), 0);
914 /* Make sure minibuffer window is erased, not ignored. */
915 windows_or_buffers_changed
++;
916 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
917 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
922 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 8, 0,
923 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
924 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
925 DEFAULT-VALUE. It normally should be nil in new code, except when
926 HIST is a cons. It is discussed in more detail below.
927 Third arg KEYMAP is a keymap to use whilst reading;
928 if omitted or nil, the default is `minibuffer-local-map'.
929 If fourth arg READ is non-nil, then interpret the result as a Lisp object
930 and return that object:
931 in other words, do `(car (read-from-string INPUT-STRING))'
932 Fifth arg HIST, if non-nil, specifies a history list and optionally
933 the initial position in the list. It can be a symbol, which is the
934 history list variable to use, or it can be a cons cell
935 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
936 to use, and HISTPOS is the initial position for use by the minibuffer
937 history commands. For consistency, you should also specify that
938 element of the history as the value of INITIAL-CONTENTS. Positions
939 are counted starting from 1 at the beginning of the list.
940 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
941 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
942 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
944 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
945 the current input method and the setting of `enable-multibyte-characters'.
946 Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
947 even empty or duplicate inputs.
948 If the variable `minibuffer-allow-text-properties' is non-nil,
949 then the string which is returned includes whatever text properties
950 were present in the minibuffer. Otherwise the value has no text properties.
952 The remainder of this documentation string describes the
953 INITIAL-CONTENTS argument in more detail. It is only relevant when
954 studying existing code, or when HIST is a cons. If non-nil,
955 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
956 reading input. Normally, point is put at the end of that string.
957 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
958 input is STRING, but point is placed at _one-indexed_ position
959 POSITION in the minibuffer. Any integer value less than or equal to
960 one puts point at the beginning of the string. *Note* that this
961 behavior differs from the way such arguments are used in `completing-read'
962 and some related functions, which use zero-indexing for POSITION. */)
963 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
, keep_all
)
964 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
965 Lisp_Object inherit_input_method
, keep_all
;
967 Lisp_Object histvar
, histpos
, val
;
970 CHECK_STRING (prompt
);
972 keymap
= Vminibuffer_local_map
;
974 keymap
= get_keymap (keymap
, 1, 0);
983 histvar
= Fcar_safe (hist
);
984 histpos
= Fcdr_safe (hist
);
987 histvar
= Qminibuffer_history
;
989 XSETFASTINT (histpos
, 0);
991 GCPRO1 (default_value
);
992 val
= read_minibuf (keymap
, initial_contents
, prompt
,
994 histvar
, histpos
, default_value
,
995 minibuffer_allow_text_properties
,
996 !NILP (inherit_input_method
),
1002 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1003 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1004 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1005 is a string to insert in the minibuffer before reading.
1006 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1007 arguments are used as in `read-from-minibuffer') */)
1008 (prompt
, initial_contents
)
1009 Lisp_Object prompt
, initial_contents
;
1011 CHECK_STRING (prompt
);
1012 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1013 prompt
, Qnil
, 1, Qminibuffer_history
,
1014 make_number (0), Qnil
, 0, 0, 0);
1017 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1018 doc
: /* Return value of Lisp expression read using the minibuffer.
1019 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1020 is a string to insert in the minibuffer before reading.
1021 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1022 arguments are used as in `read-from-minibuffer') */)
1023 (prompt
, initial_contents
)
1024 Lisp_Object prompt
, initial_contents
;
1026 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1029 /* Functions that use the minibuffer to read various things. */
1031 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1032 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1033 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1034 This argument has been superseded by DEFAULT-VALUE and should normally
1035 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1036 documentation string of that function for details.
1037 The third arg HISTORY, if non-nil, specifies a history list
1038 and optionally the initial position in the list.
1039 See `read-from-minibuffer' for details of HISTORY argument.
1040 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1041 for history commands, and as the value to return if the user enters
1043 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1044 the current input method and the setting of `enable-multibyte-characters'. */)
1045 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1046 Lisp_Object prompt
, initial_input
, history
, default_value
;
1047 Lisp_Object inherit_input_method
;
1050 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1051 Qnil
, history
, default_value
,
1052 inherit_input_method
, Qnil
);
1053 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1054 val
= default_value
;
1058 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1059 doc
: /* Read a string from the terminal, not allowing blanks.
1060 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1061 non-nil, it should be a string, which is used as initial input, with
1062 point positioned at the end, so that SPACE will accept the input.
1063 \(Actually, INITIAL can also be a cons of a string and an integer.
1064 Such values are treated as in `read-from-minibuffer', but are normally
1065 not useful in this function.)
1066 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1067 the current input method and the setting of`enable-multibyte-characters'. */)
1068 (prompt
, initial
, inherit_input_method
)
1069 Lisp_Object prompt
, initial
, inherit_input_method
;
1071 CHECK_STRING (prompt
);
1072 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1073 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1074 !NILP (inherit_input_method
), 0);
1077 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1078 doc
: /* Read the name of a command and return as a symbol.
1079 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1080 (prompt
, default_value
)
1081 Lisp_Object prompt
, default_value
;
1083 Lisp_Object name
, default_string
;
1085 if (NILP (default_value
))
1086 default_string
= Qnil
;
1087 else if (SYMBOLP (default_value
))
1088 default_string
= SYMBOL_NAME (default_value
);
1090 default_string
= default_value
;
1092 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1093 Qnil
, Qnil
, default_string
, Qnil
);
1096 return Fintern (name
, Qnil
);
1100 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1101 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1102 Prompt with PROMPT. */)
1106 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1111 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1112 doc
: /* Read the name of a user variable and return it as a symbol.
1113 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1114 A user variable is one for which `user-variable-p' returns non-nil. */)
1115 (prompt
, default_value
)
1116 Lisp_Object prompt
, default_value
;
1118 Lisp_Object name
, default_string
;
1120 if (NILP (default_value
))
1121 default_string
= Qnil
;
1122 else if (SYMBOLP (default_value
))
1123 default_string
= SYMBOL_NAME (default_value
);
1125 default_string
= default_value
;
1127 name
= Fcompleting_read (prompt
, Vobarray
,
1128 Quser_variable_p
, Qt
,
1129 Qnil
, Qnil
, default_string
, Qnil
);
1132 return Fintern (name
, Qnil
);
1135 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1136 doc
: /* Read the name of a buffer and return as a string.
1138 Optional second arg DEF is value to return if user enters an empty line.
1139 If optional third arg REQUIRE-MATCH is non-nil,
1140 only existing buffer names are allowed. */)
1141 (prompt
, def
, require_match
)
1142 Lisp_Object prompt
, def
, require_match
;
1144 Lisp_Object args
[4];
1147 def
= XBUFFER (def
)->name
;
1149 if (NILP (Vread_buffer_function
))
1153 args
[0] = build_string ("%s(default %s) ");
1156 prompt
= Fformat (3, args
);
1159 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1160 require_match
, Qnil
, Qbuffer_name_history
,
1165 args
[0] = Vread_buffer_function
;
1168 args
[3] = require_match
;
1169 return Ffuncall(4, args
);
1174 minibuf_conform_representation (string
, basis
)
1175 Lisp_Object string
, basis
;
1177 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1180 if (STRING_MULTIBYTE (string
))
1181 return Fstring_make_unibyte (string
);
1183 return Fstring_make_multibyte (string
);
1186 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1187 doc
: /* Return common substring of all completions of STRING in ALIST.
1188 Each car of each element of ALIST (or each element if it is not a cons cell)
1189 is tested to see if it begins with STRING. The possible matches may be
1190 strings or symbols. Symbols are converted to strings before testing,
1192 All that match are compared together; the longest initial sequence
1193 common to all matches is returned as a string.
1194 If there is no match at all, nil is returned.
1195 For a unique match which is exact, t is returned.
1197 If ALIST is a hash-table, all the string and symbol keys are the
1199 If ALIST is an obarray, the names of all symbols in the obarray
1200 are the possible matches.
1202 ALIST can also be a function to do the completion itself.
1203 It receives three arguments: the values STRING, PREDICATE and nil.
1204 Whatever it returns becomes the value of `try-completion'.
1206 If optional third argument PREDICATE is non-nil,
1207 it is used to test each possible match.
1208 The match is a candidate only if PREDICATE returns non-nil.
1209 The argument given to PREDICATE is the alist element
1210 or the symbol from the obarray. If ALIST is a hash-table,
1211 predicate is called with two arguments: the key and the value.
1212 Additionally to this predicate, `completion-regexp-list'
1213 is used to further constrain the set of candidates. */)
1214 (string
, alist
, predicate
)
1215 Lisp_Object string
, alist
, predicate
;
1217 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1218 /* Size in bytes of BESTMATCH. */
1219 int bestmatchsize
= 0;
1220 /* These are in bytes, too. */
1221 int compare
, matchsize
;
1222 int type
= HASH_TABLE_P (alist
) ? 3
1223 : VECTORP (alist
) ? 2
1224 : NILP (alist
) || (CONSP (alist
)
1225 && (!SYMBOLP (XCAR (alist
))
1226 || NILP (XCAR (alist
))));
1227 int index
= 0, obsize
= 0;
1230 Lisp_Object bucket
, zero
, end
, tem
;
1231 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1233 CHECK_STRING (string
);
1235 return call3 (alist
, string
, predicate
, Qnil
);
1237 bestmatch
= bucket
= Qnil
;
1238 zero
= make_number (0);
1240 /* If ALIST is not a list, set TAIL just for gc pro. */
1244 obsize
= XVECTOR (alist
)->size
;
1245 bucket
= XVECTOR (alist
)->contents
[index
];
1250 /* Get the next element of the alist, obarray, or hash-table. */
1251 /* Exit the loop if the elements are all used up. */
1252 /* elt gets the alist element or symbol.
1253 eltstring gets the name to check as a completion. */
1260 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1265 if (!EQ (bucket
, zero
))
1269 if (XSYMBOL (bucket
)->next
)
1270 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1272 XSETFASTINT (bucket
, 0);
1274 else if (++index
>= obsize
)
1278 bucket
= XVECTOR (alist
)->contents
[index
];
1282 else /* if (type == 3) */
1284 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1285 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1287 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1290 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1293 /* Is this element a possible completion? */
1295 if (SYMBOLP (eltstring
))
1296 eltstring
= Fsymbol_name (eltstring
);
1298 if (STRINGP (eltstring
)
1299 && SCHARS (string
) <= SCHARS (eltstring
)
1300 && (tem
= Fcompare_strings (eltstring
, zero
,
1301 make_number (SCHARS (string
)),
1303 completion_ignore_case
? Qt
: Qnil
),
1307 Lisp_Object regexps
;
1309 /* Ignore this element if it fails to match all the regexps. */
1311 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1312 regexps
= XCDR (regexps
))
1314 if (bindcount
< 0) {
1315 bindcount
= SPECPDL_INDEX ();
1316 specbind (Qcase_fold_search
,
1317 completion_ignore_case
? Qt
: Qnil
);
1319 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1323 if (CONSP (regexps
))
1327 /* Ignore this element if there is a predicate
1328 and the predicate doesn't like it. */
1330 if (!NILP (predicate
))
1332 if (EQ (predicate
, Qcommandp
))
1333 tem
= Fcommandp (elt
, Qnil
);
1336 if (bindcount
>= 0) {
1337 unbind_to (bindcount
, Qnil
);
1340 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1342 ? call2 (predicate
, elt
,
1343 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1344 : call1 (predicate
, elt
);
1347 if (NILP (tem
)) continue;
1350 /* Update computation of how much all possible completions match */
1352 if (NILP (bestmatch
))
1355 bestmatch
= eltstring
;
1356 bestmatchsize
= SCHARS (eltstring
);
1360 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1361 tem
= Fcompare_strings (bestmatch
, zero
,
1362 make_number (compare
),
1364 make_number (compare
),
1365 completion_ignore_case
? Qt
: Qnil
);
1367 matchsize
= compare
;
1368 else if (XINT (tem
) < 0)
1369 matchsize
= - XINT (tem
) - 1;
1371 matchsize
= XINT (tem
) - 1;
1374 /* When can this happen ? -stef */
1375 matchsize
= compare
;
1376 if (completion_ignore_case
)
1378 /* If this is an exact match except for case,
1379 use it as the best match rather than one that is not an
1380 exact match. This way, we get the case pattern
1381 of the actual match. */
1382 if ((matchsize
== SCHARS (eltstring
)
1383 && matchsize
< SCHARS (bestmatch
))
1385 /* If there is more than one exact match ignoring case,
1386 and one of them is exact including case,
1388 /* If there is no exact match ignoring case,
1389 prefer a match that does not change the case
1391 ((matchsize
== SCHARS (eltstring
))
1393 (matchsize
== SCHARS (bestmatch
))
1394 && (tem
= Fcompare_strings (eltstring
, zero
,
1395 make_number (SCHARS (string
)),
1400 && (tem
= Fcompare_strings (bestmatch
, zero
,
1401 make_number (SCHARS (string
)),
1406 bestmatch
= eltstring
;
1408 if (bestmatchsize
!= SCHARS (eltstring
)
1409 || bestmatchsize
!= matchsize
)
1410 /* Don't count the same string multiple times. */
1412 bestmatchsize
= matchsize
;
1413 if (matchsize
<= SCHARS (string
)
1415 /* No need to look any further. */
1421 if (bindcount
>= 0) {
1422 unbind_to (bindcount
, Qnil
);
1426 if (NILP (bestmatch
))
1427 return Qnil
; /* No completions found */
1428 /* If we are ignoring case, and there is no exact match,
1429 and no additional text was supplied,
1430 don't change the case of what the user typed. */
1431 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1432 && SCHARS (bestmatch
) > bestmatchsize
)
1433 return minibuf_conform_representation (string
, bestmatch
);
1435 /* Return t if the supplied string is an exact match (counting case);
1436 it does not require any change to be made. */
1437 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1438 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1439 make_number (bestmatchsize
),
1440 string
, make_number (0),
1441 make_number (bestmatchsize
),
1446 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1447 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1448 return Fsubstring (bestmatch
, zero
, end
);
1451 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1452 doc
: /* Search for partial matches to STRING in ALIST.
1453 Each car of each element of ALIST (or each element if it is not a cons cell)
1454 is tested to see if it begins with STRING. The possible matches may be
1455 strings or symbols. Symbols are converted to strings before testing,
1457 The value is a list of all the strings from ALIST that match.
1459 If ALIST is a hash-table, all the string and symbol keys are the
1461 If ALIST is an obarray, the names of all symbols in the obarray
1462 are the possible matches.
1464 ALIST can also be a function to do the completion itself.
1465 It receives three arguments: the values STRING, PREDICATE and t.
1466 Whatever it returns becomes the value of `all-completions'.
1468 If optional third argument PREDICATE is non-nil,
1469 it is used to test each possible match.
1470 The match is a candidate only if PREDICATE returns non-nil.
1471 The argument given to PREDICATE is the alist element
1472 or the symbol from the obarray. If ALIST is a hash-table,
1473 predicate is called with two arguments: the key and the value.
1474 Additionally to this predicate, `completion-regexp-list'
1475 is used to further constrain the set of candidates.
1477 If the optional fourth argument HIDE-SPACES is non-nil,
1478 strings in ALIST that start with a space
1479 are ignored unless STRING itself starts with a space. */)
1480 (string
, alist
, predicate
, hide_spaces
)
1481 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1483 Lisp_Object tail
, elt
, eltstring
;
1484 Lisp_Object allmatches
;
1485 int type
= HASH_TABLE_P (alist
) ? 3
1486 : VECTORP (alist
) ? 2
1487 : NILP (alist
) || (CONSP (alist
)
1488 && (!SYMBOLP (XCAR (alist
))
1489 || NILP (XCAR (alist
))));
1490 int index
= 0, obsize
= 0;
1492 Lisp_Object bucket
, tem
, zero
;
1493 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1495 CHECK_STRING (string
);
1497 return call3 (alist
, string
, predicate
, Qt
);
1498 allmatches
= bucket
= Qnil
;
1499 zero
= make_number (0);
1501 /* If ALIST is not a list, set TAIL just for gc pro. */
1505 obsize
= XVECTOR (alist
)->size
;
1506 bucket
= XVECTOR (alist
)->contents
[index
];
1511 /* Get the next element of the alist, obarray, or hash-table. */
1512 /* Exit the loop if the elements are all used up. */
1513 /* elt gets the alist element or symbol.
1514 eltstring gets the name to check as a completion. */
1521 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1526 if (!EQ (bucket
, zero
))
1530 if (XSYMBOL (bucket
)->next
)
1531 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1533 XSETFASTINT (bucket
, 0);
1535 else if (++index
>= obsize
)
1539 bucket
= XVECTOR (alist
)->contents
[index
];
1543 else /* if (type == 3) */
1545 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1546 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1548 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1551 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1554 /* Is this element a possible completion? */
1556 if (SYMBOLP (eltstring
))
1557 eltstring
= Fsymbol_name (eltstring
);
1559 if (STRINGP (eltstring
)
1560 && SCHARS (string
) <= SCHARS (eltstring
)
1561 /* If HIDE_SPACES, reject alternatives that start with space
1562 unless the input starts with space. */
1563 && ((SBYTES (string
) > 0
1564 && SREF (string
, 0) == ' ')
1565 || SREF (eltstring
, 0) != ' '
1566 || NILP (hide_spaces
))
1567 && (tem
= Fcompare_strings (eltstring
, zero
,
1568 make_number (SCHARS (string
)),
1570 make_number (SCHARS (string
)),
1571 completion_ignore_case
? Qt
: Qnil
),
1575 Lisp_Object regexps
;
1577 XSETFASTINT (zero
, 0);
1579 /* Ignore this element if it fails to match all the regexps. */
1581 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1582 regexps
= XCDR (regexps
))
1584 if (bindcount
< 0) {
1585 bindcount
= SPECPDL_INDEX ();
1586 specbind (Qcase_fold_search
,
1587 completion_ignore_case
? Qt
: Qnil
);
1589 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1593 if (CONSP (regexps
))
1597 /* Ignore this element if there is a predicate
1598 and the predicate doesn't like it. */
1600 if (!NILP (predicate
))
1602 if (EQ (predicate
, Qcommandp
))
1603 tem
= Fcommandp (elt
, Qnil
);
1606 if (bindcount
>= 0) {
1607 unbind_to (bindcount
, Qnil
);
1610 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1612 ? call2 (predicate
, elt
,
1613 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1614 : call1 (predicate
, elt
);
1617 if (NILP (tem
)) continue;
1619 /* Ok => put it on the list. */
1620 allmatches
= Fcons (eltstring
, allmatches
);
1624 if (bindcount
>= 0) {
1625 unbind_to (bindcount
, Qnil
);
1629 return Fnreverse (allmatches
);
1632 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1633 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1634 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1635 Lisp_Object Vminibuffer_completing_file_name
;
1637 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1638 doc
: /* Read a string in the minibuffer, with completion.
1639 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1640 TABLE can be an list of strings, an alist, an obarray or a hash table.
1641 TABLE can also be a function to do the completion itself.
1642 PREDICATE limits completion to a subset of TABLE.
1643 See `try-completion' and `all-completions' for more details
1644 on completion, TABLE, and PREDICATE.
1646 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1647 the input is (or completes to) an element of TABLE or is null.
1648 If it is also not t, typing RET does not exit if it does non-null completion.
1649 If the input is null, `completing-read' returns DEF, or an empty string
1650 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1652 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1653 with point positioned at the end.
1654 If it is (STRING . POSITION), the initial input is STRING, but point
1655 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1656 that this is different from `read-from-minibuffer' and related
1657 functions, which use one-indexing for POSITION.) This feature is
1658 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1659 default value DEF instead. The user can yank the default value into
1660 the minibuffer easily using \\[next-history-element].
1662 HIST, if non-nil, specifies a history list and optionally the initial
1663 position in the list. It can be a symbol, which is the history list
1664 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1665 that case, HISTVAR is the history list variable to use, and HISTPOS
1666 is the initial position (the position in the list used by the
1667 minibuffer history commands). For consistency, you should also
1668 specify that element of the history as the value of
1669 INITIAL-INPUT. (This is the only case in which you should use
1670 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1671 1 at the beginning of the list. The variable `history-length'
1672 controls the maximum length of a history list.
1674 DEF, if non-nil, is the default value.
1676 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1677 the current input method and the setting of `enable-multibyte-characters'.
1679 Completion ignores case if the ambient value of
1680 `completion-ignore-case' is non-nil. */)
1681 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1682 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1683 Lisp_Object hist
, def
, inherit_input_method
;
1685 Lisp_Object val
, histvar
, histpos
, position
;
1688 int count
= SPECPDL_INDEX ();
1689 struct gcpro gcpro1
;
1691 init
= initial_input
;
1694 specbind (Qminibuffer_completion_table
, table
);
1695 specbind (Qminibuffer_completion_predicate
, predicate
);
1696 specbind (Qminibuffer_completion_confirm
,
1697 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1698 last_exact_completion
= Qnil
;
1705 position
= Fcdr (init
);
1708 CHECK_STRING (init
);
1709 if (!NILP (position
))
1711 CHECK_NUMBER (position
);
1712 /* Convert to distance from end of input. */
1713 pos
= XINT (position
) - SCHARS (init
);
1724 histvar
= Fcar_safe (hist
);
1725 histpos
= Fcdr_safe (hist
);
1728 histvar
= Qminibuffer_history
;
1730 XSETFASTINT (histpos
, 0);
1732 val
= read_minibuf (NILP (require_match
)
1733 ? Vminibuffer_local_completion_map
1734 : Vminibuffer_local_must_match_map
,
1735 init
, prompt
, make_number (pos
), 0,
1736 histvar
, histpos
, def
, 0,
1737 !NILP (inherit_input_method
), 0);
1739 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1742 RETURN_UNGCPRO (unbind_to (count
, val
));
1745 Lisp_Object
Fminibuffer_completion_help ();
1746 Lisp_Object
Fassoc_string ();
1748 /* Test whether TXT is an exact completion. */
1749 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1750 doc
: /* Return non-nil if STRING is a valid completion.
1751 Takes the same arguments as `all-completions' and `try-completion'.
1752 If ALIST is a function, it is called with three arguments:
1753 the values STRING, PREDICATE and `lambda'. */)
1754 (string
, alist
, predicate
)
1755 Lisp_Object string
, alist
, predicate
;
1757 Lisp_Object regexps
, tail
, tem
= Qnil
;
1760 CHECK_STRING (string
);
1762 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1765 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1769 else if (VECTORP (alist
))
1771 /* Bypass intern-soft as that loses for nil. */
1772 tem
= oblookup (alist
,
1778 if (STRING_MULTIBYTE (string
))
1779 string
= Fstring_make_unibyte (string
);
1781 string
= Fstring_make_multibyte (string
);
1783 tem
= oblookup (alist
,
1789 if (completion_ignore_case
&& !SYMBOLP (tem
))
1791 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1793 tail
= XVECTOR (alist
)->contents
[i
];
1797 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1798 Fsymbol_name (tail
),
1799 make_number (0) , Qnil
, Qt
)),
1805 if (XSYMBOL (tail
)->next
== 0)
1807 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1815 else if (HASH_TABLE_P (alist
))
1817 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1818 i
= hash_lookup (h
, string
, NULL
);
1820 tem
= HASH_KEY (h
, i
);
1822 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1823 if (!NILP (HASH_HASH (h
, i
)) &&
1824 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1825 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1826 completion_ignore_case
? Qt
: Qnil
),
1829 tem
= HASH_KEY (h
, i
);
1836 return call3 (alist
, string
, predicate
, Qlambda
);
1838 /* Reject this element if it fails to match all the regexps. */
1839 if (CONSP (Vcompletion_regexp_list
))
1841 int count
= SPECPDL_INDEX ();
1842 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1843 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1844 regexps
= XCDR (regexps
))
1846 if (NILP (Fstring_match (XCAR (regexps
),
1847 SYMBOLP (tem
) ? string
: tem
,
1849 return unbind_to (count
, Qnil
);
1851 unbind_to (count
, Qnil
);
1854 /* Finally, check the predicate. */
1855 if (!NILP (predicate
))
1857 return HASH_TABLE_P (alist
)
1858 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1859 : call1 (predicate
, tem
);
1866 * 0 no possible completion
1867 * 1 was already an exact and unique completion
1868 * 3 was already an exact completion
1869 * 4 completed to an exact completion
1870 * 5 some completion happened
1871 * 6 no completion happened
1876 Lisp_Object completion
, string
, tem
;
1879 struct gcpro gcpro1
, gcpro2
;
1881 completion
= Ftry_completion (minibuffer_completion_contents (),
1882 Vminibuffer_completion_table
,
1883 Vminibuffer_completion_predicate
);
1884 last
= last_exact_completion
;
1885 last_exact_completion
= Qnil
;
1887 GCPRO2 (completion
, last
);
1889 if (NILP (completion
))
1892 temp_echo_area_glyphs (build_string (" [No match]"));
1897 if (EQ (completion
, Qt
)) /* exact and unique match */
1903 string
= minibuffer_completion_contents ();
1905 /* COMPLETEDP should be true if some completion was done, which
1906 doesn't include simply changing the case of the entered string.
1907 However, for appearance, the string is rewritten if the case
1909 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1910 completedp
= !EQ (tem
, Qt
);
1912 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1914 /* Rewrite the user's input. */
1916 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1917 /* Some completion happened */
1919 if (! NILP (Vminibuffer_completing_file_name
)
1920 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1922 && FETCH_CHAR (PT_BYTE
) == '/')
1924 del_range (prompt_end
, PT
+ 1);
1927 del_range (prompt_end
, PT
);
1929 Finsert (1, &completion
);
1932 /* The case of the string changed, but that's all. We're not
1933 sure whether this is a unique completion or not, so try again
1934 using the real case (this shouldn't recurse again, because
1935 the next time try-completion will return either `t' or the
1939 return do_completion ();
1943 /* It did find a match. Do we match some possibility exactly now? */
1944 tem
= Ftest_completion (Fminibuffer_contents (),
1945 Vminibuffer_completion_table
,
1946 Vminibuffer_completion_predicate
);
1949 /* not an exact match */
1953 else if (!NILP (Vcompletion_auto_help
))
1954 Fminibuffer_completion_help ();
1956 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1959 else if (completedp
)
1964 /* If the last exact completion and this one were the same,
1965 it means we've already given a "Complete but not unique"
1966 message and the user's hit TAB again, so now we give him help. */
1967 last_exact_completion
= completion
;
1970 tem
= minibuffer_completion_contents ();
1971 if (!NILP (Fequal (tem
, last
)))
1972 Fminibuffer_completion_help ();
1978 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1980 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1981 doc
: /* Like `assoc' but specifically for strings.
1982 Unibyte strings are converted to multibyte for comparison.
1983 And case is ignored if CASE-FOLD is non-nil.
1984 As opposed to `assoc', it will also match an entry consisting of a single
1985 string rather than a cons cell whose car is a string. */)
1986 (key
, list
, case_fold
)
1987 register Lisp_Object key
;
1988 Lisp_Object list
, case_fold
;
1990 register Lisp_Object tail
;
1992 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1994 register Lisp_Object elt
, tem
, thiscar
;
1996 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1997 if (!STRINGP (thiscar
))
1999 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2000 key
, make_number (0), Qnil
,
2009 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2010 doc
: /* Complete the minibuffer contents as far as possible.
2011 Return nil if there is no valid completion, else t.
2012 If no characters can be completed, display a list of possible completions.
2013 If you repeat this command after it displayed such a list,
2014 scroll the window of possible completions. */)
2018 Lisp_Object window
, tem
;
2020 /* If the previous command was not this,
2021 mark the completion buffer obsolete. */
2022 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2023 Vminibuf_scroll_window
= Qnil
;
2025 window
= Vminibuf_scroll_window
;
2026 /* If there's a fresh completion window with a live buffer,
2027 and this command is repeated, scroll that window. */
2028 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2029 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2031 struct buffer
*obuf
= current_buffer
;
2033 Fset_buffer (XWINDOW (window
)->buffer
);
2034 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2036 /* If end is in view, scroll up to the beginning. */
2037 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2039 /* Else scroll down one screen. */
2040 Fscroll_other_window (Qnil
);
2042 set_buffer_internal (obuf
);
2046 i
= do_completion ();
2054 Fgoto_char (make_number (ZV
));
2055 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2060 Fgoto_char (make_number (ZV
));
2061 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2068 /* Subroutines of Fminibuffer_complete_and_exit. */
2070 /* This one is called by internal_condition_case to do the real work. */
2073 complete_and_exit_1 ()
2075 return make_number (do_completion ());
2078 /* This one is called by internal_condition_case if an error happens.
2079 Pretend the current value is an exact match. */
2082 complete_and_exit_2 (ignore
)
2085 return make_number (1);
2088 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2090 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2091 Sminibuffer_complete_and_exit
, 0, 0, "",
2092 doc
: /* If the minibuffer contents is a valid completion then exit.
2093 Otherwise try to complete it. If completion leads to a valid completion,
2094 a repetition of this command will exit. */)
2100 /* Allow user to specify null string */
2101 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2104 val
= Fminibuffer_contents ();
2105 if (!NILP (Ftest_completion (val
,
2106 Vminibuffer_completion_table
,
2107 Vminibuffer_completion_predicate
)))
2109 if (completion_ignore_case
)
2110 { /* Fixup case of the field, if necessary. */
2112 = Ftry_completion (val
,
2113 Vminibuffer_completion_table
,
2114 Vminibuffer_completion_predicate
);
2116 /* If it weren't for this piece of paranoia, I'd replace
2117 the whole thing with a call to do_completion. */
2118 && EQ (Flength (val
), Flength (compl)))
2120 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2121 Finsert (1, &compl);
2127 /* Call do_completion, but ignore errors. */
2129 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2130 complete_and_exit_2
);
2140 if (!NILP (Vminibuffer_completion_confirm
))
2142 temp_echo_area_glyphs (build_string (" [Confirm]"));
2152 return Fexit_minibuffer ();
2156 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2158 doc
: /* Complete the minibuffer contents at most a single word.
2159 After one word is completed as much as possible, a space or hyphen
2160 is added, provided that matches some possible completion.
2161 Return nil if there is no valid completion, else t. */)
2164 Lisp_Object completion
, tem
, tem1
;
2165 register int i
, i_byte
;
2166 register const unsigned char *completion_string
;
2167 struct gcpro gcpro1
, gcpro2
;
2168 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2170 /* We keep calling Fbuffer_string rather than arrange for GC to
2171 hold onto a pointer to one of the strings thus made. */
2173 completion
= Ftry_completion (minibuffer_completion_contents (),
2174 Vminibuffer_completion_table
,
2175 Vminibuffer_completion_predicate
);
2176 if (NILP (completion
))
2179 temp_echo_area_glyphs (build_string (" [No match]"));
2182 if (EQ (completion
, Qt
))
2185 #if 0 /* How the below code used to look, for reference. */
2186 tem
= Fminibuffer_contents ();
2188 i
= ZV
- 1 - SCHARS (completion
);
2189 p
= SDATA (completion
);
2191 0 <= scmp (b
, p
, ZV
- 1))
2194 /* Set buffer to longest match of buffer tail and completion head. */
2195 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2197 del_range (1, i
+ 1);
2200 #else /* Rewritten code */
2202 int buffer_nchars
, completion_nchars
;
2204 CHECK_STRING (completion
);
2205 tem
= minibuffer_completion_contents ();
2206 GCPRO2 (completion
, tem
);
2207 /* If reading a file name,
2208 expand any $ENVVAR refs in the buffer and in TEM. */
2209 if (! NILP (Vminibuffer_completing_file_name
))
2211 Lisp_Object substituted
;
2212 substituted
= Fsubstitute_in_file_name (tem
);
2213 if (! EQ (substituted
, tem
))
2216 del_range (prompt_end_charpos
, PT
);
2220 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2221 completion_nchars
= SCHARS (completion
);
2222 i
= buffer_nchars
- completion_nchars
;
2225 (tem1
= Fcompare_strings (tem
, make_number (0),
2226 make_number (buffer_nchars
),
2227 completion
, make_number (0),
2228 make_number (buffer_nchars
),
2229 completion_ignore_case
? Qt
: Qnil
),
2234 /* Make buffer (before point) contain the longest match
2235 of TEM's tail and COMPLETION's head. */
2241 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2242 completion
, make_number (0),
2243 make_number (buffer_nchars
),
2244 completion_ignore_case
? Qt
: Qnil
);
2251 del_range (start_pos
, start_pos
+ buffer_nchars
);
2255 #endif /* Rewritten code */
2258 int prompt_end_bytepos
;
2259 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2260 i
= PT
- prompt_end_charpos
;
2261 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2264 /* If completion finds next char not unique,
2265 consider adding a space or a hyphen. */
2266 if (i
== SCHARS (completion
))
2268 GCPRO1 (completion
);
2269 tem
= Ftry_completion (concat2 (minibuffer_completion_contents (),
2270 build_string (" ")),
2271 Vminibuffer_completion_table
,
2272 Vminibuffer_completion_predicate
);
2279 GCPRO1 (completion
);
2281 Ftry_completion (concat2 (minibuffer_completion_contents (),
2282 build_string ("-")),
2283 Vminibuffer_completion_table
,
2284 Vminibuffer_completion_predicate
);
2292 /* Now find first word-break in the stuff found by completion.
2293 i gets index in string of where to stop completing. */
2296 int bytes
= SBYTES (completion
);
2297 completion_string
= SDATA (completion
);
2298 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2300 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2303 if (SYNTAX (c
) != Sword
)
2312 /* If got no characters, print help for user. */
2314 if (i
== PT
- prompt_end_charpos
)
2316 if (!NILP (Vcompletion_auto_help
))
2317 Fminibuffer_completion_help ();
2321 /* Otherwise insert in minibuffer the chars we got */
2323 if (! NILP (Vminibuffer_completing_file_name
)
2324 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2326 && FETCH_CHAR (PT_BYTE
) == '/')
2328 del_range (prompt_end_charpos
, PT
+ 1);
2331 del_range (prompt_end_charpos
, PT
);
2333 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2337 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2339 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2340 Each element may be just a symbol or string
2341 or may be a list of two strings to be printed as if concatenated.
2342 If it is a list of two strings, the first is the actual completion
2343 alternative, the second serves as annotation.
2344 `standard-output' must be a buffer.
2345 The actual completion alternatives, as inserted, are given `mouse-face'
2346 properties of `highlight'.
2347 At the end, this runs the normal hook `completion-setup-hook'.
2348 It can find the completion buffer in `standard-output'. */)
2350 Lisp_Object completions
;
2352 Lisp_Object tail
, elt
;
2355 struct gcpro gcpro1
, gcpro2
;
2356 struct buffer
*old
= current_buffer
;
2359 /* Note that (when it matters) every variable
2360 points to a non-string that is pointed to by COMPLETIONS,
2361 except for ELT. ELT can be pointing to a string
2362 when terpri or Findent_to calls a change hook. */
2364 GCPRO2 (completions
, elt
);
2366 if (BUFFERP (Vstandard_output
))
2367 set_buffer_internal (XBUFFER (Vstandard_output
));
2369 if (NILP (completions
))
2370 write_string ("There are no possible completions of what you have typed.",
2374 write_string ("Possible completions are:", -1);
2375 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
2377 Lisp_Object tem
, string
;
2379 Lisp_Object startpos
, endpos
;
2385 elt
= SYMBOL_NAME (elt
);
2386 /* Compute the length of this element. */
2391 length
= SCHARS (tem
);
2393 tem
= Fcar (XCDR (elt
));
2395 length
+= SCHARS (tem
);
2400 length
= SCHARS (elt
);
2403 /* This does a bad job for narrower than usual windows.
2404 Sadly, the window it will appear in is not known
2405 until after the text has been made. */
2407 if (BUFFERP (Vstandard_output
))
2408 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2410 /* If the previous completion was very wide,
2411 or we have two on this line already,
2412 don't put another on the same line. */
2413 if (column
> 33 || first
2414 /* If this is really wide, don't put it second on a line. */
2415 || (column
> 0 && length
> 45))
2420 /* Otherwise advance to column 35. */
2423 if (BUFFERP (Vstandard_output
))
2425 tem
= Findent_to (make_number (35), make_number (2));
2427 column
= XINT (tem
);
2433 write_string (" ", -1);
2436 while (column
< 35);
2440 if (BUFFERP (Vstandard_output
))
2442 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2443 Fset_text_properties (startpos
, endpos
,
2444 Qnil
, Vstandard_output
);
2447 /* Output this element.
2448 If necessary, convert it to unibyte or to multibyte first. */
2450 string
= Fcar (elt
);
2453 if (NILP (current_buffer
->enable_multibyte_characters
)
2454 && STRING_MULTIBYTE (string
))
2455 string
= Fstring_make_unibyte (string
);
2456 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2457 && !STRING_MULTIBYTE (string
))
2458 string
= Fstring_make_multibyte (string
);
2460 if (BUFFERP (Vstandard_output
))
2462 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2464 Fprinc (string
, Qnil
);
2466 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2468 Fput_text_property (startpos
, endpos
,
2469 Qmouse_face
, intern ("highlight"),
2474 Fprinc (string
, Qnil
);
2477 /* Output the annotation for this element. */
2480 if (BUFFERP (Vstandard_output
))
2482 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2484 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2486 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2488 Fset_text_properties (startpos
, endpos
, Qnil
,
2493 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2498 /* Update COLUMN for what we have output. */
2501 /* If output is to a buffer, recompute COLUMN in a way
2502 that takes account of character widths. */
2503 if (BUFFERP (Vstandard_output
))
2505 tem
= Fcurrent_column ();
2506 column
= XINT (tem
);
2515 if (BUFFERP (Vstandard_output
))
2516 set_buffer_internal (old
);
2518 if (!NILP (Vrun_hooks
))
2519 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2524 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2526 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2529 Lisp_Object completions
;
2531 message ("Making completion list...");
2532 completions
= Fall_completions (minibuffer_completion_contents (),
2533 Vminibuffer_completion_table
,
2534 Vminibuffer_completion_predicate
,
2536 clear_message (1, 0);
2538 if (NILP (completions
))
2541 temp_echo_area_glyphs (build_string (" [No completions]"));
2544 internal_with_output_to_temp_buffer ("*Completions*",
2545 Fdisplay_completion_list
,
2546 Fsort (completions
, Qstring_lessp
));
2550 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2551 doc
: /* Terminate minibuffer input. */)
2554 if (INTEGERP (last_command_char
))
2555 internal_self_insert (XINT (last_command_char
), 0);
2559 return Fexit_minibuffer ();
2562 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2563 doc
: /* Terminate this minibuffer argument. */)
2566 /* If the command that uses this has made modifications in the minibuffer,
2567 we don't want them to cause deactivation of the mark in the original
2569 A better solution would be to make deactivate-mark buffer-local
2570 (or to turn it into a list of buffers, ...), but in the mean time,
2571 this should do the trick in most cases. */
2572 Vdeactivate_mark
= Qnil
;
2573 Fthrow (Qexit
, Qnil
);
2576 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2577 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2580 return make_number (minibuf_level
);
2583 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2584 doc
: /* Return the prompt string of the currently-active minibuffer.
2585 If no minibuffer is active, return nil. */)
2588 return Fcopy_sequence (minibuf_prompt
);
2592 /* Temporarily display STRING at the end of the current
2593 minibuffer contents. This is used to display things like
2594 "[No Match]" when the user requests a completion for a prefix
2595 that has no possible completions, and other quick, unobtrusive
2599 temp_echo_area_glyphs (string
)
2603 int osize_byte
= ZV_BYTE
;
2605 int opoint_byte
= PT_BYTE
;
2606 Lisp_Object oinhibit
;
2607 oinhibit
= Vinhibit_quit
;
2609 /* Clear out any old echo-area message to make way for our new thing. */
2612 SET_PT_BOTH (osize
, osize_byte
);
2613 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2614 SET_PT_BOTH (opoint
, opoint_byte
);
2616 Fsit_for (make_number (2), Qnil
, Qnil
);
2617 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2618 SET_PT_BOTH (opoint
, opoint_byte
);
2619 if (!NILP (Vquit_flag
))
2622 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2624 Vinhibit_quit
= oinhibit
;
2627 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2629 doc
: /* Temporarily display STRING at the end of the minibuffer.
2630 The text is displayed for two seconds,
2631 or until the next input event arrives, whichever comes first. */)
2635 CHECK_STRING (string
);
2636 temp_echo_area_glyphs (string
);
2641 init_minibuf_once ()
2643 Vminibuffer_list
= Qnil
;
2644 staticpro (&Vminibuffer_list
);
2651 minibuf_prompt
= Qnil
;
2652 staticpro (&minibuf_prompt
);
2654 minibuf_save_list
= Qnil
;
2655 staticpro (&minibuf_save_list
);
2657 Qread_file_name_internal
= intern ("read-file-name-internal");
2658 staticpro (&Qread_file_name_internal
);
2660 Qminibuffer_default
= intern ("minibuffer-default");
2661 staticpro (&Qminibuffer_default
);
2662 Fset (Qminibuffer_default
, Qnil
);
2664 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2665 staticpro (&Qminibuffer_completion_table
);
2667 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2668 staticpro (&Qminibuffer_completion_confirm
);
2670 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2671 staticpro (&Qminibuffer_completion_predicate
);
2673 staticpro (&last_exact_completion
);
2674 last_exact_completion
= Qnil
;
2676 staticpro (&last_minibuf_string
);
2677 last_minibuf_string
= Qnil
;
2679 Quser_variable_p
= intern ("user-variable-p");
2680 staticpro (&Quser_variable_p
);
2682 Qminibuffer_history
= intern ("minibuffer-history");
2683 staticpro (&Qminibuffer_history
);
2685 Qbuffer_name_history
= intern ("buffer-name-history");
2686 staticpro (&Qbuffer_name_history
);
2687 Fset (Qbuffer_name_history
, Qnil
);
2689 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2690 staticpro (&Qminibuffer_setup_hook
);
2692 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2693 staticpro (&Qminibuffer_exit_hook
);
2695 Qhistory_length
= intern ("history-length");
2696 staticpro (&Qhistory_length
);
2698 Qcurrent_input_method
= intern ("current-input-method");
2699 staticpro (&Qcurrent_input_method
);
2701 Qactivate_input_method
= intern ("activate-input-method");
2702 staticpro (&Qactivate_input_method
);
2704 Qcase_fold_search
= intern ("case-fold-search");
2705 staticpro (&Qcase_fold_search
);
2707 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2708 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2709 Vread_buffer_function
= Qnil
;
2711 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2712 doc
: /* Normal hook run just after entry to minibuffer. */);
2713 Vminibuffer_setup_hook
= Qnil
;
2715 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2716 doc
: /* Normal hook run just after exit from minibuffer. */);
2717 Vminibuffer_exit_hook
= Qnil
;
2719 DEFVAR_LISP ("history-length", &Vhistory_length
,
2720 doc
: /* *Maximum length for history lists before truncation takes place.
2721 A number means that length; t means infinite. Truncation takes place
2722 just after a new element is inserted. Setting the history-length
2723 property of a history variable overrides this default. */);
2724 XSETFASTINT (Vhistory_length
, 30);
2726 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2727 doc
: /* *Non-nil means to delete duplicates in history.
2728 If set to t when adding a new history element, all previous identical
2729 elements are deleted. */);
2730 history_delete_duplicates
= 0;
2732 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2733 doc
: /* *Non-nil means automatically provide help for invalid completion input. */);
2734 Vcompletion_auto_help
= Qt
;
2736 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2737 doc
: /* Non-nil means don't consider case significant in completion.
2739 For file-name completion, the variable `read-file-name-completion-ignore-case'
2740 controls the behavior, rather than this variable. */);
2741 completion_ignore_case
= 0;
2743 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2744 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2745 This variable makes a difference whenever the minibuffer window is active. */);
2746 enable_recursive_minibuffers
= 0;
2748 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2749 doc
: /* Alist or obarray used for completion in the minibuffer.
2750 This becomes the ALIST argument to `try-completion' and `all-completions'.
2751 The value can also be a list of strings or a hash table.
2753 The value may alternatively be a function, which is given three arguments:
2754 STRING, the current buffer contents;
2755 PREDICATE, the predicate for filtering possible matches;
2756 CODE, which says what kind of things to do.
2757 CODE can be nil, t or `lambda'.
2758 nil means to return the best completion of STRING, or nil if there is none.
2759 t means to return a list of all possible completions of STRING.
2760 `lambda' means to return t if STRING is a valid completion as it stands. */);
2761 Vminibuffer_completion_table
= Qnil
;
2763 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2764 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2765 Vminibuffer_completion_predicate
= Qnil
;
2767 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2768 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2769 Vminibuffer_completion_confirm
= Qnil
;
2771 DEFVAR_LISP ("minibuffer-completing-file-name",
2772 &Vminibuffer_completing_file_name
,
2773 doc
: /* Non-nil means completing file names. */);
2774 Vminibuffer_completing_file_name
= Qnil
;
2776 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2777 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2778 Vminibuffer_help_form
= Qnil
;
2780 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2781 doc
: /* History list symbol to add minibuffer values to.
2782 Each string of minibuffer input, as it appears on exit from the minibuffer,
2784 (set minibuffer-history-variable
2785 (cons STRING (symbol-value minibuffer-history-variable))) */);
2786 XSETFASTINT (Vminibuffer_history_variable
, 0);
2788 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2789 doc
: /* Current position of redoing in the history list. */);
2790 Vminibuffer_history_position
= Qnil
;
2792 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2793 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2794 Some uses of the echo area also raise that frame (since they use it too). */);
2795 minibuffer_auto_raise
= 0;
2797 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2798 doc
: /* List of regexps that should restrict possible completions.
2799 The basic completion functions only consider a completion acceptable
2800 if it matches all regular expressions in this list, with
2801 `case-fold-search' bound to the value of `completion-ignore-case'.
2802 See Info node `(elisp)Basic Completion', for a description of these
2804 Vcompletion_regexp_list
= Qnil
;
2806 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2807 &minibuffer_allow_text_properties
,
2808 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2809 This also affects `read-string', but it does not affect `read-minibuffer',
2810 `read-no-blanks-input', or any of the functions that do minibuffer input
2811 with completion; they always discard text properties. */);
2812 minibuffer_allow_text_properties
= 0;
2814 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2815 doc
: /* Text properties that are added to minibuffer prompts.
2816 These are in addition to the basic `field' property, and stickiness
2818 /* We use `intern' here instead of Qread_only to avoid
2819 initialization-order problems. */
2820 Vminibuffer_prompt_properties
2821 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2823 defsubr (&Sset_minibuffer_window
);
2824 defsubr (&Sread_from_minibuffer
);
2825 defsubr (&Seval_minibuffer
);
2826 defsubr (&Sread_minibuffer
);
2827 defsubr (&Sread_string
);
2828 defsubr (&Sread_command
);
2829 defsubr (&Sread_variable
);
2830 defsubr (&Sread_buffer
);
2831 defsubr (&Sread_no_blanks_input
);
2832 defsubr (&Sminibuffer_depth
);
2833 defsubr (&Sminibuffer_prompt
);
2835 defsubr (&Sminibufferp
);
2836 defsubr (&Sminibuffer_prompt_end
);
2837 defsubr (&Sminibuffer_contents
);
2838 defsubr (&Sminibuffer_contents_no_properties
);
2839 defsubr (&Sdelete_minibuffer_contents
);
2841 defsubr (&Stry_completion
);
2842 defsubr (&Sall_completions
);
2843 defsubr (&Stest_completion
);
2844 defsubr (&Sassoc_string
);
2845 defsubr (&Scompleting_read
);
2846 defsubr (&Sminibuffer_complete
);
2847 defsubr (&Sminibuffer_complete_word
);
2848 defsubr (&Sminibuffer_complete_and_exit
);
2849 defsubr (&Sdisplay_completion_list
);
2850 defsubr (&Sminibuffer_completion_help
);
2852 defsubr (&Sself_insert_and_exit
);
2853 defsubr (&Sexit_minibuffer
);
2855 defsubr (&Sminibuffer_message
);
2861 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2862 "abort-recursive-edit");
2863 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2865 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2868 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2870 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2872 initial_define_key (Vminibuffer_local_ns_map
, '?',
2873 "self-insert-and-exit");
2875 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2876 "minibuffer-complete");
2877 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2878 "minibuffer-complete-word");
2879 initial_define_key (Vminibuffer_local_completion_map
, '?',
2880 "minibuffer-completion-help");
2882 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2883 "minibuffer-complete-and-exit");
2884 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2885 "minibuffer-complete-and-exit");
2888 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2889 (do not change this comment) */