Remove * characters from the front of variable docstrings.
[emacs.git] / src / minibuf.c
blob05f9419ba349ea3671d74e3a3e6c806289ac085c
1 /* Minibuffer input and completion.
3 Copyright (C) 1985-1986, 1993-2012 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/>. */
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <setjmp.h>
26 #include "lisp.h"
27 #include "commands.h"
28 #include "buffer.h"
29 #include "dispextern.h"
30 #include "keyboard.h"
31 #include "frame.h"
32 #include "window.h"
33 #include "syntax.h"
34 #include "intervals.h"
35 #include "keymap.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 static Lisp_Object minibuf_save_list;
50 /* Depth in minibuffer invocations. */
52 EMACS_INT minibuf_level;
54 /* The maximum length of a minibuffer history. */
56 static Lisp_Object Qhistory_length;
58 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string;
62 static Lisp_Object Qminibuffer_history, Qbuffer_name_history;
64 static Lisp_Object Qread_file_name_internal;
66 /* Normal hooks for entry to and exit from minibuffer. */
68 static Lisp_Object Qminibuffer_setup_hook;
69 static Lisp_Object Qminibuffer_exit_hook;
71 Lisp_Object Qcompletion_ignore_case;
72 static Lisp_Object Qminibuffer_completion_table;
73 static Lisp_Object Qminibuffer_completion_predicate;
74 static Lisp_Object Qminibuffer_completion_confirm;
75 static Lisp_Object Qcustom_variable_p;
77 static Lisp_Object Qminibuffer_default;
79 static Lisp_Object Qcurrent_input_method, Qactivate_input_method;
81 static Lisp_Object Qcase_fold_search;
83 static Lisp_Object Qread_expression_history;
85 /* Prompt to display in front of the mini-buffer contents. */
87 static Lisp_Object minibuf_prompt;
89 /* Width of current mini-buffer prompt. Only set after display_line
90 of the line that contains the prompt. */
92 static EMACS_INT minibuf_prompt_width;
95 /* Put minibuf on currently selected frame's minibuffer.
96 We do this whenever the user starts a new minibuffer
97 or when a minibuffer exits. */
99 static void
100 choose_minibuf_frame (void)
102 if (FRAMEP (selected_frame)
103 && FRAME_LIVE_P (XFRAME (selected_frame))
104 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
106 struct frame *sf = XFRAME (selected_frame);
107 Lisp_Object buffer;
109 /* I don't think that any frames may validly have a null minibuffer
110 window anymore. */
111 if (NILP (sf->minibuffer_window))
112 abort ();
114 /* Under X, we come here with minibuf_window being the
115 minibuffer window of the unused termcap window created in
116 init_window_once. That window doesn't have a buffer. */
117 buffer = XWINDOW (minibuf_window)->buffer;
118 if (BUFFERP (buffer))
119 Fset_window_buffer (sf->minibuffer_window, buffer, Qnil);
120 minibuf_window = sf->minibuffer_window;
123 /* Make sure no other frame has a minibuffer as its selected window,
124 because the text would not be displayed in it, and that would be
125 confusing. Only allow the selected frame to do this,
126 and that only if the minibuffer is active. */
128 Lisp_Object tail, frame;
130 FOR_EACH_FRAME (tail, frame)
131 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
132 && !(EQ (frame, selected_frame)
133 && minibuf_level > 0))
134 Fset_frame_selected_window (frame, Fframe_first_window (frame), Qnil);
138 static Lisp_Object
139 choose_minibuf_frame_1 (Lisp_Object ignore)
141 choose_minibuf_frame ();
142 return Qnil;
145 DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
146 Sactive_minibuffer_window, 0, 0, 0,
147 doc: /* Return the currently active minibuffer window, or nil if none. */)
148 (void)
150 return minibuf_level ? minibuf_window : Qnil;
153 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
154 Sset_minibuffer_window, 1, 1, 0,
155 doc: /* Specify which minibuffer window to use for the minibuffer.
156 This affects where the minibuffer is displayed if you put text in it
157 without invoking the usual minibuffer commands. */)
158 (Lisp_Object window)
160 CHECK_WINDOW (window);
161 if (! MINI_WINDOW_P (XWINDOW (window)))
162 error ("Window is not a minibuffer window");
164 minibuf_window = window;
166 return window;
170 /* Actual minibuffer invocation. */
172 static Lisp_Object read_minibuf_unwind (Lisp_Object);
173 static Lisp_Object run_exit_minibuf_hook (Lisp_Object);
174 static Lisp_Object read_minibuf (Lisp_Object, Lisp_Object,
175 Lisp_Object, Lisp_Object,
176 int, Lisp_Object,
177 Lisp_Object, Lisp_Object,
178 int, int);
179 static Lisp_Object read_minibuf_noninteractive (Lisp_Object, Lisp_Object,
180 Lisp_Object, Lisp_Object,
181 int, Lisp_Object,
182 Lisp_Object, Lisp_Object,
183 int, int);
184 static Lisp_Object string_to_object (Lisp_Object, Lisp_Object);
187 /* Read a Lisp object from VAL and return it. If VAL is an empty
188 string, and DEFALT is a string, read from DEFALT instead of VAL. */
190 static Lisp_Object
191 string_to_object (Lisp_Object val, Lisp_Object defalt)
193 struct gcpro gcpro1, gcpro2;
194 Lisp_Object expr_and_pos;
195 EMACS_INT pos;
197 GCPRO2 (val, defalt);
199 if (STRINGP (val) && SCHARS (val) == 0)
201 if (STRINGP (defalt))
202 val = defalt;
203 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
204 val = XCAR (defalt);
207 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
208 pos = XINT (Fcdr (expr_and_pos));
209 if (pos != SCHARS (val))
211 /* Ignore trailing whitespace; any other trailing junk
212 is an error. */
213 EMACS_INT i;
214 pos = string_char_to_byte (val, pos);
215 for (i = pos; i < SBYTES (val); i++)
217 int c = SREF (val, i);
218 if (c != ' ' && c != '\t' && c != '\n')
219 error ("Trailing garbage following expression");
223 val = Fcar (expr_and_pos);
224 RETURN_UNGCPRO (val);
228 /* Like read_minibuf but reading from stdin. This function is called
229 from read_minibuf to do the job if noninteractive. */
231 static Lisp_Object
232 read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
233 Lisp_Object prompt, Lisp_Object backup_n,
234 int expflag,
235 Lisp_Object histvar, Lisp_Object histpos,
236 Lisp_Object defalt,
237 int allow_props, int inherit_input_method)
239 ptrdiff_t size, len;
240 char *line;
241 Lisp_Object val;
242 int c;
244 fprintf (stdout, "%s", SDATA (prompt));
245 fflush (stdout);
247 val = Qnil;
248 size = 100;
249 len = 0;
250 line = (char *) xmalloc (size);
252 while ((c = getchar ()) != '\n')
254 if (c == EOF)
256 if (errno != EINTR)
257 break;
259 else
261 if (len == size)
263 if (STRING_BYTES_BOUND / 2 < size)
264 memory_full (SIZE_MAX);
265 size *= 2;
266 line = (char *) xrealloc (line, size);
268 line[len++] = c;
272 if (len || c == '\n')
274 val = make_string (line, len);
275 xfree (line);
277 else
279 xfree (line);
280 error ("Error reading from stdin");
283 /* If Lisp form desired instead of string, parse it. */
284 if (expflag)
285 val = string_to_object (val, CONSP (defalt) ? XCAR (defalt) : defalt);
287 return val;
290 DEFUN ("minibufferp", Fminibufferp,
291 Sminibufferp, 0, 1, 0,
292 doc: /* Return t if BUFFER is a minibuffer.
293 No argument or nil as argument means use current buffer as BUFFER.
294 BUFFER can be a buffer or a buffer name. */)
295 (Lisp_Object buffer)
297 Lisp_Object tem;
299 if (NILP (buffer))
300 buffer = Fcurrent_buffer ();
301 else if (STRINGP (buffer))
302 buffer = Fget_buffer (buffer);
303 else
304 CHECK_BUFFER (buffer);
306 tem = Fmemq (buffer, Vminibuffer_list);
307 return ! NILP (tem) ? Qt : Qnil;
310 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
311 Sminibuffer_prompt_end, 0, 0, 0,
312 doc: /* Return the buffer position of the end of the minibuffer prompt.
313 Return (point-min) if current buffer is not a minibuffer. */)
314 (void)
316 /* This function is written to be most efficient when there's a prompt. */
317 Lisp_Object beg, end, tem;
318 beg = make_number (BEGV);
320 tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
321 if (NILP (tem))
322 return beg;
324 end = Ffield_end (beg, Qnil, Qnil);
326 if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
327 return beg;
328 else
329 return end;
332 DEFUN ("minibuffer-contents", Fminibuffer_contents,
333 Sminibuffer_contents, 0, 0, 0,
334 doc: /* Return the user input in a minibuffer as a string.
335 If the current buffer is not a minibuffer, return its entire contents. */)
336 (void)
338 EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
339 return make_buffer_string (prompt_end, ZV, 1);
342 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
343 Sminibuffer_contents_no_properties, 0, 0, 0,
344 doc: /* Return the user input in a minibuffer as a string, without text-properties.
345 If the current buffer is not a minibuffer, return its entire contents. */)
346 (void)
348 EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
349 return make_buffer_string (prompt_end, ZV, 0);
352 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
353 Sminibuffer_completion_contents, 0, 0, 0,
354 doc: /* Return the user input in a minibuffer before point as a string.
355 That is what completion commands operate on.
356 If the current buffer is not a minibuffer, return its entire contents. */)
357 (void)
359 EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
360 if (PT < prompt_end)
361 error ("Cannot do completion in the prompt");
362 return make_buffer_string (prompt_end, PT, 1);
366 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
367 putting point minus BACKUP_N bytes from the end of INITIAL,
368 prompting with PROMPT (a string), using history list HISTVAR
369 with initial position HISTPOS. INITIAL should be a string or a
370 cons of a string and an integer. BACKUP_N should be <= 0, or
371 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
372 ignored and replaced with an integer that puts point at one-indexed
373 position N in INITIAL, where N is the CDR of INITIAL, or at the
374 beginning of INITIAL if N <= 0.
376 Normally return the result as a string (the text that was read),
377 but if EXPFLAG is nonzero, read it and return the object read.
378 If HISTVAR is given, save the value read on that history only if it doesn't
379 match the front of that history list exactly. The value is pushed onto
380 the list as the string that was read.
382 DEFALT specifies the default value for the sake of history commands.
384 If ALLOW_PROPS is nonzero, we do not throw away text properties.
386 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
387 current input method. */
389 static Lisp_Object
390 read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
391 Lisp_Object backup_n, int expflag,
392 Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
393 int allow_props, int inherit_input_method)
395 Lisp_Object val;
396 int count = SPECPDL_INDEX ();
397 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
398 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
399 Lisp_Object enable_multibyte;
400 int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
401 /* String to add to the history. */
402 Lisp_Object histstring;
404 Lisp_Object empty_minibuf;
405 Lisp_Object dummy, frame;
407 specbind (Qminibuffer_default, defalt);
409 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
410 in previous recursive minibuffer, but was not set explicitly
411 to t for this invocation, so set it to nil in this minibuffer.
412 Save the old value now, before we change it. */
413 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name);
414 if (EQ (Vminibuffer_completing_file_name, Qlambda))
415 Vminibuffer_completing_file_name = Qnil;
417 #ifdef HAVE_WINDOW_SYSTEM
418 if (display_hourglass_p)
419 cancel_hourglass ();
420 #endif
422 if (!NILP (initial))
424 if (CONSP (initial))
426 backup_n = Fcdr (initial);
427 initial = Fcar (initial);
428 CHECK_STRING (initial);
429 if (!NILP (backup_n))
431 CHECK_NUMBER (backup_n);
432 /* Convert to distance from end of input. */
433 if (XINT (backup_n) < 1)
434 /* A number too small means the beginning of the string. */
435 pos = - SCHARS (initial);
436 else
437 pos = XINT (backup_n) - 1 - SCHARS (initial);
440 else
441 CHECK_STRING (initial);
443 val = Qnil;
444 ambient_dir = BVAR (current_buffer, directory);
445 input_method = Qnil;
446 enable_multibyte = Qnil;
448 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
449 store them away before we can GC. Don't need to protect
450 BACKUP_N because we use the value only if it is an integer. */
451 GCPRO5 (map, initial, val, ambient_dir, input_method);
453 if (!STRINGP (prompt))
454 prompt = empty_unibyte_string;
456 if (!enable_recursive_minibuffers
457 && minibuf_level > 0)
459 if (EQ (selected_window, minibuf_window))
460 error ("Command attempted to use minibuffer while in minibuffer");
461 else
462 /* If we're in another window, cancel the minibuffer that's active. */
463 Fthrow (Qexit,
464 build_string ("Command attempted to use minibuffer while in minibuffer"));
467 if ((noninteractive
468 /* In case we are running as a daemon, only do this before
469 detaching from the terminal. */
470 || (IS_DAEMON && (daemon_pipe[1] >= 0)))
471 && NILP (Vexecuting_kbd_macro))
473 val = read_minibuf_noninteractive (map, initial, prompt,
474 make_number (pos),
475 expflag, histvar, histpos, defalt,
476 allow_props, inherit_input_method);
477 UNGCPRO;
478 return unbind_to (count, val);
481 /* Choose the minibuffer window and frame, and take action on them. */
483 choose_minibuf_frame ();
485 record_unwind_protect (choose_minibuf_frame_1, Qnil);
487 record_unwind_protect (Fset_window_configuration,
488 Fcurrent_window_configuration (Qnil));
490 /* If the minibuffer window is on a different frame, save that
491 frame's configuration too. */
492 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
493 if (!EQ (mini_frame, selected_frame))
494 record_unwind_protect (Fset_window_configuration,
495 Fcurrent_window_configuration (mini_frame));
497 /* If the minibuffer is on an iconified or invisible frame,
498 make it visible now. */
499 Fmake_frame_visible (mini_frame);
501 if (minibuffer_auto_raise)
502 Fraise_frame (mini_frame);
504 temporarily_switch_to_single_kboard (XFRAME (mini_frame));
506 /* We have to do this after saving the window configuration
507 since that is what restores the current buffer. */
509 /* Arrange to restore a number of minibuffer-related variables.
510 We could bind each variable separately, but that would use lots of
511 specpdl slots. */
512 minibuf_save_list
513 = Fcons (Voverriding_local_map,
514 Fcons (minibuf_window,
515 minibuf_save_list));
516 minibuf_save_list
517 = Fcons (minibuf_prompt,
518 Fcons (make_number (minibuf_prompt_width),
519 Fcons (Vhelp_form,
520 Fcons (Vcurrent_prefix_arg,
521 Fcons (Vminibuffer_history_position,
522 Fcons (Vminibuffer_history_variable,
523 minibuf_save_list))))));
525 record_unwind_protect (read_minibuf_unwind, Qnil);
526 minibuf_level++;
527 /* We are exiting the minibuffer one way or the other, so run the hook.
528 It should be run before unwinding the minibuf settings. Do it
529 separately from read_minibuf_unwind because we need to make sure that
530 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
531 signals an error. --Stef */
532 record_unwind_protect (run_exit_minibuf_hook, Qnil);
534 /* Now that we can restore all those variables, start changing them. */
536 minibuf_prompt_width = 0;
537 minibuf_prompt = Fcopy_sequence (prompt);
538 Vminibuffer_history_position = histpos;
539 Vminibuffer_history_variable = histvar;
540 Vhelp_form = Vminibuffer_help_form;
541 /* If this minibuffer is reading a file name, that doesn't mean
542 recursive ones are. But we cannot set it to nil, because
543 completion code still need to know the minibuffer is completing a
544 file name. So use `lambda' as intermediate value meaning
545 "t" in this minibuffer, but "nil" in next minibuffer. */
546 if (!NILP (Vminibuffer_completing_file_name))
547 Vminibuffer_completing_file_name = Qlambda;
549 if (inherit_input_method)
551 /* `current-input-method' is buffer local. So, remember it in
552 INPUT_METHOD before changing the current buffer. */
553 input_method = Fsymbol_value (Qcurrent_input_method);
554 enable_multibyte = BVAR (current_buffer, enable_multibyte_characters);
557 /* Switch to the minibuffer. */
559 minibuffer = get_minibuffer (minibuf_level);
560 Fset_buffer (minibuffer);
562 /* Defeat (setq-default truncate-lines t), since truncated lines do
563 not work correctly in minibuffers. (Bug#5715, etc) */
564 BVAR (current_buffer, truncate_lines) = Qnil;
566 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
567 if (inherit_input_method)
568 BVAR (current_buffer, enable_multibyte_characters) = enable_multibyte;
570 /* The current buffer's default directory is usually the right thing
571 for our minibuffer here. However, if you're typing a command at
572 a minibuffer-only frame when minibuf_level is zero, then buf IS
573 the current_buffer, so reset_buffer leaves buf's default
574 directory unchanged. This is a bummer when you've just started
575 up Emacs and buf's default directory is Qnil. Here's a hack; can
576 you think of something better to do? Find another buffer with a
577 better directory, and use that one instead. */
578 if (STRINGP (ambient_dir))
579 BVAR (current_buffer, directory) = ambient_dir;
580 else
582 Lisp_Object buf_list;
584 for (buf_list = Vbuffer_alist;
585 CONSP (buf_list);
586 buf_list = XCDR (buf_list))
588 Lisp_Object other_buf;
590 other_buf = XCDR (XCAR (buf_list));
591 if (STRINGP (BVAR (XBUFFER (other_buf), directory)))
593 BVAR (current_buffer, directory) = BVAR (XBUFFER (other_buf), directory);
594 break;
599 if (!EQ (mini_frame, selected_frame))
600 Fredirect_frame_focus (selected_frame, mini_frame);
602 Vminibuf_scroll_window = selected_window;
603 if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
604 minibuf_selected_window = selected_window;
606 /* Empty out the minibuffers of all frames other than the one
607 where we are going to display one now.
608 Set them to point to ` *Minibuf-0*', which is always empty. */
609 empty_minibuf = get_minibuffer (0);
611 FOR_EACH_FRAME (dummy, frame)
613 Lisp_Object root_window = Fframe_root_window (frame);
614 Lisp_Object mini_window = XWINDOW (root_window)->next;
616 if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
617 && !NILP (Fwindow_minibuffer_p (mini_window)))
618 Fset_window_buffer (mini_window, empty_minibuf, Qnil);
621 /* Display this minibuffer in the proper window. */
622 Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
623 Fselect_window (minibuf_window, Qnil);
624 XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
626 Fmake_local_variable (Qprint_escape_newlines);
627 print_escape_newlines = 1;
629 /* Erase the buffer. */
631 int count1 = SPECPDL_INDEX ();
632 specbind (Qinhibit_read_only, Qt);
633 specbind (Qinhibit_modification_hooks, Qt);
634 Ferase_buffer ();
636 if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
637 && ! STRING_MULTIBYTE (minibuf_prompt))
638 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
640 /* Insert the prompt, record where it ends. */
641 Finsert (1, &minibuf_prompt);
642 if (PT > BEG)
644 Fput_text_property (make_number (BEG), make_number (PT),
645 Qfront_sticky, Qt, Qnil);
646 Fput_text_property (make_number (BEG), make_number (PT),
647 Qrear_nonsticky, Qt, Qnil);
648 Fput_text_property (make_number (BEG), make_number (PT),
649 Qfield, Qt, Qnil);
650 Fadd_text_properties (make_number (BEG), make_number (PT),
651 Vminibuffer_prompt_properties, Qnil);
653 unbind_to (count1, Qnil);
656 minibuf_prompt_width = current_column ();
658 /* Put in the initial input. */
659 if (!NILP (initial))
661 Finsert (1, &initial);
662 Fforward_char (make_number (pos));
665 clear_message (1, 1);
666 BVAR (current_buffer, keymap) = map;
668 /* Turn on an input method stored in INPUT_METHOD if any. */
669 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
670 call1 (Qactivate_input_method, input_method);
672 Frun_hooks (1, &Qminibuffer_setup_hook);
674 /* Don't allow the user to undo past this point. */
675 BVAR (current_buffer, undo_list) = Qnil;
677 recursive_edit_1 ();
679 /* If cursor is on the minibuffer line,
680 show the user we have exited by putting it in column 0. */
681 if (XWINDOW (minibuf_window)->cursor.vpos >= 0
682 && !noninteractive)
684 XWINDOW (minibuf_window)->cursor.hpos = 0;
685 XWINDOW (minibuf_window)->cursor.x = 0;
686 XWINDOW (minibuf_window)->must_be_updated_p = 1;
687 update_frame (XFRAME (selected_frame), 1, 1);
689 struct frame *f = XFRAME (XWINDOW (minibuf_window)->frame);
690 struct redisplay_interface *rif = FRAME_RIF (f);
691 if (rif && rif->flush_display)
692 rif->flush_display (f);
696 /* Make minibuffer contents into a string. */
697 Fset_buffer (minibuffer);
698 if (allow_props)
699 val = Fminibuffer_contents ();
700 else
701 val = Fminibuffer_contents_no_properties ();
703 /* VAL is the string of minibuffer text. */
705 last_minibuf_string = val;
707 /* Choose the string to add to the history. */
708 if (SCHARS (val) != 0)
709 histstring = val;
710 else if (STRINGP (defalt))
711 histstring = defalt;
712 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
713 histstring = XCAR (defalt);
714 else
715 histstring = Qnil;
717 /* Add the value to the appropriate history list, if any. */
718 if (!NILP (Vhistory_add_new_input)
719 && SYMBOLP (Vminibuffer_history_variable)
720 && !NILP (histstring))
722 /* If the caller wanted to save the value read on a history list,
723 then do so if the value is not already the front of the list. */
724 Lisp_Object histval;
726 /* If variable is unbound, make it nil. */
728 histval = find_symbol_value (Vminibuffer_history_variable);
729 if (EQ (histval, Qunbound))
730 Fset (Vminibuffer_history_variable, Qnil);
732 /* The value of the history variable must be a cons or nil. Other
733 values are unacceptable. We silently ignore these values. */
735 if (NILP (histval)
736 || (CONSP (histval)
737 /* Don't duplicate the most recent entry in the history. */
738 && (NILP (Fequal (histstring, Fcar (histval))))))
740 Lisp_Object length;
742 if (history_delete_duplicates) Fdelete (histstring, histval);
743 histval = Fcons (histstring, histval);
744 Fset (Vminibuffer_history_variable, histval);
746 /* Truncate if requested. */
747 length = Fget (Vminibuffer_history_variable, Qhistory_length);
748 if (NILP (length)) length = Vhistory_length;
749 if (INTEGERP (length))
751 if (XINT (length) <= 0)
752 Fset (Vminibuffer_history_variable, Qnil);
753 else
755 Lisp_Object temp;
757 temp = Fnthcdr (Fsub1 (length), histval);
758 if (CONSP (temp)) Fsetcdr (temp, Qnil);
764 /* If Lisp form desired instead of string, parse it. */
765 if (expflag)
766 val = string_to_object (val, defalt);
768 /* The appropriate frame will get selected
769 in set-window-configuration. */
770 UNGCPRO;
771 return unbind_to (count, val);
774 /* Return a buffer to be used as the minibuffer at depth `depth'.
775 depth = 0 is the lowest allowed argument, and that is the value
776 used for nonrecursive minibuffer invocations. */
778 Lisp_Object
779 get_minibuffer (EMACS_INT depth)
781 Lisp_Object tail, num, buf;
782 char name[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT)];
784 XSETFASTINT (num, depth);
785 tail = Fnthcdr (num, Vminibuffer_list);
786 if (NILP (tail))
788 tail = Fcons (Qnil, Qnil);
789 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
791 buf = Fcar (tail);
792 if (NILP (buf) || NILP (BVAR (XBUFFER (buf), name)))
794 sprintf (name, " *Minibuf-%"pI"d*", depth);
795 buf = Fget_buffer_create (build_string (name));
797 /* Although the buffer's name starts with a space, undo should be
798 enabled in it. */
799 Fbuffer_enable_undo (buf);
801 XSETCAR (tail, buf);
803 else
805 int count = SPECPDL_INDEX ();
806 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
807 have to empty the list, otherwise we end up with overlays that
808 think they belong to this buffer while the buffer doesn't know about
809 them any more. */
810 delete_all_overlays (XBUFFER (buf));
811 reset_buffer (XBUFFER (buf));
812 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
813 Fset_buffer (buf);
814 if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
815 call0 (intern ("minibuffer-inactive-mode"));
816 else
817 Fkill_all_local_variables ();
818 unbind_to (count, Qnil);
821 return buf;
824 static Lisp_Object
825 run_exit_minibuf_hook (Lisp_Object data)
827 safe_run_hooks (Qminibuffer_exit_hook);
828 return Qnil;
831 /* This function is called on exiting minibuffer, whether normally or
832 not, and it restores the current window, buffer, etc. */
834 static Lisp_Object
835 read_minibuf_unwind (Lisp_Object data)
837 Lisp_Object old_deactivate_mark;
838 Lisp_Object window;
840 /* If this was a recursive minibuffer,
841 tie the minibuffer window back to the outer level minibuffer buffer. */
842 minibuf_level--;
844 window = minibuf_window;
845 /* To keep things predictable, in case it matters, let's be in the
846 minibuffer when we reset the relevant variables. */
847 Fset_buffer (XWINDOW (window)->buffer);
849 /* Restore prompt, etc, from outer minibuffer level. */
850 minibuf_prompt = Fcar (minibuf_save_list);
851 minibuf_save_list = Fcdr (minibuf_save_list);
852 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
853 minibuf_save_list = Fcdr (minibuf_save_list);
854 Vhelp_form = Fcar (minibuf_save_list);
855 minibuf_save_list = Fcdr (minibuf_save_list);
856 Vcurrent_prefix_arg = Fcar (minibuf_save_list);
857 minibuf_save_list = Fcdr (minibuf_save_list);
858 Vminibuffer_history_position = Fcar (minibuf_save_list);
859 minibuf_save_list = Fcdr (minibuf_save_list);
860 Vminibuffer_history_variable = Fcar (minibuf_save_list);
861 minibuf_save_list = Fcdr (minibuf_save_list);
862 Voverriding_local_map = Fcar (minibuf_save_list);
863 minibuf_save_list = Fcdr (minibuf_save_list);
864 #if 0
865 temp = Fcar (minibuf_save_list);
866 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
867 minibuf_window = temp;
868 #endif
869 minibuf_save_list = Fcdr (minibuf_save_list);
871 /* Erase the minibuffer we were using at this level. */
873 int count = SPECPDL_INDEX ();
874 /* Prevent error in erase-buffer. */
875 specbind (Qinhibit_read_only, Qt);
876 specbind (Qinhibit_modification_hooks, Qt);
877 old_deactivate_mark = Vdeactivate_mark;
878 Ferase_buffer ();
879 Vdeactivate_mark = old_deactivate_mark;
880 unbind_to (count, Qnil);
883 /* When we get to the outmost level, make sure we resize the
884 mini-window back to its normal size. */
885 if (minibuf_level == 0)
886 resize_mini_window (XWINDOW (window), 0);
888 /* Make sure minibuffer window is erased, not ignored. */
889 windows_or_buffers_changed++;
890 XSETFASTINT (XWINDOW (window)->last_modified, 0);
891 XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
893 /* In case the previous minibuffer displayed in this miniwindow is
894 dead, we may keep displaying this buffer (tho it's inactive), so reset it,
895 to make sure we don't leave around bindings and stuff which only
896 made sense during the read_minibuf invocation. */
897 call0 (intern ("minibuffer-inactive-mode"));
898 return Qnil;
902 DEFUN ("read-from-minibuffer", Fread_from_minibuffer,
903 Sread_from_minibuffer, 1, 7, 0,
904 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
905 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
906 DEFAULT-VALUE. It normally should be nil in new code, except when
907 HIST is a cons. It is discussed in more detail below.
909 Third arg KEYMAP is a keymap to use whilst reading;
910 if omitted or nil, the default is `minibuffer-local-map'.
912 If fourth arg READ is non-nil, interpret the result as a Lisp object
913 and return that object:
914 in other words, do `(car (read-from-string INPUT-STRING))'
916 Fifth arg HIST, if non-nil, specifies a history list and optionally
917 the initial position in the list. It can be a symbol, which is the
918 history list variable to use, or a cons cell (HISTVAR . HISTPOS).
919 In that case, HISTVAR is the history list variable to use, and
920 HISTPOS is the initial position for use by the minibuffer history
921 commands. For consistency, you should also specify that element of
922 the history as the value of INITIAL-CONTENTS. Positions are counted
923 starting from 1 at the beginning of the list.
925 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
926 as the default to `read' if READ is non-nil and the user enters
927 empty input. But if READ is nil, this function does _not_ return
928 DEFAULT-VALUE for empty input! Instead, it returns the empty string.
930 Whatever the value of READ, DEFAULT-VALUE is made available via the
931 minibuffer history commands. DEFAULT-VALUE can also be a list of
932 strings, in which case all the strings are available in the history,
933 and the first string is the default to `read' if READ is non-nil.
935 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
936 the current input method and the setting of `enable-multibyte-characters'.
938 If the variable `minibuffer-allow-text-properties' is non-nil,
939 then the string which is returned includes whatever text properties
940 were present in the minibuffer. Otherwise the value has no text properties.
942 The remainder of this documentation string describes the
943 INITIAL-CONTENTS argument in more detail. It is only relevant when
944 studying existing code, or when HIST is a cons. If non-nil,
945 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
946 reading input. Normally, point is put at the end of that string.
947 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
948 input is STRING, but point is placed at _one-indexed_ position
949 POSITION in the minibuffer. Any integer value less than or equal to
950 one puts point at the beginning of the string. *Note* that this
951 behavior differs from the way such arguments are used in `completing-read'
952 and some related functions, which use zero-indexing for POSITION. */)
953 (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)
955 Lisp_Object histvar, histpos, val;
956 struct gcpro gcpro1;
958 CHECK_STRING (prompt);
959 if (NILP (keymap))
960 keymap = Vminibuffer_local_map;
961 else
962 keymap = get_keymap (keymap, 1, 0);
964 if (SYMBOLP (hist))
966 histvar = hist;
967 histpos = Qnil;
969 else
971 histvar = Fcar_safe (hist);
972 histpos = Fcdr_safe (hist);
974 if (NILP (histvar))
975 histvar = Qminibuffer_history;
976 if (NILP (histpos))
977 XSETFASTINT (histpos, 0);
979 GCPRO1 (default_value);
980 val = read_minibuf (keymap, initial_contents, prompt,
981 Qnil, !NILP (read),
982 histvar, histpos, default_value,
983 minibuffer_allow_text_properties,
984 !NILP (inherit_input_method));
985 UNGCPRO;
986 return val;
989 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
990 doc: /* Return a Lisp object read using the minibuffer, unevaluated.
991 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
992 is a string to insert in the minibuffer before reading.
993 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
994 Such arguments are used as in `read-from-minibuffer'.) */)
995 (Lisp_Object prompt, Lisp_Object initial_contents)
997 CHECK_STRING (prompt);
998 return read_minibuf (Vminibuffer_local_map, initial_contents,
999 prompt, Qnil, 1, Qminibuffer_history,
1000 make_number (0), Qnil, 0, 0);
1003 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
1004 doc: /* Return value of Lisp expression read using the minibuffer.
1005 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1006 is a string to insert in the minibuffer before reading.
1007 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1008 Such arguments are used as in `read-from-minibuffer'.) */)
1009 (Lisp_Object prompt, Lisp_Object initial_contents)
1011 return Feval (read_minibuf (Vread_expression_map, initial_contents,
1012 prompt, Qnil, 1, Qread_expression_history,
1013 make_number (0), Qnil, 0, 0),
1014 Qnil);
1017 /* Functions that use the minibuffer to read various things. */
1019 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
1020 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
1021 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1022 This argument has been superseded by DEFAULT-VALUE and should normally
1023 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1024 documentation string of that function for details.
1025 The third arg HISTORY, if non-nil, specifies a history list
1026 and optionally the initial position in the list.
1027 See `read-from-minibuffer' for details of HISTORY argument.
1028 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1029 If non-nil, it is used for history commands, and as the value (or the first
1030 element of the list of default values) to return if the user enters the
1031 empty string.
1032 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1033 the current input method and the setting of `enable-multibyte-characters'. */)
1034 (Lisp_Object prompt, Lisp_Object initial_input, Lisp_Object history, Lisp_Object default_value, Lisp_Object inherit_input_method)
1036 Lisp_Object val;
1037 val = Fread_from_minibuffer (prompt, initial_input, Qnil,
1038 Qnil, history, default_value,
1039 inherit_input_method);
1040 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
1041 val = CONSP (default_value) ? XCAR (default_value) : default_value;
1042 return val;
1045 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
1046 doc: /* Read a string from the terminal, not allowing blanks.
1047 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1048 non-nil, it should be a string, which is used as initial input, with
1049 point positioned at the end, so that SPACE will accept the input.
1050 \(Actually, INITIAL can also be a cons of a string and an integer.
1051 Such values are treated as in `read-from-minibuffer', but are normally
1052 not useful in this function.)
1053 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1054 the current input method and the setting of`enable-multibyte-characters'. */)
1055 (Lisp_Object prompt, Lisp_Object initial, Lisp_Object inherit_input_method)
1057 CHECK_STRING (prompt);
1058 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
1059 0, Qminibuffer_history, make_number (0), Qnil, 0,
1060 !NILP (inherit_input_method));
1063 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
1064 doc: /* Read the name of a command and return as a symbol.
1065 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1066 if it is a list. */)
1067 (Lisp_Object prompt, Lisp_Object default_value)
1069 Lisp_Object name, default_string;
1071 if (NILP (default_value))
1072 default_string = Qnil;
1073 else if (SYMBOLP (default_value))
1074 default_string = SYMBOL_NAME (default_value);
1075 else
1076 default_string = default_value;
1078 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
1079 Qnil, Qnil, default_string, Qnil);
1080 if (NILP (name))
1081 return name;
1082 return Fintern (name, Qnil);
1085 #ifdef NOTDEF
1086 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
1087 doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1088 Prompt with PROMPT. */)
1089 (Lisp_Object prompt)
1091 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
1092 Qnil);
1094 #endif /* NOTDEF */
1096 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
1097 doc: /* Read the name of a user option and return it as a symbol.
1098 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1099 if it is a list.
1100 A user option, or customizable variable, is one for which
1101 `custom-variable-p' returns non-nil. */)
1102 (Lisp_Object prompt, Lisp_Object default_value)
1104 Lisp_Object name, default_string;
1106 if (NILP (default_value))
1107 default_string = Qnil;
1108 else if (SYMBOLP (default_value))
1109 default_string = SYMBOL_NAME (default_value);
1110 else
1111 default_string = default_value;
1113 name = Fcompleting_read (prompt, Vobarray,
1114 Qcustom_variable_p, Qt,
1115 Qnil, Qnil, default_string, Qnil);
1116 if (NILP (name))
1117 return name;
1118 return Fintern (name, Qnil);
1121 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
1122 doc: /* Read the name of a buffer and return as a string.
1123 Prompt with PROMPT.
1124 Optional second arg DEF is value to return if user enters an empty line.
1125 If DEF is a list of default values, return its first element.
1126 Optional third arg REQUIRE-MATCH determines whether non-existing
1127 buffer names are allowed. It has the same meaning as the
1128 REQUIRE-MATCH argument of `completing-read'.
1129 The argument PROMPT should be a string ending with a colon and a space.
1130 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1131 case while reading the buffer name.
1132 If `read-buffer-function' is non-nil, this works by calling it as a
1133 function, instead of the usual behavior. */)
1134 (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match)
1136 Lisp_Object args[4], result;
1137 char *s;
1138 ptrdiff_t len;
1139 int count = SPECPDL_INDEX ();
1141 if (BUFFERP (def))
1142 def = BVAR (XBUFFER (def), name);
1144 specbind (Qcompletion_ignore_case,
1145 read_buffer_completion_ignore_case ? Qt : Qnil);
1147 if (NILP (Vread_buffer_function))
1149 if (!NILP (def))
1151 /* A default value was provided: we must change PROMPT,
1152 editing the default value in before the colon. To achieve
1153 this, we replace PROMPT with a substring that doesn't
1154 contain the terminal space and colon (if present). They
1155 are then added back using Fformat. */
1157 if (STRINGP (prompt))
1159 s = SSDATA (prompt);
1160 len = SBYTES (prompt);
1161 if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
1162 len = len - 2;
1163 else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
1164 len--;
1166 prompt = make_specified_string (s, -1, len,
1167 STRING_MULTIBYTE (prompt));
1170 args[0] = build_string ("%s (default %s): ");
1171 args[1] = prompt;
1172 args[2] = CONSP (def) ? XCAR (def) : def;
1173 prompt = Fformat (3, args);
1176 result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
1177 Qnil, require_match, Qnil,
1178 Qbuffer_name_history, def, Qnil);
1180 else
1182 args[0] = Vread_buffer_function;
1183 args[1] = prompt;
1184 args[2] = def;
1185 args[3] = require_match;
1186 result = Ffuncall (4, args);
1188 return unbind_to (count, result);
1191 static Lisp_Object
1192 minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
1194 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1195 return string;
1197 if (STRING_MULTIBYTE (string))
1198 return Fstring_make_unibyte (string);
1199 else
1200 return Fstring_make_multibyte (string);
1203 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1204 doc: /* Return common substring of all completions of STRING in COLLECTION.
1205 Test each possible completion specified by COLLECTION
1206 to see if it begins with STRING. The possible completions may be
1207 strings or symbols. Symbols are converted to strings before testing,
1208 see `symbol-name'.
1209 All that match STRING are compared together; the longest initial sequence
1210 common to all these matches is the return value.
1211 If there is no match at all, the return value is nil.
1212 For a unique match which is exact, the return value is t.
1214 If COLLECTION is an alist, the keys (cars of elements) are the
1215 possible completions. If an element is not a cons cell, then the
1216 element itself is the possible completion.
1217 If COLLECTION is a hash-table, all the keys that are strings or symbols
1218 are the possible completions.
1219 If COLLECTION is an obarray, the names of all symbols in the obarray
1220 are the possible completions.
1222 COLLECTION can also be a function to do the completion itself.
1223 It receives three arguments: the values STRING, PREDICATE and nil.
1224 Whatever it returns becomes the value of `try-completion'.
1226 If optional third argument PREDICATE is non-nil,
1227 it is used to test each possible match.
1228 The match is a candidate only if PREDICATE returns non-nil.
1229 The argument given to PREDICATE is the alist element
1230 or the symbol from the obarray. If COLLECTION is a hash-table,
1231 predicate is called with two arguments: the key and the value.
1232 Additionally to this predicate, `completion-regexp-list'
1233 is used to further constrain the set of candidates. */)
1234 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1236 Lisp_Object bestmatch, tail, elt, eltstring;
1237 /* Size in bytes of BESTMATCH. */
1238 int bestmatchsize = 0;
1239 /* These are in bytes, too. */
1240 int compare, matchsize;
1241 enum { function_table, list_table, obarray_table, hash_table}
1242 type = (HASH_TABLE_P (collection) ? hash_table
1243 : VECTORP (collection) ? obarray_table
1244 : ((NILP (collection)
1245 || (CONSP (collection)
1246 && (!SYMBOLP (XCAR (collection))
1247 || NILP (XCAR (collection)))))
1248 ? list_table : function_table));
1249 EMACS_INT idx = 0, obsize = 0;
1250 int matchcount = 0;
1251 int bindcount = -1;
1252 Lisp_Object bucket, zero, end, tem;
1253 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1255 CHECK_STRING (string);
1256 if (type == function_table)
1257 return call3 (collection, string, predicate, Qnil);
1259 bestmatch = bucket = Qnil;
1260 zero = make_number (0);
1262 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1263 tail = collection;
1264 if (type == obarray_table)
1266 collection = check_obarray (collection);
1267 obsize = ASIZE (collection);
1268 bucket = XVECTOR (collection)->contents[idx];
1271 while (1)
1273 /* Get the next element of the alist, obarray, or hash-table. */
1274 /* Exit the loop if the elements are all used up. */
1275 /* elt gets the alist element or symbol.
1276 eltstring gets the name to check as a completion. */
1278 if (type == list_table)
1280 if (!CONSP (tail))
1281 break;
1282 elt = XCAR (tail);
1283 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1284 tail = XCDR (tail);
1286 else if (type == obarray_table)
1288 if (!EQ (bucket, zero))
1290 if (!SYMBOLP (bucket))
1291 error ("Bad data in guts of obarray");
1292 elt = bucket;
1293 eltstring = elt;
1294 if (XSYMBOL (bucket)->next)
1295 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1296 else
1297 XSETFASTINT (bucket, 0);
1299 else if (++idx >= obsize)
1300 break;
1301 else
1303 bucket = XVECTOR (collection)->contents[idx];
1304 continue;
1307 else /* if (type == hash_table) */
1309 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1310 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1311 idx++;
1312 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1313 break;
1314 else
1315 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
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)),
1327 string, zero, Qnil,
1328 completion_ignore_case ? Qt : Qnil),
1329 EQ (Qt, tem)))
1331 /* Yes. */
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);
1345 if (NILP (tem))
1346 break;
1348 if (CONSP (regexps))
1349 continue;
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);
1359 else
1361 if (bindcount >= 0)
1363 unbind_to (bindcount, Qnil);
1364 bindcount = -1;
1366 GCPRO4 (tail, string, eltstring, bestmatch);
1367 tem = (type == hash_table
1368 ? call2 (predicate, elt,
1369 HASH_VALUE (XHASH_TABLE (collection),
1370 idx - 1))
1371 : call1 (predicate, elt));
1372 UNGCPRO;
1374 if (NILP (tem)) continue;
1377 /* Update computation of how much all possible completions match */
1379 if (NILP (bestmatch))
1381 matchcount = 1;
1382 bestmatch = eltstring;
1383 bestmatchsize = SCHARS (eltstring);
1385 else
1387 compare = min (bestmatchsize, SCHARS (eltstring));
1388 tem = Fcompare_strings (bestmatch, zero,
1389 make_number (compare),
1390 eltstring, zero,
1391 make_number (compare),
1392 completion_ignore_case ? Qt : Qnil);
1393 if (EQ (tem, Qt))
1394 matchsize = compare;
1395 else if (XINT (tem) < 0)
1396 matchsize = - XINT (tem) - 1;
1397 else
1398 matchsize = XINT (tem) - 1;
1400 if (completion_ignore_case)
1402 /* If this is an exact match except for case,
1403 use it as the best match rather than one that is not an
1404 exact match. This way, we get the case pattern
1405 of the actual match. */
1406 if ((matchsize == SCHARS (eltstring)
1407 && matchsize < SCHARS (bestmatch))
1409 /* If there is more than one exact match ignoring case,
1410 and one of them is exact including case,
1411 prefer that one. */
1412 /* If there is no exact match ignoring case,
1413 prefer a match that does not change the case
1414 of the input. */
1415 ((matchsize == SCHARS (eltstring))
1417 (matchsize == SCHARS (bestmatch))
1418 && (tem = Fcompare_strings (eltstring, zero,
1419 make_number (SCHARS (string)),
1420 string, zero,
1421 Qnil,
1422 Qnil),
1423 EQ (Qt, tem))
1424 && (tem = Fcompare_strings (bestmatch, zero,
1425 make_number (SCHARS (string)),
1426 string, zero,
1427 Qnil,
1428 Qnil),
1429 ! EQ (Qt, tem))))
1430 bestmatch = eltstring;
1432 if (bestmatchsize != SCHARS (eltstring)
1433 || bestmatchsize != matchsize)
1434 /* Don't count the same string multiple times. */
1435 matchcount++;
1436 bestmatchsize = matchsize;
1437 if (matchsize <= SCHARS (string)
1438 /* If completion-ignore-case is non-nil, don't
1439 short-circuit because we want to find the best
1440 possible match *including* case differences. */
1441 && !completion_ignore_case
1442 && matchcount > 1)
1443 /* No need to look any further. */
1444 break;
1449 if (bindcount >= 0) {
1450 unbind_to (bindcount, Qnil);
1451 bindcount = -1;
1454 if (NILP (bestmatch))
1455 return Qnil; /* No completions found. */
1456 /* If we are ignoring case, and there is no exact match,
1457 and no additional text was supplied,
1458 don't change the case of what the user typed. */
1459 if (completion_ignore_case && bestmatchsize == SCHARS (string)
1460 && SCHARS (bestmatch) > bestmatchsize)
1461 return minibuf_conform_representation (string, bestmatch);
1463 /* Return t if the supplied string is an exact match (counting case);
1464 it does not require any change to be made. */
1465 if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
1466 return Qt;
1468 XSETFASTINT (zero, 0); /* Else extract the part in which */
1469 XSETFASTINT (end, bestmatchsize); /* all completions agree. */
1470 return Fsubstring (bestmatch, zero, end);
1473 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1474 doc: /* Search for partial matches to STRING in COLLECTION.
1475 Test each of the possible completions specified by COLLECTION
1476 to see if it begins with STRING. The possible completions may be
1477 strings or symbols. Symbols are converted to strings before testing,
1478 see `symbol-name'.
1479 The value is a list of all the possible completions that match STRING.
1481 If COLLECTION is an alist, the keys (cars of elements) are the
1482 possible completions. If an element is not a cons cell, then the
1483 element itself is the possible completion.
1484 If COLLECTION is a hash-table, all the keys that are strings or symbols
1485 are the possible completions.
1486 If COLLECTION is an obarray, the names of all symbols in the obarray
1487 are the possible completions.
1489 COLLECTION 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 COLLECTION 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 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1503 backward compatibility. If non-nil, strings in COLLECTION that start
1504 with a space are ignored unless STRING itself starts with a space. */)
1505 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate, Lisp_Object hide_spaces)
1507 Lisp_Object tail, elt, eltstring;
1508 Lisp_Object allmatches;
1509 int type = HASH_TABLE_P (collection) ? 3
1510 : VECTORP (collection) ? 2
1511 : NILP (collection) || (CONSP (collection)
1512 && (!SYMBOLP (XCAR (collection))
1513 || NILP (XCAR (collection))));
1514 EMACS_INT idx = 0, obsize = 0;
1515 int bindcount = -1;
1516 Lisp_Object bucket, tem, zero;
1517 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1519 CHECK_STRING (string);
1520 if (type == 0)
1521 return call3 (collection, string, predicate, Qt);
1522 allmatches = bucket = Qnil;
1523 zero = make_number (0);
1525 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1526 tail = collection;
1527 if (type == 2)
1529 collection = check_obarray (collection);
1530 obsize = ASIZE (collection);
1531 bucket = XVECTOR (collection)->contents[idx];
1534 while (1)
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. */
1541 if (type == 1)
1543 if (!CONSP (tail))
1544 break;
1545 elt = XCAR (tail);
1546 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1547 tail = XCDR (tail);
1549 else if (type == 2)
1551 if (!EQ (bucket, zero))
1553 if (!SYMBOLP (bucket))
1554 error ("Bad data in guts of obarray");
1555 elt = bucket;
1556 eltstring = elt;
1557 if (XSYMBOL (bucket)->next)
1558 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1559 else
1560 XSETFASTINT (bucket, 0);
1562 else if (++idx >= obsize)
1563 break;
1564 else
1566 bucket = XVECTOR (collection)->contents[idx];
1567 continue;
1570 else /* if (type == 3) */
1572 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1573 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1574 idx++;
1575 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1576 break;
1577 else
1578 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1581 /* Is this element a possible completion? */
1583 if (SYMBOLP (eltstring))
1584 eltstring = Fsymbol_name (eltstring);
1586 if (STRINGP (eltstring)
1587 && SCHARS (string) <= SCHARS (eltstring)
1588 /* If HIDE_SPACES, reject alternatives that start with space
1589 unless the input starts with space. */
1590 && (NILP (hide_spaces)
1591 || (SBYTES (string) > 0
1592 && SREF (string, 0) == ' ')
1593 || SREF (eltstring, 0) != ' ')
1594 && (tem = Fcompare_strings (eltstring, zero,
1595 make_number (SCHARS (string)),
1596 string, zero,
1597 make_number (SCHARS (string)),
1598 completion_ignore_case ? Qt : Qnil),
1599 EQ (Qt, tem)))
1601 /* Yes. */
1602 Lisp_Object regexps;
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);
1615 if (NILP (tem))
1616 break;
1618 if (CONSP (regexps))
1619 continue;
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);
1629 else
1631 if (bindcount >= 0) {
1632 unbind_to (bindcount, Qnil);
1633 bindcount = -1;
1635 GCPRO4 (tail, eltstring, allmatches, string);
1636 tem = type == 3
1637 ? call2 (predicate, elt,
1638 HASH_VALUE (XHASH_TABLE (collection), idx - 1))
1639 : call1 (predicate, elt);
1640 UNGCPRO;
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);
1651 bindcount = -1;
1654 return Fnreverse (allmatches);
1657 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1658 doc: /* Read a string in the minibuffer, with completion.
1659 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1660 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1661 COLLECTION can also be a function to do the completion itself.
1662 PREDICATE limits completion to a subset of COLLECTION.
1663 See `try-completion' and `all-completions' for more details
1664 on completion, COLLECTION, and PREDICATE.
1666 REQUIRE-MATCH can take the following values:
1667 - t means that the user is not allowed to exit unless
1668 the input is (or completes to) an element of COLLECTION or is null.
1669 - nil means that the user can exit with any input.
1670 - `confirm' means that the user can exit with any input, but she needs
1671 to confirm her choice if the input is not an element of COLLECTION.
1672 - `confirm-after-completion' means that the user can exit with any
1673 input, but she needs to confirm her choice if she called
1674 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1675 and the input is not an element of COLLECTION.
1676 - anything else behaves like t except that typing RET does not exit if it
1677 does non-null completion.
1679 If the input is null, `completing-read' returns DEF, or the first element
1680 of the list of default values, or an empty string if DEF is nil,
1681 regardless of the value of REQUIRE-MATCH.
1683 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1684 with point positioned at the end.
1685 If it is (STRING . POSITION), the initial input is STRING, but point
1686 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1687 that this is different from `read-from-minibuffer' and related
1688 functions, which use one-indexing for POSITION.) This feature is
1689 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1690 default value DEF instead. The user can yank the default value into
1691 the minibuffer easily using \\[next-history-element].
1693 HIST, if non-nil, specifies a history list and optionally the initial
1694 position in the list. It can be a symbol, which is the history list
1695 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1696 that case, HISTVAR is the history list variable to use, and HISTPOS
1697 is the initial position (the position in the list used by the
1698 minibuffer history commands). For consistency, you should also
1699 specify that element of the history as the value of
1700 INITIAL-INPUT. (This is the only case in which you should use
1701 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1702 1 at the beginning of the list. The variable `history-length'
1703 controls the maximum length of a history list.
1705 DEF, if non-nil, is the default value or the list of default values.
1707 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1708 the current input method and the setting of `enable-multibyte-characters'.
1710 Completion ignores case if the ambient value of
1711 `completion-ignore-case' is non-nil.
1713 See also `completing-read-function'. */)
1714 (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)
1716 Lisp_Object args[9];
1717 args[0] = Fsymbol_value (intern ("completing-read-function"));
1718 args[1] = prompt;
1719 args[2] = collection;
1720 args[3] = predicate;
1721 args[4] = require_match;
1722 args[5] = initial_input;
1723 args[6] = hist;
1724 args[7] = def;
1725 args[8] = inherit_input_method;
1726 return Ffuncall (9, args);
1729 Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold);
1731 /* Test whether TXT is an exact completion. */
1732 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1733 doc: /* Return non-nil if STRING is a valid completion.
1734 Takes the same arguments as `all-completions' and `try-completion'.
1735 If COLLECTION is a function, it is called with three arguments:
1736 the values STRING, PREDICATE and `lambda'. */)
1737 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1739 Lisp_Object regexps, tail, tem = Qnil;
1740 ptrdiff_t i = 0;
1742 CHECK_STRING (string);
1744 if ((CONSP (collection)
1745 && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
1746 || NILP (collection))
1748 tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
1749 if (NILP (tem))
1750 return Qnil;
1752 else if (VECTORP (collection))
1754 /* Bypass intern-soft as that loses for nil. */
1755 tem = oblookup (collection,
1756 SSDATA (string),
1757 SCHARS (string),
1758 SBYTES (string));
1759 if (!SYMBOLP (tem))
1761 if (STRING_MULTIBYTE (string))
1762 string = Fstring_make_unibyte (string);
1763 else
1764 string = Fstring_make_multibyte (string);
1766 tem = oblookup (collection,
1767 SSDATA (string),
1768 SCHARS (string),
1769 SBYTES (string));
1772 if (completion_ignore_case && !SYMBOLP (tem))
1774 for (i = ASIZE (collection) - 1; i >= 0; i--)
1776 tail = XVECTOR (collection)->contents[i];
1777 if (SYMBOLP (tail))
1778 while (1)
1780 if (EQ (Fcompare_strings (string, make_number (0), Qnil,
1781 Fsymbol_name (tail),
1782 make_number (0) , Qnil, Qt),
1783 Qt))
1785 tem = tail;
1786 break;
1788 if (XSYMBOL (tail)->next == 0)
1789 break;
1790 XSETSYMBOL (tail, XSYMBOL (tail)->next);
1795 if (!SYMBOLP (tem))
1796 return Qnil;
1798 else if (HASH_TABLE_P (collection))
1800 struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
1801 i = hash_lookup (h, string, NULL);
1802 if (i >= 0)
1803 tem = HASH_KEY (h, i);
1804 else
1805 for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1806 if (!NILP (HASH_HASH (h, i))
1807 && EQ (Fcompare_strings (string, make_number (0), Qnil,
1808 HASH_KEY (h, i), make_number (0) , Qnil,
1809 completion_ignore_case ? Qt : Qnil),
1810 Qt))
1812 tem = HASH_KEY (h, i);
1813 break;
1815 if (!STRINGP (tem))
1816 return Qnil;
1818 else
1819 return call3 (collection, string, predicate, Qlambda);
1821 /* Reject this element if it fails to match all the regexps. */
1822 if (CONSP (Vcompletion_regexp_list))
1824 int count = SPECPDL_INDEX ();
1825 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1826 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1827 regexps = XCDR (regexps))
1829 if (NILP (Fstring_match (XCAR (regexps),
1830 SYMBOLP (tem) ? string : tem,
1831 Qnil)))
1832 return unbind_to (count, Qnil);
1834 unbind_to (count, Qnil);
1837 /* Finally, check the predicate. */
1838 if (!NILP (predicate))
1840 return HASH_TABLE_P (collection)
1841 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
1842 : call1 (predicate, tem);
1844 else
1845 return Qt;
1848 static Lisp_Object Qmetadata;
1849 extern Lisp_Object Qbuffer;
1851 DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
1852 doc: /* Perform completion on buffer names.
1853 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1854 `all-completions', otherwise invoke `test-completion'.
1856 The arguments STRING and PREDICATE are as in `try-completion',
1857 `all-completions', and `test-completion'. */)
1858 (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag)
1860 if (NILP (flag))
1861 return Ftry_completion (string, Vbuffer_alist, predicate);
1862 else if (EQ (flag, Qt))
1864 Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
1865 if (SCHARS (string) > 0)
1866 return res;
1867 else
1868 { /* Strip out internal buffers. */
1869 Lisp_Object bufs = res;
1870 /* First, look for a non-internal buffer in `res'. */
1871 while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
1872 bufs = XCDR (bufs);
1873 if (NILP (bufs))
1874 return (EQ (Flength (res), Flength (Vbuffer_alist))
1875 /* If all bufs are internal don't strip them out. */
1876 ? res : bufs);
1877 res = bufs;
1878 while (CONSP (XCDR (bufs)))
1879 if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
1880 XSETCDR (bufs, XCDR (XCDR (bufs)));
1881 else
1882 bufs = XCDR (bufs);
1883 return res;
1886 else if (EQ (flag, Qlambda))
1887 return Ftest_completion (string, Vbuffer_alist, predicate);
1888 else if (EQ (flag, Qmetadata))
1889 return Fcons (Qmetadata, Fcons (Fcons (Qcategory, Qbuffer), Qnil));
1890 else
1891 return Qnil;
1894 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1896 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
1897 doc: /* Like `assoc' but specifically for strings (and symbols).
1899 This returns the first element of LIST whose car matches the string or
1900 symbol KEY, or nil if no match exists. When performing the
1901 comparison, symbols are first converted to strings, and unibyte
1902 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1903 is ignored.
1905 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1906 single string, rather than a cons cell whose car is a string. */)
1907 (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
1909 register Lisp_Object tail;
1911 if (SYMBOLP (key))
1912 key = Fsymbol_name (key);
1914 for (tail = list; CONSP (tail); tail = XCDR (tail))
1916 register Lisp_Object elt, tem, thiscar;
1917 elt = XCAR (tail);
1918 thiscar = CONSP (elt) ? XCAR (elt) : elt;
1919 if (SYMBOLP (thiscar))
1920 thiscar = Fsymbol_name (thiscar);
1921 else if (!STRINGP (thiscar))
1922 continue;
1923 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1924 key, make_number (0), Qnil,
1925 case_fold);
1926 if (EQ (tem, Qt))
1927 return elt;
1928 QUIT;
1930 return Qnil;
1934 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
1935 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1936 (void)
1938 return make_number (minibuf_level);
1941 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
1942 doc: /* Return the prompt string of the currently-active minibuffer.
1943 If no minibuffer is active, return nil. */)
1944 (void)
1946 return Fcopy_sequence (minibuf_prompt);
1950 void
1951 init_minibuf_once (void)
1953 Vminibuffer_list = Qnil;
1954 staticpro (&Vminibuffer_list);
1957 void
1958 syms_of_minibuf (void)
1960 minibuf_level = 0;
1961 minibuf_prompt = Qnil;
1962 staticpro (&minibuf_prompt);
1964 minibuf_save_list = Qnil;
1965 staticpro (&minibuf_save_list);
1967 DEFSYM (Qcompletion_ignore_case, "completion-ignore-case");
1968 DEFSYM (Qread_file_name_internal, "read-file-name-internal");
1969 DEFSYM (Qminibuffer_default, "minibuffer-default");
1970 Fset (Qminibuffer_default, Qnil);
1972 DEFSYM (Qminibuffer_completion_table, "minibuffer-completion-table");
1973 DEFSYM (Qminibuffer_completion_confirm, "minibuffer-completion-confirm");
1974 DEFSYM (Qminibuffer_completion_predicate, "minibuffer-completion-predicate");
1976 staticpro (&last_minibuf_string);
1977 last_minibuf_string = Qnil;
1979 DEFSYM (Qminibuffer_history, "minibuffer-history");
1980 DEFSYM (Qbuffer_name_history, "buffer-name-history");
1981 Fset (Qbuffer_name_history, Qnil);
1983 DEFSYM (Qcustom_variable_p, "custom-variable-p");
1984 DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
1985 DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
1986 DEFSYM (Qhistory_length, "history-length");
1987 DEFSYM (Qcurrent_input_method, "current-input-method");
1988 DEFSYM (Qactivate_input_method, "activate-input-method");
1989 DEFSYM (Qcase_fold_search, "case-fold-search");
1990 DEFSYM (Qmetadata, "metadata");
1992 DEFVAR_LISP ("read-expression-history", Vread_expression_history,
1993 doc: /* A history list for arguments that are Lisp expressions to evaluate.
1994 For example, `eval-expression' uses this. */);
1995 Vread_expression_history = Qnil;
1997 DEFSYM (Qread_expression_history, "read-expression-history");
1999 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function,
2000 doc: /* If this is non-nil, `read-buffer' does its work by calling this function.
2001 The function is called with the arguments passed to `read-buffer'. */);
2002 Vread_buffer_function = Qnil;
2004 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2005 read_buffer_completion_ignore_case,
2006 doc: /* Non-nil means completion ignores case when reading a buffer name. */);
2007 read_buffer_completion_ignore_case = 0;
2009 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook,
2010 doc: /* Normal hook run just after entry to minibuffer. */);
2011 Vminibuffer_setup_hook = Qnil;
2013 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook,
2014 doc: /* Normal hook run just after exit from minibuffer. */);
2015 Vminibuffer_exit_hook = Qnil;
2017 DEFVAR_LISP ("history-length", Vhistory_length,
2018 doc: /* Maximum length of history lists before truncation takes place.
2019 A number means truncate to that length; truncation deletes old
2020 elements, and is done just after inserting a new element.
2021 A value of t means no truncation.
2023 This variable only affects history lists that don't specify their own
2024 maximum lengths. Setting the `history-length' property of a history
2025 variable overrides this default. */);
2026 XSETFASTINT (Vhistory_length, 30);
2028 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates,
2029 doc: /* Non-nil means to delete duplicates in history.
2030 If set to t when adding a new history element, all previous identical
2031 elements are deleted from the history list. */);
2032 history_delete_duplicates = 0;
2034 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input,
2035 doc: /* Non-nil means to add new elements in history.
2036 If set to nil, minibuffer reading functions don't add new elements to the
2037 history list, so it is possible to do this afterwards by calling
2038 `add-to-history' explicitly. */);
2039 Vhistory_add_new_input = Qt;
2041 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case,
2042 doc: /* Non-nil means don't consider case significant in completion.
2043 For file-name completion, `read-file-name-completion-ignore-case'
2044 controls the behavior, rather than this variable.
2045 For buffer name completion, `read-buffer-completion-ignore-case'
2046 controls the behavior, rather than this variable. */);
2047 completion_ignore_case = 0;
2049 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers,
2050 doc: /* Non-nil means to allow minibuffer commands while in the minibuffer.
2051 This variable makes a difference whenever the minibuffer window is active. */);
2052 enable_recursive_minibuffers = 0;
2054 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table,
2055 doc: /* Alist or obarray used for completion in the minibuffer.
2056 This becomes the ALIST argument to `try-completion' and `all-completions'.
2057 The value can also be a list of strings or a hash table.
2059 The value may alternatively be a function, which is given three arguments:
2060 STRING, the current buffer contents;
2061 PREDICATE, the predicate for filtering possible matches;
2062 CODE, which says what kind of things to do.
2063 CODE can be nil, t or `lambda':
2064 nil -- return the best completion of STRING, or nil if there is none.
2065 t -- return a list of all possible completions of STRING.
2066 lambda -- return t if STRING is a valid completion as it stands. */);
2067 Vminibuffer_completion_table = Qnil;
2069 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate,
2070 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2071 Vminibuffer_completion_predicate = Qnil;
2073 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm,
2074 doc: /* Whether to demand confirmation of completion before exiting minibuffer.
2075 If nil, confirmation is not required.
2076 If the value is `confirm', the user may exit with an input that is not
2077 a valid completion alternative, but Emacs asks for confirmation.
2078 If the value is `confirm-after-completion', the user may exit with an
2079 input that is not a valid completion alternative, but Emacs asks for
2080 confirmation if the user submitted the input right after any of the
2081 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2082 Vminibuffer_completion_confirm = Qnil;
2084 DEFVAR_LISP ("minibuffer-completing-file-name",
2085 Vminibuffer_completing_file_name,
2086 doc: /* Non-nil means completing file names. */);
2087 Vminibuffer_completing_file_name = Qnil;
2089 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form,
2090 doc: /* Value that `help-form' takes on inside the minibuffer. */);
2091 Vminibuffer_help_form = Qnil;
2093 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable,
2094 doc: /* History list symbol to add minibuffer values to.
2095 Each string of minibuffer input, as it appears on exit from the minibuffer,
2096 is added with
2097 (set minibuffer-history-variable
2098 (cons STRING (symbol-value minibuffer-history-variable))) */);
2099 XSETFASTINT (Vminibuffer_history_variable, 0);
2101 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position,
2102 doc: /* Current position of redoing in the history list. */);
2103 Vminibuffer_history_position = Qnil;
2105 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise,
2106 doc: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2107 Some uses of the echo area also raise that frame (since they use it too). */);
2108 minibuffer_auto_raise = 0;
2110 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list,
2111 doc: /* List of regexps that should restrict possible completions.
2112 The basic completion functions only consider a completion acceptable
2113 if it matches all regular expressions in this list, with
2114 `case-fold-search' bound to the value of `completion-ignore-case'.
2115 See Info node `(elisp)Basic Completion', for a description of these
2116 functions. */);
2117 Vcompletion_regexp_list = Qnil;
2119 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2120 minibuffer_allow_text_properties,
2121 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2122 This also affects `read-string', but it does not affect `read-minibuffer',
2123 `read-no-blanks-input', or any of the functions that do minibuffer input
2124 with completion; they always discard text properties. */);
2125 minibuffer_allow_text_properties = 0;
2127 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties,
2128 doc: /* Text properties that are added to minibuffer prompts.
2129 These are in addition to the basic `field' property, and stickiness
2130 properties. */);
2131 /* We use `intern' here instead of Qread_only to avoid
2132 initialization-order problems. */
2133 Vminibuffer_prompt_properties
2134 = Fcons (intern_c_string ("read-only"), Fcons (Qt, Qnil));
2136 DEFVAR_LISP ("read-expression-map", Vread_expression_map,
2137 doc: /* Minibuffer keymap used for reading Lisp expressions. */);
2138 Vread_expression_map = Qnil;
2140 defsubr (&Sactive_minibuffer_window);
2141 defsubr (&Sset_minibuffer_window);
2142 defsubr (&Sread_from_minibuffer);
2143 defsubr (&Seval_minibuffer);
2144 defsubr (&Sread_minibuffer);
2145 defsubr (&Sread_string);
2146 defsubr (&Sread_command);
2147 defsubr (&Sread_variable);
2148 defsubr (&Sinternal_complete_buffer);
2149 defsubr (&Sread_buffer);
2150 defsubr (&Sread_no_blanks_input);
2151 defsubr (&Sminibuffer_depth);
2152 defsubr (&Sminibuffer_prompt);
2154 defsubr (&Sminibufferp);
2155 defsubr (&Sminibuffer_prompt_end);
2156 defsubr (&Sminibuffer_contents);
2157 defsubr (&Sminibuffer_contents_no_properties);
2158 defsubr (&Sminibuffer_completion_contents);
2160 defsubr (&Stry_completion);
2161 defsubr (&Sall_completions);
2162 defsubr (&Stest_completion);
2163 defsubr (&Sassoc_string);
2164 defsubr (&Scompleting_read);