1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
30 #include "dispextern.h"
35 #include "intervals.h"
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 minibuffer. */)
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 ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
393 Sminibuffer_completion_contents
, 0, 0, 0,
394 doc
: /* Return the user input in a minibuffer before point as a string.
395 That is what completion commands operate on.
396 The current buffer must be a minibuffer. */)
399 int prompt_end
= XINT (Fminibuffer_prompt_end ());
401 error ("Cannot do completion in the prompt");
402 return make_buffer_string (prompt_end
, PT
, 1);
405 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents
,
406 Sdelete_minibuffer_contents
, 0, 0, 0,
407 doc
: /* Delete all user input in a minibuffer.
408 The current buffer must be a minibuffer. */)
411 int prompt_end
= XINT (Fminibuffer_prompt_end ());
413 del_range (prompt_end
, ZV
);
418 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
419 putting point minus BACKUP_N bytes from the end of INITIAL,
420 prompting with PROMPT (a string), using history list HISTVAR
421 with initial position HISTPOS. INITIAL should be a string or a
422 cons of a string and an integer. BACKUP_N should be <= 0, or
423 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
424 ignored and replaced with an integer that puts point at one-indexed
425 position N in INITIAL, where N is the CDR of INITIAL, or at the
426 beginning of INITIAL if N <= 0.
428 Normally return the result as a string (the text that was read),
429 but if EXPFLAG is nonzero, read it and return the object read.
430 If HISTVAR is given, save the value read on that history only if it doesn't
431 match the front of that history list exactly. The value is pushed onto
432 the list as the string that was read.
434 DEFALT specifies the default value for the sake of history commands.
436 If ALLOW_PROPS is nonzero, we do not throw away text properties.
438 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
439 current input method. */
442 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
,
443 histvar
, histpos
, defalt
, allow_props
, inherit_input_method
,
448 Lisp_Object backup_n
;
454 int inherit_input_method
;
458 int count
= SPECPDL_INDEX ();
459 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
460 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
461 Lisp_Object enable_multibyte
;
462 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
464 /* String to add to the history. */
465 Lisp_Object histstring
;
467 extern Lisp_Object Qfront_sticky
;
468 extern Lisp_Object Qrear_nonsticky
;
470 specbind (Qminibuffer_default
, defalt
);
472 #ifdef HAVE_X_WINDOWS
473 if (display_hourglass_p
)
481 backup_n
= Fcdr (initial
);
482 initial
= Fcar (initial
);
483 CHECK_STRING (initial
);
484 if (!NILP (backup_n
))
486 CHECK_NUMBER (backup_n
);
487 /* Convert to distance from end of input. */
488 if (XINT (backup_n
) < 1)
489 /* A number too small means the beginning of the string. */
490 pos
= - SCHARS (initial
);
492 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
496 CHECK_STRING (initial
);
499 ambient_dir
= current_buffer
->directory
;
501 enable_multibyte
= Qnil
;
503 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
504 store them away before we can GC. Don't need to protect
505 BACKUP_N because we use the value only if it is an integer. */
506 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
508 if (!STRINGP (prompt
))
509 prompt
= empty_string
;
511 if (!enable_recursive_minibuffers
512 && minibuf_level
> 0)
514 if (EQ (selected_window
, minibuf_window
))
515 error ("Command attempted to use minibuffer while in minibuffer");
517 /* If we're in another window, cancel the minibuffer that's active. */
519 build_string ("Command attempted to use minibuffer while in minibuffer"));
524 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
526 expflag
, histvar
, histpos
, defalt
,
527 allow_props
, inherit_input_method
);
529 return unbind_to (count
, val
);
532 /* Choose the minibuffer window and frame, and take action on them. */
534 choose_minibuf_frame ();
536 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
538 record_unwind_protect (Fset_window_configuration
,
539 Fcurrent_window_configuration (Qnil
));
541 /* If the minibuffer window is on a different frame, save that
542 frame's configuration too. */
543 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
544 if (!EQ (mini_frame
, selected_frame
))
545 record_unwind_protect (Fset_window_configuration
,
546 Fcurrent_window_configuration (mini_frame
));
548 /* If the minibuffer is on an iconified or invisible frame,
549 make it visible now. */
550 Fmake_frame_visible (mini_frame
);
552 if (minibuffer_auto_raise
)
553 Fraise_frame (mini_frame
);
555 temporarily_switch_to_single_kboard (XFRAME (mini_frame
)->terminal
->kboard
);
557 /* We have to do this after saving the window configuration
558 since that is what restores the current buffer. */
560 /* Arrange to restore a number of minibuffer-related variables.
561 We could bind each variable separately, but that would use lots of
564 = Fcons (Voverriding_local_map
,
565 Fcons (minibuf_window
, minibuf_save_list
));
567 = Fcons (minibuf_prompt
,
568 Fcons (make_number (minibuf_prompt_width
),
570 Fcons (Vcurrent_prefix_arg
,
571 Fcons (Vminibuffer_history_position
,
572 Fcons (Vminibuffer_history_variable
,
573 minibuf_save_list
))))));
575 record_unwind_protect (read_minibuf_unwind
, Qnil
);
577 /* We are exiting the minibuffer one way or the other, so run the hook.
578 It should be run before unwinding the minibuf settings. Do it
579 separately from read_minibuf_unwind because we need to make sure that
580 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
581 signals an error. --Stef */
582 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
584 /* Now that we can restore all those variables, start changing them. */
586 minibuf_prompt_width
= 0;
587 minibuf_prompt
= Fcopy_sequence (prompt
);
588 Vminibuffer_history_position
= histpos
;
589 Vminibuffer_history_variable
= histvar
;
590 Vhelp_form
= Vminibuffer_help_form
;
592 if (inherit_input_method
)
594 /* `current-input-method' is buffer local. So, remember it in
595 INPUT_METHOD before changing the current buffer. */
596 input_method
= Fsymbol_value (Qcurrent_input_method
);
597 enable_multibyte
= current_buffer
->enable_multibyte_characters
;
600 /* Switch to the minibuffer. */
602 minibuffer
= get_minibuffer (minibuf_level
);
603 Fset_buffer (minibuffer
);
605 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
606 if (inherit_input_method
)
607 current_buffer
->enable_multibyte_characters
= enable_multibyte
;
609 /* The current buffer's default directory is usually the right thing
610 for our minibuffer here. However, if you're typing a command at
611 a minibuffer-only frame when minibuf_level is zero, then buf IS
612 the current_buffer, so reset_buffer leaves buf's default
613 directory unchanged. This is a bummer when you've just started
614 up Emacs and buf's default directory is Qnil. Here's a hack; can
615 you think of something better to do? Find another buffer with a
616 better directory, and use that one instead. */
617 if (STRINGP (ambient_dir
))
618 current_buffer
->directory
= ambient_dir
;
621 Lisp_Object buf_list
;
623 for (buf_list
= Vbuffer_alist
;
625 buf_list
= XCDR (buf_list
))
627 Lisp_Object other_buf
;
629 other_buf
= XCDR (XCAR (buf_list
));
630 if (STRINGP (XBUFFER (other_buf
)->directory
))
632 current_buffer
->directory
= XBUFFER (other_buf
)->directory
;
638 if (!EQ (mini_frame
, selected_frame
))
639 Fredirect_frame_focus (selected_frame
, mini_frame
);
641 Vminibuf_scroll_window
= selected_window
;
642 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
643 minibuf_selected_window
= selected_window
;
644 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
645 Fselect_window (minibuf_window
, Qnil
);
646 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
648 Fmake_local_variable (Qprint_escape_newlines
);
649 print_escape_newlines
= 1;
651 /* Erase the buffer. */
653 int count1
= SPECPDL_INDEX ();
654 specbind (Qinhibit_read_only
, Qt
);
655 specbind (Qinhibit_modification_hooks
, Qt
);
657 unbind_to (count1
, Qnil
);
660 if (!NILP (current_buffer
->enable_multibyte_characters
)
661 && ! STRING_MULTIBYTE (minibuf_prompt
))
662 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
664 /* Insert the prompt, record where it ends. */
665 Finsert (1, &minibuf_prompt
);
668 Fput_text_property (make_number (BEG
), make_number (PT
),
669 Qfront_sticky
, Qt
, Qnil
);
670 Fput_text_property (make_number (BEG
), make_number (PT
),
671 Qrear_nonsticky
, Qt
, Qnil
);
672 Fput_text_property (make_number (BEG
), make_number (PT
),
674 Fadd_text_properties (make_number (BEG
), make_number (PT
),
675 Vminibuffer_prompt_properties
, Qnil
);
678 minibuf_prompt_width
= (int) current_column (); /* iftc */
680 /* Put in the initial input. */
683 Finsert (1, &initial
);
684 Fforward_char (make_number (pos
));
687 clear_message (1, 1);
688 current_buffer
->keymap
= map
;
690 /* Turn on an input method stored in INPUT_METHOD if any. */
691 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
692 call1 (Qactivate_input_method
, input_method
);
694 /* Run our hook, but not if it is empty.
695 (run-hooks would do nothing if it is empty,
696 but it's important to save time here in the usual case.) */
697 if (!NILP (Vminibuffer_setup_hook
) && !EQ (Vminibuffer_setup_hook
, Qunbound
)
698 && !NILP (Vrun_hooks
))
699 call1 (Vrun_hooks
, Qminibuffer_setup_hook
);
701 /* Don't allow the user to undo past this point. */
702 current_buffer
->undo_list
= Qnil
;
706 /* If cursor is on the minibuffer line,
707 show the user we have exited by putting it in column 0. */
708 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
711 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
712 XWINDOW (minibuf_window
)->cursor
.x
= 0;
713 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
714 update_frame (XFRAME (selected_frame
), 1, 1);
716 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
717 struct redisplay_interface
*rif
= FRAME_RIF (f
);
718 if (rif
&& rif
->flush_display
)
719 rif
->flush_display (f
);
723 /* Make minibuffer contents into a string. */
724 Fset_buffer (minibuffer
);
726 val
= Fminibuffer_contents ();
728 val
= Fminibuffer_contents_no_properties ();
730 /* VAL is the string of minibuffer text. */
732 last_minibuf_string
= val
;
734 /* Choose the string to add to the history. */
735 if (SCHARS (val
) != 0 || keep_all
)
737 else if (STRINGP (defalt
))
742 /* Add the value to the appropriate history list, if any. */
743 if (SYMBOLP (Vminibuffer_history_variable
)
744 && !NILP (histstring
))
746 /* If the caller wanted to save the value read on a history list,
747 then do so if the value is not already the front of the list. */
750 /* If variable is unbound, make it nil. */
751 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable
), Qunbound
))
752 Fset (Vminibuffer_history_variable
, Qnil
);
754 histval
= Fsymbol_value (Vminibuffer_history_variable
);
756 /* The value of the history variable must be a cons or nil. Other
757 values are unacceptable. We silently ignore these values. */
761 /* Don't duplicate the most recent entry in the history. */
763 || NILP (Fequal (histstring
, Fcar (histval
))))))
767 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
768 histval
= Fcons (histstring
, histval
);
769 Fset (Vminibuffer_history_variable
, histval
);
771 /* Truncate if requested. */
772 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
773 if (NILP (length
)) length
= Vhistory_length
;
774 if (INTEGERP (length
))
776 if (XINT (length
) <= 0)
777 Fset (Vminibuffer_history_variable
, Qnil
);
782 temp
= Fnthcdr (Fsub1 (length
), histval
);
783 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
789 /* If Lisp form desired instead of string, parse it. */
791 val
= string_to_object (val
, defalt
);
793 /* The appropriate frame will get selected
794 in set-window-configuration. */
796 return unbind_to (count
, val
);
799 /* Return a buffer to be used as the minibuffer at depth `depth'.
800 depth = 0 is the lowest allowed argument, and that is the value
801 used for nonrecursive minibuffer invocations */
804 get_minibuffer (depth
)
807 Lisp_Object tail
, num
, buf
;
809 extern Lisp_Object
nconc2 ();
811 XSETFASTINT (num
, depth
);
812 tail
= Fnthcdr (num
, Vminibuffer_list
);
815 tail
= Fcons (Qnil
, Qnil
);
816 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
819 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
821 sprintf (name
, " *Minibuf-%d*", depth
);
822 buf
= Fget_buffer_create (build_string (name
));
824 /* Although the buffer's name starts with a space, undo should be
826 Fbuffer_enable_undo (buf
);
832 int count
= SPECPDL_INDEX ();
833 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
834 have to empty the list, otherwise we end up with overlays that
835 think they belong to this buffer while the buffer doesn't know about
837 delete_all_overlays (XBUFFER (buf
));
838 reset_buffer (XBUFFER (buf
));
839 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
841 Fkill_all_local_variables ();
842 unbind_to (count
, Qnil
);
849 run_exit_minibuf_hook (data
)
852 if (!NILP (Vminibuffer_exit_hook
) && !EQ (Vminibuffer_exit_hook
, Qunbound
)
853 && !NILP (Vrun_hooks
))
854 safe_run_hooks (Qminibuffer_exit_hook
);
859 /* This function is called on exiting minibuffer, whether normally or
860 not, and it restores the current window, buffer, etc. */
863 read_minibuf_unwind (data
)
866 Lisp_Object old_deactivate_mark
;
869 /* If this was a recursive minibuffer,
870 tie the minibuffer window back to the outer level minibuffer buffer. */
873 window
= minibuf_window
;
874 /* To keep things predictable, in case it matters, let's be in the
875 minibuffer when we reset the relevant variables. */
876 Fset_buffer (XWINDOW (window
)->buffer
);
878 /* Restore prompt, etc, from outer minibuffer level. */
879 minibuf_prompt
= Fcar (minibuf_save_list
);
880 minibuf_save_list
= Fcdr (minibuf_save_list
);
881 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
882 minibuf_save_list
= Fcdr (minibuf_save_list
);
883 Vhelp_form
= Fcar (minibuf_save_list
);
884 minibuf_save_list
= Fcdr (minibuf_save_list
);
885 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
886 minibuf_save_list
= Fcdr (minibuf_save_list
);
887 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
888 minibuf_save_list
= Fcdr (minibuf_save_list
);
889 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
890 minibuf_save_list
= Fcdr (minibuf_save_list
);
891 Voverriding_local_map
= Fcar (minibuf_save_list
);
892 minibuf_save_list
= Fcdr (minibuf_save_list
);
894 temp
= Fcar (minibuf_save_list
);
895 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
896 minibuf_window
= temp
;
898 minibuf_save_list
= Fcdr (minibuf_save_list
);
900 /* Erase the minibuffer we were using at this level. */
902 int count
= SPECPDL_INDEX ();
903 /* Prevent error in erase-buffer. */
904 specbind (Qinhibit_read_only
, Qt
);
905 specbind (Qinhibit_modification_hooks
, Qt
);
906 old_deactivate_mark
= Vdeactivate_mark
;
908 Vdeactivate_mark
= old_deactivate_mark
;
909 unbind_to (count
, Qnil
);
912 /* When we get to the outmost level, make sure we resize the
913 mini-window back to its normal size. */
914 if (minibuf_level
== 0)
915 resize_mini_window (XWINDOW (window
), 0);
917 /* Make sure minibuffer window is erased, not ignored. */
918 windows_or_buffers_changed
++;
919 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
920 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
925 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 8, 0,
926 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
927 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
928 DEFAULT-VALUE. It normally should be nil in new code, except when
929 HIST is a cons. It is discussed in more detail below.
930 Third arg KEYMAP is a keymap to use whilst reading;
931 if omitted or nil, the default is `minibuffer-local-map'.
932 If fourth arg READ is non-nil, then interpret the result as a Lisp object
933 and return that object:
934 in other words, do `(car (read-from-string INPUT-STRING))'
935 Fifth arg HIST, if non-nil, specifies a history list and optionally
936 the initial position in the list. It can be a symbol, which is the
937 history list variable to use, or it can be a cons cell
938 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
939 to use, and HISTPOS is the initial position for use by the minibuffer
940 history commands. For consistency, you should also specify that
941 element of the history as the value of INITIAL-CONTENTS. Positions
942 are counted starting from 1 at the beginning of the list.
943 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
944 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
945 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
947 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
948 the current input method and the setting of `enable-multibyte-characters'.
949 Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
950 even empty or duplicate inputs.
951 If the variable `minibuffer-allow-text-properties' is non-nil,
952 then the string which is returned includes whatever text properties
953 were present in the minibuffer. Otherwise the value has no text properties.
955 The remainder of this documentation string describes the
956 INITIAL-CONTENTS argument in more detail. It is only relevant when
957 studying existing code, or when HIST is a cons. If non-nil,
958 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
959 reading input. Normally, point is put at the end of that string.
960 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
961 input is STRING, but point is placed at _one-indexed_ position
962 POSITION in the minibuffer. Any integer value less than or equal to
963 one puts point at the beginning of the string. *Note* that this
964 behavior differs from the way such arguments are used in `completing-read'
965 and some related functions, which use zero-indexing for POSITION. */)
966 (prompt
, initial_contents
, keymap
, read
, hist
, default_value
, inherit_input_method
, keep_all
)
967 Lisp_Object prompt
, initial_contents
, keymap
, read
, hist
, default_value
;
968 Lisp_Object inherit_input_method
, keep_all
;
970 Lisp_Object histvar
, histpos
, val
;
973 CHECK_STRING (prompt
);
975 keymap
= Vminibuffer_local_map
;
977 keymap
= get_keymap (keymap
, 1, 0);
986 histvar
= Fcar_safe (hist
);
987 histpos
= Fcdr_safe (hist
);
990 histvar
= Qminibuffer_history
;
992 XSETFASTINT (histpos
, 0);
994 GCPRO1 (default_value
);
995 val
= read_minibuf (keymap
, initial_contents
, prompt
,
997 histvar
, histpos
, default_value
,
998 minibuffer_allow_text_properties
,
999 !NILP (inherit_input_method
),
1005 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
1006 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
1007 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1008 is a string to insert in the minibuffer before reading.
1009 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1010 arguments are used as in `read-from-minibuffer') */)
1011 (prompt
, initial_contents
)
1012 Lisp_Object prompt
, initial_contents
;
1014 CHECK_STRING (prompt
);
1015 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
1016 prompt
, Qnil
, 1, Qminibuffer_history
,
1017 make_number (0), Qnil
, 0, 0, 0);
1020 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
1021 doc
: /* Return value of Lisp expression read using the minibuffer.
1022 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1023 is a string to insert in the minibuffer before reading.
1024 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1025 arguments are used as in `read-from-minibuffer'.) */)
1026 (prompt
, initial_contents
)
1027 Lisp_Object prompt
, initial_contents
;
1029 return Feval (Fread_minibuffer (prompt
, initial_contents
));
1032 /* Functions that use the minibuffer to read various things. */
1034 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
1035 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
1036 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1037 This argument has been superseded by DEFAULT-VALUE and should normally
1038 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1039 documentation string of that function for details.
1040 The third arg HISTORY, if non-nil, specifies a history list
1041 and optionally the initial position in the list.
1042 See `read-from-minibuffer' for details of HISTORY argument.
1043 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1044 for history commands, and as the value to return if the user enters
1046 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1047 the current input method and the setting of `enable-multibyte-characters'. */)
1048 (prompt
, initial_input
, history
, default_value
, inherit_input_method
)
1049 Lisp_Object prompt
, initial_input
, history
, default_value
;
1050 Lisp_Object inherit_input_method
;
1053 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1054 Qnil
, history
, default_value
,
1055 inherit_input_method
, Qnil
);
1056 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1057 val
= default_value
;
1061 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1062 doc
: /* Read a string from the terminal, not allowing blanks.
1063 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1064 non-nil, it should be a string, which is used as initial input, with
1065 point positioned at the end, so that SPACE will accept the input.
1066 \(Actually, INITIAL can also be a cons of a string and an integer.
1067 Such values are treated as in `read-from-minibuffer', but are normally
1068 not useful in this function.)
1069 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1070 the current input method and the setting of`enable-multibyte-characters'. */)
1071 (prompt
, initial
, inherit_input_method
)
1072 Lisp_Object prompt
, initial
, inherit_input_method
;
1074 CHECK_STRING (prompt
);
1075 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1076 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1077 !NILP (inherit_input_method
), 0);
1080 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1081 doc
: /* Read the name of a command and return as a symbol.
1082 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1083 (prompt
, default_value
)
1084 Lisp_Object prompt
, default_value
;
1086 Lisp_Object name
, default_string
;
1088 if (NILP (default_value
))
1089 default_string
= Qnil
;
1090 else if (SYMBOLP (default_value
))
1091 default_string
= SYMBOL_NAME (default_value
);
1093 default_string
= default_value
;
1095 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1096 Qnil
, Qnil
, default_string
, Qnil
);
1099 return Fintern (name
, Qnil
);
1103 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1104 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1105 Prompt with PROMPT. */)
1109 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1114 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1115 doc
: /* Read the name of a user variable and return it as a symbol.
1116 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1117 A user variable is one for which `user-variable-p' returns non-nil. */)
1118 (prompt
, default_value
)
1119 Lisp_Object prompt
, default_value
;
1121 Lisp_Object name
, default_string
;
1123 if (NILP (default_value
))
1124 default_string
= Qnil
;
1125 else if (SYMBOLP (default_value
))
1126 default_string
= SYMBOL_NAME (default_value
);
1128 default_string
= default_value
;
1130 name
= Fcompleting_read (prompt
, Vobarray
,
1131 Quser_variable_p
, Qt
,
1132 Qnil
, Qnil
, default_string
, Qnil
);
1135 return Fintern (name
, Qnil
);
1138 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1139 doc
: /* Read the name of a buffer and return as a string.
1141 Optional second arg DEF is value to return if user enters an empty line.
1142 If optional third arg REQUIRE-MATCH is non-nil,
1143 only existing buffer names are allowed.
1144 The argument PROMPT should be a string ending with a colon and a space. */)
1145 (prompt
, def
, require_match
)
1146 Lisp_Object prompt
, def
, require_match
;
1148 Lisp_Object args
[4];
1153 def
= XBUFFER (def
)->name
;
1155 if (NILP (Vread_buffer_function
))
1159 /* A default value was provided: we must change PROMPT,
1160 editing the default value in before the colon. To achieve
1161 this, we replace PROMPT with a substring that doesn't
1162 contain the terminal space and colon (if present). They
1163 are then added back using Fformat. */
1165 if (STRINGP (prompt
))
1169 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1171 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1174 prompt
= make_specified_string (s
, -1, len
,
1175 STRING_MULTIBYTE (prompt
));
1178 args
[0] = build_string ("%s (default %s): ");
1181 prompt
= Fformat (3, args
);
1184 return Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
,
1185 require_match
, Qnil
, Qbuffer_name_history
,
1190 args
[0] = Vread_buffer_function
;
1193 args
[3] = require_match
;
1194 return Ffuncall(4, args
);
1199 minibuf_conform_representation (string
, basis
)
1200 Lisp_Object string
, basis
;
1202 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1205 if (STRING_MULTIBYTE (string
))
1206 return Fstring_make_unibyte (string
);
1208 return Fstring_make_multibyte (string
);
1211 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1212 doc
: /* Return common substring of all completions of STRING in ALIST.
1213 Each car of each element of ALIST (or each element if it is not a cons cell)
1214 is tested to see if it begins with STRING. The possible matches may be
1215 strings or symbols. Symbols are converted to strings before testing,
1217 All that match are compared together; the longest initial sequence
1218 common to all matches is returned as a string.
1219 If there is no match at all, nil is returned.
1220 For a unique match which is exact, t is returned.
1222 If ALIST is a hash-table, all the string and symbol keys are the
1224 If ALIST is an obarray, the names of all symbols in the obarray
1225 are the possible matches.
1227 ALIST can also be a function to do the completion itself.
1228 It receives three arguments: the values STRING, PREDICATE and nil.
1229 Whatever it returns becomes the value of `try-completion'.
1231 If optional third argument PREDICATE is non-nil,
1232 it is used to test each possible match.
1233 The match is a candidate only if PREDICATE returns non-nil.
1234 The argument given to PREDICATE is the alist element
1235 or the symbol from the obarray. If ALIST is a hash-table,
1236 predicate is called with two arguments: the key and the value.
1237 Additionally to this predicate, `completion-regexp-list'
1238 is used to further constrain the set of candidates. */)
1239 (string
, alist
, predicate
)
1240 Lisp_Object string
, alist
, predicate
;
1242 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1243 /* Size in bytes of BESTMATCH. */
1244 int bestmatchsize
= 0;
1245 /* These are in bytes, too. */
1246 int compare
, matchsize
;
1247 int type
= (HASH_TABLE_P (alist
) ? 3
1248 : VECTORP (alist
) ? 2
1249 : NILP (alist
) || (CONSP (alist
)
1250 && (!SYMBOLP (XCAR (alist
))
1251 || NILP (XCAR (alist
)))));
1252 int index
= 0, obsize
= 0;
1255 Lisp_Object bucket
, zero
, end
, tem
;
1256 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1258 CHECK_STRING (string
);
1260 return call3 (alist
, string
, predicate
, Qnil
);
1262 bestmatch
= bucket
= Qnil
;
1263 zero
= make_number (0);
1265 /* If ALIST is not a list, set TAIL just for gc pro. */
1269 obsize
= XVECTOR (alist
)->size
;
1270 bucket
= XVECTOR (alist
)->contents
[index
];
1275 /* Get the next element of the alist, obarray, or hash-table. */
1276 /* Exit the loop if the elements are all used up. */
1277 /* elt gets the alist element or symbol.
1278 eltstring gets the name to check as a completion. */
1285 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1290 if (!EQ (bucket
, zero
))
1294 if (XSYMBOL (bucket
)->next
)
1295 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1297 XSETFASTINT (bucket
, 0);
1299 else if (++index
>= obsize
)
1303 bucket
= XVECTOR (alist
)->contents
[index
];
1307 else /* if (type == 3) */
1309 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1310 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1312 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1315 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1318 /* Is this element a possible completion? */
1320 if (SYMBOLP (eltstring
))
1321 eltstring
= Fsymbol_name (eltstring
);
1323 if (STRINGP (eltstring
)
1324 && SCHARS (string
) <= SCHARS (eltstring
)
1325 && (tem
= Fcompare_strings (eltstring
, zero
,
1326 make_number (SCHARS (string
)),
1328 completion_ignore_case
? Qt
: Qnil
),
1332 Lisp_Object regexps
;
1334 /* Ignore this element if it fails to match all the regexps. */
1336 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1337 regexps
= XCDR (regexps
))
1339 if (bindcount
< 0) {
1340 bindcount
= SPECPDL_INDEX ();
1341 specbind (Qcase_fold_search
,
1342 completion_ignore_case
? Qt
: Qnil
);
1344 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1348 if (CONSP (regexps
))
1352 /* Ignore this element if there is a predicate
1353 and the predicate doesn't like it. */
1355 if (!NILP (predicate
))
1357 if (EQ (predicate
, Qcommandp
))
1358 tem
= Fcommandp (elt
, Qnil
);
1361 if (bindcount
>= 0) {
1362 unbind_to (bindcount
, Qnil
);
1365 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1367 ? call2 (predicate
, elt
,
1368 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1369 : call1 (predicate
, elt
);
1372 if (NILP (tem
)) continue;
1375 /* Update computation of how much all possible completions match */
1377 if (NILP (bestmatch
))
1380 bestmatch
= eltstring
;
1381 bestmatchsize
= SCHARS (eltstring
);
1385 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1386 tem
= Fcompare_strings (bestmatch
, zero
,
1387 make_number (compare
),
1389 make_number (compare
),
1390 completion_ignore_case
? Qt
: Qnil
);
1392 matchsize
= compare
;
1393 else if (XINT (tem
) < 0)
1394 matchsize
= - XINT (tem
) - 1;
1396 matchsize
= XINT (tem
) - 1;
1399 /* When can this happen ? -stef */
1400 matchsize
= compare
;
1401 if (completion_ignore_case
)
1403 /* If this is an exact match except for case,
1404 use it as the best match rather than one that is not an
1405 exact match. This way, we get the case pattern
1406 of the actual match. */
1407 if ((matchsize
== SCHARS (eltstring
)
1408 && matchsize
< SCHARS (bestmatch
))
1410 /* If there is more than one exact match ignoring case,
1411 and one of them is exact including case,
1413 /* If there is no exact match ignoring case,
1414 prefer a match that does not change the case
1416 ((matchsize
== SCHARS (eltstring
))
1418 (matchsize
== SCHARS (bestmatch
))
1419 && (tem
= Fcompare_strings (eltstring
, zero
,
1420 make_number (SCHARS (string
)),
1425 && (tem
= Fcompare_strings (bestmatch
, zero
,
1426 make_number (SCHARS (string
)),
1431 bestmatch
= eltstring
;
1433 if (bestmatchsize
!= SCHARS (eltstring
)
1434 || bestmatchsize
!= matchsize
)
1435 /* Don't count the same string multiple times. */
1437 bestmatchsize
= matchsize
;
1438 if (matchsize
<= SCHARS (string
)
1440 /* No need to look any further. */
1446 if (bindcount
>= 0) {
1447 unbind_to (bindcount
, Qnil
);
1451 if (NILP (bestmatch
))
1452 return Qnil
; /* No completions found */
1453 /* If we are ignoring case, and there is no exact match,
1454 and no additional text was supplied,
1455 don't change the case of what the user typed. */
1456 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1457 && SCHARS (bestmatch
) > bestmatchsize
)
1458 return minibuf_conform_representation (string
, bestmatch
);
1460 /* Return t if the supplied string is an exact match (counting case);
1461 it does not require any change to be made. */
1462 if (matchcount
== 1 && bestmatchsize
== SCHARS (string
)
1463 && (tem
= Fcompare_strings (bestmatch
, make_number (0),
1464 make_number (bestmatchsize
),
1465 string
, make_number (0),
1466 make_number (bestmatchsize
),
1471 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1472 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1473 return Fsubstring (bestmatch
, zero
, end
);
1476 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1477 doc
: /* Search for partial matches to STRING in ALIST.
1478 Each car of each element of ALIST (or each element if it is not a cons cell)
1479 is tested to see if it begins with STRING. The possible matches may be
1480 strings or symbols. Symbols are converted to strings before testing,
1482 The value is a list of all the strings from ALIST that match.
1484 If ALIST is a hash-table, all the string and symbol keys are the
1486 If ALIST is an obarray, the names of all symbols in the obarray
1487 are the possible matches.
1489 ALIST can also be a function to do the completion itself.
1490 It receives three arguments: the values STRING, PREDICATE and t.
1491 Whatever it returns becomes the value of `all-completions'.
1493 If optional third argument PREDICATE is non-nil,
1494 it is used to test each possible match.
1495 The match is a candidate only if PREDICATE returns non-nil.
1496 The argument given to PREDICATE is the alist element
1497 or the symbol from the obarray. If ALIST is a hash-table,
1498 predicate is called with two arguments: the key and the value.
1499 Additionally to this predicate, `completion-regexp-list'
1500 is used to further constrain the set of candidates.
1502 If the optional fourth argument HIDE-SPACES is non-nil,
1503 strings in ALIST that start with a space
1504 are ignored unless STRING itself starts with a space. */)
1505 (string
, alist
, predicate
, hide_spaces
)
1506 Lisp_Object string
, alist
, predicate
, hide_spaces
;
1508 Lisp_Object tail
, elt
, eltstring
;
1509 Lisp_Object allmatches
;
1510 int type
= HASH_TABLE_P (alist
) ? 3
1511 : VECTORP (alist
) ? 2
1512 : NILP (alist
) || (CONSP (alist
)
1513 && (!SYMBOLP (XCAR (alist
))
1514 || NILP (XCAR (alist
))));
1515 int index
= 0, obsize
= 0;
1517 Lisp_Object bucket
, tem
, zero
;
1518 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1520 CHECK_STRING (string
);
1522 return call3 (alist
, string
, predicate
, Qt
);
1523 allmatches
= bucket
= Qnil
;
1524 zero
= make_number (0);
1526 /* If ALIST is not a list, set TAIL just for gc pro. */
1530 obsize
= XVECTOR (alist
)->size
;
1531 bucket
= XVECTOR (alist
)->contents
[index
];
1536 /* Get the next element of the alist, obarray, or hash-table. */
1537 /* Exit the loop if the elements are all used up. */
1538 /* elt gets the alist element or symbol.
1539 eltstring gets the name to check as a completion. */
1546 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1551 if (!EQ (bucket
, zero
))
1555 if (XSYMBOL (bucket
)->next
)
1556 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1558 XSETFASTINT (bucket
, 0);
1560 else if (++index
>= obsize
)
1564 bucket
= XVECTOR (alist
)->contents
[index
];
1568 else /* if (type == 3) */
1570 while (index
< HASH_TABLE_SIZE (XHASH_TABLE (alist
))
1571 && NILP (HASH_HASH (XHASH_TABLE (alist
), index
)))
1573 if (index
>= HASH_TABLE_SIZE (XHASH_TABLE (alist
)))
1576 elt
= eltstring
= HASH_KEY (XHASH_TABLE (alist
), index
++);
1579 /* Is this element a possible completion? */
1581 if (SYMBOLP (eltstring
))
1582 eltstring
= Fsymbol_name (eltstring
);
1584 if (STRINGP (eltstring
)
1585 && SCHARS (string
) <= SCHARS (eltstring
)
1586 /* If HIDE_SPACES, reject alternatives that start with space
1587 unless the input starts with space. */
1588 && ((SBYTES (string
) > 0
1589 && SREF (string
, 0) == ' ')
1590 || SREF (eltstring
, 0) != ' '
1591 || NILP (hide_spaces
))
1592 && (tem
= Fcompare_strings (eltstring
, zero
,
1593 make_number (SCHARS (string
)),
1595 make_number (SCHARS (string
)),
1596 completion_ignore_case
? Qt
: Qnil
),
1600 Lisp_Object regexps
;
1602 XSETFASTINT (zero
, 0);
1604 /* Ignore this element if it fails to match all the regexps. */
1606 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1607 regexps
= XCDR (regexps
))
1609 if (bindcount
< 0) {
1610 bindcount
= SPECPDL_INDEX ();
1611 specbind (Qcase_fold_search
,
1612 completion_ignore_case
? Qt
: Qnil
);
1614 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1618 if (CONSP (regexps
))
1622 /* Ignore this element if there is a predicate
1623 and the predicate doesn't like it. */
1625 if (!NILP (predicate
))
1627 if (EQ (predicate
, Qcommandp
))
1628 tem
= Fcommandp (elt
, Qnil
);
1631 if (bindcount
>= 0) {
1632 unbind_to (bindcount
, Qnil
);
1635 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1637 ? call2 (predicate
, elt
,
1638 HASH_VALUE (XHASH_TABLE (alist
), index
- 1))
1639 : call1 (predicate
, elt
);
1642 if (NILP (tem
)) continue;
1644 /* Ok => put it on the list. */
1645 allmatches
= Fcons (eltstring
, allmatches
);
1649 if (bindcount
>= 0) {
1650 unbind_to (bindcount
, Qnil
);
1654 return Fnreverse (allmatches
);
1657 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
1658 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
1659 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
1660 Lisp_Object Vminibuffer_completing_file_name
;
1662 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1663 doc
: /* Read a string in the minibuffer, with completion.
1664 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1665 TABLE can be an list of strings, an alist, an obarray or a hash table.
1666 TABLE can also be a function to do the completion itself.
1667 PREDICATE limits completion to a subset of TABLE.
1668 See `try-completion' and `all-completions' for more details
1669 on completion, TABLE, and PREDICATE.
1671 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1672 the input is (or completes to) an element of TABLE or is null.
1673 If it is also not t, typing RET does not exit if it does non-null completion.
1674 If the input is null, `completing-read' returns DEF, or an empty string
1675 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1677 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1678 with point positioned at the end.
1679 If it is (STRING . POSITION), the initial input is STRING, but point
1680 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1681 that this is different from `read-from-minibuffer' and related
1682 functions, which use one-indexing for POSITION.) This feature is
1683 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1684 default value DEF instead. The user can yank the default value into
1685 the minibuffer easily using \\[next-history-element].
1687 HIST, if non-nil, specifies a history list and optionally the initial
1688 position in the list. It can be a symbol, which is the history list
1689 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1690 that case, HISTVAR is the history list variable to use, and HISTPOS
1691 is the initial position (the position in the list used by the
1692 minibuffer history commands). For consistency, you should also
1693 specify that element of the history as the value of
1694 INITIAL-INPUT. (This is the only case in which you should use
1695 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1696 1 at the beginning of the list. The variable `history-length'
1697 controls the maximum length of a history list.
1699 DEF, if non-nil, is the default value.
1701 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1702 the current input method and the setting of `enable-multibyte-characters'.
1704 Completion ignores case if the ambient value of
1705 `completion-ignore-case' is non-nil. */)
1706 (prompt
, table
, predicate
, require_match
, initial_input
, hist
, def
, inherit_input_method
)
1707 Lisp_Object prompt
, table
, predicate
, require_match
, initial_input
;
1708 Lisp_Object hist
, def
, inherit_input_method
;
1710 Lisp_Object val
, histvar
, histpos
, position
;
1713 int count
= SPECPDL_INDEX ();
1714 struct gcpro gcpro1
;
1716 init
= initial_input
;
1719 specbind (Qminibuffer_completion_table
, table
);
1720 specbind (Qminibuffer_completion_predicate
, predicate
);
1721 specbind (Qminibuffer_completion_confirm
,
1722 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1723 last_exact_completion
= Qnil
;
1730 position
= Fcdr (init
);
1733 CHECK_STRING (init
);
1734 if (!NILP (position
))
1736 CHECK_NUMBER (position
);
1737 /* Convert to distance from end of input. */
1738 pos
= XINT (position
) - SCHARS (init
);
1749 histvar
= Fcar_safe (hist
);
1750 histpos
= Fcdr_safe (hist
);
1753 histvar
= Qminibuffer_history
;
1755 XSETFASTINT (histpos
, 0);
1757 val
= read_minibuf (NILP (require_match
)
1758 ? (NILP (Vminibuffer_completing_file_name
)
1759 ? Vminibuffer_local_completion_map
1760 : Vminibuffer_local_filename_completion_map
)
1761 : (NILP (Vminibuffer_completing_file_name
)
1762 ? Vminibuffer_local_must_match_map
1763 : Vminibuffer_local_must_match_filename_map
),
1764 init
, prompt
, make_number (pos
), 0,
1765 histvar
, histpos
, def
, 0,
1766 !NILP (inherit_input_method
), 0);
1768 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1771 RETURN_UNGCPRO (unbind_to (count
, val
));
1774 Lisp_Object
Fminibuffer_completion_help ();
1775 Lisp_Object
Fassoc_string ();
1777 /* Test whether TXT is an exact completion. */
1778 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1779 doc
: /* Return non-nil if STRING is a valid completion.
1780 Takes the same arguments as `all-completions' and `try-completion'.
1781 If ALIST is a function, it is called with three arguments:
1782 the values STRING, PREDICATE and `lambda'. */)
1783 (string
, alist
, predicate
)
1784 Lisp_Object string
, alist
, predicate
;
1786 Lisp_Object regexps
, tail
, tem
= Qnil
;
1789 CHECK_STRING (string
);
1791 if ((CONSP (alist
) && (!SYMBOLP (XCAR (alist
)) || NILP (XCAR (alist
))))
1794 tem
= Fassoc_string (string
, alist
, completion_ignore_case
? Qt
: Qnil
);
1798 else if (VECTORP (alist
))
1800 /* Bypass intern-soft as that loses for nil. */
1801 tem
= oblookup (alist
,
1807 if (STRING_MULTIBYTE (string
))
1808 string
= Fstring_make_unibyte (string
);
1810 string
= Fstring_make_multibyte (string
);
1812 tem
= oblookup (alist
,
1818 if (completion_ignore_case
&& !SYMBOLP (tem
))
1820 for (i
= XVECTOR (alist
)->size
- 1; i
>= 0; i
--)
1822 tail
= XVECTOR (alist
)->contents
[i
];
1826 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1827 Fsymbol_name (tail
),
1828 make_number (0) , Qnil
, Qt
)),
1834 if (XSYMBOL (tail
)->next
== 0)
1836 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1844 else if (HASH_TABLE_P (alist
))
1846 struct Lisp_Hash_Table
*h
= XHASH_TABLE (alist
);
1847 i
= hash_lookup (h
, string
, NULL
);
1849 tem
= HASH_KEY (h
, i
);
1851 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1852 if (!NILP (HASH_HASH (h
, i
)) &&
1853 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1854 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1855 completion_ignore_case
? Qt
: Qnil
),
1858 tem
= HASH_KEY (h
, i
);
1865 return call3 (alist
, string
, predicate
, Qlambda
);
1867 /* Reject this element if it fails to match all the regexps. */
1868 if (CONSP (Vcompletion_regexp_list
))
1870 int count
= SPECPDL_INDEX ();
1871 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1872 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1873 regexps
= XCDR (regexps
))
1875 if (NILP (Fstring_match (XCAR (regexps
),
1876 SYMBOLP (tem
) ? string
: tem
,
1878 return unbind_to (count
, Qnil
);
1880 unbind_to (count
, Qnil
);
1883 /* Finally, check the predicate. */
1884 if (!NILP (predicate
))
1886 return HASH_TABLE_P (alist
)
1887 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (alist
), i
))
1888 : call1 (predicate
, tem
);
1895 * 0 no possible completion
1896 * 1 was already an exact and unique completion
1897 * 3 was already an exact completion
1898 * 4 completed to an exact completion
1899 * 5 some completion happened
1900 * 6 no completion happened
1905 Lisp_Object completion
, string
, tem
;
1908 struct gcpro gcpro1
, gcpro2
;
1910 completion
= Ftry_completion (Fminibuffer_completion_contents (),
1911 Vminibuffer_completion_table
,
1912 Vminibuffer_completion_predicate
);
1913 last
= last_exact_completion
;
1914 last_exact_completion
= Qnil
;
1916 GCPRO2 (completion
, last
);
1918 if (NILP (completion
))
1921 temp_echo_area_glyphs (build_string (" [No match]"));
1926 if (EQ (completion
, Qt
)) /* exact and unique match */
1932 string
= Fminibuffer_completion_contents ();
1934 /* COMPLETEDP should be true if some completion was done, which
1935 doesn't include simply changing the case of the entered string.
1936 However, for appearance, the string is rewritten if the case
1938 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qt
);
1939 completedp
= !EQ (tem
, Qt
);
1941 tem
= Fcompare_strings (completion
, Qnil
, Qnil
, string
, Qnil
, Qnil
, Qnil
);
1943 /* Rewrite the user's input. */
1945 int prompt_end
= XINT (Fminibuffer_prompt_end ());
1946 /* Some completion happened */
1948 if (! NILP (Vminibuffer_completing_file_name
)
1949 && SREF (completion
, SBYTES (completion
) - 1) == '/'
1951 && FETCH_CHAR (PT_BYTE
) == '/')
1953 del_range (prompt_end
, PT
+ 1);
1956 del_range (prompt_end
, PT
);
1958 Finsert (1, &completion
);
1961 /* The case of the string changed, but that's all. We're not
1962 sure whether this is a unique completion or not, so try again
1963 using the real case (this shouldn't recurse again, because
1964 the next time try-completion will return either `t' or the
1968 return do_completion ();
1972 /* It did find a match. Do we match some possibility exactly now? */
1973 tem
= Ftest_completion (Fminibuffer_contents (),
1974 Vminibuffer_completion_table
,
1975 Vminibuffer_completion_predicate
);
1978 /* not an exact match */
1982 else if (!NILP (Vcompletion_auto_help
))
1983 Fminibuffer_completion_help ();
1985 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1988 else if (completedp
)
1993 /* If the last exact completion and this one were the same,
1994 it means we've already given a "Complete but not unique"
1995 message and the user's hit TAB again, so now we give him help. */
1996 last_exact_completion
= completion
;
1999 tem
= Fminibuffer_completion_contents ();
2000 if (!NILP (Fequal (tem
, last
)))
2001 Fminibuffer_completion_help ();
2007 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2009 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
2010 doc
: /* Like `assoc' but specifically for strings.
2011 Unibyte strings are converted to multibyte for comparison.
2012 And case is ignored if CASE-FOLD is non-nil.
2013 As opposed to `assoc', it will also match an entry consisting of a single
2014 string rather than a cons cell whose car is a string. */)
2015 (key
, list
, case_fold
)
2016 register Lisp_Object key
;
2017 Lisp_Object list
, case_fold
;
2019 register Lisp_Object tail
;
2021 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
2023 register Lisp_Object elt
, tem
, thiscar
;
2025 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
2026 if (!STRINGP (thiscar
))
2028 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
2029 key
, make_number (0), Qnil
,
2038 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
2039 doc
: /* Complete the minibuffer contents as far as possible.
2040 Return nil if there is no valid completion, else t.
2041 If no characters can be completed, display a list of possible completions.
2042 If you repeat this command after it displayed such a list,
2043 scroll the window of possible completions. */)
2047 Lisp_Object window
, tem
;
2049 /* If the previous command was not this,
2050 mark the completion buffer obsolete. */
2051 if (! EQ (current_kboard
->Vlast_command
, Vthis_command
))
2052 Vminibuf_scroll_window
= Qnil
;
2054 window
= Vminibuf_scroll_window
;
2055 /* If there's a fresh completion window with a live buffer,
2056 and this command is repeated, scroll that window. */
2057 if (! NILP (window
) && ! NILP (XWINDOW (window
)->buffer
)
2058 && !NILP (XBUFFER (XWINDOW (window
)->buffer
)->name
))
2060 struct buffer
*obuf
= current_buffer
;
2062 Fset_buffer (XWINDOW (window
)->buffer
);
2063 tem
= Fpos_visible_in_window_p (make_number (ZV
), window
, Qnil
);
2065 /* If end is in view, scroll up to the beginning. */
2066 Fset_window_start (window
, make_number (BEGV
), Qnil
);
2068 /* Else scroll down one screen. */
2069 Fscroll_other_window (Qnil
);
2071 set_buffer_internal (obuf
);
2075 i
= do_completion ();
2083 Fgoto_char (make_number (ZV
));
2084 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2089 Fgoto_char (make_number (ZV
));
2090 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2097 /* Subroutines of Fminibuffer_complete_and_exit. */
2099 /* This one is called by internal_condition_case to do the real work. */
2102 complete_and_exit_1 ()
2104 return make_number (do_completion ());
2107 /* This one is called by internal_condition_case if an error happens.
2108 Pretend the current value is an exact match. */
2111 complete_and_exit_2 (ignore
)
2114 return make_number (1);
2117 EXFUN (Fexit_minibuffer
, 0) NO_RETURN
;
2119 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
2120 Sminibuffer_complete_and_exit
, 0, 0, "",
2121 doc
: /* If the minibuffer contents is a valid completion then exit.
2122 Otherwise try to complete it. If completion leads to a valid completion,
2123 a repetition of this command will exit. */)
2127 Lisp_Object val
, tem
;
2129 /* Allow user to specify null string */
2130 if (XINT (Fminibuffer_prompt_end ()) == ZV
)
2133 val
= Fminibuffer_contents ();
2134 tem
= Ftest_completion (val
,
2135 Vminibuffer_completion_table
,
2136 Vminibuffer_completion_predicate
);
2139 if (completion_ignore_case
)
2140 { /* Fixup case of the field, if necessary. */
2142 = Ftry_completion (val
,
2143 Vminibuffer_completion_table
,
2144 Vminibuffer_completion_predicate
);
2146 /* If it weren't for this piece of paranoia, I'd replace
2147 the whole thing with a call to do_completion. */
2148 && EQ (Flength (val
), Flength (compl)))
2150 del_range (XINT (Fminibuffer_prompt_end ()), ZV
);
2151 Finsert (1, &compl);
2157 /* Call do_completion, but ignore errors. */
2159 val
= internal_condition_case (complete_and_exit_1
, Qerror
,
2160 complete_and_exit_2
);
2170 if (!NILP (Vminibuffer_completion_confirm
))
2172 temp_echo_area_glyphs (build_string (" [Confirm]"));
2182 return Fexit_minibuffer ();
2186 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
2188 doc
: /* Complete the minibuffer contents at most a single word.
2189 After one word is completed as much as possible, a space or hyphen
2190 is added, provided that matches some possible completion.
2191 Return nil if there is no valid completion, else t. */)
2194 Lisp_Object completion
, tem
, tem1
;
2195 register int i
, i_byte
;
2196 struct gcpro gcpro1
, gcpro2
;
2197 int prompt_end_charpos
= XINT (Fminibuffer_prompt_end ());
2199 /* We keep calling Fbuffer_string rather than arrange for GC to
2200 hold onto a pointer to one of the strings thus made. */
2202 completion
= Ftry_completion (Fminibuffer_completion_contents (),
2203 Vminibuffer_completion_table
,
2204 Vminibuffer_completion_predicate
);
2205 if (NILP (completion
))
2208 temp_echo_area_glyphs (build_string (" [No match]"));
2211 if (EQ (completion
, Qt
))
2214 #if 0 /* How the below code used to look, for reference. */
2215 tem
= Fminibuffer_contents ();
2217 i
= ZV
- 1 - SCHARS (completion
);
2218 p
= SDATA (completion
);
2220 0 <= scmp (b
, p
, ZV
- 1))
2223 /* Set buffer to longest match of buffer tail and completion head. */
2224 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
2226 del_range (1, i
+ 1);
2229 #else /* Rewritten code */
2231 int buffer_nchars
, completion_nchars
;
2233 CHECK_STRING (completion
);
2234 tem
= Fminibuffer_completion_contents ();
2235 GCPRO2 (completion
, tem
);
2236 /* If reading a file name,
2237 expand any $ENVVAR refs in the buffer and in TEM. */
2238 if (! NILP (Vminibuffer_completing_file_name
))
2240 Lisp_Object substituted
;
2241 substituted
= Fsubstitute_in_file_name (tem
);
2242 if (! EQ (substituted
, tem
))
2245 del_range (prompt_end_charpos
, PT
);
2249 buffer_nchars
= SCHARS (tem
); /* # chars in what we completed. */
2250 completion_nchars
= SCHARS (completion
);
2251 i
= buffer_nchars
- completion_nchars
;
2254 (tem1
= Fcompare_strings (tem
, make_number (0),
2255 make_number (buffer_nchars
),
2256 completion
, make_number (0),
2257 make_number (buffer_nchars
),
2258 completion_ignore_case
? Qt
: Qnil
),
2263 /* Make buffer (before point) contain the longest match
2264 of TEM's tail and COMPLETION's head. */
2270 tem1
= Fcompare_strings (tem
, make_number (start_pos
), Qnil
,
2271 completion
, make_number (0),
2272 make_number (buffer_nchars
),
2273 completion_ignore_case
? Qt
: Qnil
);
2280 del_range (start_pos
, start_pos
+ buffer_nchars
);
2284 #endif /* Rewritten code */
2287 int prompt_end_bytepos
;
2288 prompt_end_bytepos
= CHAR_TO_BYTE (prompt_end_charpos
);
2289 i
= PT
- prompt_end_charpos
;
2290 i_byte
= PT_BYTE
- prompt_end_bytepos
;
2293 /* If completion finds next char not unique,
2294 consider adding a space or a hyphen. */
2295 if (i
== SCHARS (completion
))
2297 GCPRO1 (completion
);
2298 tem
= Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2299 build_string (" ")),
2300 Vminibuffer_completion_table
,
2301 Vminibuffer_completion_predicate
);
2308 GCPRO1 (completion
);
2310 Ftry_completion (concat2 (Fminibuffer_completion_contents (),
2311 build_string ("-")),
2312 Vminibuffer_completion_table
,
2313 Vminibuffer_completion_predicate
);
2321 /* Now find first word-break in the stuff found by completion.
2322 i gets index in string of where to stop completing. */
2325 int bytes
= SBYTES (completion
);
2326 register const unsigned char *completion_string
= SDATA (completion
);
2327 for (; i_byte
< SBYTES (completion
); i_byte
+= len
, i
++)
2329 c
= STRING_CHAR_AND_LENGTH (completion_string
+ i_byte
,
2332 if (SYNTAX (c
) != Sword
)
2341 /* If got no characters, print help for user. */
2343 if (i
== PT
- prompt_end_charpos
)
2345 if (!NILP (Vcompletion_auto_help
))
2346 Fminibuffer_completion_help ();
2350 /* Otherwise insert in minibuffer the chars we got */
2352 if (! NILP (Vminibuffer_completing_file_name
)
2353 && SREF (completion
, SBYTES (completion
) - 1) == '/'
2355 && FETCH_CHAR (PT_BYTE
) == '/')
2357 del_range (prompt_end_charpos
, PT
+ 1);
2360 del_range (prompt_end_charpos
, PT
);
2362 insert_from_string (completion
, 0, 0, i
, i_byte
, 1);
2366 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
2368 doc
: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2369 Each element may be just a symbol or string
2370 or may be a list of two strings to be printed as if concatenated.
2371 If it is a list of two strings, the first is the actual completion
2372 alternative, the second serves as annotation.
2373 `standard-output' must be a buffer.
2374 The actual completion alternatives, as inserted, are given `mouse-face'
2375 properties of `highlight'.
2376 At the end, this runs the normal hook `completion-setup-hook'.
2377 It can find the completion buffer in `standard-output'.
2378 The optional second arg COMMON-SUBSTRING is a string.
2379 It is used to put faces, `completions-first-difference' and
2380 `completions-common-part' on the completion buffer. The
2381 `completions-common-part' face is put on the common substring
2382 specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil
2383 and the current buffer is not the minibuffer, the faces are not put.
2384 Internally, COMMON-SUBSTRING is bound to `completion-common-substring'
2385 during running `completion-setup-hook'. */)
2386 (completions
, common_substring
)
2387 Lisp_Object completions
;
2388 Lisp_Object common_substring
;
2390 Lisp_Object tail
, elt
;
2393 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2394 struct buffer
*old
= current_buffer
;
2397 /* Note that (when it matters) every variable
2398 points to a non-string that is pointed to by COMPLETIONS,
2399 except for ELT. ELT can be pointing to a string
2400 when terpri or Findent_to calls a change hook. */
2402 GCPRO3 (completions
, elt
, common_substring
);
2404 if (BUFFERP (Vstandard_output
))
2405 set_buffer_internal (XBUFFER (Vstandard_output
));
2407 if (NILP (completions
))
2408 write_string ("There are no possible completions of what you have typed.",
2412 write_string ("Possible completions are:", -1);
2413 for (tail
= completions
, i
= 0; CONSP (tail
); tail
= XCDR (tail
), i
++)
2415 Lisp_Object tem
, string
;
2417 Lisp_Object startpos
, endpos
;
2423 elt
= SYMBOL_NAME (elt
);
2424 /* Compute the length of this element. */
2429 length
= SCHARS (tem
);
2431 tem
= Fcar (XCDR (elt
));
2433 length
+= SCHARS (tem
);
2438 length
= SCHARS (elt
);
2441 /* This does a bad job for narrower than usual windows.
2442 Sadly, the window it will appear in is not known
2443 until after the text has been made. */
2445 if (BUFFERP (Vstandard_output
))
2446 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2448 /* If the previous completion was very wide,
2449 or we have two on this line already,
2450 don't put another on the same line. */
2451 if (column
> 33 || first
2452 /* If this is really wide, don't put it second on a line. */
2453 || (column
> 0 && length
> 45))
2458 /* Otherwise advance to column 35. */
2461 if (BUFFERP (Vstandard_output
))
2463 tem
= Findent_to (make_number (35), make_number (2));
2465 column
= XINT (tem
);
2471 write_string (" ", -1);
2474 while (column
< 35);
2478 if (BUFFERP (Vstandard_output
))
2480 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2481 Fset_text_properties (startpos
, endpos
,
2482 Qnil
, Vstandard_output
);
2485 /* Output this element.
2486 If necessary, convert it to unibyte or to multibyte first. */
2488 string
= Fcar (elt
);
2491 if (NILP (current_buffer
->enable_multibyte_characters
)
2492 && STRING_MULTIBYTE (string
))
2493 string
= Fstring_make_unibyte (string
);
2494 else if (!NILP (current_buffer
->enable_multibyte_characters
)
2495 && !STRING_MULTIBYTE (string
))
2496 string
= Fstring_make_multibyte (string
);
2498 if (BUFFERP (Vstandard_output
))
2500 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2502 Fprinc (string
, Qnil
);
2504 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2506 Fput_text_property (startpos
, endpos
,
2507 Qmouse_face
, intern ("highlight"),
2512 Fprinc (string
, Qnil
);
2515 /* Output the annotation for this element. */
2518 if (BUFFERP (Vstandard_output
))
2520 XSETINT (startpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2522 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2524 XSETINT (endpos
, BUF_PT (XBUFFER (Vstandard_output
)));
2526 Fset_text_properties (startpos
, endpos
, Qnil
,
2531 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
2536 /* Update COLUMN for what we have output. */
2539 /* If output is to a buffer, recompute COLUMN in a way
2540 that takes account of character widths. */
2541 if (BUFFERP (Vstandard_output
))
2543 tem
= Fcurrent_column ();
2544 column
= XINT (tem
);
2551 if (BUFFERP (Vstandard_output
))
2552 set_buffer_internal (old
);
2554 if (!NILP (Vrun_hooks
))
2556 int count1
= SPECPDL_INDEX ();
2558 specbind (intern ("completion-common-substring"), common_substring
);
2559 call1 (Vrun_hooks
, intern ("completion-setup-hook"));
2561 unbind_to (count1
, Qnil
);
2571 display_completion_list_1 (list
)
2574 return Fdisplay_completion_list (list
, Qnil
);
2577 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
2579 doc
: /* Display a list of possible completions of the current minibuffer contents. */)
2582 Lisp_Object completions
;
2584 message ("Making completion list...");
2585 completions
= Fall_completions (Fminibuffer_completion_contents (),
2586 Vminibuffer_completion_table
,
2587 Vminibuffer_completion_predicate
,
2589 clear_message (1, 0);
2591 if (NILP (completions
))
2594 temp_echo_area_glyphs (build_string (" [No completions]"));
2598 /* Sort and remove duplicates. */
2599 Lisp_Object tmp
= completions
= Fsort (completions
, Qstring_lessp
);
2602 if (CONSP (XCDR (tmp
))
2603 && !NILP (Fequal (XCAR (tmp
), XCAR (XCDR (tmp
)))))
2604 XSETCDR (tmp
, XCDR (XCDR (tmp
)));
2608 internal_with_output_to_temp_buffer ("*Completions*",
2609 display_completion_list_1
,
2615 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
2616 doc
: /* Terminate minibuffer input. */)
2619 if (INTEGERP (last_command_char
))
2620 internal_self_insert (XINT (last_command_char
), 0);
2624 return Fexit_minibuffer ();
2627 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
2628 doc
: /* Terminate this minibuffer argument. */)
2631 /* If the command that uses this has made modifications in the minibuffer,
2632 we don't want them to cause deactivation of the mark in the original
2634 A better solution would be to make deactivate-mark buffer-local
2635 (or to turn it into a list of buffers, ...), but in the mean time,
2636 this should do the trick in most cases. */
2637 Vdeactivate_mark
= Qnil
;
2638 Fthrow (Qexit
, Qnil
);
2641 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
2642 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2645 return make_number (minibuf_level
);
2648 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
2649 doc
: /* Return the prompt string of the currently-active minibuffer.
2650 If no minibuffer is active, return nil. */)
2653 return Fcopy_sequence (minibuf_prompt
);
2657 /* Temporarily display STRING at the end of the current
2658 minibuffer contents. This is used to display things like
2659 "[No Match]" when the user requests a completion for a prefix
2660 that has no possible completions, and other quick, unobtrusive
2664 temp_echo_area_glyphs (string
)
2668 int osize_byte
= ZV_BYTE
;
2670 int opoint_byte
= PT_BYTE
;
2671 Lisp_Object oinhibit
;
2672 oinhibit
= Vinhibit_quit
;
2674 /* Clear out any old echo-area message to make way for our new thing. */
2677 SET_PT_BOTH (osize
, osize_byte
);
2678 insert_from_string (string
, 0, 0, SCHARS (string
), SBYTES (string
), 0);
2679 SET_PT_BOTH (opoint
, opoint_byte
);
2681 Fsit_for (make_number (2), Qnil
, Qnil
);
2682 del_range_both (osize
, osize_byte
, ZV
, ZV_BYTE
, 1);
2683 SET_PT_BOTH (opoint
, opoint_byte
);
2684 if (!NILP (Vquit_flag
))
2687 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
2689 Vinhibit_quit
= oinhibit
;
2692 DEFUN ("minibuffer-message", Fminibuffer_message
, Sminibuffer_message
,
2694 doc
: /* Temporarily display STRING at the end of the minibuffer.
2695 The text is displayed for a period controlled by `minibuffer-message-timeout',
2696 or until the next input event arrives, whichever comes first. */)
2700 CHECK_STRING (string
);
2701 temp_echo_area_glyphs (string
);
2706 init_minibuf_once ()
2708 Vminibuffer_list
= Qnil
;
2709 staticpro (&Vminibuffer_list
);
2716 minibuf_prompt
= Qnil
;
2717 staticpro (&minibuf_prompt
);
2719 minibuf_save_list
= Qnil
;
2720 staticpro (&minibuf_save_list
);
2722 Qread_file_name_internal
= intern ("read-file-name-internal");
2723 staticpro (&Qread_file_name_internal
);
2725 Qminibuffer_default
= intern ("minibuffer-default");
2726 staticpro (&Qminibuffer_default
);
2727 Fset (Qminibuffer_default
, Qnil
);
2729 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
2730 staticpro (&Qminibuffer_completion_table
);
2732 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
2733 staticpro (&Qminibuffer_completion_confirm
);
2735 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
2736 staticpro (&Qminibuffer_completion_predicate
);
2738 staticpro (&last_exact_completion
);
2739 last_exact_completion
= Qnil
;
2741 staticpro (&last_minibuf_string
);
2742 last_minibuf_string
= Qnil
;
2744 Quser_variable_p
= intern ("user-variable-p");
2745 staticpro (&Quser_variable_p
);
2747 Qminibuffer_history
= intern ("minibuffer-history");
2748 staticpro (&Qminibuffer_history
);
2750 Qbuffer_name_history
= intern ("buffer-name-history");
2751 staticpro (&Qbuffer_name_history
);
2752 Fset (Qbuffer_name_history
, Qnil
);
2754 Qminibuffer_setup_hook
= intern ("minibuffer-setup-hook");
2755 staticpro (&Qminibuffer_setup_hook
);
2757 Qminibuffer_exit_hook
= intern ("minibuffer-exit-hook");
2758 staticpro (&Qminibuffer_exit_hook
);
2760 Qhistory_length
= intern ("history-length");
2761 staticpro (&Qhistory_length
);
2763 Qcurrent_input_method
= intern ("current-input-method");
2764 staticpro (&Qcurrent_input_method
);
2766 Qactivate_input_method
= intern ("activate-input-method");
2767 staticpro (&Qactivate_input_method
);
2769 Qcase_fold_search
= intern ("case-fold-search");
2770 staticpro (&Qcase_fold_search
);
2772 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function
,
2773 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2774 Vread_buffer_function
= Qnil
;
2776 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook
,
2777 doc
: /* Normal hook run just after entry to minibuffer. */);
2778 Vminibuffer_setup_hook
= Qnil
;
2780 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook
,
2781 doc
: /* Normal hook run just after exit from minibuffer. */);
2782 Vminibuffer_exit_hook
= Qnil
;
2784 DEFVAR_LISP ("history-length", &Vhistory_length
,
2785 doc
: /* *Maximum length for history lists before truncation takes place.
2786 A number means that length; t means infinite. Truncation takes place
2787 just after a new element is inserted. Setting the history-length
2788 property of a history variable overrides this default. */);
2789 XSETFASTINT (Vhistory_length
, 30);
2791 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates
,
2792 doc
: /* *Non-nil means to delete duplicates in history.
2793 If set to t when adding a new history element, all previous identical
2794 elements are deleted. */);
2795 history_delete_duplicates
= 0;
2797 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help
,
2798 doc
: /* *Non-nil means automatically provide help for invalid completion input.
2799 Under Partial Completion mode, a non-nil, non-t value has a special meaning;
2800 see the doc string of `partial-completion-mode' for more details. */);
2801 Vcompletion_auto_help
= Qt
;
2803 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
2804 doc
: /* Non-nil means don't consider case significant in completion.
2806 For file-name completion, the variable `read-file-name-completion-ignore-case'
2807 controls the behavior, rather than this variable. */);
2808 completion_ignore_case
= 0;
2810 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
2811 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2812 This variable makes a difference whenever the minibuffer window is active. */);
2813 enable_recursive_minibuffers
= 0;
2815 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
2816 doc
: /* Alist or obarray used for completion in the minibuffer.
2817 This becomes the ALIST argument to `try-completion' and `all-completions'.
2818 The value can also be a list of strings or a hash table.
2820 The value may alternatively be a function, which is given three arguments:
2821 STRING, the current buffer contents;
2822 PREDICATE, the predicate for filtering possible matches;
2823 CODE, which says what kind of things to do.
2824 CODE can be nil, t or `lambda'.
2825 nil means to return the best completion of STRING, or nil if there is none.
2826 t means to return a list of all possible completions of STRING.
2827 `lambda' means to return t if STRING is a valid completion as it stands. */);
2828 Vminibuffer_completion_table
= Qnil
;
2830 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
2831 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2832 Vminibuffer_completion_predicate
= Qnil
;
2834 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
2835 doc
: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2836 Vminibuffer_completion_confirm
= Qnil
;
2838 DEFVAR_LISP ("minibuffer-completing-file-name",
2839 &Vminibuffer_completing_file_name
,
2840 doc
: /* Non-nil means completing file names. */);
2841 Vminibuffer_completing_file_name
= Qnil
;
2843 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
2844 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2845 Vminibuffer_help_form
= Qnil
;
2847 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
2848 doc
: /* History list symbol to add minibuffer values to.
2849 Each string of minibuffer input, as it appears on exit from the minibuffer,
2851 (set minibuffer-history-variable
2852 (cons STRING (symbol-value minibuffer-history-variable))) */);
2853 XSETFASTINT (Vminibuffer_history_variable
, 0);
2855 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
2856 doc
: /* Current position of redoing in the history list. */);
2857 Vminibuffer_history_position
= Qnil
;
2859 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise
,
2860 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2861 Some uses of the echo area also raise that frame (since they use it too). */);
2862 minibuffer_auto_raise
= 0;
2864 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list
,
2865 doc
: /* List of regexps that should restrict possible completions.
2866 The basic completion functions only consider a completion acceptable
2867 if it matches all regular expressions in this list, with
2868 `case-fold-search' bound to the value of `completion-ignore-case'.
2869 See Info node `(elisp)Basic Completion', for a description of these
2871 Vcompletion_regexp_list
= Qnil
;
2873 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2874 &minibuffer_allow_text_properties
,
2875 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2876 This also affects `read-string', but it does not affect `read-minibuffer',
2877 `read-no-blanks-input', or any of the functions that do minibuffer input
2878 with completion; they always discard text properties. */);
2879 minibuffer_allow_text_properties
= 0;
2881 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties
,
2882 doc
: /* Text properties that are added to minibuffer prompts.
2883 These are in addition to the basic `field' property, and stickiness
2885 /* We use `intern' here instead of Qread_only to avoid
2886 initialization-order problems. */
2887 Vminibuffer_prompt_properties
2888 = Fcons (intern ("read-only"), Fcons (Qt
, Qnil
));
2890 defsubr (&Sset_minibuffer_window
);
2891 defsubr (&Sread_from_minibuffer
);
2892 defsubr (&Seval_minibuffer
);
2893 defsubr (&Sread_minibuffer
);
2894 defsubr (&Sread_string
);
2895 defsubr (&Sread_command
);
2896 defsubr (&Sread_variable
);
2897 defsubr (&Sread_buffer
);
2898 defsubr (&Sread_no_blanks_input
);
2899 defsubr (&Sminibuffer_depth
);
2900 defsubr (&Sminibuffer_prompt
);
2902 defsubr (&Sminibufferp
);
2903 defsubr (&Sminibuffer_prompt_end
);
2904 defsubr (&Sminibuffer_contents
);
2905 defsubr (&Sminibuffer_contents_no_properties
);
2906 defsubr (&Sminibuffer_completion_contents
);
2907 defsubr (&Sdelete_minibuffer_contents
);
2909 defsubr (&Stry_completion
);
2910 defsubr (&Sall_completions
);
2911 defsubr (&Stest_completion
);
2912 defsubr (&Sassoc_string
);
2913 defsubr (&Scompleting_read
);
2914 defsubr (&Sminibuffer_complete
);
2915 defsubr (&Sminibuffer_complete_word
);
2916 defsubr (&Sminibuffer_complete_and_exit
);
2917 defsubr (&Sdisplay_completion_list
);
2918 defsubr (&Sminibuffer_completion_help
);
2920 defsubr (&Sself_insert_and_exit
);
2921 defsubr (&Sexit_minibuffer
);
2923 defsubr (&Sminibuffer_message
);
2929 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
2930 "abort-recursive-edit");
2931 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
2933 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
2936 initial_define_key (Vminibuffer_local_ns_map
, ' ',
2938 initial_define_key (Vminibuffer_local_ns_map
, '\t',
2940 initial_define_key (Vminibuffer_local_ns_map
, '?',
2941 "self-insert-and-exit");
2943 initial_define_key (Vminibuffer_local_completion_map
, '\t',
2944 "minibuffer-complete");
2945 initial_define_key (Vminibuffer_local_completion_map
, ' ',
2946 "minibuffer-complete-word");
2947 initial_define_key (Vminibuffer_local_completion_map
, '?',
2948 "minibuffer-completion-help");
2950 Fdefine_key (Vminibuffer_local_filename_completion_map
,
2951 build_string (" "), Qnil
);
2953 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
2954 "minibuffer-complete-and-exit");
2955 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
2956 "minibuffer-complete-and-exit");
2958 Fdefine_key (Vminibuffer_local_must_match_filename_map
,
2959 build_string (" "), Qnil
);
2962 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2963 (do not change this comment) */