Auto-commit of generated files.
[emacs.git] / src / minibuf.c
bloba9bdf06b735405676b1a8e5ef23089b0b6575f65
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 Quser_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 variable 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 variable is one for which `user-variable-p' returns non-nil. */)
1101 (Lisp_Object prompt, Lisp_Object default_value)
1103 Lisp_Object name, default_string;
1105 if (NILP (default_value))
1106 default_string = Qnil;
1107 else if (SYMBOLP (default_value))
1108 default_string = SYMBOL_NAME (default_value);
1109 else
1110 default_string = default_value;
1112 name = Fcompleting_read (prompt, Vobarray,
1113 Quser_variable_p, Qt,
1114 Qnil, Qnil, default_string, Qnil);
1115 if (NILP (name))
1116 return name;
1117 return Fintern (name, Qnil);
1120 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
1121 doc: /* Read the name of a buffer and return as a string.
1122 Prompt with PROMPT.
1123 Optional second arg DEF is value to return if user enters an empty line.
1124 If DEF is a list of default values, return its first element.
1125 Optional third arg REQUIRE-MATCH determines whether non-existing
1126 buffer names are allowed. It has the same meaning as the
1127 REQUIRE-MATCH argument of `completing-read'.
1128 The argument PROMPT should be a string ending with a colon and a space.
1129 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1130 case while reading the buffer name.
1131 If `read-buffer-function' is non-nil, this works by calling it as a
1132 function, instead of the usual behavior. */)
1133 (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match)
1135 Lisp_Object args[4], result;
1136 char *s;
1137 ptrdiff_t len;
1138 int count = SPECPDL_INDEX ();
1140 if (BUFFERP (def))
1141 def = BVAR (XBUFFER (def), name);
1143 specbind (Qcompletion_ignore_case,
1144 read_buffer_completion_ignore_case ? Qt : Qnil);
1146 if (NILP (Vread_buffer_function))
1148 if (!NILP (def))
1150 /* A default value was provided: we must change PROMPT,
1151 editing the default value in before the colon. To achieve
1152 this, we replace PROMPT with a substring that doesn't
1153 contain the terminal space and colon (if present). They
1154 are then added back using Fformat. */
1156 if (STRINGP (prompt))
1158 s = SSDATA (prompt);
1159 len = SBYTES (prompt);
1160 if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
1161 len = len - 2;
1162 else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
1163 len--;
1165 prompt = make_specified_string (s, -1, len,
1166 STRING_MULTIBYTE (prompt));
1169 args[0] = build_string ("%s (default %s): ");
1170 args[1] = prompt;
1171 args[2] = CONSP (def) ? XCAR (def) : def;
1172 prompt = Fformat (3, args);
1175 result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
1176 Qnil, require_match, Qnil,
1177 Qbuffer_name_history, def, Qnil);
1179 else
1181 args[0] = Vread_buffer_function;
1182 args[1] = prompt;
1183 args[2] = def;
1184 args[3] = require_match;
1185 result = Ffuncall (4, args);
1187 return unbind_to (count, result);
1190 static Lisp_Object
1191 minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
1193 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1194 return string;
1196 if (STRING_MULTIBYTE (string))
1197 return Fstring_make_unibyte (string);
1198 else
1199 return Fstring_make_multibyte (string);
1202 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1203 doc: /* Return common substring of all completions of STRING in COLLECTION.
1204 Test each possible completion specified by COLLECTION
1205 to see if it begins with STRING. The possible completions may be
1206 strings or symbols. Symbols are converted to strings before testing,
1207 see `symbol-name'.
1208 All that match STRING are compared together; the longest initial sequence
1209 common to all these matches is the return value.
1210 If there is no match at all, the return value is nil.
1211 For a unique match which is exact, the return value is t.
1213 If COLLECTION is an alist, the keys (cars of elements) are the
1214 possible completions. If an element is not a cons cell, then the
1215 element itself is the possible completion.
1216 If COLLECTION is a hash-table, all the keys that are strings or symbols
1217 are the possible completions.
1218 If COLLECTION is an obarray, the names of all symbols in the obarray
1219 are the possible completions.
1221 COLLECTION can also be a function to do the completion itself.
1222 It receives three arguments: the values STRING, PREDICATE and nil.
1223 Whatever it returns becomes the value of `try-completion'.
1225 If optional third argument PREDICATE is non-nil,
1226 it is used to test each possible match.
1227 The match is a candidate only if PREDICATE returns non-nil.
1228 The argument given to PREDICATE is the alist element
1229 or the symbol from the obarray. If COLLECTION is a hash-table,
1230 predicate is called with two arguments: the key and the value.
1231 Additionally to this predicate, `completion-regexp-list'
1232 is used to further constrain the set of candidates. */)
1233 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1235 Lisp_Object bestmatch, tail, elt, eltstring;
1236 /* Size in bytes of BESTMATCH. */
1237 int bestmatchsize = 0;
1238 /* These are in bytes, too. */
1239 int compare, matchsize;
1240 enum { function_table, list_table, obarray_table, hash_table}
1241 type = (HASH_TABLE_P (collection) ? hash_table
1242 : VECTORP (collection) ? obarray_table
1243 : ((NILP (collection)
1244 || (CONSP (collection)
1245 && (!SYMBOLP (XCAR (collection))
1246 || NILP (XCAR (collection)))))
1247 ? list_table : function_table));
1248 EMACS_INT idx = 0, obsize = 0;
1249 int matchcount = 0;
1250 int bindcount = -1;
1251 Lisp_Object bucket, zero, end, tem;
1252 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1254 CHECK_STRING (string);
1255 if (type == function_table)
1256 return call3 (collection, string, predicate, Qnil);
1258 bestmatch = bucket = Qnil;
1259 zero = make_number (0);
1261 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1262 tail = collection;
1263 if (type == obarray_table)
1265 collection = check_obarray (collection);
1266 obsize = ASIZE (collection);
1267 bucket = XVECTOR (collection)->contents[idx];
1270 while (1)
1272 /* Get the next element of the alist, obarray, or hash-table. */
1273 /* Exit the loop if the elements are all used up. */
1274 /* elt gets the alist element or symbol.
1275 eltstring gets the name to check as a completion. */
1277 if (type == list_table)
1279 if (!CONSP (tail))
1280 break;
1281 elt = XCAR (tail);
1282 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1283 tail = XCDR (tail);
1285 else if (type == obarray_table)
1287 if (!EQ (bucket, zero))
1289 if (!SYMBOLP (bucket))
1290 error ("Bad data in guts of obarray");
1291 elt = bucket;
1292 eltstring = elt;
1293 if (XSYMBOL (bucket)->next)
1294 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1295 else
1296 XSETFASTINT (bucket, 0);
1298 else if (++idx >= obsize)
1299 break;
1300 else
1302 bucket = XVECTOR (collection)->contents[idx];
1303 continue;
1306 else /* if (type == hash_table) */
1308 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1309 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1310 idx++;
1311 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1312 break;
1313 else
1314 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1317 /* Is this element a possible completion? */
1319 if (SYMBOLP (eltstring))
1320 eltstring = Fsymbol_name (eltstring);
1322 if (STRINGP (eltstring)
1323 && SCHARS (string) <= SCHARS (eltstring)
1324 && (tem = Fcompare_strings (eltstring, zero,
1325 make_number (SCHARS (string)),
1326 string, zero, Qnil,
1327 completion_ignore_case ? Qt : Qnil),
1328 EQ (Qt, tem)))
1330 /* Yes. */
1331 Lisp_Object regexps;
1333 /* Ignore this element if it fails to match all the regexps. */
1335 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1336 regexps = XCDR (regexps))
1338 if (bindcount < 0) {
1339 bindcount = SPECPDL_INDEX ();
1340 specbind (Qcase_fold_search,
1341 completion_ignore_case ? Qt : Qnil);
1343 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1344 if (NILP (tem))
1345 break;
1347 if (CONSP (regexps))
1348 continue;
1351 /* Ignore this element if there is a predicate
1352 and the predicate doesn't like it. */
1354 if (!NILP (predicate))
1356 if (EQ (predicate, Qcommandp))
1357 tem = Fcommandp (elt, Qnil);
1358 else
1360 if (bindcount >= 0)
1362 unbind_to (bindcount, Qnil);
1363 bindcount = -1;
1365 GCPRO4 (tail, string, eltstring, bestmatch);
1366 tem = (type == hash_table
1367 ? call2 (predicate, elt,
1368 HASH_VALUE (XHASH_TABLE (collection),
1369 idx - 1))
1370 : call1 (predicate, elt));
1371 UNGCPRO;
1373 if (NILP (tem)) continue;
1376 /* Update computation of how much all possible completions match */
1378 if (NILP (bestmatch))
1380 matchcount = 1;
1381 bestmatch = eltstring;
1382 bestmatchsize = SCHARS (eltstring);
1384 else
1386 compare = min (bestmatchsize, SCHARS (eltstring));
1387 tem = Fcompare_strings (bestmatch, zero,
1388 make_number (compare),
1389 eltstring, zero,
1390 make_number (compare),
1391 completion_ignore_case ? Qt : Qnil);
1392 if (EQ (tem, Qt))
1393 matchsize = compare;
1394 else if (XINT (tem) < 0)
1395 matchsize = - XINT (tem) - 1;
1396 else
1397 matchsize = XINT (tem) - 1;
1399 if (completion_ignore_case)
1401 /* If this is an exact match except for case,
1402 use it as the best match rather than one that is not an
1403 exact match. This way, we get the case pattern
1404 of the actual match. */
1405 if ((matchsize == SCHARS (eltstring)
1406 && matchsize < SCHARS (bestmatch))
1408 /* If there is more than one exact match ignoring case,
1409 and one of them is exact including case,
1410 prefer that one. */
1411 /* If there is no exact match ignoring case,
1412 prefer a match that does not change the case
1413 of the input. */
1414 ((matchsize == SCHARS (eltstring))
1416 (matchsize == SCHARS (bestmatch))
1417 && (tem = Fcompare_strings (eltstring, zero,
1418 make_number (SCHARS (string)),
1419 string, zero,
1420 Qnil,
1421 Qnil),
1422 EQ (Qt, tem))
1423 && (tem = Fcompare_strings (bestmatch, zero,
1424 make_number (SCHARS (string)),
1425 string, zero,
1426 Qnil,
1427 Qnil),
1428 ! EQ (Qt, tem))))
1429 bestmatch = eltstring;
1431 if (bestmatchsize != SCHARS (eltstring)
1432 || bestmatchsize != matchsize)
1433 /* Don't count the same string multiple times. */
1434 matchcount++;
1435 bestmatchsize = matchsize;
1436 if (matchsize <= SCHARS (string)
1437 /* If completion-ignore-case is non-nil, don't
1438 short-circuit because we want to find the best
1439 possible match *including* case differences. */
1440 && !completion_ignore_case
1441 && matchcount > 1)
1442 /* No need to look any further. */
1443 break;
1448 if (bindcount >= 0) {
1449 unbind_to (bindcount, Qnil);
1450 bindcount = -1;
1453 if (NILP (bestmatch))
1454 return Qnil; /* No completions found. */
1455 /* If we are ignoring case, and there is no exact match,
1456 and no additional text was supplied,
1457 don't change the case of what the user typed. */
1458 if (completion_ignore_case && bestmatchsize == SCHARS (string)
1459 && SCHARS (bestmatch) > bestmatchsize)
1460 return minibuf_conform_representation (string, bestmatch);
1462 /* Return t if the supplied string is an exact match (counting case);
1463 it does not require any change to be made. */
1464 if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
1465 return Qt;
1467 XSETFASTINT (zero, 0); /* Else extract the part in which */
1468 XSETFASTINT (end, bestmatchsize); /* all completions agree. */
1469 return Fsubstring (bestmatch, zero, end);
1472 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1473 doc: /* Search for partial matches to STRING in COLLECTION.
1474 Test each of the possible completions specified by COLLECTION
1475 to see if it begins with STRING. The possible completions may be
1476 strings or symbols. Symbols are converted to strings before testing,
1477 see `symbol-name'.
1478 The value is a list of all the possible completions that match STRING.
1480 If COLLECTION is an alist, the keys (cars of elements) are the
1481 possible completions. If an element is not a cons cell, then the
1482 element itself is the possible completion.
1483 If COLLECTION is a hash-table, all the keys that are strings or symbols
1484 are the possible completions.
1485 If COLLECTION is an obarray, the names of all symbols in the obarray
1486 are the possible completions.
1488 COLLECTION can also be a function to do the completion itself.
1489 It receives three arguments: the values STRING, PREDICATE and t.
1490 Whatever it returns becomes the value of `all-completions'.
1492 If optional third argument PREDICATE is non-nil,
1493 it is used to test each possible match.
1494 The match is a candidate only if PREDICATE returns non-nil.
1495 The argument given to PREDICATE is the alist element
1496 or the symbol from the obarray. If COLLECTION is a hash-table,
1497 predicate is called with two arguments: the key and the value.
1498 Additionally to this predicate, `completion-regexp-list'
1499 is used to further constrain the set of candidates.
1501 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1502 backward compatibility. If non-nil, strings in COLLECTION that start
1503 with a space are ignored unless STRING itself starts with a space. */)
1504 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate, Lisp_Object hide_spaces)
1506 Lisp_Object tail, elt, eltstring;
1507 Lisp_Object allmatches;
1508 int type = HASH_TABLE_P (collection) ? 3
1509 : VECTORP (collection) ? 2
1510 : NILP (collection) || (CONSP (collection)
1511 && (!SYMBOLP (XCAR (collection))
1512 || NILP (XCAR (collection))));
1513 EMACS_INT idx = 0, obsize = 0;
1514 int bindcount = -1;
1515 Lisp_Object bucket, tem, zero;
1516 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1518 CHECK_STRING (string);
1519 if (type == 0)
1520 return call3 (collection, string, predicate, Qt);
1521 allmatches = bucket = Qnil;
1522 zero = make_number (0);
1524 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1525 tail = collection;
1526 if (type == 2)
1528 collection = check_obarray (collection);
1529 obsize = ASIZE (collection);
1530 bucket = XVECTOR (collection)->contents[idx];
1533 while (1)
1535 /* Get the next element of the alist, obarray, or hash-table. */
1536 /* Exit the loop if the elements are all used up. */
1537 /* elt gets the alist element or symbol.
1538 eltstring gets the name to check as a completion. */
1540 if (type == 1)
1542 if (!CONSP (tail))
1543 break;
1544 elt = XCAR (tail);
1545 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1546 tail = XCDR (tail);
1548 else if (type == 2)
1550 if (!EQ (bucket, zero))
1552 if (!SYMBOLP (bucket))
1553 error ("Bad data in guts of obarray");
1554 elt = bucket;
1555 eltstring = elt;
1556 if (XSYMBOL (bucket)->next)
1557 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1558 else
1559 XSETFASTINT (bucket, 0);
1561 else if (++idx >= obsize)
1562 break;
1563 else
1565 bucket = XVECTOR (collection)->contents[idx];
1566 continue;
1569 else /* if (type == 3) */
1571 while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1572 && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1573 idx++;
1574 if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1575 break;
1576 else
1577 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1580 /* Is this element a possible completion? */
1582 if (SYMBOLP (eltstring))
1583 eltstring = Fsymbol_name (eltstring);
1585 if (STRINGP (eltstring)
1586 && SCHARS (string) <= SCHARS (eltstring)
1587 /* If HIDE_SPACES, reject alternatives that start with space
1588 unless the input starts with space. */
1589 && (NILP (hide_spaces)
1590 || (SBYTES (string) > 0
1591 && SREF (string, 0) == ' ')
1592 || SREF (eltstring, 0) != ' ')
1593 && (tem = Fcompare_strings (eltstring, zero,
1594 make_number (SCHARS (string)),
1595 string, zero,
1596 make_number (SCHARS (string)),
1597 completion_ignore_case ? Qt : Qnil),
1598 EQ (Qt, tem)))
1600 /* Yes. */
1601 Lisp_Object regexps;
1603 /* Ignore this element if it fails to match all the regexps. */
1605 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1606 regexps = XCDR (regexps))
1608 if (bindcount < 0) {
1609 bindcount = SPECPDL_INDEX ();
1610 specbind (Qcase_fold_search,
1611 completion_ignore_case ? Qt : Qnil);
1613 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1614 if (NILP (tem))
1615 break;
1617 if (CONSP (regexps))
1618 continue;
1621 /* Ignore this element if there is a predicate
1622 and the predicate doesn't like it. */
1624 if (!NILP (predicate))
1626 if (EQ (predicate, Qcommandp))
1627 tem = Fcommandp (elt, Qnil);
1628 else
1630 if (bindcount >= 0) {
1631 unbind_to (bindcount, Qnil);
1632 bindcount = -1;
1634 GCPRO4 (tail, eltstring, allmatches, string);
1635 tem = type == 3
1636 ? call2 (predicate, elt,
1637 HASH_VALUE (XHASH_TABLE (collection), idx - 1))
1638 : call1 (predicate, elt);
1639 UNGCPRO;
1641 if (NILP (tem)) continue;
1643 /* Ok => put it on the list. */
1644 allmatches = Fcons (eltstring, allmatches);
1648 if (bindcount >= 0) {
1649 unbind_to (bindcount, Qnil);
1650 bindcount = -1;
1653 return Fnreverse (allmatches);
1656 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1657 doc: /* Read a string in the minibuffer, with completion.
1658 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1659 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1660 COLLECTION can also be a function to do the completion itself.
1661 PREDICATE limits completion to a subset of COLLECTION.
1662 See `try-completion' and `all-completions' for more details
1663 on completion, COLLECTION, and PREDICATE.
1665 REQUIRE-MATCH can take the following values:
1666 - t means that the user is not allowed to exit unless
1667 the input is (or completes to) an element of COLLECTION or is null.
1668 - nil means that the user can exit with any input.
1669 - `confirm' means that the user can exit with any input, but she needs
1670 to confirm her choice if the input is not an element of COLLECTION.
1671 - `confirm-after-completion' means that the user can exit with any
1672 input, but she needs to confirm her choice if she called
1673 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1674 and the input is not an element of COLLECTION.
1675 - anything else behaves like t except that typing RET does not exit if it
1676 does non-null completion.
1678 If the input is null, `completing-read' returns DEF, or the first element
1679 of the list of default values, or an empty string if DEF is nil,
1680 regardless of the value of REQUIRE-MATCH.
1682 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1683 with point positioned at the end.
1684 If it is (STRING . POSITION), the initial input is STRING, but point
1685 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1686 that this is different from `read-from-minibuffer' and related
1687 functions, which use one-indexing for POSITION.) This feature is
1688 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1689 default value DEF instead. The user can yank the default value into
1690 the minibuffer easily using \\[next-history-element].
1692 HIST, if non-nil, specifies a history list and optionally the initial
1693 position in the list. It can be a symbol, which is the history list
1694 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1695 that case, HISTVAR is the history list variable to use, and HISTPOS
1696 is the initial position (the position in the list used by the
1697 minibuffer history commands). For consistency, you should also
1698 specify that element of the history as the value of
1699 INITIAL-INPUT. (This is the only case in which you should use
1700 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1701 1 at the beginning of the list. The variable `history-length'
1702 controls the maximum length of a history list.
1704 DEF, if non-nil, is the default value or the list of default values.
1706 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1707 the current input method and the setting of `enable-multibyte-characters'.
1709 Completion ignores case if the ambient value of
1710 `completion-ignore-case' is non-nil.
1712 See also `completing-read-function'. */)
1713 (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)
1715 Lisp_Object args[9];
1716 args[0] = Fsymbol_value (intern ("completing-read-function"));
1717 args[1] = prompt;
1718 args[2] = collection;
1719 args[3] = predicate;
1720 args[4] = require_match;
1721 args[5] = initial_input;
1722 args[6] = hist;
1723 args[7] = def;
1724 args[8] = inherit_input_method;
1725 return Ffuncall (9, args);
1728 Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold);
1730 /* Test whether TXT is an exact completion. */
1731 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1732 doc: /* Return non-nil if STRING is a valid completion.
1733 Takes the same arguments as `all-completions' and `try-completion'.
1734 If COLLECTION is a function, it is called with three arguments:
1735 the values STRING, PREDICATE and `lambda'. */)
1736 (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1738 Lisp_Object regexps, tail, tem = Qnil;
1739 ptrdiff_t i = 0;
1741 CHECK_STRING (string);
1743 if ((CONSP (collection)
1744 && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
1745 || NILP (collection))
1747 tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
1748 if (NILP (tem))
1749 return Qnil;
1751 else if (VECTORP (collection))
1753 /* Bypass intern-soft as that loses for nil. */
1754 tem = oblookup (collection,
1755 SSDATA (string),
1756 SCHARS (string),
1757 SBYTES (string));
1758 if (!SYMBOLP (tem))
1760 if (STRING_MULTIBYTE (string))
1761 string = Fstring_make_unibyte (string);
1762 else
1763 string = Fstring_make_multibyte (string);
1765 tem = oblookup (collection,
1766 SSDATA (string),
1767 SCHARS (string),
1768 SBYTES (string));
1771 if (completion_ignore_case && !SYMBOLP (tem))
1773 for (i = ASIZE (collection) - 1; i >= 0; i--)
1775 tail = XVECTOR (collection)->contents[i];
1776 if (SYMBOLP (tail))
1777 while (1)
1779 if (EQ (Fcompare_strings (string, make_number (0), Qnil,
1780 Fsymbol_name (tail),
1781 make_number (0) , Qnil, Qt),
1782 Qt))
1784 tem = tail;
1785 break;
1787 if (XSYMBOL (tail)->next == 0)
1788 break;
1789 XSETSYMBOL (tail, XSYMBOL (tail)->next);
1794 if (!SYMBOLP (tem))
1795 return Qnil;
1797 else if (HASH_TABLE_P (collection))
1799 struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
1800 i = hash_lookup (h, string, NULL);
1801 if (i >= 0)
1802 tem = HASH_KEY (h, i);
1803 else
1804 for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1805 if (!NILP (HASH_HASH (h, i))
1806 && EQ (Fcompare_strings (string, make_number (0), Qnil,
1807 HASH_KEY (h, i), make_number (0) , Qnil,
1808 completion_ignore_case ? Qt : Qnil),
1809 Qt))
1811 tem = HASH_KEY (h, i);
1812 break;
1814 if (!STRINGP (tem))
1815 return Qnil;
1817 else
1818 return call3 (collection, string, predicate, Qlambda);
1820 /* Reject this element if it fails to match all the regexps. */
1821 if (CONSP (Vcompletion_regexp_list))
1823 int count = SPECPDL_INDEX ();
1824 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1825 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1826 regexps = XCDR (regexps))
1828 if (NILP (Fstring_match (XCAR (regexps),
1829 SYMBOLP (tem) ? string : tem,
1830 Qnil)))
1831 return unbind_to (count, Qnil);
1833 unbind_to (count, Qnil);
1836 /* Finally, check the predicate. */
1837 if (!NILP (predicate))
1839 return HASH_TABLE_P (collection)
1840 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
1841 : call1 (predicate, tem);
1843 else
1844 return Qt;
1847 static Lisp_Object Qmetadata;
1848 extern Lisp_Object Qbuffer;
1850 DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
1851 doc: /* Perform completion on buffer names.
1852 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1853 `all-completions', otherwise invoke `test-completion'.
1855 The arguments STRING and PREDICATE are as in `try-completion',
1856 `all-completions', and `test-completion'. */)
1857 (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag)
1859 if (NILP (flag))
1860 return Ftry_completion (string, Vbuffer_alist, predicate);
1861 else if (EQ (flag, Qt))
1863 Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
1864 if (SCHARS (string) > 0)
1865 return res;
1866 else
1867 { /* Strip out internal buffers. */
1868 Lisp_Object bufs = res;
1869 /* First, look for a non-internal buffer in `res'. */
1870 while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
1871 bufs = XCDR (bufs);
1872 if (NILP (bufs))
1873 return (EQ (Flength (res), Flength (Vbuffer_alist))
1874 /* If all bufs are internal don't strip them out. */
1875 ? res : bufs);
1876 res = bufs;
1877 while (CONSP (XCDR (bufs)))
1878 if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
1879 XSETCDR (bufs, XCDR (XCDR (bufs)));
1880 else
1881 bufs = XCDR (bufs);
1882 return res;
1885 else if (EQ (flag, Qlambda))
1886 return Ftest_completion (string, Vbuffer_alist, predicate);
1887 else if (EQ (flag, Qmetadata))
1888 return Fcons (Qmetadata, Fcons (Fcons (Qcategory, Qbuffer), Qnil));
1889 else
1890 return Qnil;
1893 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1895 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
1896 doc: /* Like `assoc' but specifically for strings (and symbols).
1898 This returns the first element of LIST whose car matches the string or
1899 symbol KEY, or nil if no match exists. When performing the
1900 comparison, symbols are first converted to strings, and unibyte
1901 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
1902 is ignored.
1904 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1905 single string, rather than a cons cell whose car is a string. */)
1906 (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
1908 register Lisp_Object tail;
1910 if (SYMBOLP (key))
1911 key = Fsymbol_name (key);
1913 for (tail = list; CONSP (tail); tail = XCDR (tail))
1915 register Lisp_Object elt, tem, thiscar;
1916 elt = XCAR (tail);
1917 thiscar = CONSP (elt) ? XCAR (elt) : elt;
1918 if (SYMBOLP (thiscar))
1919 thiscar = Fsymbol_name (thiscar);
1920 else if (!STRINGP (thiscar))
1921 continue;
1922 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1923 key, make_number (0), Qnil,
1924 case_fold);
1925 if (EQ (tem, Qt))
1926 return elt;
1927 QUIT;
1929 return Qnil;
1933 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
1934 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
1935 (void)
1937 return make_number (minibuf_level);
1940 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
1941 doc: /* Return the prompt string of the currently-active minibuffer.
1942 If no minibuffer is active, return nil. */)
1943 (void)
1945 return Fcopy_sequence (minibuf_prompt);
1949 void
1950 init_minibuf_once (void)
1952 Vminibuffer_list = Qnil;
1953 staticpro (&Vminibuffer_list);
1956 void
1957 syms_of_minibuf (void)
1959 minibuf_level = 0;
1960 minibuf_prompt = Qnil;
1961 staticpro (&minibuf_prompt);
1963 minibuf_save_list = Qnil;
1964 staticpro (&minibuf_save_list);
1966 DEFSYM (Qcompletion_ignore_case, "completion-ignore-case");
1967 DEFSYM (Qread_file_name_internal, "read-file-name-internal");
1968 DEFSYM (Qminibuffer_default, "minibuffer-default");
1969 Fset (Qminibuffer_default, Qnil);
1971 DEFSYM (Qminibuffer_completion_table, "minibuffer-completion-table");
1972 DEFSYM (Qminibuffer_completion_confirm, "minibuffer-completion-confirm");
1973 DEFSYM (Qminibuffer_completion_predicate, "minibuffer-completion-predicate");
1975 staticpro (&last_minibuf_string);
1976 last_minibuf_string = Qnil;
1978 DEFSYM (Quser_variable_p, "user-variable-p");
1979 DEFSYM (Qminibuffer_history, "minibuffer-history");
1980 DEFSYM (Qbuffer_name_history, "buffer-name-history");
1981 Fset (Qbuffer_name_history, Qnil);
1983 DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
1984 DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
1985 DEFSYM (Qhistory_length, "history-length");
1986 DEFSYM (Qcurrent_input_method, "current-input-method");
1987 DEFSYM (Qactivate_input_method, "activate-input-method");
1988 DEFSYM (Qcase_fold_search, "case-fold-search");
1989 DEFSYM (Qmetadata, "metadata");
1991 DEFVAR_LISP ("read-expression-history", Vread_expression_history,
1992 doc: /* A history list for arguments that are Lisp expressions to evaluate.
1993 For example, `eval-expression' uses this. */);
1994 Vread_expression_history = Qnil;
1996 DEFSYM (Qread_expression_history, "read-expression-history");
1998 DEFVAR_LISP ("read-buffer-function", Vread_buffer_function,
1999 doc: /* If this is non-nil, `read-buffer' does its work by calling this function.
2000 The function is called with the arguments passed to `read-buffer'. */);
2001 Vread_buffer_function = Qnil;
2003 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2004 read_buffer_completion_ignore_case,
2005 doc: /* Non-nil means completion ignores case when reading a buffer name. */);
2006 read_buffer_completion_ignore_case = 0;
2008 DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook,
2009 doc: /* Normal hook run just after entry to minibuffer. */);
2010 Vminibuffer_setup_hook = Qnil;
2012 DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook,
2013 doc: /* Normal hook run just after exit from minibuffer. */);
2014 Vminibuffer_exit_hook = Qnil;
2016 DEFVAR_LISP ("history-length", Vhistory_length,
2017 doc: /* Maximum length of history lists before truncation takes place.
2018 A number means truncate to that length; truncation deletes old
2019 elements, and is done just after inserting a new element.
2020 A value of t means no truncation.
2022 This variable only affects history lists that don't specify their own
2023 maximum lengths. Setting the `history-length' property of a history
2024 variable overrides this default. */);
2025 XSETFASTINT (Vhistory_length, 30);
2027 DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates,
2028 doc: /* Non-nil means to delete duplicates in history.
2029 If set to t when adding a new history element, all previous identical
2030 elements are deleted from the history list. */);
2031 history_delete_duplicates = 0;
2033 DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input,
2034 doc: /* Non-nil means to add new elements in history.
2035 If set to nil, minibuffer reading functions don't add new elements to the
2036 history list, so it is possible to do this afterwards by calling
2037 `add-to-history' explicitly. */);
2038 Vhistory_add_new_input = Qt;
2040 DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case,
2041 doc: /* Non-nil means don't consider case significant in completion.
2042 For file-name completion, `read-file-name-completion-ignore-case'
2043 controls the behavior, rather than this variable.
2044 For buffer name completion, `read-buffer-completion-ignore-case'
2045 controls the behavior, rather than this variable. */);
2046 completion_ignore_case = 0;
2048 DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers,
2049 doc: /* Non-nil means to allow minibuffer commands while in the minibuffer.
2050 This variable makes a difference whenever the minibuffer window is active. */);
2051 enable_recursive_minibuffers = 0;
2053 DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table,
2054 doc: /* Alist or obarray used for completion in the minibuffer.
2055 This becomes the ALIST argument to `try-completion' and `all-completions'.
2056 The value can also be a list of strings or a hash table.
2058 The value may alternatively be a function, which is given three arguments:
2059 STRING, the current buffer contents;
2060 PREDICATE, the predicate for filtering possible matches;
2061 CODE, which says what kind of things to do.
2062 CODE can be nil, t or `lambda':
2063 nil -- return the best completion of STRING, or nil if there is none.
2064 t -- return a list of all possible completions of STRING.
2065 lambda -- return t if STRING is a valid completion as it stands. */);
2066 Vminibuffer_completion_table = Qnil;
2068 DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate,
2069 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2070 Vminibuffer_completion_predicate = Qnil;
2072 DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm,
2073 doc: /* Whether to demand confirmation of completion before exiting minibuffer.
2074 If nil, confirmation is not required.
2075 If the value is `confirm', the user may exit with an input that is not
2076 a valid completion alternative, but Emacs asks for confirmation.
2077 If the value is `confirm-after-completion', the user may exit with an
2078 input that is not a valid completion alternative, but Emacs asks for
2079 confirmation if the user submitted the input right after any of the
2080 completion commands listed in `minibuffer-confirm-exit-commands'. */);
2081 Vminibuffer_completion_confirm = Qnil;
2083 DEFVAR_LISP ("minibuffer-completing-file-name",
2084 Vminibuffer_completing_file_name,
2085 doc: /* Non-nil means completing file names. */);
2086 Vminibuffer_completing_file_name = Qnil;
2088 DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form,
2089 doc: /* Value that `help-form' takes on inside the minibuffer. */);
2090 Vminibuffer_help_form = Qnil;
2092 DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable,
2093 doc: /* History list symbol to add minibuffer values to.
2094 Each string of minibuffer input, as it appears on exit from the minibuffer,
2095 is added with
2096 (set minibuffer-history-variable
2097 (cons STRING (symbol-value minibuffer-history-variable))) */);
2098 XSETFASTINT (Vminibuffer_history_variable, 0);
2100 DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position,
2101 doc: /* Current position of redoing in the history list. */);
2102 Vminibuffer_history_position = Qnil;
2104 DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise,
2105 doc: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2106 Some uses of the echo area also raise that frame (since they use it too). */);
2107 minibuffer_auto_raise = 0;
2109 DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list,
2110 doc: /* List of regexps that should restrict possible completions.
2111 The basic completion functions only consider a completion acceptable
2112 if it matches all regular expressions in this list, with
2113 `case-fold-search' bound to the value of `completion-ignore-case'.
2114 See Info node `(elisp)Basic Completion', for a description of these
2115 functions. */);
2116 Vcompletion_regexp_list = Qnil;
2118 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2119 minibuffer_allow_text_properties,
2120 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2121 This also affects `read-string', but it does not affect `read-minibuffer',
2122 `read-no-blanks-input', or any of the functions that do minibuffer input
2123 with completion; they always discard text properties. */);
2124 minibuffer_allow_text_properties = 0;
2126 DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties,
2127 doc: /* Text properties that are added to minibuffer prompts.
2128 These are in addition to the basic `field' property, and stickiness
2129 properties. */);
2130 /* We use `intern' here instead of Qread_only to avoid
2131 initialization-order problems. */
2132 Vminibuffer_prompt_properties
2133 = Fcons (intern_c_string ("read-only"), Fcons (Qt, Qnil));
2135 DEFVAR_LISP ("read-expression-map", Vread_expression_map,
2136 doc: /* Minibuffer keymap used for reading Lisp expressions. */);
2137 Vread_expression_map = Qnil;
2139 defsubr (&Sactive_minibuffer_window);
2140 defsubr (&Sset_minibuffer_window);
2141 defsubr (&Sread_from_minibuffer);
2142 defsubr (&Seval_minibuffer);
2143 defsubr (&Sread_minibuffer);
2144 defsubr (&Sread_string);
2145 defsubr (&Sread_command);
2146 defsubr (&Sread_variable);
2147 defsubr (&Sinternal_complete_buffer);
2148 defsubr (&Sread_buffer);
2149 defsubr (&Sread_no_blanks_input);
2150 defsubr (&Sminibuffer_depth);
2151 defsubr (&Sminibuffer_prompt);
2153 defsubr (&Sminibufferp);
2154 defsubr (&Sminibuffer_prompt_end);
2155 defsubr (&Sminibuffer_contents);
2156 defsubr (&Sminibuffer_contents_no_properties);
2157 defsubr (&Sminibuffer_completion_contents);
2159 defsubr (&Stry_completion);
2160 defsubr (&Sall_completions);
2161 defsubr (&Stest_completion);
2162 defsubr (&Sassoc_string);
2163 defsubr (&Scompleting_read);