1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2011 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
28 #include "character.h"
29 #include "dispextern.h"
34 #include "intervals.h"
36 #include "termhooks.h"
38 /* List of buffers for use as minibuffers.
39 The first element of the list is used for the outermost minibuffer
40 invocation, the next element is used for a recursive minibuffer
41 invocation, etc. The list is extended at the end as deeper
42 minibuffer recursions are encountered. */
44 Lisp_Object Vminibuffer_list
;
46 /* Data to remember during recursive minibuffer invocations */
48 Lisp_Object minibuf_save_list
;
50 /* Depth in minibuffer invocations. */
54 /* The maximum length of a minibuffer history. */
56 Lisp_Object Qhistory_length
;
58 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string
;
62 Lisp_Object Qminibuffer_history
, Qbuffer_name_history
;
64 Lisp_Object Qread_file_name_internal
;
66 /* Normal hooks for entry to and exit from minibuffer. */
68 Lisp_Object Qminibuffer_setup_hook
;
69 Lisp_Object Qminibuffer_exit_hook
;
71 Lisp_Object Qcompletion_ignore_case
;
72 Lisp_Object Qminibuffer_completion_table
;
73 Lisp_Object Qminibuffer_completion_predicate
;
74 Lisp_Object Qminibuffer_completion_confirm
;
75 Lisp_Object Qcompleting_read_default
;
76 Lisp_Object Quser_variable_p
;
78 Lisp_Object Qminibuffer_default
;
80 Lisp_Object Qcurrent_input_method
, Qactivate_input_method
;
82 Lisp_Object Qcase_fold_search
;
84 Lisp_Object Qread_expression_history
;
86 /* Prompt to display in front of the mini-buffer contents. */
88 static Lisp_Object minibuf_prompt
;
90 /* Width of current mini-buffer prompt. Only set after display_line
91 of the line that contains the prompt. */
93 static EMACS_INT minibuf_prompt_width
;
96 /* Put minibuf on currently selected frame's minibuffer.
97 We do this whenever the user starts a new minibuffer
98 or when a minibuffer exits. */
101 choose_minibuf_frame (void)
103 if (FRAMEP (selected_frame
)
104 && FRAME_LIVE_P (XFRAME (selected_frame
))
105 && !EQ (minibuf_window
, XFRAME (selected_frame
)->minibuffer_window
))
107 struct frame
*sf
= XFRAME (selected_frame
);
110 /* I don't think that any frames may validly have a null minibuffer
112 if (NILP (sf
->minibuffer_window
))
115 /* Under X, we come here with minibuf_window being the
116 minibuffer window of the unused termcap window created in
117 init_window_once. That window doesn't have a buffer. */
118 buffer
= XWINDOW (minibuf_window
)->buffer
;
119 if (BUFFERP (buffer
))
120 Fset_window_buffer (sf
->minibuffer_window
, buffer
, Qnil
);
121 minibuf_window
= sf
->minibuffer_window
;
124 /* Make sure no other frame has a minibuffer as its selected window,
125 because the text would not be displayed in it, and that would be
126 confusing. Only allow the selected frame to do this,
127 and that only if the minibuffer is active. */
129 Lisp_Object tail
, frame
;
131 FOR_EACH_FRAME (tail
, frame
)
132 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame
))))
133 && !(EQ (frame
, selected_frame
)
134 && minibuf_level
> 0))
135 Fset_frame_selected_window (frame
, Fframe_first_window (frame
), Qnil
);
140 choose_minibuf_frame_1 (Lisp_Object ignore
)
142 choose_minibuf_frame ();
146 DEFUN ("set-minibuffer-window", Fset_minibuffer_window
,
147 Sset_minibuffer_window
, 1, 1, 0,
148 doc
: /* Specify which minibuffer window to use for the minibuffer.
149 This affects where the minibuffer is displayed if you put text in it
150 without invoking the usual minibuffer commands. */)
153 CHECK_WINDOW (window
);
154 if (! MINI_WINDOW_P (XWINDOW (window
)))
155 error ("Window is not a minibuffer window");
157 minibuf_window
= window
;
163 /* Actual minibuffer invocation. */
165 static Lisp_Object
read_minibuf_unwind (Lisp_Object
);
166 static Lisp_Object
run_exit_minibuf_hook (Lisp_Object
);
167 static Lisp_Object
read_minibuf (Lisp_Object
, Lisp_Object
,
168 Lisp_Object
, Lisp_Object
,
170 Lisp_Object
, Lisp_Object
,
172 static Lisp_Object
read_minibuf_noninteractive (Lisp_Object
, Lisp_Object
,
173 Lisp_Object
, Lisp_Object
,
175 Lisp_Object
, Lisp_Object
,
177 static Lisp_Object
string_to_object (Lisp_Object
, Lisp_Object
);
180 /* Read a Lisp object from VAL and return it. If VAL is an empty
181 string, and DEFALT is a string, read from DEFALT instead of VAL. */
184 string_to_object (Lisp_Object val
, Lisp_Object defalt
)
186 struct gcpro gcpro1
, gcpro2
;
187 Lisp_Object expr_and_pos
;
190 GCPRO2 (val
, defalt
);
192 if (STRINGP (val
) && SCHARS (val
) == 0)
194 if (STRINGP (defalt
))
196 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
200 expr_and_pos
= Fread_from_string (val
, Qnil
, Qnil
);
201 pos
= XINT (Fcdr (expr_and_pos
));
202 if (pos
!= SCHARS (val
))
204 /* Ignore trailing whitespace; any other trailing junk
207 pos
= string_char_to_byte (val
, pos
);
208 for (i
= pos
; i
< SBYTES (val
); i
++)
210 int c
= SREF (val
, i
);
211 if (c
!= ' ' && c
!= '\t' && c
!= '\n')
212 error ("Trailing garbage following expression");
216 val
= Fcar (expr_and_pos
);
217 RETURN_UNGCPRO (val
);
221 /* Like read_minibuf but reading from stdin. This function is called
222 from read_minibuf to do the job if noninteractive. */
225 read_minibuf_noninteractive (Lisp_Object map
, Lisp_Object initial
,
226 Lisp_Object prompt
, Lisp_Object backup_n
,
228 Lisp_Object histvar
, Lisp_Object histpos
,
230 int allow_props
, int inherit_input_method
)
236 fprintf (stdout
, "%s", SDATA (prompt
));
242 line
= (char *) xmalloc (size
* sizeof *line
);
243 while ((s
= fgets (line
+ len
, size
- len
, stdin
)) != NULL
244 && (len
= strlen (line
),
245 len
== size
- 1 && line
[len
- 1] != '\n'))
247 if ((size_t) -1 / 2 < size
)
250 line
= (char *) xrealloc (line
, size
);
257 if (len
> 0 && line
[len
- 1] == '\n')
260 val
= build_string (line
);
266 error ("Error reading from stdin");
269 /* If Lisp form desired instead of string, parse it. */
271 val
= string_to_object (val
, CONSP (defalt
) ? XCAR (defalt
) : defalt
);
276 DEFUN ("minibufferp", Fminibufferp
,
277 Sminibufferp
, 0, 1, 0,
278 doc
: /* Return t if BUFFER is a minibuffer.
279 No argument or nil as argument means use current buffer as BUFFER.
280 BUFFER can be a buffer or a buffer name. */)
286 buffer
= Fcurrent_buffer ();
287 else if (STRINGP (buffer
))
288 buffer
= Fget_buffer (buffer
);
290 CHECK_BUFFER (buffer
);
292 tem
= Fmemq (buffer
, Vminibuffer_list
);
293 return ! NILP (tem
) ? Qt
: Qnil
;
296 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end
,
297 Sminibuffer_prompt_end
, 0, 0, 0,
298 doc
: /* Return the buffer position of the end of the minibuffer prompt.
299 Return (point-min) if current buffer is not a minibuffer. */)
302 /* This function is written to be most efficient when there's a prompt. */
303 Lisp_Object beg
, end
, tem
;
304 beg
= make_number (BEGV
);
306 tem
= Fmemq (Fcurrent_buffer (), Vminibuffer_list
);
310 end
= Ffield_end (beg
, Qnil
, Qnil
);
312 if (XINT (end
) == ZV
&& NILP (Fget_char_property (beg
, Qfield
, Qnil
)))
318 DEFUN ("minibuffer-contents", Fminibuffer_contents
,
319 Sminibuffer_contents
, 0, 0, 0,
320 doc
: /* Return the user input in a minibuffer as a string.
321 If the current buffer is not a minibuffer, return its entire contents. */)
324 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
325 return make_buffer_string (prompt_end
, ZV
, 1);
328 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties
,
329 Sminibuffer_contents_no_properties
, 0, 0, 0,
330 doc
: /* Return the user input in a minibuffer as a string, without text-properties.
331 If the current buffer is not a minibuffer, return its entire contents. */)
334 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
335 return make_buffer_string (prompt_end
, ZV
, 0);
338 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents
,
339 Sminibuffer_completion_contents
, 0, 0, 0,
340 doc
: /* Return the user input in a minibuffer before point as a string.
341 That is what completion commands operate on.
342 If the current buffer is not a minibuffer, return its entire contents. */)
345 EMACS_INT prompt_end
= XINT (Fminibuffer_prompt_end ());
347 error ("Cannot do completion in the prompt");
348 return make_buffer_string (prompt_end
, PT
, 1);
352 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
353 putting point minus BACKUP_N bytes from the end of INITIAL,
354 prompting with PROMPT (a string), using history list HISTVAR
355 with initial position HISTPOS. INITIAL should be a string or a
356 cons of a string and an integer. BACKUP_N should be <= 0, or
357 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
358 ignored and replaced with an integer that puts point at one-indexed
359 position N in INITIAL, where N is the CDR of INITIAL, or at the
360 beginning of INITIAL if N <= 0.
362 Normally return the result as a string (the text that was read),
363 but if EXPFLAG is nonzero, read it and return the object read.
364 If HISTVAR is given, save the value read on that history only if it doesn't
365 match the front of that history list exactly. The value is pushed onto
366 the list as the string that was read.
368 DEFALT specifies the default value for the sake of history commands.
370 If ALLOW_PROPS is nonzero, we do not throw away text properties.
372 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
373 current input method. */
376 read_minibuf (Lisp_Object map
, Lisp_Object initial
, Lisp_Object prompt
,
377 Lisp_Object backup_n
, int expflag
,
378 Lisp_Object histvar
, Lisp_Object histpos
, Lisp_Object defalt
,
379 int allow_props
, int inherit_input_method
)
382 int count
= SPECPDL_INDEX ();
383 Lisp_Object mini_frame
, ambient_dir
, minibuffer
, input_method
;
384 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
385 Lisp_Object enable_multibyte
;
386 int pos
= INTEGERP (backup_n
) ? XINT (backup_n
) : 0;
387 /* String to add to the history. */
388 Lisp_Object histstring
;
390 Lisp_Object empty_minibuf
;
391 Lisp_Object dummy
, frame
;
393 specbind (Qminibuffer_default
, defalt
);
395 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
396 in previous recursive minibuffer, but was not set explicitly
397 to t for this invocation, so set it to nil in this minibuffer.
398 Save the old value now, before we change it. */
399 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name
);
400 if (EQ (Vminibuffer_completing_file_name
, Qlambda
))
401 Vminibuffer_completing_file_name
= Qnil
;
403 #ifdef HAVE_WINDOW_SYSTEM
404 if (display_hourglass_p
)
412 backup_n
= Fcdr (initial
);
413 initial
= Fcar (initial
);
414 CHECK_STRING (initial
);
415 if (!NILP (backup_n
))
417 CHECK_NUMBER (backup_n
);
418 /* Convert to distance from end of input. */
419 if (XINT (backup_n
) < 1)
420 /* A number too small means the beginning of the string. */
421 pos
= - SCHARS (initial
);
423 pos
= XINT (backup_n
) - 1 - SCHARS (initial
);
427 CHECK_STRING (initial
);
430 ambient_dir
= BVAR (current_buffer
, directory
);
432 enable_multibyte
= Qnil
;
434 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
435 store them away before we can GC. Don't need to protect
436 BACKUP_N because we use the value only if it is an integer. */
437 GCPRO5 (map
, initial
, val
, ambient_dir
, input_method
);
439 if (!STRINGP (prompt
))
440 prompt
= empty_unibyte_string
;
442 if (!enable_recursive_minibuffers
443 && minibuf_level
> 0)
445 if (EQ (selected_window
, minibuf_window
))
446 error ("Command attempted to use minibuffer while in minibuffer");
448 /* If we're in another window, cancel the minibuffer that's active. */
450 build_string ("Command attempted to use minibuffer while in minibuffer"));
454 /* In case we are running as a daemon, only do this before
455 detaching from the terminal. */
456 || (IS_DAEMON
&& (daemon_pipe
[1] >= 0)))
457 && NILP (Vexecuting_kbd_macro
))
459 val
= read_minibuf_noninteractive (map
, initial
, prompt
,
461 expflag
, histvar
, histpos
, defalt
,
462 allow_props
, inherit_input_method
);
464 return unbind_to (count
, val
);
467 /* Choose the minibuffer window and frame, and take action on them. */
469 choose_minibuf_frame ();
471 record_unwind_protect (choose_minibuf_frame_1
, Qnil
);
473 record_unwind_protect (Fset_window_configuration
,
474 Fcurrent_window_configuration (Qnil
));
476 /* If the minibuffer window is on a different frame, save that
477 frame's configuration too. */
478 mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
479 if (!EQ (mini_frame
, selected_frame
))
480 record_unwind_protect (Fset_window_configuration
,
481 Fcurrent_window_configuration (mini_frame
));
483 /* If the minibuffer is on an iconified or invisible frame,
484 make it visible now. */
485 Fmake_frame_visible (mini_frame
);
487 if (minibuffer_auto_raise
)
488 Fraise_frame (mini_frame
);
490 temporarily_switch_to_single_kboard (XFRAME (mini_frame
));
492 /* We have to do this after saving the window configuration
493 since that is what restores the current buffer. */
495 /* Arrange to restore a number of minibuffer-related variables.
496 We could bind each variable separately, but that would use lots of
499 = Fcons (Voverriding_local_map
,
500 Fcons (minibuf_window
,
503 = Fcons (minibuf_prompt
,
504 Fcons (make_number (minibuf_prompt_width
),
506 Fcons (Vcurrent_prefix_arg
,
507 Fcons (Vminibuffer_history_position
,
508 Fcons (Vminibuffer_history_variable
,
509 minibuf_save_list
))))));
511 record_unwind_protect (read_minibuf_unwind
, Qnil
);
513 /* We are exiting the minibuffer one way or the other, so run the hook.
514 It should be run before unwinding the minibuf settings. Do it
515 separately from read_minibuf_unwind because we need to make sure that
516 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
517 signals an error. --Stef */
518 record_unwind_protect (run_exit_minibuf_hook
, Qnil
);
520 /* Now that we can restore all those variables, start changing them. */
522 minibuf_prompt_width
= 0;
523 minibuf_prompt
= Fcopy_sequence (prompt
);
524 Vminibuffer_history_position
= histpos
;
525 Vminibuffer_history_variable
= histvar
;
526 Vhelp_form
= Vminibuffer_help_form
;
527 /* If this minibuffer is reading a file name, that doesn't mean
528 recursive ones are. But we cannot set it to nil, because
529 completion code still need to know the minibuffer is completing a
530 file name. So use `lambda' as intermediate value meaning
531 "t" in this minibuffer, but "nil" in next minibuffer. */
532 if (!NILP (Vminibuffer_completing_file_name
))
533 Vminibuffer_completing_file_name
= Qlambda
;
535 if (inherit_input_method
)
537 /* `current-input-method' is buffer local. So, remember it in
538 INPUT_METHOD before changing the current buffer. */
539 input_method
= Fsymbol_value (Qcurrent_input_method
);
540 enable_multibyte
= BVAR (current_buffer
, enable_multibyte_characters
);
543 /* Switch to the minibuffer. */
545 minibuffer
= get_minibuffer (minibuf_level
);
546 Fset_buffer (minibuffer
);
548 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
549 if (inherit_input_method
)
550 BVAR (current_buffer
, enable_multibyte_characters
) = enable_multibyte
;
552 /* The current buffer's default directory is usually the right thing
553 for our minibuffer here. However, if you're typing a command at
554 a minibuffer-only frame when minibuf_level is zero, then buf IS
555 the current_buffer, so reset_buffer leaves buf's default
556 directory unchanged. This is a bummer when you've just started
557 up Emacs and buf's default directory is Qnil. Here's a hack; can
558 you think of something better to do? Find another buffer with a
559 better directory, and use that one instead. */
560 if (STRINGP (ambient_dir
))
561 BVAR (current_buffer
, directory
) = ambient_dir
;
564 Lisp_Object buf_list
;
566 for (buf_list
= Vbuffer_alist
;
568 buf_list
= XCDR (buf_list
))
570 Lisp_Object other_buf
;
572 other_buf
= XCDR (XCAR (buf_list
));
573 if (STRINGP (BVAR (XBUFFER (other_buf
), directory
)))
575 BVAR (current_buffer
, directory
) = BVAR (XBUFFER (other_buf
), directory
);
581 if (!EQ (mini_frame
, selected_frame
))
582 Fredirect_frame_focus (selected_frame
, mini_frame
);
584 Vminibuf_scroll_window
= selected_window
;
585 if (minibuf_level
== 1 || !EQ (minibuf_window
, selected_window
))
586 minibuf_selected_window
= selected_window
;
588 /* Empty out the minibuffers of all frames other than the one
589 where we are going to display one now.
590 Set them to point to ` *Minibuf-0*', which is always empty. */
591 empty_minibuf
= Fget_buffer (build_string (" *Minibuf-0*"));
593 FOR_EACH_FRAME (dummy
, frame
)
595 Lisp_Object root_window
= Fframe_root_window (frame
);
596 Lisp_Object mini_window
= XWINDOW (root_window
)->next
;
598 if (! NILP (mini_window
) && ! EQ (mini_window
, minibuf_window
)
599 && !NILP (Fwindow_minibuffer_p (mini_window
)))
600 Fset_window_buffer (mini_window
, empty_minibuf
, Qnil
);
603 /* Display this minibuffer in the proper window. */
604 Fset_window_buffer (minibuf_window
, Fcurrent_buffer (), Qnil
);
605 Fselect_window (minibuf_window
, Qnil
);
606 XSETFASTINT (XWINDOW (minibuf_window
)->hscroll
, 0);
608 Fmake_local_variable (Qprint_escape_newlines
);
609 print_escape_newlines
= 1;
611 /* Erase the buffer. */
613 int count1
= SPECPDL_INDEX ();
614 specbind (Qinhibit_read_only
, Qt
);
615 specbind (Qinhibit_modification_hooks
, Qt
);
618 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
619 && ! STRING_MULTIBYTE (minibuf_prompt
))
620 minibuf_prompt
= Fstring_make_multibyte (minibuf_prompt
);
622 /* Insert the prompt, record where it ends. */
623 Finsert (1, &minibuf_prompt
);
626 Fput_text_property (make_number (BEG
), make_number (PT
),
627 Qfront_sticky
, Qt
, Qnil
);
628 Fput_text_property (make_number (BEG
), make_number (PT
),
629 Qrear_nonsticky
, Qt
, Qnil
);
630 Fput_text_property (make_number (BEG
), make_number (PT
),
632 Fadd_text_properties (make_number (BEG
), make_number (PT
),
633 Vminibuffer_prompt_properties
, Qnil
);
635 unbind_to (count1
, Qnil
);
638 minibuf_prompt_width
= current_column ();
640 /* Put in the initial input. */
643 Finsert (1, &initial
);
644 Fforward_char (make_number (pos
));
647 clear_message (1, 1);
648 BVAR (current_buffer
, keymap
) = map
;
650 /* Turn on an input method stored in INPUT_METHOD if any. */
651 if (STRINGP (input_method
) && !NILP (Ffboundp (Qactivate_input_method
)))
652 call1 (Qactivate_input_method
, input_method
);
654 Frun_hooks (1, &Qminibuffer_setup_hook
);
656 /* Don't allow the user to undo past this point. */
657 BVAR (current_buffer
, undo_list
) = Qnil
;
661 /* If cursor is on the minibuffer line,
662 show the user we have exited by putting it in column 0. */
663 if (XWINDOW (minibuf_window
)->cursor
.vpos
>= 0
666 XWINDOW (minibuf_window
)->cursor
.hpos
= 0;
667 XWINDOW (minibuf_window
)->cursor
.x
= 0;
668 XWINDOW (minibuf_window
)->must_be_updated_p
= 1;
669 update_frame (XFRAME (selected_frame
), 1, 1);
671 struct frame
*f
= XFRAME (XWINDOW (minibuf_window
)->frame
);
672 struct redisplay_interface
*rif
= FRAME_RIF (f
);
673 if (rif
&& rif
->flush_display
)
674 rif
->flush_display (f
);
678 /* Make minibuffer contents into a string. */
679 Fset_buffer (minibuffer
);
681 val
= Fminibuffer_contents ();
683 val
= Fminibuffer_contents_no_properties ();
685 /* VAL is the string of minibuffer text. */
687 last_minibuf_string
= val
;
689 /* Choose the string to add to the history. */
690 if (SCHARS (val
) != 0)
692 else if (STRINGP (defalt
))
694 else if (CONSP (defalt
) && STRINGP (XCAR (defalt
)))
695 histstring
= XCAR (defalt
);
699 /* Add the value to the appropriate history list, if any. */
700 if (!NILP (Vhistory_add_new_input
)
701 && SYMBOLP (Vminibuffer_history_variable
)
702 && !NILP (histstring
))
704 /* If the caller wanted to save the value read on a history list,
705 then do so if the value is not already the front of the list. */
708 /* If variable is unbound, make it nil. */
710 histval
= find_symbol_value (Vminibuffer_history_variable
);
711 if (EQ (histval
, Qunbound
))
712 Fset (Vminibuffer_history_variable
, Qnil
);
714 /* The value of the history variable must be a cons or nil. Other
715 values are unacceptable. We silently ignore these values. */
719 /* Don't duplicate the most recent entry in the history. */
720 && (NILP (Fequal (histstring
, Fcar (histval
))))))
724 if (history_delete_duplicates
) Fdelete (histstring
, histval
);
725 histval
= Fcons (histstring
, histval
);
726 Fset (Vminibuffer_history_variable
, histval
);
728 /* Truncate if requested. */
729 length
= Fget (Vminibuffer_history_variable
, Qhistory_length
);
730 if (NILP (length
)) length
= Vhistory_length
;
731 if (INTEGERP (length
))
733 if (XINT (length
) <= 0)
734 Fset (Vminibuffer_history_variable
, Qnil
);
739 temp
= Fnthcdr (Fsub1 (length
), histval
);
740 if (CONSP (temp
)) Fsetcdr (temp
, Qnil
);
746 /* If Lisp form desired instead of string, parse it. */
748 val
= string_to_object (val
, defalt
);
750 /* The appropriate frame will get selected
751 in set-window-configuration. */
753 return unbind_to (count
, val
);
756 /* Return a buffer to be used as the minibuffer at depth `depth'.
757 depth = 0 is the lowest allowed argument, and that is the value
758 used for nonrecursive minibuffer invocations */
761 get_minibuffer (int depth
)
763 Lisp_Object tail
, num
, buf
;
766 XSETFASTINT (num
, depth
);
767 tail
= Fnthcdr (num
, Vminibuffer_list
);
770 tail
= Fcons (Qnil
, Qnil
);
771 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
774 if (NILP (buf
) || NILP (BVAR (XBUFFER (buf
), name
)))
776 sprintf (name
, " *Minibuf-%d*", depth
);
777 buf
= Fget_buffer_create (build_string (name
));
779 /* Although the buffer's name starts with a space, undo should be
781 Fbuffer_enable_undo (buf
);
787 int count
= SPECPDL_INDEX ();
788 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
789 have to empty the list, otherwise we end up with overlays that
790 think they belong to this buffer while the buffer doesn't know about
792 delete_all_overlays (XBUFFER (buf
));
793 reset_buffer (XBUFFER (buf
));
794 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
796 Fkill_all_local_variables ();
797 unbind_to (count
, Qnil
);
804 run_exit_minibuf_hook (Lisp_Object data
)
806 safe_run_hooks (Qminibuffer_exit_hook
);
810 /* This function is called on exiting minibuffer, whether normally or
811 not, and it restores the current window, buffer, etc. */
814 read_minibuf_unwind (Lisp_Object data
)
816 Lisp_Object old_deactivate_mark
;
819 /* If this was a recursive minibuffer,
820 tie the minibuffer window back to the outer level minibuffer buffer. */
823 window
= minibuf_window
;
824 /* To keep things predictable, in case it matters, let's be in the
825 minibuffer when we reset the relevant variables. */
826 Fset_buffer (XWINDOW (window
)->buffer
);
828 /* Restore prompt, etc, from outer minibuffer level. */
829 minibuf_prompt
= Fcar (minibuf_save_list
);
830 minibuf_save_list
= Fcdr (minibuf_save_list
);
831 minibuf_prompt_width
= XFASTINT (Fcar (minibuf_save_list
));
832 minibuf_save_list
= Fcdr (minibuf_save_list
);
833 Vhelp_form
= Fcar (minibuf_save_list
);
834 minibuf_save_list
= Fcdr (minibuf_save_list
);
835 Vcurrent_prefix_arg
= Fcar (minibuf_save_list
);
836 minibuf_save_list
= Fcdr (minibuf_save_list
);
837 Vminibuffer_history_position
= Fcar (minibuf_save_list
);
838 minibuf_save_list
= Fcdr (minibuf_save_list
);
839 Vminibuffer_history_variable
= Fcar (minibuf_save_list
);
840 minibuf_save_list
= Fcdr (minibuf_save_list
);
841 Voverriding_local_map
= Fcar (minibuf_save_list
);
842 minibuf_save_list
= Fcdr (minibuf_save_list
);
844 temp
= Fcar (minibuf_save_list
);
845 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp
)))))
846 minibuf_window
= temp
;
848 minibuf_save_list
= Fcdr (minibuf_save_list
);
850 /* Erase the minibuffer we were using at this level. */
852 int count
= SPECPDL_INDEX ();
853 /* Prevent error in erase-buffer. */
854 specbind (Qinhibit_read_only
, Qt
);
855 specbind (Qinhibit_modification_hooks
, Qt
);
856 old_deactivate_mark
= Vdeactivate_mark
;
858 Vdeactivate_mark
= old_deactivate_mark
;
859 unbind_to (count
, Qnil
);
862 /* When we get to the outmost level, make sure we resize the
863 mini-window back to its normal size. */
864 if (minibuf_level
== 0)
865 resize_mini_window (XWINDOW (window
), 0);
867 /* Make sure minibuffer window is erased, not ignored. */
868 windows_or_buffers_changed
++;
869 XSETFASTINT (XWINDOW (window
)->last_modified
, 0);
870 XSETFASTINT (XWINDOW (window
)->last_overlay_modified
, 0);
875 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 7, 0,
876 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
877 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
878 DEFAULT-VALUE. It normally should be nil in new code, except when
879 HIST is a cons. It is discussed in more detail below.
880 Third arg KEYMAP is a keymap to use whilst reading;
881 if omitted or nil, the default is `minibuffer-local-map'.
882 If fourth arg READ is non-nil, then interpret the result as a Lisp object
883 and return that object:
884 in other words, do `(car (read-from-string INPUT-STRING))'
885 Fifth arg HIST, if non-nil, specifies a history list and optionally
886 the initial position in the list. It can be a symbol, which is the
887 history list variable to use, or it can be a cons cell
888 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
889 to use, and HISTPOS is the initial position for use by the minibuffer
890 history commands. For consistency, you should also specify that
891 element of the history as the value of INITIAL-CONTENTS. Positions
892 are counted starting from 1 at the beginning of the list.
893 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
894 If non-nil, it is available for history commands, and as the value
895 (or the first element of the list of default values) to return
896 if the user enters the empty string. But, unless READ is non-nil,
897 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
898 empty input! It returns the empty string.
899 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
900 the current input method and the setting of `enable-multibyte-characters'.
901 If the variable `minibuffer-allow-text-properties' is non-nil,
902 then the string which is returned includes whatever text properties
903 were present in the minibuffer. Otherwise the value has no text properties.
905 The remainder of this documentation string describes the
906 INITIAL-CONTENTS argument in more detail. It is only relevant when
907 studying existing code, or when HIST is a cons. If non-nil,
908 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
909 reading input. Normally, point is put at the end of that string.
910 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
911 input is STRING, but point is placed at _one-indexed_ position
912 POSITION in the minibuffer. Any integer value less than or equal to
913 one puts point at the beginning of the string. *Note* that this
914 behavior differs from the way such arguments are used in `completing-read'
915 and some related functions, which use zero-indexing for POSITION. */)
916 (Lisp_Object prompt
, Lisp_Object initial_contents
, Lisp_Object keymap
, Lisp_Object read
, Lisp_Object hist
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
918 Lisp_Object histvar
, histpos
, val
;
921 CHECK_STRING (prompt
);
923 keymap
= Vminibuffer_local_map
;
925 keymap
= get_keymap (keymap
, 1, 0);
934 histvar
= Fcar_safe (hist
);
935 histpos
= Fcdr_safe (hist
);
938 histvar
= Qminibuffer_history
;
940 XSETFASTINT (histpos
, 0);
942 GCPRO1 (default_value
);
943 val
= read_minibuf (keymap
, initial_contents
, prompt
,
945 histvar
, histpos
, default_value
,
946 minibuffer_allow_text_properties
,
947 !NILP (inherit_input_method
));
952 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
953 doc
: /* Return a Lisp object read using the minibuffer, unevaluated.
954 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
955 is a string to insert in the minibuffer before reading.
956 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
957 Such arguments are used as in `read-from-minibuffer'.) */)
958 (Lisp_Object prompt
, Lisp_Object initial_contents
)
960 CHECK_STRING (prompt
);
961 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
962 prompt
, Qnil
, 1, Qminibuffer_history
,
963 make_number (0), Qnil
, 0, 0);
966 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
967 doc
: /* Return value of Lisp expression read using the minibuffer.
968 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
969 is a string to insert in the minibuffer before reading.
970 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
971 Such arguments are used as in `read-from-minibuffer'.) */)
972 (Lisp_Object prompt
, Lisp_Object initial_contents
)
974 return Feval (read_minibuf (Vread_expression_map
, initial_contents
,
975 prompt
, Qnil
, 1, Qread_expression_history
,
976 make_number (0), Qnil
, 0, 0),
980 /* Functions that use the minibuffer to read various things. */
982 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 5, 0,
983 doc
: /* Read a string from the minibuffer, prompting with string PROMPT.
984 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
985 This argument has been superseded by DEFAULT-VALUE and should normally
986 be nil in new code. It behaves as in `read-from-minibuffer'. See the
987 documentation string of that function for details.
988 The third arg HISTORY, if non-nil, specifies a history list
989 and optionally the initial position in the list.
990 See `read-from-minibuffer' for details of HISTORY argument.
991 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
992 If non-nil, it is used for history commands, and as the value (or the first
993 element of the list of default values) to return if the user enters the
995 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
996 the current input method and the setting of `enable-multibyte-characters'. */)
997 (Lisp_Object prompt
, Lisp_Object initial_input
, Lisp_Object history
, Lisp_Object default_value
, Lisp_Object inherit_input_method
)
1000 val
= Fread_from_minibuffer (prompt
, initial_input
, Qnil
,
1001 Qnil
, history
, default_value
,
1002 inherit_input_method
);
1003 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (default_value
))
1004 val
= CONSP (default_value
) ? XCAR (default_value
) : default_value
;
1008 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 1, 3, 0,
1009 doc
: /* Read a string from the terminal, not allowing blanks.
1010 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1011 non-nil, it should be a string, which is used as initial input, with
1012 point positioned at the end, so that SPACE will accept the input.
1013 \(Actually, INITIAL can also be a cons of a string and an integer.
1014 Such values are treated as in `read-from-minibuffer', but are normally
1015 not useful in this function.)
1016 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1017 the current input method and the setting of`enable-multibyte-characters'. */)
1018 (Lisp_Object prompt
, Lisp_Object initial
, Lisp_Object inherit_input_method
)
1020 CHECK_STRING (prompt
);
1021 return read_minibuf (Vminibuffer_local_ns_map
, initial
, prompt
, Qnil
,
1022 0, Qminibuffer_history
, make_number (0), Qnil
, 0,
1023 !NILP (inherit_input_method
));
1026 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 2, 0,
1027 doc
: /* Read the name of a command and return as a symbol.
1028 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1029 if it is a list. */)
1030 (Lisp_Object prompt
, Lisp_Object default_value
)
1032 Lisp_Object name
, default_string
;
1034 if (NILP (default_value
))
1035 default_string
= Qnil
;
1036 else if (SYMBOLP (default_value
))
1037 default_string
= SYMBOL_NAME (default_value
);
1039 default_string
= default_value
;
1041 name
= Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
,
1042 Qnil
, Qnil
, default_string
, Qnil
);
1045 return Fintern (name
, Qnil
);
1049 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
1050 doc
: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1051 Prompt with PROMPT. */)
1052 (Lisp_Object prompt
)
1054 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
, Qnil
, Qnil
),
1059 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 2, 0,
1060 doc
: /* Read the name of a user variable and return it as a symbol.
1061 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1063 A user variable is one for which `user-variable-p' returns non-nil. */)
1064 (Lisp_Object prompt
, Lisp_Object default_value
)
1066 Lisp_Object name
, default_string
;
1068 if (NILP (default_value
))
1069 default_string
= Qnil
;
1070 else if (SYMBOLP (default_value
))
1071 default_string
= SYMBOL_NAME (default_value
);
1073 default_string
= default_value
;
1075 name
= Fcompleting_read (prompt
, Vobarray
,
1076 Quser_variable_p
, Qt
,
1077 Qnil
, Qnil
, default_string
, Qnil
);
1080 return Fintern (name
, Qnil
);
1083 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
1084 doc
: /* Read the name of a buffer and return as a string.
1086 Optional second arg DEF is value to return if user enters an empty line.
1087 If DEF is a list of default values, return its first element.
1088 Optional third arg REQUIRE-MATCH determines whether non-existing
1089 buffer names are allowed. It has the same meaning as the
1090 REQUIRE-MATCH argument of `completing-read'.
1091 The argument PROMPT should be a string ending with a colon and a space.
1092 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1093 case while reading the buffer name.
1094 If `read-buffer-function' is non-nil, this works by calling it as a
1095 function, instead of the usual behavior. */)
1096 (Lisp_Object prompt
, Lisp_Object def
, Lisp_Object require_match
)
1098 Lisp_Object args
[4], result
;
1101 int count
= SPECPDL_INDEX ();
1104 def
= BVAR (XBUFFER (def
), name
);
1106 specbind (Qcompletion_ignore_case
,
1107 read_buffer_completion_ignore_case
? Qt
: Qnil
);
1109 if (NILP (Vread_buffer_function
))
1113 /* A default value was provided: we must change PROMPT,
1114 editing the default value in before the colon. To achieve
1115 this, we replace PROMPT with a substring that doesn't
1116 contain the terminal space and colon (if present). They
1117 are then added back using Fformat. */
1119 if (STRINGP (prompt
))
1121 s
= SSDATA (prompt
);
1123 if (len
>= 2 && s
[len
- 2] == ':' && s
[len
- 1] == ' ')
1125 else if (len
>= 1 && (s
[len
- 1] == ':' || s
[len
- 1] == ' '))
1128 prompt
= make_specified_string (s
, -1, len
,
1129 STRING_MULTIBYTE (prompt
));
1132 args
[0] = build_string ("%s (default %s): ");
1134 args
[2] = CONSP (def
) ? XCAR (def
) : def
;
1135 prompt
= Fformat (3, args
);
1138 result
= Fcompleting_read (prompt
, intern ("internal-complete-buffer"),
1139 Qnil
, require_match
, Qnil
, Qbuffer_name_history
,
1144 args
[0] = Vread_buffer_function
;
1147 args
[3] = require_match
;
1148 result
= Ffuncall(4, args
);
1150 return unbind_to (count
, result
);
1154 minibuf_conform_representation (Lisp_Object string
, Lisp_Object basis
)
1156 if (STRING_MULTIBYTE (string
) == STRING_MULTIBYTE (basis
))
1159 if (STRING_MULTIBYTE (string
))
1160 return Fstring_make_unibyte (string
);
1162 return Fstring_make_multibyte (string
);
1165 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
1166 doc
: /* Return common substring of all completions of STRING in COLLECTION.
1167 Test each possible completion specified by COLLECTION
1168 to see if it begins with STRING. The possible completions may be
1169 strings or symbols. Symbols are converted to strings before testing,
1171 All that match STRING are compared together; the longest initial sequence
1172 common to all these matches is the return value.
1173 If there is no match at all, the return value is nil.
1174 For a unique match which is exact, the return value is t.
1176 If COLLECTION is an alist, the keys (cars of elements) are the
1177 possible completions. If an element is not a cons cell, then the
1178 element itself is the possible completion.
1179 If COLLECTION is a hash-table, all the keys that are strings or symbols
1180 are the possible completions.
1181 If COLLECTION is an obarray, the names of all symbols in the obarray
1182 are the possible completions.
1184 COLLECTION can also be a function to do the completion itself.
1185 It receives three arguments: the values STRING, PREDICATE and nil.
1186 Whatever it returns becomes the value of `try-completion'.
1188 If optional third argument PREDICATE is non-nil,
1189 it is used to test each possible match.
1190 The match is a candidate only if PREDICATE returns non-nil.
1191 The argument given to PREDICATE is the alist element
1192 or the symbol from the obarray. If COLLECTION is a hash-table,
1193 predicate is called with two arguments: the key and the value.
1194 Additionally to this predicate, `completion-regexp-list'
1195 is used to further constrain the set of candidates. */)
1196 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1198 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
1199 /* Size in bytes of BESTMATCH. */
1200 int bestmatchsize
= 0;
1201 /* These are in bytes, too. */
1202 int compare
, matchsize
;
1203 enum { function_table
, list_table
, obarray_table
, hash_table
}
1204 type
= (HASH_TABLE_P (collection
) ? hash_table
1205 : VECTORP (collection
) ? obarray_table
1206 : ((NILP (collection
)
1207 || (CONSP (collection
)
1208 && (!SYMBOLP (XCAR (collection
))
1209 || NILP (XCAR (collection
)))))
1210 ? list_table
: function_table
));
1211 int idx
= 0, obsize
= 0;
1214 Lisp_Object bucket
, zero
, end
, tem
;
1215 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1217 CHECK_STRING (string
);
1218 if (type
== function_table
)
1219 return call3 (collection
, string
, predicate
, Qnil
);
1221 bestmatch
= bucket
= Qnil
;
1222 zero
= make_number (0);
1224 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1226 if (type
== obarray_table
)
1228 collection
= check_obarray (collection
);
1229 obsize
= XVECTOR (collection
)->size
;
1230 bucket
= XVECTOR (collection
)->contents
[idx
];
1235 /* Get the next element of the alist, obarray, or hash-table. */
1236 /* Exit the loop if the elements are all used up. */
1237 /* elt gets the alist element or symbol.
1238 eltstring gets the name to check as a completion. */
1240 if (type
== list_table
)
1245 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1248 else if (type
== obarray_table
)
1250 if (!EQ (bucket
, zero
))
1252 if (!SYMBOLP (bucket
))
1253 error ("Bad data in guts of obarray");
1256 if (XSYMBOL (bucket
)->next
)
1257 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1259 XSETFASTINT (bucket
, 0);
1261 else if (++idx
>= obsize
)
1265 bucket
= XVECTOR (collection
)->contents
[idx
];
1269 else /* if (type == hash_table) */
1271 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1272 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1274 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1277 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1280 /* Is this element a possible completion? */
1282 if (SYMBOLP (eltstring
))
1283 eltstring
= Fsymbol_name (eltstring
);
1285 if (STRINGP (eltstring
)
1286 && SCHARS (string
) <= SCHARS (eltstring
)
1287 && (tem
= Fcompare_strings (eltstring
, zero
,
1288 make_number (SCHARS (string
)),
1290 completion_ignore_case
? Qt
: Qnil
),
1294 Lisp_Object regexps
;
1296 /* Ignore this element if it fails to match all the regexps. */
1298 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1299 regexps
= XCDR (regexps
))
1301 if (bindcount
< 0) {
1302 bindcount
= SPECPDL_INDEX ();
1303 specbind (Qcase_fold_search
,
1304 completion_ignore_case
? Qt
: Qnil
);
1306 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1310 if (CONSP (regexps
))
1314 /* Ignore this element if there is a predicate
1315 and the predicate doesn't like it. */
1317 if (!NILP (predicate
))
1319 if (EQ (predicate
, Qcommandp
))
1320 tem
= Fcommandp (elt
, Qnil
);
1325 unbind_to (bindcount
, Qnil
);
1328 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
1329 tem
= (type
== hash_table
1330 ? call2 (predicate
, elt
,
1331 HASH_VALUE (XHASH_TABLE (collection
),
1333 : call1 (predicate
, elt
));
1336 if (NILP (tem
)) continue;
1339 /* Update computation of how much all possible completions match */
1341 if (NILP (bestmatch
))
1344 bestmatch
= eltstring
;
1345 bestmatchsize
= SCHARS (eltstring
);
1349 compare
= min (bestmatchsize
, SCHARS (eltstring
));
1350 tem
= Fcompare_strings (bestmatch
, zero
,
1351 make_number (compare
),
1353 make_number (compare
),
1354 completion_ignore_case
? Qt
: Qnil
);
1356 matchsize
= compare
;
1357 else if (XINT (tem
) < 0)
1358 matchsize
= - XINT (tem
) - 1;
1360 matchsize
= XINT (tem
) - 1;
1362 if (completion_ignore_case
)
1364 /* If this is an exact match except for case,
1365 use it as the best match rather than one that is not an
1366 exact match. This way, we get the case pattern
1367 of the actual match. */
1368 if ((matchsize
== SCHARS (eltstring
)
1369 && matchsize
< SCHARS (bestmatch
))
1371 /* If there is more than one exact match ignoring case,
1372 and one of them is exact including case,
1374 /* If there is no exact match ignoring case,
1375 prefer a match that does not change the case
1377 ((matchsize
== SCHARS (eltstring
))
1379 (matchsize
== SCHARS (bestmatch
))
1380 && (tem
= Fcompare_strings (eltstring
, zero
,
1381 make_number (SCHARS (string
)),
1386 && (tem
= Fcompare_strings (bestmatch
, zero
,
1387 make_number (SCHARS (string
)),
1392 bestmatch
= eltstring
;
1394 if (bestmatchsize
!= SCHARS (eltstring
)
1395 || bestmatchsize
!= matchsize
)
1396 /* Don't count the same string multiple times. */
1398 bestmatchsize
= matchsize
;
1399 if (matchsize
<= SCHARS (string
)
1400 /* If completion-ignore-case is non-nil, don't
1401 short-circuit because we want to find the best
1402 possible match *including* case differences. */
1403 && !completion_ignore_case
1405 /* No need to look any further. */
1411 if (bindcount
>= 0) {
1412 unbind_to (bindcount
, Qnil
);
1416 if (NILP (bestmatch
))
1417 return Qnil
; /* No completions found */
1418 /* If we are ignoring case, and there is no exact match,
1419 and no additional text was supplied,
1420 don't change the case of what the user typed. */
1421 if (completion_ignore_case
&& bestmatchsize
== SCHARS (string
)
1422 && SCHARS (bestmatch
) > bestmatchsize
)
1423 return minibuf_conform_representation (string
, bestmatch
);
1425 /* Return t if the supplied string is an exact match (counting case);
1426 it does not require any change to be made. */
1427 if (matchcount
== 1 && !NILP (Fequal (bestmatch
, string
)))
1430 XSETFASTINT (zero
, 0); /* Else extract the part in which */
1431 XSETFASTINT (end
, bestmatchsize
); /* all completions agree */
1432 return Fsubstring (bestmatch
, zero
, end
);
1435 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 4, 0,
1436 doc
: /* Search for partial matches to STRING in COLLECTION.
1437 Test each of the possible completions specified by COLLECTION
1438 to see if it begins with STRING. The possible completions may be
1439 strings or symbols. Symbols are converted to strings before testing,
1441 The value is a list of all the possible completions that match STRING.
1443 If COLLECTION is an alist, the keys (cars of elements) are the
1444 possible completions. If an element is not a cons cell, then the
1445 element itself is the possible completion.
1446 If COLLECTION is a hash-table, all the keys that are strings or symbols
1447 are the possible completions.
1448 If COLLECTION is an obarray, the names of all symbols in the obarray
1449 are the possible completions.
1451 COLLECTION can also be a function to do the completion itself.
1452 It receives three arguments: the values STRING, PREDICATE and t.
1453 Whatever it returns becomes the value of `all-completions'.
1455 If optional third argument PREDICATE is non-nil,
1456 it is used to test each possible match.
1457 The match is a candidate only if PREDICATE returns non-nil.
1458 The argument given to PREDICATE is the alist element
1459 or the symbol from the obarray. If COLLECTION is a hash-table,
1460 predicate is called with two arguments: the key and the value.
1461 Additionally to this predicate, `completion-regexp-list'
1462 is used to further constrain the set of candidates.
1464 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1465 backward compatibility. If non-nil, strings in COLLECTION that start
1466 with a space are ignored unless STRING itself starts with a space. */)
1467 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object hide_spaces
)
1469 Lisp_Object tail
, elt
, eltstring
;
1470 Lisp_Object allmatches
;
1471 int type
= HASH_TABLE_P (collection
) ? 3
1472 : VECTORP (collection
) ? 2
1473 : NILP (collection
) || (CONSP (collection
)
1474 && (!SYMBOLP (XCAR (collection
))
1475 || NILP (XCAR (collection
))));
1476 int idx
= 0, obsize
= 0;
1478 Lisp_Object bucket
, tem
, zero
;
1479 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
1481 CHECK_STRING (string
);
1483 return call3 (collection
, string
, predicate
, Qt
);
1484 allmatches
= bucket
= Qnil
;
1485 zero
= make_number (0);
1487 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1491 collection
= check_obarray (collection
);
1492 obsize
= XVECTOR (collection
)->size
;
1493 bucket
= XVECTOR (collection
)->contents
[idx
];
1498 /* Get the next element of the alist, obarray, or hash-table. */
1499 /* Exit the loop if the elements are all used up. */
1500 /* elt gets the alist element or symbol.
1501 eltstring gets the name to check as a completion. */
1508 eltstring
= CONSP (elt
) ? XCAR (elt
) : elt
;
1513 if (!EQ (bucket
, zero
))
1515 if (!SYMBOLP (bucket
))
1516 error ("Bad data in guts of obarray");
1519 if (XSYMBOL (bucket
)->next
)
1520 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
1522 XSETFASTINT (bucket
, 0);
1524 else if (++idx
>= obsize
)
1528 bucket
= XVECTOR (collection
)->contents
[idx
];
1532 else /* if (type == 3) */
1534 while (idx
< HASH_TABLE_SIZE (XHASH_TABLE (collection
))
1535 && NILP (HASH_HASH (XHASH_TABLE (collection
), idx
)))
1537 if (idx
>= HASH_TABLE_SIZE (XHASH_TABLE (collection
)))
1540 elt
= eltstring
= HASH_KEY (XHASH_TABLE (collection
), idx
++);
1543 /* Is this element a possible completion? */
1545 if (SYMBOLP (eltstring
))
1546 eltstring
= Fsymbol_name (eltstring
);
1548 if (STRINGP (eltstring
)
1549 && SCHARS (string
) <= SCHARS (eltstring
)
1550 /* If HIDE_SPACES, reject alternatives that start with space
1551 unless the input starts with space. */
1552 && (NILP (hide_spaces
)
1553 || (SBYTES (string
) > 0
1554 && SREF (string
, 0) == ' ')
1555 || SREF (eltstring
, 0) != ' ')
1556 && (tem
= Fcompare_strings (eltstring
, zero
,
1557 make_number (SCHARS (string
)),
1559 make_number (SCHARS (string
)),
1560 completion_ignore_case
? Qt
: Qnil
),
1564 Lisp_Object regexps
;
1566 /* Ignore this element if it fails to match all the regexps. */
1568 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1569 regexps
= XCDR (regexps
))
1571 if (bindcount
< 0) {
1572 bindcount
= SPECPDL_INDEX ();
1573 specbind (Qcase_fold_search
,
1574 completion_ignore_case
? Qt
: Qnil
);
1576 tem
= Fstring_match (XCAR (regexps
), eltstring
, zero
);
1580 if (CONSP (regexps
))
1584 /* Ignore this element if there is a predicate
1585 and the predicate doesn't like it. */
1587 if (!NILP (predicate
))
1589 if (EQ (predicate
, Qcommandp
))
1590 tem
= Fcommandp (elt
, Qnil
);
1593 if (bindcount
>= 0) {
1594 unbind_to (bindcount
, Qnil
);
1597 GCPRO4 (tail
, eltstring
, allmatches
, string
);
1599 ? call2 (predicate
, elt
,
1600 HASH_VALUE (XHASH_TABLE (collection
), idx
- 1))
1601 : call1 (predicate
, elt
);
1604 if (NILP (tem
)) continue;
1606 /* Ok => put it on the list. */
1607 allmatches
= Fcons (eltstring
, allmatches
);
1611 if (bindcount
>= 0) {
1612 unbind_to (bindcount
, Qnil
);
1616 return Fnreverse (allmatches
);
1619 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 8, 0,
1620 doc
: /* Read a string in the minibuffer, with completion.
1621 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1622 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1623 COLLECTION can also be a function to do the completion itself.
1624 PREDICATE limits completion to a subset of COLLECTION.
1625 See `try-completion' and `all-completions' for more details
1626 on completion, COLLECTION, and PREDICATE.
1628 REQUIRE-MATCH can take the following values:
1629 - t means that the user is not allowed to exit unless
1630 the input is (or completes to) an element of COLLECTION or is null.
1631 - nil means that the user can exit with any input.
1632 - `confirm' means that the user can exit with any input, but she needs
1633 to confirm her choice if the input is not an element of COLLECTION.
1634 - `confirm-after-completion' means that the user can exit with any
1635 input, but she needs to confirm her choice if she called
1636 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1637 and the input is not an element of COLLECTION.
1638 - anything else behaves like t except that typing RET does not exit if it
1639 does non-null completion.
1641 If the input is null, `completing-read' returns DEF, or the first element
1642 of the list of default values, or an empty string if DEF is nil,
1643 regardless of the value of REQUIRE-MATCH.
1645 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1646 with point positioned at the end.
1647 If it is (STRING . POSITION), the initial input is STRING, but point
1648 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1649 that this is different from `read-from-minibuffer' and related
1650 functions, which use one-indexing for POSITION.) This feature is
1651 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1652 default value DEF instead. The user can yank the default value into
1653 the minibuffer easily using \\[next-history-element].
1655 HIST, if non-nil, specifies a history list and optionally the initial
1656 position in the list. It can be a symbol, which is the history list
1657 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1658 that case, HISTVAR is the history list variable to use, and HISTPOS
1659 is the initial position (the position in the list used by the
1660 minibuffer history commands). For consistency, you should also
1661 specify that element of the history as the value of
1662 INITIAL-INPUT. (This is the only case in which you should use
1663 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1664 1 at the beginning of the list. The variable `history-length'
1665 controls the maximum length of a history list.
1667 DEF, if non-nil, is the default value or the list of default values.
1669 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1670 the current input method and the setting of `enable-multibyte-characters'.
1672 Completion ignores case if the ambient value of
1673 `completion-ignore-case' is non-nil.
1675 See also `completing-read-function'. */)
1676 (Lisp_Object prompt
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object require_match
, Lisp_Object initial_input
, Lisp_Object hist
, Lisp_Object def
, Lisp_Object inherit_input_method
)
1678 Lisp_Object args
[9];
1679 args
[0] = Vcompleting_read_function
;
1681 args
[2] = collection
;
1682 args
[3] = predicate
;
1683 args
[4] = require_match
;
1684 args
[5] = initial_input
;
1687 args
[8] = inherit_input_method
;
1688 return Ffuncall (9, args
);
1691 DEFUN ("completing-read-default", Fcompleting_read_default
, Scompleting_read_default
, 2, 8, 0,
1692 doc
: /* Default method for reading from the minibuffer with completion.
1693 See `completing-read' for the meaning of the arguments. */)
1694 (Lisp_Object prompt
, Lisp_Object collection
, Lisp_Object predicate
, Lisp_Object require_match
, Lisp_Object initial_input
, Lisp_Object hist
, Lisp_Object def
, Lisp_Object inherit_input_method
)
1696 Lisp_Object val
, histvar
, histpos
, position
;
1699 int count
= SPECPDL_INDEX ();
1700 struct gcpro gcpro1
;
1702 init
= initial_input
;
1705 specbind (Qminibuffer_completion_table
, collection
);
1706 specbind (Qminibuffer_completion_predicate
, predicate
);
1707 specbind (Qminibuffer_completion_confirm
,
1708 EQ (require_match
, Qt
) ? Qnil
: require_match
);
1715 position
= Fcdr (init
);
1718 CHECK_STRING (init
);
1719 if (!NILP (position
))
1721 CHECK_NUMBER (position
);
1722 /* Convert to distance from end of input. */
1723 pos
= XINT (position
) - SCHARS (init
);
1734 histvar
= Fcar_safe (hist
);
1735 histpos
= Fcdr_safe (hist
);
1738 histvar
= Qminibuffer_history
;
1740 XSETFASTINT (histpos
, 0);
1742 val
= read_minibuf (NILP (require_match
)
1743 ? (NILP (Vminibuffer_completing_file_name
)
1744 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1745 ? Vminibuffer_local_completion_map
1746 : Vminibuffer_local_filename_completion_map
)
1747 : (NILP (Vminibuffer_completing_file_name
)
1748 || EQ (Vminibuffer_completing_file_name
, Qlambda
)
1749 ? Vminibuffer_local_must_match_map
1750 : Vminibuffer_local_filename_must_match_map
),
1751 init
, prompt
, make_number (pos
), 0,
1752 histvar
, histpos
, def
, 0,
1753 !NILP (inherit_input_method
));
1755 if (STRINGP (val
) && SCHARS (val
) == 0 && ! NILP (def
))
1756 val
= CONSP (def
) ? XCAR (def
) : def
;
1758 RETURN_UNGCPRO (unbind_to (count
, val
));
1761 Lisp_Object
Fassoc_string (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
);
1763 /* Test whether TXT is an exact completion. */
1764 DEFUN ("test-completion", Ftest_completion
, Stest_completion
, 2, 3, 0,
1765 doc
: /* Return non-nil if STRING is a valid completion.
1766 Takes the same arguments as `all-completions' and `try-completion'.
1767 If COLLECTION is a function, it is called with three arguments:
1768 the values STRING, PREDICATE and `lambda'. */)
1769 (Lisp_Object string
, Lisp_Object collection
, Lisp_Object predicate
)
1771 Lisp_Object regexps
, tail
, tem
= Qnil
;
1774 CHECK_STRING (string
);
1776 if ((CONSP (collection
)
1777 && (!SYMBOLP (XCAR (collection
)) || NILP (XCAR (collection
))))
1778 || NILP (collection
))
1780 tem
= Fassoc_string (string
, collection
, completion_ignore_case
? Qt
: Qnil
);
1784 else if (VECTORP (collection
))
1786 /* Bypass intern-soft as that loses for nil. */
1787 tem
= oblookup (collection
,
1793 if (STRING_MULTIBYTE (string
))
1794 string
= Fstring_make_unibyte (string
);
1796 string
= Fstring_make_multibyte (string
);
1798 tem
= oblookup (collection
,
1804 if (completion_ignore_case
&& !SYMBOLP (tem
))
1806 for (i
= XVECTOR (collection
)->size
- 1; i
>= 0; i
--)
1808 tail
= XVECTOR (collection
)->contents
[i
];
1812 if (EQ((Fcompare_strings (string
, make_number (0), Qnil
,
1813 Fsymbol_name (tail
),
1814 make_number (0) , Qnil
, Qt
)),
1820 if (XSYMBOL (tail
)->next
== 0)
1822 XSETSYMBOL (tail
, XSYMBOL (tail
)->next
);
1830 else if (HASH_TABLE_P (collection
))
1832 struct Lisp_Hash_Table
*h
= XHASH_TABLE (collection
);
1833 i
= hash_lookup (h
, string
, NULL
);
1835 tem
= HASH_KEY (h
, i
);
1837 for (i
= 0; i
< HASH_TABLE_SIZE (h
); ++i
)
1838 if (!NILP (HASH_HASH (h
, i
)) &&
1839 EQ (Fcompare_strings (string
, make_number (0), Qnil
,
1840 HASH_KEY (h
, i
), make_number (0) , Qnil
,
1841 completion_ignore_case
? Qt
: Qnil
),
1844 tem
= HASH_KEY (h
, i
);
1851 return call3 (collection
, string
, predicate
, Qlambda
);
1853 /* Reject this element if it fails to match all the regexps. */
1854 if (CONSP (Vcompletion_regexp_list
))
1856 int count
= SPECPDL_INDEX ();
1857 specbind (Qcase_fold_search
, completion_ignore_case
? Qt
: Qnil
);
1858 for (regexps
= Vcompletion_regexp_list
; CONSP (regexps
);
1859 regexps
= XCDR (regexps
))
1861 if (NILP (Fstring_match (XCAR (regexps
),
1862 SYMBOLP (tem
) ? string
: tem
,
1864 return unbind_to (count
, Qnil
);
1866 unbind_to (count
, Qnil
);
1869 /* Finally, check the predicate. */
1870 if (!NILP (predicate
))
1872 return HASH_TABLE_P (collection
)
1873 ? call2 (predicate
, tem
, HASH_VALUE (XHASH_TABLE (collection
), i
))
1874 : call1 (predicate
, tem
);
1880 DEFUN ("internal-complete-buffer", Finternal_complete_buffer
, Sinternal_complete_buffer
, 3, 3, 0,
1881 doc
: /* Perform completion on buffer names.
1882 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1883 `all-completions', otherwise invoke `test-completion'.
1885 The arguments STRING and PREDICATE are as in `try-completion',
1886 `all-completions', and `test-completion'. */)
1887 (Lisp_Object string
, Lisp_Object predicate
, Lisp_Object flag
)
1890 return Ftry_completion (string
, Vbuffer_alist
, predicate
);
1891 else if (EQ (flag
, Qt
))
1893 Lisp_Object res
= Fall_completions (string
, Vbuffer_alist
, predicate
, Qnil
);
1894 if (SCHARS (string
) > 0)
1897 { /* Strip out internal buffers. */
1898 Lisp_Object bufs
= res
;
1899 /* First, look for a non-internal buffer in `res'. */
1900 while (CONSP (bufs
) && SREF (XCAR (bufs
), 0) == ' ')
1903 /* All bufs in `res' are internal, so don't trip them out. */
1906 while (CONSP (XCDR (bufs
)))
1907 if (SREF (XCAR (XCDR (bufs
)), 0) == ' ')
1908 XSETCDR (bufs
, XCDR (XCDR (bufs
)));
1914 else /* assume `lambda' */
1915 return Ftest_completion (string
, Vbuffer_alist
, predicate
);
1918 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1920 DEFUN ("assoc-string", Fassoc_string
, Sassoc_string
, 2, 3, 0,
1921 doc
: /* Like `assoc' but specifically for strings (and symbols).
1923 This returns the first element of LIST whose car matches the string or
1924 symbol KEY, or nil if no match exists. When performing the
1925 comparison, symbols are first converted to strings, and unibyte
1926 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1929 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1930 single string, rather than a cons cell whose car is a string. */)
1931 (register Lisp_Object key
, Lisp_Object list
, Lisp_Object case_fold
)
1933 register Lisp_Object tail
;
1936 key
= Fsymbol_name (key
);
1938 for (tail
= list
; CONSP (tail
); tail
= XCDR (tail
))
1940 register Lisp_Object elt
, tem
, thiscar
;
1942 thiscar
= CONSP (elt
) ? XCAR (elt
) : elt
;
1943 if (SYMBOLP (thiscar
))
1944 thiscar
= Fsymbol_name (thiscar
);
1945 else if (!STRINGP (thiscar
))
1947 tem
= Fcompare_strings (thiscar
, make_number (0), Qnil
,
1948 key
, make_number (0), Qnil
,
1958 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1959 doc
: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1962 return make_number (minibuf_level
);
1965 DEFUN ("minibuffer-prompt", Fminibuffer_prompt
, Sminibuffer_prompt
, 0, 0, 0,
1966 doc
: /* Return the prompt string of the currently-active minibuffer.
1967 If no minibuffer is active, return nil. */)
1970 return Fcopy_sequence (minibuf_prompt
);
1975 init_minibuf_once (void)
1977 Vminibuffer_list
= Qnil
;
1978 staticpro (&Vminibuffer_list
);
1982 syms_of_minibuf (void)
1985 minibuf_prompt
= Qnil
;
1986 staticpro (&minibuf_prompt
);
1988 minibuf_save_list
= Qnil
;
1989 staticpro (&minibuf_save_list
);
1991 Qcompleting_read_default
= intern_c_string ("completing-read-default");
1992 staticpro (&Qcompleting_read_default
);
1994 Qcompletion_ignore_case
= intern_c_string ("completion-ignore-case");
1995 staticpro (&Qcompletion_ignore_case
);
1997 Qread_file_name_internal
= intern_c_string ("read-file-name-internal");
1998 staticpro (&Qread_file_name_internal
);
2000 Qminibuffer_default
= intern_c_string ("minibuffer-default");
2001 staticpro (&Qminibuffer_default
);
2002 Fset (Qminibuffer_default
, Qnil
);
2004 Qminibuffer_completion_table
= intern_c_string ("minibuffer-completion-table");
2005 staticpro (&Qminibuffer_completion_table
);
2007 Qminibuffer_completion_confirm
= intern_c_string ("minibuffer-completion-confirm");
2008 staticpro (&Qminibuffer_completion_confirm
);
2010 Qminibuffer_completion_predicate
= intern_c_string ("minibuffer-completion-predicate");
2011 staticpro (&Qminibuffer_completion_predicate
);
2013 staticpro (&last_minibuf_string
);
2014 last_minibuf_string
= Qnil
;
2016 Quser_variable_p
= intern_c_string ("user-variable-p");
2017 staticpro (&Quser_variable_p
);
2019 Qminibuffer_history
= intern_c_string ("minibuffer-history");
2020 staticpro (&Qminibuffer_history
);
2022 Qbuffer_name_history
= intern_c_string ("buffer-name-history");
2023 staticpro (&Qbuffer_name_history
);
2024 Fset (Qbuffer_name_history
, Qnil
);
2026 Qminibuffer_setup_hook
= intern_c_string ("minibuffer-setup-hook");
2027 staticpro (&Qminibuffer_setup_hook
);
2029 Qminibuffer_exit_hook
= intern_c_string ("minibuffer-exit-hook");
2030 staticpro (&Qminibuffer_exit_hook
);
2032 Qhistory_length
= intern_c_string ("history-length");
2033 staticpro (&Qhistory_length
);
2035 Qcurrent_input_method
= intern_c_string ("current-input-method");
2036 staticpro (&Qcurrent_input_method
);
2038 Qactivate_input_method
= intern_c_string ("activate-input-method");
2039 staticpro (&Qactivate_input_method
);
2041 Qcase_fold_search
= intern_c_string ("case-fold-search");
2042 staticpro (&Qcase_fold_search
);
2044 DEFVAR_LISP ("read-expression-history", Vread_expression_history
,
2045 doc
: /* A history list for arguments that are Lisp expressions to evaluate.
2046 For example, `eval-expression' uses this. */);
2047 Vread_expression_history
= Qnil
;
2049 Qread_expression_history
= intern_c_string ("read-expression-history");
2050 staticpro (&Qread_expression_history
);
2052 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function
,
2053 doc
: /* If this is non-nil, `read-buffer' does its work by calling this function.
2054 The function is called with the arguments passed to `read-buffer'. */);
2055 Vread_buffer_function
= Qnil
;
2057 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2058 read_buffer_completion_ignore_case
,
2059 doc
: /* *Non-nil means completion ignores case when reading a buffer name. */);
2060 read_buffer_completion_ignore_case
= 0;
2062 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook
,
2063 doc
: /* Normal hook run just after entry to minibuffer. */);
2064 Vminibuffer_setup_hook
= Qnil
;
2066 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook
,
2067 doc
: /* Normal hook run just after exit from minibuffer. */);
2068 Vminibuffer_exit_hook
= Qnil
;
2070 DEFVAR_LISP ("history-length", Vhistory_length
,
2071 doc
: /* *Maximum length for history lists before truncation takes place.
2072 A number means that length; t means infinite. Truncation takes place
2073 just after a new element is inserted. Setting the `history-length'
2074 property of a history variable overrides this default. */);
2075 XSETFASTINT (Vhistory_length
, 30);
2077 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates
,
2078 doc
: /* *Non-nil means to delete duplicates in history.
2079 If set to t when adding a new history element, all previous identical
2080 elements are deleted from the history list. */);
2081 history_delete_duplicates
= 0;
2083 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input
,
2084 doc
: /* *Non-nil means to add new elements in history.
2085 If set to nil, minibuffer reading functions don't add new elements to the
2086 history list, so it is possible to do this afterwards by calling
2087 `add-to-history' explicitly. */);
2088 Vhistory_add_new_input
= Qt
;
2090 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case
,
2091 doc
: /* Non-nil means don't consider case significant in completion.
2092 For file-name completion, `read-file-name-completion-ignore-case'
2093 controls the behavior, rather than this variable.
2094 For buffer name completion, `read-buffer-completion-ignore-case'
2095 controls the behavior, rather than this variable. */);
2096 completion_ignore_case
= 0;
2098 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers
,
2099 doc
: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2100 This variable makes a difference whenever the minibuffer window is active. */);
2101 enable_recursive_minibuffers
= 0;
2103 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table
,
2104 doc
: /* Alist or obarray used for completion in the minibuffer.
2105 This becomes the ALIST argument to `try-completion' and `all-completions'.
2106 The value can also be a list of strings or a hash table.
2108 The value may alternatively be a function, which is given three arguments:
2109 STRING, the current buffer contents;
2110 PREDICATE, the predicate for filtering possible matches;
2111 CODE, which says what kind of things to do.
2112 CODE can be nil, t or `lambda':
2113 nil -- return the best completion of STRING, or nil if there is none.
2114 t -- return a list of all possible completions of STRING.
2115 lambda -- return t if STRING is a valid completion as it stands. */);
2116 Vminibuffer_completion_table
= Qnil
;
2118 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate
,
2119 doc
: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2120 Vminibuffer_completion_predicate
= Qnil
;
2122 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm
,
2123 doc
: /* Whether to demand confirmation of completion before exiting minibuffer.
2124 If nil, confirmation is not required.
2125 If the value is `confirm', the user may exit with an input that is not
2126 a valid completion alternative, but Emacs asks for confirmation.
2127 If the value is `confirm-after-completion', the user may exit with an
2128 input that is not a valid completion alternative, but Emacs asks for
2129 confirmation if the user submitted the input right after any of the
2130 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2131 Vminibuffer_completion_confirm
= Qnil
;
2133 DEFVAR_LISP ("minibuffer-completing-file-name",
2134 Vminibuffer_completing_file_name
,
2135 doc
: /* Non-nil means completing file names. */);
2136 Vminibuffer_completing_file_name
= Qnil
;
2138 DEFVAR_LISP ("completing-read-function",
2139 Vcompleting_read_function
,
2140 doc
: /* The function called by `completing-read' to do the work.
2141 It should accept the same arguments as `completing-read'. */);
2142 Vcompleting_read_function
= Qcompleting_read_default
;
2144 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form
,
2145 doc
: /* Value that `help-form' takes on inside the minibuffer. */);
2146 Vminibuffer_help_form
= Qnil
;
2148 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable
,
2149 doc
: /* History list symbol to add minibuffer values to.
2150 Each string of minibuffer input, as it appears on exit from the minibuffer,
2152 (set minibuffer-history-variable
2153 (cons STRING (symbol-value minibuffer-history-variable))) */);
2154 XSETFASTINT (Vminibuffer_history_variable
, 0);
2156 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position
,
2157 doc
: /* Current position of redoing in the history list. */);
2158 Vminibuffer_history_position
= Qnil
;
2160 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise
,
2161 doc
: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2162 Some uses of the echo area also raise that frame (since they use it too). */);
2163 minibuffer_auto_raise
= 0;
2165 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list
,
2166 doc
: /* List of regexps that should restrict possible completions.
2167 The basic completion functions only consider a completion acceptable
2168 if it matches all regular expressions in this list, with
2169 `case-fold-search' bound to the value of `completion-ignore-case'.
2170 See Info node `(elisp)Basic Completion', for a description of these
2172 Vcompletion_regexp_list
= Qnil
;
2174 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2175 minibuffer_allow_text_properties
,
2176 doc
: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2177 This also affects `read-string', but it does not affect `read-minibuffer',
2178 `read-no-blanks-input', or any of the functions that do minibuffer input
2179 with completion; they always discard text properties. */);
2180 minibuffer_allow_text_properties
= 0;
2182 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties
,
2183 doc
: /* Text properties that are added to minibuffer prompts.
2184 These are in addition to the basic `field' property, and stickiness
2186 /* We use `intern' here instead of Qread_only to avoid
2187 initialization-order problems. */
2188 Vminibuffer_prompt_properties
2189 = Fcons (intern_c_string ("read-only"), Fcons (Qt
, Qnil
));
2191 DEFVAR_LISP ("read-expression-map", Vread_expression_map
,
2192 doc
: /* Minibuffer keymap used for reading Lisp expressions. */);
2193 Vread_expression_map
= Qnil
;
2195 defsubr (&Sset_minibuffer_window
);
2196 defsubr (&Sread_from_minibuffer
);
2197 defsubr (&Seval_minibuffer
);
2198 defsubr (&Sread_minibuffer
);
2199 defsubr (&Sread_string
);
2200 defsubr (&Sread_command
);
2201 defsubr (&Sread_variable
);
2202 defsubr (&Sinternal_complete_buffer
);
2203 defsubr (&Sread_buffer
);
2204 defsubr (&Sread_no_blanks_input
);
2205 defsubr (&Sminibuffer_depth
);
2206 defsubr (&Sminibuffer_prompt
);
2208 defsubr (&Sminibufferp
);
2209 defsubr (&Sminibuffer_prompt_end
);
2210 defsubr (&Sminibuffer_contents
);
2211 defsubr (&Sminibuffer_contents_no_properties
);
2212 defsubr (&Sminibuffer_completion_contents
);
2214 defsubr (&Stry_completion
);
2215 defsubr (&Sall_completions
);
2216 defsubr (&Stest_completion
);
2217 defsubr (&Sassoc_string
);
2218 defsubr (&Scompleting_read
);
2219 defsubr (&Scompleting_read_default
);