Add 2009 to copyright years.
[emacs.git] / src / minibuf.c
blob9daffac2525de0c3b543f1b34b624e24161d1674
1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 2008, 2009 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <config.h>
23 #include <stdio.h>
25 #include "lisp.h"
26 #include "commands.h"
27 #include "buffer.h"
28 #include "character.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 extern int quit_char;
40 /* List of buffers for use as minibuffers.
41 The first element of the list is used for the outermost minibuffer
42 invocation, the next element is used for a recursive minibuffer
43 invocation, etc. The list is extended at the end as deeper
44 minibuffer recursions are encountered. */
46 Lisp_Object Vminibuffer_list;
48 /* Data to remember during recursive minibuffer invocations */
50 Lisp_Object minibuf_save_list;
52 /* Depth in minibuffer invocations. */
54 int minibuf_level;
56 /* The maximum length of a minibuffer history. */
58 Lisp_Object Qhistory_length, Vhistory_length;
60 /* No duplicates in history. */
62 int history_delete_duplicates;
64 /* Non-nil means add new input to history. */
66 Lisp_Object Vhistory_add_new_input;
68 /* Fread_minibuffer leaves the input here as a string. */
70 Lisp_Object last_minibuf_string;
72 /* Nonzero means let functions called when within a minibuffer
73 invoke recursive minibuffers (to read arguments, or whatever) */
75 int enable_recursive_minibuffers;
77 /* Nonzero means don't ignore text properties
78 in Fread_from_minibuffer. */
80 int minibuffer_allow_text_properties;
82 /* help-form is bound to this while in the minibuffer. */
84 Lisp_Object Vminibuffer_help_form;
86 /* Variable which is the history list to add minibuffer values to. */
88 Lisp_Object Vminibuffer_history_variable;
90 /* Current position in the history list (adjusted by M-n and M-p). */
92 Lisp_Object Vminibuffer_history_position;
94 /* Text properties that are added to minibuffer prompts.
95 These are in addition to the basic `field' property, and stickiness
96 properties. */
98 Lisp_Object Vminibuffer_prompt_properties;
100 Lisp_Object Qminibuffer_history, Qbuffer_name_history;
102 Lisp_Object Qread_file_name_internal;
104 /* Normal hooks for entry to and exit from minibuffer. */
106 Lisp_Object Qminibuffer_setup_hook, Vminibuffer_setup_hook;
107 Lisp_Object Qminibuffer_exit_hook, Vminibuffer_exit_hook;
109 /* Function to call to read a buffer name. */
110 Lisp_Object Vread_buffer_function;
112 /* Nonzero means completion ignores case. */
114 int completion_ignore_case;
115 Lisp_Object Qcompletion_ignore_case;
116 int read_buffer_completion_ignore_case;
118 /* List of regexps that should restrict possible completions. */
120 Lisp_Object Vcompletion_regexp_list;
122 /* Nonzero means raise the minibuffer frame when the minibuffer
123 is entered. */
125 int minibuffer_auto_raise;
127 /* Keymap for reading expressions. */
128 Lisp_Object Vread_expression_map;
130 Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
131 Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
132 Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
133 Lisp_Object Vminibuffer_completing_file_name;
135 Lisp_Object Quser_variable_p;
137 Lisp_Object Qminibuffer_default;
139 Lisp_Object Qcurrent_input_method, Qactivate_input_method;
141 Lisp_Object Qcase_fold_search;
143 Lisp_Object Qread_expression_history;
145 extern Lisp_Object Voverriding_local_map;
147 extern Lisp_Object Qmouse_face;
149 extern Lisp_Object Qfield;
151 /* Put minibuf on currently selected frame's minibuffer.
152 We do this whenever the user starts a new minibuffer
153 or when a minibuffer exits. */
155 void
156 choose_minibuf_frame ()
158 if (FRAMEP (selected_frame)
159 && FRAME_LIVE_P (XFRAME (selected_frame))
160 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
162 struct frame *sf = XFRAME (selected_frame);
163 Lisp_Object buffer;
165 /* I don't think that any frames may validly have a null minibuffer
166 window anymore. */
167 if (NILP (sf->minibuffer_window))
168 abort ();
170 /* Under X, we come here with minibuf_window being the
171 minibuffer window of the unused termcap window created in
172 init_window_once. That window doesn't have a buffer. */
173 buffer = XWINDOW (minibuf_window)->buffer;
174 if (BUFFERP (buffer))
175 Fset_window_buffer (sf->minibuffer_window, buffer, Qnil);
176 minibuf_window = sf->minibuffer_window;
179 /* Make sure no other frame has a minibuffer as its selected window,
180 because the text would not be displayed in it, and that would be
181 confusing. Only allow the selected frame to do this,
182 and that only if the minibuffer is active. */
184 Lisp_Object tail, frame;
186 FOR_EACH_FRAME (tail, frame)
187 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
188 && !(EQ (frame, selected_frame)
189 && minibuf_level > 0))
190 Fset_frame_selected_window (frame, Fframe_first_window (frame), Qnil);
194 Lisp_Object
195 choose_minibuf_frame_1 (ignore)
196 Lisp_Object ignore;
198 choose_minibuf_frame ();
199 return Qnil;
202 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
203 Sset_minibuffer_window, 1, 1, 0,
204 doc: /* Specify which minibuffer window to use for the minibuffer.
205 This affects where the minibuffer is displayed if you put text in it
206 without invoking the usual minibuffer commands. */)
207 (window)
208 Lisp_Object window;
210 CHECK_WINDOW (window);
211 if (! MINI_WINDOW_P (XWINDOW (window)))
212 error ("Window is not a minibuffer window");
214 minibuf_window = window;
216 return window;
220 /* Actual minibuffer invocation. */
222 static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
223 static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object));
224 static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
225 Lisp_Object, Lisp_Object,
226 int, Lisp_Object,
227 Lisp_Object, Lisp_Object,
228 int, int));
229 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
230 Lisp_Object, Lisp_Object,
231 int, Lisp_Object,
232 Lisp_Object, Lisp_Object,
233 int, int));
234 static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object));
237 /* Read a Lisp object from VAL and return it. If VAL is an empty
238 string, and DEFALT is a string, read from DEFALT instead of VAL. */
240 static Lisp_Object
241 string_to_object (val, defalt)
242 Lisp_Object val, defalt;
244 struct gcpro gcpro1, gcpro2;
245 Lisp_Object expr_and_pos;
246 int pos;
248 GCPRO2 (val, defalt);
250 if (STRINGP (val) && SCHARS (val) == 0)
252 if (STRINGP (defalt))
253 val = defalt;
254 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
255 val = XCAR (defalt);
258 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
259 pos = XINT (Fcdr (expr_and_pos));
260 if (pos != SCHARS (val))
262 /* Ignore trailing whitespace; any other trailing junk
263 is an error. */
264 int i;
265 pos = string_char_to_byte (val, pos);
266 for (i = pos; i < SBYTES (val); i++)
268 int c = SREF (val, i);
269 if (c != ' ' && c != '\t' && c != '\n')
270 error ("Trailing garbage following expression");
274 val = Fcar (expr_and_pos);
275 RETURN_UNGCPRO (val);
279 /* Like read_minibuf but reading from stdin. This function is called
280 from read_minibuf to do the job if noninteractive. */
282 static Lisp_Object
283 read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
284 histvar, histpos, defalt, allow_props,
285 inherit_input_method)
286 Lisp_Object map;
287 Lisp_Object initial;
288 Lisp_Object prompt;
289 Lisp_Object backup_n;
290 int expflag;
291 Lisp_Object histvar;
292 Lisp_Object histpos;
293 Lisp_Object defalt;
294 int allow_props;
295 int inherit_input_method;
297 int size, len;
298 char *line, *s;
299 Lisp_Object val;
301 fprintf (stdout, "%s", SDATA (prompt));
302 fflush (stdout);
304 val = Qnil;
305 size = 100;
306 len = 0;
307 line = (char *) xmalloc (size * sizeof *line);
308 while ((s = fgets (line + len, size - len, stdin)) != NULL
309 && (len = strlen (line),
310 len == size - 1 && line[len - 1] != '\n'))
312 size *= 2;
313 line = (char *) xrealloc (line, size);
316 if (s)
318 len = strlen (line);
320 if (len > 0 && line[len - 1] == '\n')
321 line[--len] = '\0';
323 val = build_string (line);
324 xfree (line);
326 else
328 xfree (line);
329 error ("Error reading from stdin");
332 /* If Lisp form desired instead of string, parse it. */
333 if (expflag)
334 val = string_to_object (val, CONSP (defalt) ? XCAR (defalt) : defalt);
336 return val;
339 DEFUN ("minibufferp", Fminibufferp,
340 Sminibufferp, 0, 1, 0,
341 doc: /* Return t if BUFFER is a minibuffer.
342 No argument or nil as argument means use current buffer as BUFFER.
343 BUFFER can be a buffer or a buffer name. */)
344 (buffer)
345 Lisp_Object buffer;
347 Lisp_Object tem;
349 if (NILP (buffer))
350 buffer = Fcurrent_buffer ();
351 else if (STRINGP (buffer))
352 buffer = Fget_buffer (buffer);
353 else
354 CHECK_BUFFER (buffer);
356 tem = Fmemq (buffer, Vminibuffer_list);
357 return ! NILP (tem) ? Qt : Qnil;
360 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
361 Sminibuffer_prompt_end, 0, 0, 0,
362 doc: /* Return the buffer position of the end of the minibuffer prompt.
363 Return (point-min) if current buffer is not a minibuffer. */)
366 /* This function is written to be most efficient when there's a prompt. */
367 Lisp_Object beg, end, tem;
368 beg = make_number (BEGV);
370 tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
371 if (NILP (tem))
372 return beg;
374 end = Ffield_end (beg, Qnil, Qnil);
376 if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
377 return beg;
378 else
379 return end;
382 DEFUN ("minibuffer-contents", Fminibuffer_contents,
383 Sminibuffer_contents, 0, 0, 0,
384 doc: /* Return the user input in a minibuffer as a string.
385 If the current buffer is not a minibuffer, return its entire contents. */)
388 int prompt_end = XINT (Fminibuffer_prompt_end ());
389 return make_buffer_string (prompt_end, ZV, 1);
392 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
393 Sminibuffer_contents_no_properties, 0, 0, 0,
394 doc: /* Return the user input in a minibuffer as a string, without text-properties.
395 If the current buffer is not a minibuffer, return its entire contents. */)
398 int prompt_end = XINT (Fminibuffer_prompt_end ());
399 return make_buffer_string (prompt_end, ZV, 0);
402 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
403 Sminibuffer_completion_contents, 0, 0, 0,
404 doc: /* Return the user input in a minibuffer before point as a string.
405 That is what completion commands operate on.
406 If the current buffer is not a minibuffer, return its entire contents. */)
409 int prompt_end = XINT (Fminibuffer_prompt_end ());
410 if (PT < prompt_end)
411 error ("Cannot do completion in the prompt");
412 return make_buffer_string (prompt_end, PT, 1);
416 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
417 putting point minus BACKUP_N bytes from the end of INITIAL,
418 prompting with PROMPT (a string), using history list HISTVAR
419 with initial position HISTPOS. INITIAL should be a string or a
420 cons of a string and an integer. BACKUP_N should be <= 0, or
421 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
422 ignored and replaced with an integer that puts point at one-indexed
423 position N in INITIAL, where N is the CDR of INITIAL, or at the
424 beginning of INITIAL if N <= 0.
426 Normally return the result as a string (the text that was read),
427 but if EXPFLAG is nonzero, read it and return the object read.
428 If HISTVAR is given, save the value read on that history only if it doesn't
429 match the front of that history list exactly. The value is pushed onto
430 the list as the string that was read.
432 DEFALT specifies the default value for the sake of history commands.
434 If ALLOW_PROPS is nonzero, we do not throw away text properties.
436 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
437 current input method. */
439 static Lisp_Object
440 read_minibuf (map, initial, prompt, backup_n, expflag,
441 histvar, histpos, defalt, allow_props, inherit_input_method)
442 Lisp_Object map;
443 Lisp_Object initial;
444 Lisp_Object prompt;
445 Lisp_Object backup_n;
446 int expflag;
447 Lisp_Object histvar;
448 Lisp_Object histpos;
449 Lisp_Object defalt;
450 int allow_props;
451 int inherit_input_method;
453 Lisp_Object val;
454 int count = SPECPDL_INDEX ();
455 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
456 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
457 Lisp_Object enable_multibyte;
458 int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
459 /* String to add to the history. */
460 Lisp_Object histstring;
462 Lisp_Object empty_minibuf;
463 Lisp_Object dummy, frame;
465 extern Lisp_Object Qfront_sticky;
466 extern Lisp_Object Qrear_nonsticky;
468 specbind (Qminibuffer_default, defalt);
470 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
471 in previous recursive minibuffer, but was not set explicitly
472 to t for this invocation, so set it to nil in this minibuffer.
473 Save the old value now, before we change it. */
474 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name);
475 if (EQ (Vminibuffer_completing_file_name, Qlambda))
476 Vminibuffer_completing_file_name = Qnil;
478 #ifdef HAVE_WINDOW_SYSTEM
479 if (display_hourglass_p)
480 cancel_hourglass ();
481 #endif
483 if (!NILP (initial))
485 if (CONSP (initial))
487 backup_n = Fcdr (initial);
488 initial = Fcar (initial);
489 CHECK_STRING (initial);
490 if (!NILP (backup_n))
492 CHECK_NUMBER (backup_n);
493 /* Convert to distance from end of input. */
494 if (XINT (backup_n) < 1)
495 /* A number too small means the beginning of the string. */
496 pos = - SCHARS (initial);
497 else
498 pos = XINT (backup_n) - 1 - SCHARS (initial);
501 else
502 CHECK_STRING (initial);
504 val = Qnil;
505 ambient_dir = current_buffer->directory;
506 input_method = Qnil;
507 enable_multibyte = Qnil;
509 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
510 store them away before we can GC. Don't need to protect
511 BACKUP_N because we use the value only if it is an integer. */
512 GCPRO5 (map, initial, val, ambient_dir, input_method);
514 if (!STRINGP (prompt))
515 prompt = empty_unibyte_string;
517 if (!enable_recursive_minibuffers
518 && minibuf_level > 0)
520 if (EQ (selected_window, minibuf_window))
521 error ("Command attempted to use minibuffer while in minibuffer");
522 else
523 /* If we're in another window, cancel the minibuffer that's active. */
524 Fthrow (Qexit,
525 build_string ("Command attempted to use minibuffer while in minibuffer"));
528 if ((noninteractive
529 /* In case we are running as a daemon, only do this before
530 detaching from the terminal. */
531 || (IS_DAEMON && (daemon_pipe[1] >= 0)))
532 && NILP (Vexecuting_kbd_macro))
534 val = read_minibuf_noninteractive (map, initial, prompt,
535 make_number (pos),
536 expflag, histvar, histpos, defalt,
537 allow_props, inherit_input_method);
538 UNGCPRO;
539 return unbind_to (count, val);
542 /* Choose the minibuffer window and frame, and take action on them. */
544 choose_minibuf_frame ();
546 record_unwind_protect (choose_minibuf_frame_1, Qnil);
548 record_unwind_protect (Fset_window_configuration,
549 Fcurrent_window_configuration (Qnil));
551 /* If the minibuffer window is on a different frame, save that
552 frame's configuration too. */
553 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
554 if (!EQ (mini_frame, selected_frame))
555 record_unwind_protect (Fset_window_configuration,
556 Fcurrent_window_configuration (mini_frame));
558 /* If the minibuffer is on an iconified or invisible frame,
559 make it visible now. */
560 Fmake_frame_visible (mini_frame);
562 if (minibuffer_auto_raise)
563 Fraise_frame (mini_frame);
565 temporarily_switch_to_single_kboard (XFRAME (mini_frame));
567 /* We have to do this after saving the window configuration
568 since that is what restores the current buffer. */
570 /* Arrange to restore a number of minibuffer-related variables.
571 We could bind each variable separately, but that would use lots of
572 specpdl slots. */
573 minibuf_save_list
574 = Fcons (Voverriding_local_map,
575 Fcons (minibuf_window,
576 minibuf_save_list));
577 minibuf_save_list
578 = Fcons (minibuf_prompt,
579 Fcons (make_number (minibuf_prompt_width),
580 Fcons (Vhelp_form,
581 Fcons (Vcurrent_prefix_arg,
582 Fcons (Vminibuffer_history_position,
583 Fcons (Vminibuffer_history_variable,
584 minibuf_save_list))))));
586 record_unwind_protect (read_minibuf_unwind, Qnil);
587 minibuf_level++;
588 /* We are exiting the minibuffer one way or the other, so run the hook.
589 It should be run before unwinding the minibuf settings. Do it
590 separately from read_minibuf_unwind because we need to make sure that
591 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
592 signals an error. --Stef */
593 record_unwind_protect (run_exit_minibuf_hook, Qnil);
595 /* Now that we can restore all those variables, start changing them. */
597 minibuf_prompt_width = 0;
598 minibuf_prompt = Fcopy_sequence (prompt);
599 Vminibuffer_history_position = histpos;
600 Vminibuffer_history_variable = histvar;
601 Vhelp_form = Vminibuffer_help_form;
602 /* If this minibuffer is reading a file name, that doesn't mean
603 recursive ones are. But we cannot set it to nil, because
604 completion code still need to know the minibuffer is completing a
605 file name. So use `lambda' as intermediate value meaning
606 "t" in this minibuffer, but "nil" in next minibuffer. */
607 if (!NILP (Vminibuffer_completing_file_name))
608 Vminibuffer_completing_file_name = Qlambda;
610 if (inherit_input_method)
612 /* `current-input-method' is buffer local. So, remember it in
613 INPUT_METHOD before changing the current buffer. */
614 input_method = Fsymbol_value (Qcurrent_input_method);
615 enable_multibyte = current_buffer->enable_multibyte_characters;
618 /* Switch to the minibuffer. */
620 minibuffer = get_minibuffer (minibuf_level);
621 Fset_buffer (minibuffer);
623 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
624 if (inherit_input_method)
625 current_buffer->enable_multibyte_characters = enable_multibyte;
627 /* The current buffer's default directory is usually the right thing
628 for our minibuffer here. However, if you're typing a command at
629 a minibuffer-only frame when minibuf_level is zero, then buf IS
630 the current_buffer, so reset_buffer leaves buf's default
631 directory unchanged. This is a bummer when you've just started
632 up Emacs and buf's default directory is Qnil. Here's a hack; can
633 you think of something better to do? Find another buffer with a
634 better directory, and use that one instead. */
635 if (STRINGP (ambient_dir))
636 current_buffer->directory = ambient_dir;
637 else
639 Lisp_Object buf_list;
641 for (buf_list = Vbuffer_alist;
642 CONSP (buf_list);
643 buf_list = XCDR (buf_list))
645 Lisp_Object other_buf;
647 other_buf = XCDR (XCAR (buf_list));
648 if (STRINGP (XBUFFER (other_buf)->directory))
650 current_buffer->directory = XBUFFER (other_buf)->directory;
651 break;
656 if (!EQ (mini_frame, selected_frame))
657 Fredirect_frame_focus (selected_frame, mini_frame);
659 Vminibuf_scroll_window = selected_window;
660 if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
661 minibuf_selected_window = selected_window;
663 /* Empty out the minibuffers of all frames other than the one
664 where we are going to display one now.
665 Set them to point to ` *Minibuf-0*', which is always empty. */
666 empty_minibuf = Fget_buffer (build_string (" *Minibuf-0*"));
668 FOR_EACH_FRAME (dummy, frame)
670 Lisp_Object root_window = Fframe_root_window (frame);
671 Lisp_Object mini_window = XWINDOW (root_window)->next;
673 if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
674 && !NILP (Fwindow_minibuffer_p (mini_window)))
675 Fset_window_buffer (mini_window, empty_minibuf, Qnil);
678 /* Display this minibuffer in the proper window. */
679 Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
680 Fselect_window (minibuf_window, Qnil);
681 XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
683 Fmake_local_variable (Qprint_escape_newlines);
684 print_escape_newlines = 1;
686 /* Erase the buffer. */
688 int count1 = SPECPDL_INDEX ();
689 specbind (Qinhibit_read_only, Qt);
690 specbind (Qinhibit_modification_hooks, Qt);
691 Ferase_buffer ();
693 if (!NILP (current_buffer->enable_multibyte_characters)
694 && ! STRING_MULTIBYTE (minibuf_prompt))
695 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
697 /* Insert the prompt, record where it ends. */
698 Finsert (1, &minibuf_prompt);
699 if (PT > BEG)
701 Fput_text_property (make_number (BEG), make_number (PT),
702 Qfront_sticky, Qt, Qnil);
703 Fput_text_property (make_number (BEG), make_number (PT),
704 Qrear_nonsticky, Qt, Qnil);
705 Fput_text_property (make_number (BEG), make_number (PT),
706 Qfield, Qt, Qnil);
707 Fadd_text_properties (make_number (BEG), make_number (PT),
708 Vminibuffer_prompt_properties, Qnil);
710 unbind_to (count1, Qnil);
713 minibuf_prompt_width = (int) current_column (); /* iftc */
715 /* Put in the initial input. */
716 if (!NILP (initial))
718 Finsert (1, &initial);
719 Fforward_char (make_number (pos));
722 clear_message (1, 1);
723 current_buffer->keymap = map;
725 /* Turn on an input method stored in INPUT_METHOD if any. */
726 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
727 call1 (Qactivate_input_method, input_method);
729 /* Run our hook, but not if it is empty.
730 (run-hooks would do nothing if it is empty,
731 but it's important to save time here in the usual case.) */
732 if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
733 && !NILP (Vrun_hooks))
734 call1 (Vrun_hooks, Qminibuffer_setup_hook);
736 /* Don't allow the user to undo past this point. */
737 current_buffer->undo_list = Qnil;
739 recursive_edit_1 ();
741 /* If cursor is on the minibuffer line,
742 show the user we have exited by putting it in column 0. */
743 if (XWINDOW (minibuf_window)->cursor.vpos >= 0
744 && !noninteractive)
746 XWINDOW (minibuf_window)->cursor.hpos = 0;
747 XWINDOW (minibuf_window)->cursor.x = 0;
748 XWINDOW (minibuf_window)->must_be_updated_p = 1;
749 update_frame (XFRAME (selected_frame), 1, 1);
751 struct frame *f = XFRAME (XWINDOW (minibuf_window)->frame);
752 struct redisplay_interface *rif = FRAME_RIF (f);
753 if (rif && rif->flush_display)
754 rif->flush_display (f);
758 /* Make minibuffer contents into a string. */
759 Fset_buffer (minibuffer);
760 if (allow_props)
761 val = Fminibuffer_contents ();
762 else
763 val = Fminibuffer_contents_no_properties ();
765 /* VAL is the string of minibuffer text. */
767 last_minibuf_string = val;
769 /* Choose the string to add to the history. */
770 if (SCHARS (val) != 0)
771 histstring = val;
772 else if (STRINGP (defalt))
773 histstring = defalt;
774 else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
775 histstring = XCAR (defalt);
776 else
777 histstring = Qnil;
779 /* Add the value to the appropriate history list, if any. */
780 if (!NILP (Vhistory_add_new_input)
781 && SYMBOLP (Vminibuffer_history_variable)
782 && !NILP (histstring))
784 /* If the caller wanted to save the value read on a history list,
785 then do so if the value is not already the front of the list. */
786 Lisp_Object histval;
788 /* If variable is unbound, make it nil. */
790 histval = find_symbol_value (Vminibuffer_history_variable);
791 if (EQ (histval, Qunbound))
792 Fset (Vminibuffer_history_variable, Qnil);
794 /* The value of the history variable must be a cons or nil. Other
795 values are unacceptable. We silently ignore these values. */
797 if (NILP (histval)
798 || (CONSP (histval)
799 /* Don't duplicate the most recent entry in the history. */
800 && (NILP (Fequal (histstring, Fcar (histval))))))
802 Lisp_Object length;
804 if (history_delete_duplicates) Fdelete (histstring, histval);
805 histval = Fcons (histstring, histval);
806 Fset (Vminibuffer_history_variable, histval);
808 /* Truncate if requested. */
809 length = Fget (Vminibuffer_history_variable, Qhistory_length);
810 if (NILP (length)) length = Vhistory_length;
811 if (INTEGERP (length))
813 if (XINT (length) <= 0)
814 Fset (Vminibuffer_history_variable, Qnil);
815 else
817 Lisp_Object temp;
819 temp = Fnthcdr (Fsub1 (length), histval);
820 if (CONSP (temp)) Fsetcdr (temp, Qnil);
826 /* If Lisp form desired instead of string, parse it. */
827 if (expflag)
828 val = string_to_object (val, defalt);
830 /* The appropriate frame will get selected
831 in set-window-configuration. */
832 UNGCPRO;
833 return unbind_to (count, val);
836 /* Return a buffer to be used as the minibuffer at depth `depth'.
837 depth = 0 is the lowest allowed argument, and that is the value
838 used for nonrecursive minibuffer invocations */
840 Lisp_Object
841 get_minibuffer (depth)
842 int depth;
844 Lisp_Object tail, num, buf;
845 char name[24];
846 extern Lisp_Object nconc2 ();
848 XSETFASTINT (num, depth);
849 tail = Fnthcdr (num, Vminibuffer_list);
850 if (NILP (tail))
852 tail = Fcons (Qnil, Qnil);
853 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
855 buf = Fcar (tail);
856 if (NILP (buf) || NILP (XBUFFER (buf)->name))
858 sprintf (name, " *Minibuf-%d*", depth);
859 buf = Fget_buffer_create (build_string (name));
861 /* Although the buffer's name starts with a space, undo should be
862 enabled in it. */
863 Fbuffer_enable_undo (buf);
865 XSETCAR (tail, buf);
867 else
869 int count = SPECPDL_INDEX ();
870 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
871 have to empty the list, otherwise we end up with overlays that
872 think they belong to this buffer while the buffer doesn't know about
873 them any more. */
874 delete_all_overlays (XBUFFER (buf));
875 reset_buffer (XBUFFER (buf));
876 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
877 Fset_buffer (buf);
878 Fkill_all_local_variables ();
879 unbind_to (count, Qnil);
882 return buf;
885 static Lisp_Object
886 run_exit_minibuf_hook (data)
887 Lisp_Object data;
889 if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
890 && !NILP (Vrun_hooks))
891 safe_run_hooks (Qminibuffer_exit_hook);
893 return Qnil;
896 /* This function is called on exiting minibuffer, whether normally or
897 not, and it restores the current window, buffer, etc. */
899 static Lisp_Object
900 read_minibuf_unwind (data)
901 Lisp_Object data;
903 Lisp_Object old_deactivate_mark;
904 Lisp_Object window;
906 /* If this was a recursive minibuffer,
907 tie the minibuffer window back to the outer level minibuffer buffer. */
908 minibuf_level--;
910 window = minibuf_window;
911 /* To keep things predictable, in case it matters, let's be in the
912 minibuffer when we reset the relevant variables. */
913 Fset_buffer (XWINDOW (window)->buffer);
915 /* Restore prompt, etc, from outer minibuffer level. */
916 minibuf_prompt = Fcar (minibuf_save_list);
917 minibuf_save_list = Fcdr (minibuf_save_list);
918 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
919 minibuf_save_list = Fcdr (minibuf_save_list);
920 Vhelp_form = Fcar (minibuf_save_list);
921 minibuf_save_list = Fcdr (minibuf_save_list);
922 Vcurrent_prefix_arg = Fcar (minibuf_save_list);
923 minibuf_save_list = Fcdr (minibuf_save_list);
924 Vminibuffer_history_position = Fcar (minibuf_save_list);
925 minibuf_save_list = Fcdr (minibuf_save_list);
926 Vminibuffer_history_variable = Fcar (minibuf_save_list);
927 minibuf_save_list = Fcdr (minibuf_save_list);
928 Voverriding_local_map = Fcar (minibuf_save_list);
929 minibuf_save_list = Fcdr (minibuf_save_list);
930 #if 0
931 temp = Fcar (minibuf_save_list);
932 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
933 minibuf_window = temp;
934 #endif
935 minibuf_save_list = Fcdr (minibuf_save_list);
937 /* Erase the minibuffer we were using at this level. */
939 int count = SPECPDL_INDEX ();
940 /* Prevent error in erase-buffer. */
941 specbind (Qinhibit_read_only, Qt);
942 specbind (Qinhibit_modification_hooks, Qt);
943 old_deactivate_mark = Vdeactivate_mark;
944 Ferase_buffer ();
945 Vdeactivate_mark = old_deactivate_mark;
946 unbind_to (count, Qnil);
949 /* When we get to the outmost level, make sure we resize the
950 mini-window back to its normal size. */
951 if (minibuf_level == 0)
952 resize_mini_window (XWINDOW (window), 0);
954 /* Make sure minibuffer window is erased, not ignored. */
955 windows_or_buffers_changed++;
956 XSETFASTINT (XWINDOW (window)->last_modified, 0);
957 XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
958 return Qnil;
962 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
963 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
964 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
965 DEFAULT-VALUE. It normally should be nil in new code, except when
966 HIST is a cons. It is discussed in more detail below.
967 Third arg KEYMAP is a keymap to use whilst reading;
968 if omitted or nil, the default is `minibuffer-local-map'.
969 If fourth arg READ is non-nil, then interpret the result as a Lisp object
970 and return that object:
971 in other words, do `(car (read-from-string INPUT-STRING))'
972 Fifth arg HIST, if non-nil, specifies a history list and optionally
973 the initial position in the list. It can be a symbol, which is the
974 history list variable to use, or it can be a cons cell
975 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
976 to use, and HISTPOS is the initial position for use by the minibuffer
977 history commands. For consistency, you should also specify that
978 element of the history as the value of INITIAL-CONTENTS. Positions
979 are counted starting from 1 at the beginning of the list.
980 Sixth arg DEFAULT-VALUE is the default value or the list of default values.
981 If non-nil, it is available for history commands, and as the value
982 (or the first element of the list of default values) to return
983 if the user enters the empty string. But, unless READ is non-nil,
984 `read-from-minibuffer' does NOT return DEFAULT-VALUE if the user enters
985 empty input! It returns the empty string.
986 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
987 the current input method and the setting of `enable-multibyte-characters'.
988 If the variable `minibuffer-allow-text-properties' is non-nil,
989 then the string which is returned includes whatever text properties
990 were present in the minibuffer. Otherwise the value has no text properties.
992 The remainder of this documentation string describes the
993 INITIAL-CONTENTS argument in more detail. It is only relevant when
994 studying existing code, or when HIST is a cons. If non-nil,
995 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
996 reading input. Normally, point is put at the end of that string.
997 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
998 input is STRING, but point is placed at _one-indexed_ position
999 POSITION in the minibuffer. Any integer value less than or equal to
1000 one puts point at the beginning of the string. *Note* that this
1001 behavior differs from the way such arguments are used in `completing-read'
1002 and some related functions, which use zero-indexing for POSITION. */)
1003 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
1004 Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
1005 Lisp_Object inherit_input_method;
1007 Lisp_Object histvar, histpos, val;
1008 struct gcpro gcpro1;
1010 CHECK_STRING (prompt);
1011 if (NILP (keymap))
1012 keymap = Vminibuffer_local_map;
1013 else
1014 keymap = get_keymap (keymap, 1, 0);
1016 if (SYMBOLP (hist))
1018 histvar = hist;
1019 histpos = Qnil;
1021 else
1023 histvar = Fcar_safe (hist);
1024 histpos = Fcdr_safe (hist);
1026 if (NILP (histvar))
1027 histvar = Qminibuffer_history;
1028 if (NILP (histpos))
1029 XSETFASTINT (histpos, 0);
1031 GCPRO1 (default_value);
1032 val = read_minibuf (keymap, initial_contents, prompt,
1033 Qnil, !NILP (read),
1034 histvar, histpos, default_value,
1035 minibuffer_allow_text_properties,
1036 !NILP (inherit_input_method));
1037 UNGCPRO;
1038 return val;
1041 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
1042 doc: /* Return a Lisp object read using the minibuffer, unevaluated.
1043 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1044 is a string to insert in the minibuffer before reading.
1045 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1046 Such arguments are used as in `read-from-minibuffer'.) */)
1047 (prompt, initial_contents)
1048 Lisp_Object prompt, initial_contents;
1050 CHECK_STRING (prompt);
1051 return read_minibuf (Vminibuffer_local_map, initial_contents,
1052 prompt, Qnil, 1, Qminibuffer_history,
1053 make_number (0), Qnil, 0, 0);
1056 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
1057 doc: /* Return value of Lisp expression read using the minibuffer.
1058 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1059 is a string to insert in the minibuffer before reading.
1060 \(INITIAL-CONTENTS can also be a cons of a string and an integer.
1061 Such arguments are used as in `read-from-minibuffer'.) */)
1062 (prompt, initial_contents)
1063 Lisp_Object prompt, initial_contents;
1065 return Feval (read_minibuf (Vread_expression_map, initial_contents,
1066 prompt, Qnil, 1, Qread_expression_history,
1067 make_number (0), Qnil, 0, 0));
1070 /* Functions that use the minibuffer to read various things. */
1072 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
1073 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
1074 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1075 This argument has been superseded by DEFAULT-VALUE and should normally
1076 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1077 documentation string of that function for details.
1078 The third arg HISTORY, if non-nil, specifies a history list
1079 and optionally the initial position in the list.
1080 See `read-from-minibuffer' for details of HISTORY argument.
1081 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
1082 If non-nil, it is used for history commands, and as the value (or the first
1083 element of the list of default values) to return if the user enters the
1084 empty string.
1085 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1086 the current input method and the setting of `enable-multibyte-characters'. */)
1087 (prompt, initial_input, history, default_value, inherit_input_method)
1088 Lisp_Object prompt, initial_input, history, default_value;
1089 Lisp_Object inherit_input_method;
1091 Lisp_Object val;
1092 val = Fread_from_minibuffer (prompt, initial_input, Qnil,
1093 Qnil, history, default_value,
1094 inherit_input_method);
1095 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
1096 val = CONSP (default_value) ? XCAR (default_value) : default_value;
1097 return val;
1100 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
1101 doc: /* Read a string from the terminal, not allowing blanks.
1102 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1103 non-nil, it should be a string, which is used as initial input, with
1104 point positioned at the end, so that SPACE will accept the input.
1105 \(Actually, INITIAL can also be a cons of a string and an integer.
1106 Such values are treated as in `read-from-minibuffer', but are normally
1107 not useful in this function.)
1108 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1109 the current input method and the setting of`enable-multibyte-characters'. */)
1110 (prompt, initial, inherit_input_method)
1111 Lisp_Object prompt, initial, inherit_input_method;
1113 CHECK_STRING (prompt);
1114 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
1115 0, Qminibuffer_history, make_number (0), Qnil, 0,
1116 !NILP (inherit_input_method));
1119 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
1120 doc: /* Read the name of a command and return as a symbol.
1121 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1122 if it is a list. */)
1123 (prompt, default_value)
1124 Lisp_Object prompt, default_value;
1126 Lisp_Object name, default_string;
1128 if (NILP (default_value))
1129 default_string = Qnil;
1130 else if (SYMBOLP (default_value))
1131 default_string = SYMBOL_NAME (default_value);
1132 else
1133 default_string = default_value;
1135 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
1136 Qnil, Qnil, default_string, Qnil);
1137 if (NILP (name))
1138 return name;
1139 return Fintern (name, Qnil);
1142 #ifdef NOTDEF
1143 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
1144 doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1145 Prompt with PROMPT. */)
1146 (prompt)
1147 Lisp_Object prompt;
1149 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
1150 Qnil);
1152 #endif /* NOTDEF */
1154 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
1155 doc: /* Read the name of a user variable and return it as a symbol.
1156 Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
1157 if it is a list.
1158 A user variable is one for which `user-variable-p' returns non-nil. */)
1159 (prompt, default_value)
1160 Lisp_Object prompt, default_value;
1162 Lisp_Object name, default_string;
1164 if (NILP (default_value))
1165 default_string = Qnil;
1166 else if (SYMBOLP (default_value))
1167 default_string = SYMBOL_NAME (default_value);
1168 else
1169 default_string = default_value;
1171 name = Fcompleting_read (prompt, Vobarray,
1172 Quser_variable_p, Qt,
1173 Qnil, Qnil, default_string, Qnil);
1174 if (NILP (name))
1175 return name;
1176 return Fintern (name, Qnil);
1179 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
1180 doc: /* Read the name of a buffer and return as a string.
1181 Prompt with PROMPT.
1182 Optional second arg DEF is value to return if user enters an empty line.
1183 If DEF is a list of default values, return its first element.
1184 Optional third arg REQUIRE-MATCH determines whether non-existing
1185 buffer names are allowed. It has the same meaning as the
1186 REQUIRE-MATCH argument of `confirm-after-completion'.
1187 The argument PROMPT should be a string ending with a colon and a space.
1188 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1189 case while reading the buffer name.
1190 If `read-buffer-function' is non-nil, this works by calling it as a
1191 function, instead of the usual behavior. */)
1192 (prompt, def, require_match)
1193 Lisp_Object prompt, def, require_match;
1195 Lisp_Object args[4], result;
1196 unsigned char *s;
1197 int len;
1198 int count = SPECPDL_INDEX ();
1200 if (BUFFERP (def))
1201 def = XBUFFER (def)->name;
1203 specbind (Qcompletion_ignore_case,
1204 read_buffer_completion_ignore_case ? Qt : Qnil);
1206 if (NILP (Vread_buffer_function))
1208 if (!NILP (def))
1210 /* A default value was provided: we must change PROMPT,
1211 editing the default value in before the colon. To achieve
1212 this, we replace PROMPT with a substring that doesn't
1213 contain the terminal space and colon (if present). They
1214 are then added back using Fformat. */
1216 if (STRINGP (prompt))
1218 s = SDATA (prompt);
1219 len = strlen (s);
1220 if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
1221 len = len - 2;
1222 else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
1223 len--;
1225 prompt = make_specified_string (s, -1, len,
1226 STRING_MULTIBYTE (prompt));
1229 args[0] = build_string ("%s (default %s): ");
1230 args[1] = prompt;
1231 args[2] = CONSP (def) ? XCAR (def) : def;
1232 prompt = Fformat (3, args);
1235 result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
1236 Qnil, require_match, Qnil, Qbuffer_name_history,
1237 def, Qnil);
1239 else
1241 args[0] = Vread_buffer_function;
1242 args[1] = prompt;
1243 args[2] = def;
1244 args[3] = require_match;
1245 result = Ffuncall(4, args);
1247 return unbind_to (count, result);
1250 static Lisp_Object
1251 minibuf_conform_representation (string, basis)
1252 Lisp_Object string, basis;
1254 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1255 return string;
1257 if (STRING_MULTIBYTE (string))
1258 return Fstring_make_unibyte (string);
1259 else
1260 return Fstring_make_multibyte (string);
1263 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1264 doc: /* Return common substring of all completions of STRING in COLLECTION.
1265 Test each possible completion specified by COLLECTION
1266 to see if it begins with STRING. The possible completions may be
1267 strings or symbols. Symbols are converted to strings before testing,
1268 see `symbol-name'.
1269 All that match STRING are compared together; the longest initial sequence
1270 common to all these matches is the return value.
1271 If there is no match at all, the return value is nil.
1272 For a unique match which is exact, the return value is t.
1274 If COLLECTION is an alist, the keys (cars of elements) are the
1275 possible completions. If an element is not a cons cell, then the
1276 element itself is the possible completion.
1277 If COLLECTION is a hash-table, all the keys that are strings or symbols
1278 are the possible completions.
1279 If COLLECTION is an obarray, the names of all symbols in the obarray
1280 are the possible completions.
1282 COLLECTION can also be a function to do the completion itself.
1283 It receives three arguments: the values STRING, PREDICATE and nil.
1284 Whatever it returns becomes the value of `try-completion'.
1286 If optional third argument PREDICATE is non-nil,
1287 it is used to test each possible match.
1288 The match is a candidate only if PREDICATE returns non-nil.
1289 The argument given to PREDICATE is the alist element
1290 or the symbol from the obarray. If COLLECTION is a hash-table,
1291 predicate is called with two arguments: the key and the value.
1292 Additionally to this predicate, `completion-regexp-list'
1293 is used to further constrain the set of candidates. */)
1294 (string, collection, predicate)
1295 Lisp_Object string, collection, predicate;
1297 Lisp_Object bestmatch, tail, elt, eltstring;
1298 /* Size in bytes of BESTMATCH. */
1299 int bestmatchsize = 0;
1300 /* These are in bytes, too. */
1301 int compare, matchsize;
1302 enum { function_table, list_table, obarray_table, hash_table}
1303 type = (HASH_TABLE_P (collection) ? hash_table
1304 : VECTORP (collection) ? obarray_table
1305 : ((NILP (collection)
1306 || (CONSP (collection)
1307 && (!SYMBOLP (XCAR (collection))
1308 || NILP (XCAR (collection)))))
1309 ? list_table : function_table));
1310 int index = 0, obsize = 0;
1311 int matchcount = 0;
1312 int bindcount = -1;
1313 Lisp_Object bucket, zero, end, tem;
1314 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1316 CHECK_STRING (string);
1317 if (type == function_table)
1318 return call3 (collection, string, predicate, Qnil);
1320 bestmatch = bucket = Qnil;
1321 zero = make_number (0);
1323 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1324 tail = collection;
1325 if (type == obarray_table)
1327 collection = check_obarray (collection);
1328 obsize = XVECTOR (collection)->size;
1329 bucket = XVECTOR (collection)->contents[index];
1332 while (1)
1334 /* Get the next element of the alist, obarray, or hash-table. */
1335 /* Exit the loop if the elements are all used up. */
1336 /* elt gets the alist element or symbol.
1337 eltstring gets the name to check as a completion. */
1339 if (type == list_table)
1341 if (!CONSP (tail))
1342 break;
1343 elt = XCAR (tail);
1344 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1345 tail = XCDR (tail);
1347 else if (type == obarray_table)
1349 if (!EQ (bucket, zero))
1351 if (!SYMBOLP (bucket))
1352 error ("Bad data in guts of obarray");
1353 elt = bucket;
1354 eltstring = elt;
1355 if (XSYMBOL (bucket)->next)
1356 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1357 else
1358 XSETFASTINT (bucket, 0);
1360 else if (++index >= obsize)
1361 break;
1362 else
1364 bucket = XVECTOR (collection)->contents[index];
1365 continue;
1368 else /* if (type == hash_table) */
1370 while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1371 && NILP (HASH_HASH (XHASH_TABLE (collection), index)))
1372 index++;
1373 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1374 break;
1375 else
1376 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
1379 /* Is this element a possible completion? */
1381 if (SYMBOLP (eltstring))
1382 eltstring = Fsymbol_name (eltstring);
1384 if (STRINGP (eltstring)
1385 && SCHARS (string) <= SCHARS (eltstring)
1386 && (tem = Fcompare_strings (eltstring, zero,
1387 make_number (SCHARS (string)),
1388 string, zero, Qnil,
1389 completion_ignore_case ? Qt : Qnil),
1390 EQ (Qt, tem)))
1392 /* Yes. */
1393 Lisp_Object regexps;
1395 /* Ignore this element if it fails to match all the regexps. */
1397 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1398 regexps = XCDR (regexps))
1400 if (bindcount < 0) {
1401 bindcount = SPECPDL_INDEX ();
1402 specbind (Qcase_fold_search,
1403 completion_ignore_case ? Qt : Qnil);
1405 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1406 if (NILP (tem))
1407 break;
1409 if (CONSP (regexps))
1410 continue;
1413 /* Ignore this element if there is a predicate
1414 and the predicate doesn't like it. */
1416 if (!NILP (predicate))
1418 if (EQ (predicate, Qcommandp))
1419 tem = Fcommandp (elt, Qnil);
1420 else
1422 if (bindcount >= 0)
1424 unbind_to (bindcount, Qnil);
1425 bindcount = -1;
1427 GCPRO4 (tail, string, eltstring, bestmatch);
1428 tem = (type == hash_table
1429 ? call2 (predicate, elt,
1430 HASH_VALUE (XHASH_TABLE (collection),
1431 index - 1))
1432 : call1 (predicate, elt));
1433 UNGCPRO;
1435 if (NILP (tem)) continue;
1438 /* Update computation of how much all possible completions match */
1440 if (NILP (bestmatch))
1442 matchcount = 1;
1443 bestmatch = eltstring;
1444 bestmatchsize = SCHARS (eltstring);
1446 else
1448 compare = min (bestmatchsize, SCHARS (eltstring));
1449 tem = Fcompare_strings (bestmatch, zero,
1450 make_number (compare),
1451 eltstring, zero,
1452 make_number (compare),
1453 completion_ignore_case ? Qt : Qnil);
1454 if (EQ (tem, Qt))
1455 matchsize = compare;
1456 else if (XINT (tem) < 0)
1457 matchsize = - XINT (tem) - 1;
1458 else
1459 matchsize = XINT (tem) - 1;
1461 if (completion_ignore_case)
1463 /* If this is an exact match except for case,
1464 use it as the best match rather than one that is not an
1465 exact match. This way, we get the case pattern
1466 of the actual match. */
1467 if ((matchsize == SCHARS (eltstring)
1468 && matchsize < SCHARS (bestmatch))
1470 /* If there is more than one exact match ignoring case,
1471 and one of them is exact including case,
1472 prefer that one. */
1473 /* If there is no exact match ignoring case,
1474 prefer a match that does not change the case
1475 of the input. */
1476 ((matchsize == SCHARS (eltstring))
1478 (matchsize == SCHARS (bestmatch))
1479 && (tem = Fcompare_strings (eltstring, zero,
1480 make_number (SCHARS (string)),
1481 string, zero,
1482 Qnil,
1483 Qnil),
1484 EQ (Qt, tem))
1485 && (tem = Fcompare_strings (bestmatch, zero,
1486 make_number (SCHARS (string)),
1487 string, zero,
1488 Qnil,
1489 Qnil),
1490 ! EQ (Qt, tem))))
1491 bestmatch = eltstring;
1493 if (bestmatchsize != SCHARS (eltstring)
1494 || bestmatchsize != matchsize)
1495 /* Don't count the same string multiple times. */
1496 matchcount++;
1497 bestmatchsize = matchsize;
1498 if (matchsize <= SCHARS (string)
1499 /* If completion-ignore-case is non-nil, don't
1500 short-circuit because we want to find the best
1501 possible match *including* case differences. */
1502 && !completion_ignore_case
1503 && matchcount > 1)
1504 /* No need to look any further. */
1505 break;
1510 if (bindcount >= 0) {
1511 unbind_to (bindcount, Qnil);
1512 bindcount = -1;
1515 if (NILP (bestmatch))
1516 return Qnil; /* No completions found */
1517 /* If we are ignoring case, and there is no exact match,
1518 and no additional text was supplied,
1519 don't change the case of what the user typed. */
1520 if (completion_ignore_case && bestmatchsize == SCHARS (string)
1521 && SCHARS (bestmatch) > bestmatchsize)
1522 return minibuf_conform_representation (string, bestmatch);
1524 /* Return t if the supplied string is an exact match (counting case);
1525 it does not require any change to be made. */
1526 if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
1527 return Qt;
1529 XSETFASTINT (zero, 0); /* Else extract the part in which */
1530 XSETFASTINT (end, bestmatchsize); /* all completions agree */
1531 return Fsubstring (bestmatch, zero, end);
1534 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1535 doc: /* Search for partial matches to STRING in COLLECTION.
1536 Test each of the possible completions specified by COLLECTION
1537 to see if it begins with STRING. The possible completions may be
1538 strings or symbols. Symbols are converted to strings before testing,
1539 see `symbol-name'.
1540 The value is a list of all the possible completions that match STRING.
1542 If COLLECTION is an alist, the keys (cars of elements) are the
1543 possible completions. If an element is not a cons cell, then the
1544 element itself is the possible completion.
1545 If COLLECTION is a hash-table, all the keys that are strings or symbols
1546 are the possible completions.
1547 If COLLECTION is an obarray, the names of all symbols in the obarray
1548 are the possible completions.
1550 COLLECTION can also be a function to do the completion itself.
1551 It receives three arguments: the values STRING, PREDICATE and t.
1552 Whatever it returns becomes the value of `all-completions'.
1554 If optional third argument PREDICATE is non-nil,
1555 it is used to test each possible match.
1556 The match is a candidate only if PREDICATE returns non-nil.
1557 The argument given to PREDICATE is the alist element
1558 or the symbol from the obarray. If COLLECTION is a hash-table,
1559 predicate is called with two arguments: the key and the value.
1560 Additionally to this predicate, `completion-regexp-list'
1561 is used to further constrain the set of candidates.
1563 If the optional fourth argument HIDE-SPACES is non-nil,
1564 strings in COLLECTION that start with a space
1565 are ignored unless STRING itself starts with a space. */)
1566 (string, collection, predicate, hide_spaces)
1567 Lisp_Object string, collection, predicate, hide_spaces;
1569 Lisp_Object tail, elt, eltstring;
1570 Lisp_Object allmatches;
1571 int type = HASH_TABLE_P (collection) ? 3
1572 : VECTORP (collection) ? 2
1573 : NILP (collection) || (CONSP (collection)
1574 && (!SYMBOLP (XCAR (collection))
1575 || NILP (XCAR (collection))));
1576 int index = 0, obsize = 0;
1577 int bindcount = -1;
1578 Lisp_Object bucket, tem, zero;
1579 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1581 CHECK_STRING (string);
1582 if (type == 0)
1583 return call3 (collection, string, predicate, Qt);
1584 allmatches = bucket = Qnil;
1585 zero = make_number (0);
1587 /* If COLLECTION is not a list, set TAIL just for gc pro. */
1588 tail = collection;
1589 if (type == 2)
1591 obsize = XVECTOR (collection)->size;
1592 bucket = XVECTOR (collection)->contents[index];
1595 while (1)
1597 /* Get the next element of the alist, obarray, or hash-table. */
1598 /* Exit the loop if the elements are all used up. */
1599 /* elt gets the alist element or symbol.
1600 eltstring gets the name to check as a completion. */
1602 if (type == 1)
1604 if (!CONSP (tail))
1605 break;
1606 elt = XCAR (tail);
1607 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1608 tail = XCDR (tail);
1610 else if (type == 2)
1612 if (!EQ (bucket, zero))
1614 elt = bucket;
1615 eltstring = elt;
1616 if (XSYMBOL (bucket)->next)
1617 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1618 else
1619 XSETFASTINT (bucket, 0);
1621 else if (++index >= obsize)
1622 break;
1623 else
1625 bucket = XVECTOR (collection)->contents[index];
1626 continue;
1629 else /* if (type == 3) */
1631 while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1632 && NILP (HASH_HASH (XHASH_TABLE (collection), index)))
1633 index++;
1634 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1635 break;
1636 else
1637 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);
1640 /* Is this element a possible completion? */
1642 if (SYMBOLP (eltstring))
1643 eltstring = Fsymbol_name (eltstring);
1645 if (STRINGP (eltstring)
1646 && SCHARS (string) <= SCHARS (eltstring)
1647 /* If HIDE_SPACES, reject alternatives that start with space
1648 unless the input starts with space. */
1649 && ((SBYTES (string) > 0
1650 && SREF (string, 0) == ' ')
1651 || SREF (eltstring, 0) != ' '
1652 || NILP (hide_spaces))
1653 && (tem = Fcompare_strings (eltstring, zero,
1654 make_number (SCHARS (string)),
1655 string, zero,
1656 make_number (SCHARS (string)),
1657 completion_ignore_case ? Qt : Qnil),
1658 EQ (Qt, tem)))
1660 /* Yes. */
1661 Lisp_Object regexps;
1662 Lisp_Object zero;
1663 XSETFASTINT (zero, 0);
1665 /* Ignore this element if it fails to match all the regexps. */
1667 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1668 regexps = XCDR (regexps))
1670 if (bindcount < 0) {
1671 bindcount = SPECPDL_INDEX ();
1672 specbind (Qcase_fold_search,
1673 completion_ignore_case ? Qt : Qnil);
1675 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1676 if (NILP (tem))
1677 break;
1679 if (CONSP (regexps))
1680 continue;
1683 /* Ignore this element if there is a predicate
1684 and the predicate doesn't like it. */
1686 if (!NILP (predicate))
1688 if (EQ (predicate, Qcommandp))
1689 tem = Fcommandp (elt, Qnil);
1690 else
1692 if (bindcount >= 0) {
1693 unbind_to (bindcount, Qnil);
1694 bindcount = -1;
1696 GCPRO4 (tail, eltstring, allmatches, string);
1697 tem = type == 3
1698 ? call2 (predicate, elt,
1699 HASH_VALUE (XHASH_TABLE (collection), index - 1))
1700 : call1 (predicate, elt);
1701 UNGCPRO;
1703 if (NILP (tem)) continue;
1705 /* Ok => put it on the list. */
1706 allmatches = Fcons (eltstring, allmatches);
1710 if (bindcount >= 0) {
1711 unbind_to (bindcount, Qnil);
1712 bindcount = -1;
1715 return Fnreverse (allmatches);
1718 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1719 doc: /* Read a string in the minibuffer, with completion.
1720 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1721 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1722 COLLECTION can also be a function to do the completion itself.
1723 PREDICATE limits completion to a subset of COLLECTION.
1724 See `try-completion' and `all-completions' for more details
1725 on completion, COLLECTION, and PREDICATE.
1727 REQUIRE-MATCH can take the following values:
1728 - t means that the user is not allowed to exit unless
1729 the input is (or completes to) an element of COLLECTION or is null.
1730 - nil means that the user can exit with any input.
1731 - `confirm' means that the user can exit with any input, but she needs
1732 to confirm her choice if the input is not an element of COLLECTION.
1733 - `confirm-after-completion' means that the user can exit with any
1734 input, but she needs to confirm her choice if she called
1735 `minibuffer-complete' right before `minibuffer-complete-and-exit'
1736 and the input is not an element of COLLECTION.
1737 - anything else behaves like t except that typing RET does not exit if it
1738 does non-null completion.
1740 If the input is null, `completing-read' returns DEF, or the first element
1741 of the list of default values, or an empty string if DEF is nil,
1742 regardless of the value of REQUIRE-MATCH.
1744 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1745 with point positioned at the end.
1746 If it is (STRING . POSITION), the initial input is STRING, but point
1747 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1748 that this is different from `read-from-minibuffer' and related
1749 functions, which use one-indexing for POSITION.) This feature is
1750 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1751 default value DEF instead. The user can yank the default value into
1752 the minibuffer easily using \\[next-history-element].
1754 HIST, if non-nil, specifies a history list and optionally the initial
1755 position in the list. It can be a symbol, which is the history list
1756 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1757 that case, HISTVAR is the history list variable to use, and HISTPOS
1758 is the initial position (the position in the list used by the
1759 minibuffer history commands). For consistency, you should also
1760 specify that element of the history as the value of
1761 INITIAL-INPUT. (This is the only case in which you should use
1762 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1763 1 at the beginning of the list. The variable `history-length'
1764 controls the maximum length of a history list.
1766 DEF, if non-nil, is the default value or the list of default values.
1768 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1769 the current input method and the setting of `enable-multibyte-characters'.
1771 Completion ignores case if the ambient value of
1772 `completion-ignore-case' is non-nil. */)
1773 (prompt, collection, predicate, require_match, initial_input, hist, def, inherit_input_method)
1774 Lisp_Object prompt, collection, predicate, require_match, initial_input;
1775 Lisp_Object hist, def, inherit_input_method;
1777 Lisp_Object val, histvar, histpos, position;
1778 Lisp_Object init;
1779 int pos = 0;
1780 int count = SPECPDL_INDEX ();
1781 struct gcpro gcpro1;
1783 init = initial_input;
1784 GCPRO1 (def);
1786 specbind (Qminibuffer_completion_table, collection);
1787 specbind (Qminibuffer_completion_predicate, predicate);
1788 specbind (Qminibuffer_completion_confirm,
1789 EQ (require_match, Qt) ? Qnil : require_match);
1791 position = Qnil;
1792 if (!NILP (init))
1794 if (CONSP (init))
1796 position = Fcdr (init);
1797 init = Fcar (init);
1799 CHECK_STRING (init);
1800 if (!NILP (position))
1802 CHECK_NUMBER (position);
1803 /* Convert to distance from end of input. */
1804 pos = XINT (position) - SCHARS (init);
1808 if (SYMBOLP (hist))
1810 histvar = hist;
1811 histpos = Qnil;
1813 else
1815 histvar = Fcar_safe (hist);
1816 histpos = Fcdr_safe (hist);
1818 if (NILP (histvar))
1819 histvar = Qminibuffer_history;
1820 if (NILP (histpos))
1821 XSETFASTINT (histpos, 0);
1823 val = read_minibuf (NILP (require_match)
1824 ? (NILP (Vminibuffer_completing_file_name)
1825 || EQ (Vminibuffer_completing_file_name, Qlambda)
1826 ? Vminibuffer_local_completion_map
1827 : Vminibuffer_local_filename_completion_map)
1828 : (NILP (Vminibuffer_completing_file_name)
1829 || EQ (Vminibuffer_completing_file_name, Qlambda)
1830 ? Vminibuffer_local_must_match_map
1831 : Vminibuffer_local_filename_must_match_map),
1832 init, prompt, make_number (pos), 0,
1833 histvar, histpos, def, 0,
1834 !NILP (inherit_input_method));
1836 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
1837 val = CONSP (def) ? XCAR (def) : def;
1839 RETURN_UNGCPRO (unbind_to (count, val));
1842 Lisp_Object Fassoc_string ();
1844 /* Test whether TXT is an exact completion. */
1845 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1846 doc: /* Return non-nil if STRING is a valid completion.
1847 Takes the same arguments as `all-completions' and `try-completion'.
1848 If COLLECTION is a function, it is called with three arguments:
1849 the values STRING, PREDICATE and `lambda'. */)
1850 (string, collection, predicate)
1851 Lisp_Object string, collection, predicate;
1853 Lisp_Object regexps, tail, tem = Qnil;
1854 int i = 0;
1856 CHECK_STRING (string);
1858 if ((CONSP (collection)
1859 && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
1860 || NILP (collection))
1862 tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
1863 if (NILP (tem))
1864 return Qnil;
1866 else if (VECTORP (collection))
1868 /* Bypass intern-soft as that loses for nil. */
1869 tem = oblookup (collection,
1870 SDATA (string),
1871 SCHARS (string),
1872 SBYTES (string));
1873 if (!SYMBOLP (tem))
1875 if (STRING_MULTIBYTE (string))
1876 string = Fstring_make_unibyte (string);
1877 else
1878 string = Fstring_make_multibyte (string);
1880 tem = oblookup (collection,
1881 SDATA (string),
1882 SCHARS (string),
1883 SBYTES (string));
1886 if (completion_ignore_case && !SYMBOLP (tem))
1888 for (i = XVECTOR (collection)->size - 1; i >= 0; i--)
1890 tail = XVECTOR (collection)->contents[i];
1891 if (SYMBOLP (tail))
1892 while (1)
1894 if (EQ((Fcompare_strings (string, make_number (0), Qnil,
1895 Fsymbol_name (tail),
1896 make_number (0) , Qnil, Qt)),
1897 Qt))
1899 tem = tail;
1900 break;
1902 if (XSYMBOL (tail)->next == 0)
1903 break;
1904 XSETSYMBOL (tail, XSYMBOL (tail)->next);
1909 if (!SYMBOLP (tem))
1910 return Qnil;
1912 else if (HASH_TABLE_P (collection))
1914 struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
1915 i = hash_lookup (h, string, NULL);
1916 if (i >= 0)
1917 tem = HASH_KEY (h, i);
1918 else
1919 for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1920 if (!NILP (HASH_HASH (h, i)) &&
1921 EQ (Fcompare_strings (string, make_number (0), Qnil,
1922 HASH_KEY (h, i), make_number (0) , Qnil,
1923 completion_ignore_case ? Qt : Qnil),
1924 Qt))
1926 tem = HASH_KEY (h, i);
1927 break;
1929 if (!STRINGP (tem))
1930 return Qnil;
1932 else
1933 return call3 (collection, string, predicate, Qlambda);
1935 /* Reject this element if it fails to match all the regexps. */
1936 if (CONSP (Vcompletion_regexp_list))
1938 int count = SPECPDL_INDEX ();
1939 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1940 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1941 regexps = XCDR (regexps))
1943 if (NILP (Fstring_match (XCAR (regexps),
1944 SYMBOLP (tem) ? string : tem,
1945 Qnil)))
1946 return unbind_to (count, Qnil);
1948 unbind_to (count, Qnil);
1951 /* Finally, check the predicate. */
1952 if (!NILP (predicate))
1954 return HASH_TABLE_P (collection)
1955 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
1956 : call1 (predicate, tem);
1958 else
1959 return Qt;
1962 DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
1963 doc: /* Perform completion on buffer names.
1964 If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
1965 `all-completions', otherwise invoke `test-completion'.
1967 The arguments STRING and PREDICATE are as in `try-completion',
1968 `all-completions', and `test-completion'. */)
1969 (string, predicate, flag)
1970 Lisp_Object string, predicate, flag;
1972 if (NILP (flag))
1973 return Ftry_completion (string, Vbuffer_alist, predicate);
1974 else if (EQ (flag, Qt))
1976 Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
1977 if (SCHARS (string) > 0)
1978 return res;
1979 else
1980 { /* Strip out internal buffers. */
1981 Lisp_Object bufs = res;
1982 /* First, look for a non-internal buffer in `res'. */
1983 while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
1984 bufs = XCDR (bufs);
1985 if (NILP (bufs))
1986 /* All bufs in `res' are internal, so don't trip them out. */
1987 return res;
1988 res = bufs;
1989 while (CONSP (XCDR (bufs)))
1990 if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
1991 XSETCDR (bufs, XCDR (XCDR (bufs)));
1992 else
1993 bufs = XCDR (bufs);
1994 return res;
1997 else /* assume `lambda' */
1998 return Ftest_completion (string, Vbuffer_alist, predicate);
2001 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
2003 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
2004 doc: /* Like `assoc' but specifically for strings (and symbols).
2006 This returns the first element of LIST whose car matches the string or
2007 symbol KEY, or nil if no match exists. When performing the
2008 comparison, symbols are first converted to strings, and unibyte
2009 strings to multibyte. If the optional arg CASE-FOLD is non-nil, case
2010 is ignored.
2012 Unlike `assoc', KEY can also match an entry in LIST consisting of a
2013 single string, rather than a cons cell whose car is a string. */)
2014 (key, list, case_fold)
2015 register Lisp_Object key;
2016 Lisp_Object list, case_fold;
2018 register Lisp_Object tail;
2020 if (SYMBOLP (key))
2021 key = Fsymbol_name (key);
2023 for (tail = list; CONSP (tail); tail = XCDR (tail))
2025 register Lisp_Object elt, tem, thiscar;
2026 elt = XCAR (tail);
2027 thiscar = CONSP (elt) ? XCAR (elt) : elt;
2028 if (SYMBOLP (thiscar))
2029 thiscar = Fsymbol_name (thiscar);
2030 else if (!STRINGP (thiscar))
2031 continue;
2032 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
2033 key, make_number (0), Qnil,
2034 case_fold);
2035 if (EQ (tem, Qt))
2036 return elt;
2037 QUIT;
2039 return Qnil;
2043 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
2044 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2047 return make_number (minibuf_level);
2050 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
2051 doc: /* Return the prompt string of the currently-active minibuffer.
2052 If no minibuffer is active, return nil. */)
2055 return Fcopy_sequence (minibuf_prompt);
2059 void
2060 init_minibuf_once ()
2062 Vminibuffer_list = Qnil;
2063 staticpro (&Vminibuffer_list);
2066 void
2067 syms_of_minibuf ()
2069 minibuf_level = 0;
2070 minibuf_prompt = Qnil;
2071 staticpro (&minibuf_prompt);
2073 minibuf_save_list = Qnil;
2074 staticpro (&minibuf_save_list);
2076 Qcompletion_ignore_case = intern ("completion-ignore-case");
2077 staticpro (&Qcompletion_ignore_case);
2079 Qread_file_name_internal = intern ("read-file-name-internal");
2080 staticpro (&Qread_file_name_internal);
2082 Qminibuffer_default = intern ("minibuffer-default");
2083 staticpro (&Qminibuffer_default);
2084 Fset (Qminibuffer_default, Qnil);
2086 Qminibuffer_completion_table = intern ("minibuffer-completion-table");
2087 staticpro (&Qminibuffer_completion_table);
2089 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
2090 staticpro (&Qminibuffer_completion_confirm);
2092 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
2093 staticpro (&Qminibuffer_completion_predicate);
2095 staticpro (&last_minibuf_string);
2096 last_minibuf_string = Qnil;
2098 Quser_variable_p = intern ("user-variable-p");
2099 staticpro (&Quser_variable_p);
2101 Qminibuffer_history = intern ("minibuffer-history");
2102 staticpro (&Qminibuffer_history);
2104 Qbuffer_name_history = intern ("buffer-name-history");
2105 staticpro (&Qbuffer_name_history);
2106 Fset (Qbuffer_name_history, Qnil);
2108 Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
2109 staticpro (&Qminibuffer_setup_hook);
2111 Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
2112 staticpro (&Qminibuffer_exit_hook);
2114 Qhistory_length = intern ("history-length");
2115 staticpro (&Qhistory_length);
2117 Qcurrent_input_method = intern ("current-input-method");
2118 staticpro (&Qcurrent_input_method);
2120 Qactivate_input_method = intern ("activate-input-method");
2121 staticpro (&Qactivate_input_method);
2123 Qcase_fold_search = intern ("case-fold-search");
2124 staticpro (&Qcase_fold_search);
2126 Qread_expression_history = intern ("read-expression-history");
2127 staticpro (&Qread_expression_history);
2129 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
2130 doc: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2131 Vread_buffer_function = Qnil;
2133 DEFVAR_BOOL ("read-buffer-completion-ignore-case",
2134 &read_buffer_completion_ignore_case,
2135 doc: /* *Non-nil means completion ignores case when reading a buffer name. */);
2136 read_buffer_completion_ignore_case = 0;
2138 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
2139 doc: /* Normal hook run just after entry to minibuffer. */);
2140 Vminibuffer_setup_hook = Qnil;
2142 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook,
2143 doc: /* Normal hook run just after exit from minibuffer. */);
2144 Vminibuffer_exit_hook = Qnil;
2146 DEFVAR_LISP ("history-length", &Vhistory_length,
2147 doc: /* *Maximum length for history lists before truncation takes place.
2148 A number means that length; t means infinite. Truncation takes place
2149 just after a new element is inserted. Setting the `history-length'
2150 property of a history variable overrides this default. */);
2151 XSETFASTINT (Vhistory_length, 30);
2153 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
2154 doc: /* *Non-nil means to delete duplicates in history.
2155 If set to t when adding a new history element, all previous identical
2156 elements are deleted from the history list. */);
2157 history_delete_duplicates = 0;
2159 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input,
2160 doc: /* *Non-nil means to add new elements in history.
2161 If set to nil, minibuffer reading functions don't add new elements to the
2162 history list, so it is possible to do this afterwards by calling
2163 `add-to-history' explicitly. */);
2164 Vhistory_add_new_input = Qt;
2166 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
2167 doc: /* Non-nil means don't consider case significant in completion.
2168 For file-name completion, `read-file-name-completion-ignore-case'
2169 controls the behavior, rather than this variable.
2170 For buffer name completion, `read-buffer-completion-ignore-case'
2171 controls the behavior, rather than this variable. */);
2172 completion_ignore_case = 0;
2174 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
2175 doc: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2176 This variable makes a difference whenever the minibuffer window is active. */);
2177 enable_recursive_minibuffers = 0;
2179 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
2180 doc: /* Alist or obarray used for completion in the minibuffer.
2181 This becomes the ALIST argument to `try-completion' and `all-completions'.
2182 The value can also be a list of strings or a hash table.
2184 The value may alternatively be a function, which is given three arguments:
2185 STRING, the current buffer contents;
2186 PREDICATE, the predicate for filtering possible matches;
2187 CODE, which says what kind of things to do.
2188 CODE can be nil, t or `lambda':
2189 nil -- return the best completion of STRING, or nil if there is none.
2190 t -- return a list of all possible completions of STRING.
2191 lambda -- return t if STRING is a valid completion as it stands. */);
2192 Vminibuffer_completion_table = Qnil;
2194 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
2195 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2196 Vminibuffer_completion_predicate = Qnil;
2198 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
2199 doc: /* Whether to demand confirmation of completion before exiting minibuffer.
2200 If nil, confirmation is not required.
2201 If the value is `confirm', the user may exit with an input that is not
2202 a valid completion alternative, but Emacs asks for confirmation.
2203 If the value is `confirm-after-completion', the user may exit with an
2204 input that is not a valid completion alternative, but Emacs asks for
2205 confirmation if the user submitted the input right after
2206 `minibuffer-complete'. */);
2207 Vminibuffer_completion_confirm = Qnil;
2209 DEFVAR_LISP ("minibuffer-completing-file-name",
2210 &Vminibuffer_completing_file_name,
2211 doc: /* Non-nil means completing file names. */);
2212 Vminibuffer_completing_file_name = Qnil;
2214 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
2215 doc: /* Value that `help-form' takes on inside the minibuffer. */);
2216 Vminibuffer_help_form = Qnil;
2218 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
2219 doc: /* History list symbol to add minibuffer values to.
2220 Each string of minibuffer input, as it appears on exit from the minibuffer,
2221 is added with
2222 (set minibuffer-history-variable
2223 (cons STRING (symbol-value minibuffer-history-variable))) */);
2224 XSETFASTINT (Vminibuffer_history_variable, 0);
2226 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position,
2227 doc: /* Current position of redoing in the history list. */);
2228 Vminibuffer_history_position = Qnil;
2230 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
2231 doc: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2232 Some uses of the echo area also raise that frame (since they use it too). */);
2233 minibuffer_auto_raise = 0;
2235 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
2236 doc: /* List of regexps that should restrict possible completions.
2237 The basic completion functions only consider a completion acceptable
2238 if it matches all regular expressions in this list, with
2239 `case-fold-search' bound to the value of `completion-ignore-case'.
2240 See Info node `(elisp)Basic Completion', for a description of these
2241 functions. */);
2242 Vcompletion_regexp_list = Qnil;
2244 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2245 &minibuffer_allow_text_properties,
2246 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2247 This also affects `read-string', but it does not affect `read-minibuffer',
2248 `read-no-blanks-input', or any of the functions that do minibuffer input
2249 with completion; they always discard text properties. */);
2250 minibuffer_allow_text_properties = 0;
2252 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties,
2253 doc: /* Text properties that are added to minibuffer prompts.
2254 These are in addition to the basic `field' property, and stickiness
2255 properties. */);
2256 /* We use `intern' here instead of Qread_only to avoid
2257 initialization-order problems. */
2258 Vminibuffer_prompt_properties
2259 = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
2261 DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
2262 doc: /* Minibuffer keymap used for reading Lisp expressions. */);
2263 Vread_expression_map = Qnil;
2265 defsubr (&Sset_minibuffer_window);
2266 defsubr (&Sread_from_minibuffer);
2267 defsubr (&Seval_minibuffer);
2268 defsubr (&Sread_minibuffer);
2269 defsubr (&Sread_string);
2270 defsubr (&Sread_command);
2271 defsubr (&Sread_variable);
2272 defsubr (&Sinternal_complete_buffer);
2273 defsubr (&Sread_buffer);
2274 defsubr (&Sread_no_blanks_input);
2275 defsubr (&Sminibuffer_depth);
2276 defsubr (&Sminibuffer_prompt);
2278 defsubr (&Sminibufferp);
2279 defsubr (&Sminibuffer_prompt_end);
2280 defsubr (&Sminibuffer_contents);
2281 defsubr (&Sminibuffer_contents_no_properties);
2282 defsubr (&Sminibuffer_completion_contents);
2284 defsubr (&Stry_completion);
2285 defsubr (&Sall_completions);
2286 defsubr (&Stest_completion);
2287 defsubr (&Sassoc_string);
2288 defsubr (&Scompleting_read);
2291 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2292 (do not change this comment) */