*** empty log message ***
[emacs.git] / src / minibuf.c
blob09e5675d68e0c8085d5b5f84c123a626c3ebb73e
1 /* Minibuffer input and completion.
2 Copyright (C) 1985,86,93,94,95,96,97,98,99,2000,01,03,04
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 #include <config.h>
24 #include <stdio.h>
26 #include "lisp.h"
27 #include "commands.h"
28 #include "buffer.h"
29 #include "charset.h"
30 #include "dispextern.h"
31 #include "keyboard.h"
32 #include "frame.h"
33 #include "window.h"
34 #include "syntax.h"
35 #include "intervals.h"
36 #include "keymap.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 /* Nonzero means display completion help for invalid input. */
58 Lisp_Object Vcompletion_auto_help;
60 /* The maximum length of a minibuffer history. */
62 Lisp_Object Qhistory_length, Vhistory_length;
64 /* No duplicates in history. */
66 int history_delete_duplicates;
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;
116 /* List of regexps that should restrict possible completions. */
118 Lisp_Object Vcompletion_regexp_list;
120 /* Nonzero means raise the minibuffer frame when the minibuffer
121 is entered. */
123 int minibuffer_auto_raise;
125 /* If last completion attempt reported "Complete but not unique"
126 then this is the string completed then; otherwise this is nil. */
128 static Lisp_Object last_exact_completion;
130 extern Lisp_Object Voverriding_local_map;
132 Lisp_Object Quser_variable_p;
134 Lisp_Object Qminibuffer_default;
136 Lisp_Object Qcurrent_input_method, Qactivate_input_method;
138 Lisp_Object Qcase_fold_search;
140 extern Lisp_Object Qmouse_face;
142 extern Lisp_Object Qfield;
144 /* Put minibuf on currently selected frame's minibuffer.
145 We do this whenever the user starts a new minibuffer
146 or when a minibuffer exits. */
148 void
149 choose_minibuf_frame ()
151 if (FRAMEP (selected_frame)
152 && FRAME_LIVE_P (XFRAME (selected_frame))
153 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
155 struct frame *sf = XFRAME (selected_frame);
156 Lisp_Object buffer;
158 /* I don't think that any frames may validly have a null minibuffer
159 window anymore. */
160 if (NILP (sf->minibuffer_window))
161 abort ();
163 /* Under X, we come here with minibuf_window being the
164 minibuffer window of the unused termcap window created in
165 init_window_once. That window doesn't have a buffer. */
166 buffer = XWINDOW (minibuf_window)->buffer;
167 if (BUFFERP (buffer))
168 Fset_window_buffer (sf->minibuffer_window, buffer, Qnil);
169 minibuf_window = sf->minibuffer_window;
172 /* Make sure no other frame has a minibuffer as its selected window,
173 because the text would not be displayed in it, and that would be
174 confusing. Only allow the selected frame to do this,
175 and that only if the minibuffer is active. */
177 Lisp_Object tail, frame;
179 FOR_EACH_FRAME (tail, frame)
180 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
181 && !(EQ (frame, selected_frame)
182 && minibuf_level > 0))
183 Fset_frame_selected_window (frame, Fframe_first_window (frame));
187 Lisp_Object
188 choose_minibuf_frame_1 (ignore)
189 Lisp_Object ignore;
191 choose_minibuf_frame ();
192 return Qnil;
195 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
196 Sset_minibuffer_window, 1, 1, 0,
197 doc: /* Specify which minibuffer window to use for the minibuffer.
198 This affects where the minibuffer is displayed if you put text in it
199 without invoking the usual minibuffer commands. */)
200 (window)
201 Lisp_Object window;
203 CHECK_WINDOW (window);
204 if (! MINI_WINDOW_P (XWINDOW (window)))
205 error ("Window is not a minibuffer window");
207 minibuf_window = window;
209 return window;
213 /* Actual minibuffer invocation. */
215 static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
216 static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object));
217 static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
218 Lisp_Object, Lisp_Object,
219 int, Lisp_Object,
220 Lisp_Object, Lisp_Object,
221 int, int));
222 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
223 Lisp_Object, Lisp_Object,
224 int, Lisp_Object,
225 Lisp_Object, Lisp_Object,
226 int, int));
227 static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object));
230 /* Read a Lisp object from VAL and return it. If VAL is an empty
231 string, and DEFALT is a string, read from DEFALT instead of VAL. */
233 static Lisp_Object
234 string_to_object (val, defalt)
235 Lisp_Object val, defalt;
237 struct gcpro gcpro1, gcpro2;
238 Lisp_Object expr_and_pos;
239 int pos;
241 GCPRO2 (val, defalt);
243 if (STRINGP (val) && SCHARS (val) == 0
244 && STRINGP (defalt))
245 val = defalt;
247 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
248 pos = XINT (Fcdr (expr_and_pos));
249 if (pos != SCHARS (val))
251 /* Ignore trailing whitespace; any other trailing junk
252 is an error. */
253 int i;
254 pos = string_char_to_byte (val, pos);
255 for (i = pos; i < SBYTES (val); i++)
257 int c = SREF (val, i);
258 if (c != ' ' && c != '\t' && c != '\n')
259 error ("Trailing garbage following expression");
263 val = Fcar (expr_and_pos);
264 RETURN_UNGCPRO (val);
268 /* Like read_minibuf but reading from stdin. This function is called
269 from read_minibuf to do the job if noninteractive. */
271 static Lisp_Object
272 read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
273 histvar, histpos, defalt, allow_props,
274 inherit_input_method)
275 Lisp_Object map;
276 Lisp_Object initial;
277 Lisp_Object prompt;
278 Lisp_Object backup_n;
279 int expflag;
280 Lisp_Object histvar;
281 Lisp_Object histpos;
282 Lisp_Object defalt;
283 int allow_props;
284 int inherit_input_method;
286 int size, len;
287 char *line, *s;
288 Lisp_Object val;
290 fprintf (stdout, "%s", SDATA (prompt));
291 fflush (stdout);
293 val = Qnil;
294 size = 100;
295 len = 0;
296 line = (char *) xmalloc (size * sizeof *line);
297 while ((s = fgets (line + len, size - len, stdin)) != NULL
298 && (len = strlen (line),
299 len == size - 1 && line[len - 1] != '\n'))
301 size *= 2;
302 line = (char *) xrealloc (line, size);
305 if (s)
307 len = strlen (line);
309 if (len > 0 && line[len - 1] == '\n')
310 line[--len] = '\0';
312 val = build_string (line);
313 xfree (line);
315 else
317 xfree (line);
318 error ("Error reading from stdin");
321 /* If Lisp form desired instead of string, parse it. */
322 if (expflag)
323 val = string_to_object (val, defalt);
325 return val;
328 DEFUN ("minibufferp", Fminibufferp,
329 Sminibufferp, 0, 1, 0,
330 doc: /* Return t if BUFFER is a minibuffer.
331 No argument or nil as argument means use current buffer as BUFFER.
332 BUFFER can be a buffer or a buffer name. */)
333 (buffer)
334 Lisp_Object buffer;
336 Lisp_Object tem;
338 if (NILP (buffer))
339 buffer = Fcurrent_buffer ();
340 else if (STRINGP (buffer))
341 buffer = Fget_buffer (buffer);
342 else
343 CHECK_BUFFER (buffer);
345 tem = Fmemq (buffer, Vminibuffer_list);
346 return ! NILP (tem) ? Qt : Qnil;
349 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
350 Sminibuffer_prompt_end, 0, 0, 0,
351 doc: /* Return the buffer position of the end of the minibuffer prompt.
352 Return (point-min) if current buffer is not a mini-buffer. */)
355 /* This function is written to be most efficient when there's a prompt. */
356 Lisp_Object beg, end, tem;
357 beg = make_number (BEGV);
359 tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
360 if (NILP (tem))
361 return beg;
363 end = Ffield_end (beg, Qnil, Qnil);
365 if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
366 return beg;
367 else
368 return end;
371 DEFUN ("minibuffer-contents", Fminibuffer_contents,
372 Sminibuffer_contents, 0, 0, 0,
373 doc: /* Return the user input in a minibuffer as a string.
374 The current buffer must be a minibuffer. */)
377 int prompt_end = XINT (Fminibuffer_prompt_end ());
378 return make_buffer_string (prompt_end, ZV, 1);
381 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
382 Sminibuffer_contents_no_properties, 0, 0, 0,
383 doc: /* Return the user input in a minibuffer as a string, without text-properties.
384 The current buffer must be a minibuffer. */)
387 int prompt_end = XINT (Fminibuffer_prompt_end ());
388 return make_buffer_string (prompt_end, ZV, 0);
391 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents,
392 Sdelete_minibuffer_contents, 0, 0, 0,
393 doc: /* Delete all user input in a minibuffer.
394 The current buffer must be a minibuffer. */)
397 int prompt_end = XINT (Fminibuffer_prompt_end ());
398 if (prompt_end < ZV)
399 del_range (prompt_end, ZV);
400 return Qnil;
403 /* Get the text in the minibuffer before point.
404 That is what completion commands operate on. */
406 Lisp_Object
407 minibuffer_completion_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);
415 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
416 putting point minus BACKUP_N bytes from the end of INITIAL,
417 prompting with PROMPT (a string), using history list HISTVAR
418 with initial position HISTPOS. INITIAL should be a string or a
419 cons of a string and an integer. BACKUP_N should be <= 0, or
420 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is
421 ignored and replaced with an integer that puts point at one-indexed
422 position N in INITIAL, where N is the CDR of INITIAL, or at the
423 beginning of INITIAL if N <= 0.
425 Normally return the result as a string (the text that was read),
426 but if EXPFLAG is nonzero, read it and return the object read.
427 If HISTVAR is given, save the value read on that history only if it doesn't
428 match the front of that history list exactly. The value is pushed onto
429 the list as the string that was read.
431 DEFALT specifies the default value for the sake of history commands.
433 If ALLOW_PROPS is nonzero, we do not throw away text properties.
435 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the
436 current input method. */
438 static Lisp_Object
439 read_minibuf (map, initial, prompt, backup_n, expflag,
440 histvar, histpos, defalt, allow_props, inherit_input_method)
441 Lisp_Object map;
442 Lisp_Object initial;
443 Lisp_Object prompt;
444 Lisp_Object backup_n;
445 int expflag;
446 Lisp_Object histvar;
447 Lisp_Object histpos;
448 Lisp_Object defalt;
449 int allow_props;
450 int inherit_input_method;
452 Lisp_Object val;
453 int count = SPECPDL_INDEX ();
454 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
455 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
456 Lisp_Object enable_multibyte;
457 int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
459 /* String to add to the history. */
460 Lisp_Object histstring;
462 extern Lisp_Object Qfront_sticky;
463 extern Lisp_Object Qrear_nonsticky;
465 specbind (Qminibuffer_default, defalt);
467 single_kboard_state ();
468 #ifdef HAVE_X_WINDOWS
469 if (display_hourglass_p)
470 cancel_hourglass ();
471 #endif
473 if (!NILP (initial))
475 if (CONSP (initial))
477 backup_n = Fcdr (initial);
478 initial = Fcar (initial);
479 CHECK_STRING (initial);
480 if (!NILP (backup_n))
482 CHECK_NUMBER (backup_n);
483 /* Convert to distance from end of input. */
484 if (XINT (backup_n) < 1)
485 /* A number too small means the beginning of the string. */
486 pos = - SCHARS (initial);
487 else
488 pos = XINT (backup_n) - 1 - SCHARS (initial);
491 else
492 CHECK_STRING (initial);
494 val = Qnil;
495 ambient_dir = current_buffer->directory;
496 input_method = Qnil;
497 enable_multibyte = Qnil;
499 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
500 store them away before we can GC. Don't need to protect
501 BACKUP_N because we use the value only if it is an integer. */
502 GCPRO5 (map, initial, val, ambient_dir, input_method);
504 if (!STRINGP (prompt))
505 prompt = empty_string;
507 if (!enable_recursive_minibuffers
508 && minibuf_level > 0)
510 if (EQ (selected_window, minibuf_window))
511 error ("Command attempted to use minibuffer while in minibuffer");
512 else
513 /* If we're in another window, cancel the minibuffer that's active. */
514 Fthrow (Qexit,
515 build_string ("Command attempted to use minibuffer while in minibuffer"));
518 if (noninteractive)
520 val = read_minibuf_noninteractive (map, initial, prompt,
521 make_number (pos),
522 expflag, histvar, histpos, defalt,
523 allow_props, inherit_input_method);
524 UNGCPRO;
525 return unbind_to (count, val);
528 /* Choose the minibuffer window and frame, and take action on them. */
530 choose_minibuf_frame ();
532 record_unwind_protect (choose_minibuf_frame_1, Qnil);
534 record_unwind_protect (Fset_window_configuration,
535 Fcurrent_window_configuration (Qnil));
537 /* If the minibuffer window is on a different frame, save that
538 frame's configuration too. */
539 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
540 if (!EQ (mini_frame, selected_frame))
541 record_unwind_protect (Fset_window_configuration,
542 Fcurrent_window_configuration (mini_frame));
544 /* If the minibuffer is on an iconified or invisible frame,
545 make it visible now. */
546 Fmake_frame_visible (mini_frame);
548 if (minibuffer_auto_raise)
549 Fraise_frame (mini_frame);
551 /* We have to do this after saving the window configuration
552 since that is what restores the current buffer. */
554 /* Arrange to restore a number of minibuffer-related variables.
555 We could bind each variable separately, but that would use lots of
556 specpdl slots. */
557 minibuf_save_list
558 = Fcons (Voverriding_local_map,
559 Fcons (minibuf_window, minibuf_save_list));
560 minibuf_save_list
561 = Fcons (minibuf_prompt,
562 Fcons (make_number (minibuf_prompt_width),
563 Fcons (Vhelp_form,
564 Fcons (Vcurrent_prefix_arg,
565 Fcons (Vminibuffer_history_position,
566 Fcons (Vminibuffer_history_variable,
567 minibuf_save_list))))));
569 record_unwind_protect (read_minibuf_unwind, Qnil);
570 minibuf_level++;
571 /* We are exiting the minibuffer one way or the other, so run the hook.
572 It should be run before unwinding the minibuf settings. Do it
573 separately from read_minibuf_unwind because we need to make sure that
574 read_minibuf_unwind is fully executed even if exit-minibuffer-hook
575 signals an error. --Stef */
576 record_unwind_protect (run_exit_minibuf_hook, Qnil);
578 /* Now that we can restore all those variables, start changing them. */
580 minibuf_prompt_width = 0;
581 minibuf_prompt = Fcopy_sequence (prompt);
582 Vminibuffer_history_position = histpos;
583 Vminibuffer_history_variable = histvar;
584 Vhelp_form = Vminibuffer_help_form;
586 if (inherit_input_method)
588 /* `current-input-method' is buffer local. So, remember it in
589 INPUT_METHOD before changing the current buffer. */
590 input_method = Fsymbol_value (Qcurrent_input_method);
591 enable_multibyte = current_buffer->enable_multibyte_characters;
594 /* Switch to the minibuffer. */
596 minibuffer = get_minibuffer (minibuf_level);
597 Fset_buffer (minibuffer);
599 /* The current buffer's default directory is usually the right thing
600 for our minibuffer here. However, if you're typing a command at
601 a minibuffer-only frame when minibuf_level is zero, then buf IS
602 the current_buffer, so reset_buffer leaves buf's default
603 directory unchanged. This is a bummer when you've just started
604 up Emacs and buf's default directory is Qnil. Here's a hack; can
605 you think of something better to do? Find another buffer with a
606 better directory, and use that one instead. */
607 if (STRINGP (ambient_dir))
608 current_buffer->directory = ambient_dir;
609 else
611 Lisp_Object buf_list;
613 for (buf_list = Vbuffer_alist;
614 CONSP (buf_list);
615 buf_list = XCDR (buf_list))
617 Lisp_Object other_buf;
619 other_buf = XCDR (XCAR (buf_list));
620 if (STRINGP (XBUFFER (other_buf)->directory))
622 current_buffer->directory = XBUFFER (other_buf)->directory;
623 break;
628 if (!EQ (mini_frame, selected_frame))
629 Fredirect_frame_focus (selected_frame, mini_frame);
631 Vminibuf_scroll_window = selected_window;
632 if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
633 minibuf_selected_window = selected_window;
634 Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
635 Fselect_window (minibuf_window, Qnil);
636 XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
638 Fmake_local_variable (Qprint_escape_newlines);
639 print_escape_newlines = 1;
641 /* Erase the buffer. */
643 int count1 = SPECPDL_INDEX ();
644 specbind (Qinhibit_read_only, Qt);
645 specbind (Qinhibit_modification_hooks, Qt);
646 Ferase_buffer ();
647 unbind_to (count1, Qnil);
650 if (!NILP (current_buffer->enable_multibyte_characters)
651 && ! STRING_MULTIBYTE (minibuf_prompt))
652 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
654 /* Insert the prompt, record where it ends. */
655 Finsert (1, &minibuf_prompt);
656 if (PT > BEG)
658 Fput_text_property (make_number (BEG), make_number (PT),
659 Qfront_sticky, Qt, Qnil);
660 Fput_text_property (make_number (BEG), make_number (PT),
661 Qrear_nonsticky, Qt, Qnil);
662 Fput_text_property (make_number (BEG), make_number (PT),
663 Qfield, Qt, Qnil);
664 Fadd_text_properties (make_number (BEG), make_number (PT),
665 Vminibuffer_prompt_properties, Qnil);
668 minibuf_prompt_width = (int) current_column (); /* iftc */
670 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */
671 if (inherit_input_method)
672 current_buffer->enable_multibyte_characters = enable_multibyte;
674 /* Put in the initial input. */
675 if (!NILP (initial))
677 Finsert (1, &initial);
678 Fforward_char (make_number (pos));
681 clear_message (1, 1);
682 current_buffer->keymap = map;
684 /* Turn on an input method stored in INPUT_METHOD if any. */
685 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
686 call1 (Qactivate_input_method, input_method);
688 /* Run our hook, but not if it is empty.
689 (run-hooks would do nothing if it is empty,
690 but it's important to save time here in the usual case.) */
691 if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
692 && !NILP (Vrun_hooks))
693 call1 (Vrun_hooks, Qminibuffer_setup_hook);
695 /* Don't allow the user to undo past this point. */
696 current_buffer->undo_list = Qnil;
698 recursive_edit_1 ();
700 /* If cursor is on the minibuffer line,
701 show the user we have exited by putting it in column 0. */
702 if (XWINDOW (minibuf_window)->cursor.vpos >= 0
703 && !noninteractive)
705 XWINDOW (minibuf_window)->cursor.hpos = 0;
706 XWINDOW (minibuf_window)->cursor.x = 0;
707 XWINDOW (minibuf_window)->must_be_updated_p = 1;
708 update_frame (XFRAME (selected_frame), 1, 1);
709 if (rif && rif->flush_display)
710 rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame));
713 /* Make minibuffer contents into a string. */
714 Fset_buffer (minibuffer);
715 if (allow_props)
716 val = Fminibuffer_contents ();
717 else
718 val = Fminibuffer_contents_no_properties ();
720 /* VAL is the string of minibuffer text. */
722 last_minibuf_string = val;
724 /* Choose the string to add to the history. */
725 if (SCHARS (val) != 0)
726 histstring = val;
727 else if (STRINGP (defalt))
728 histstring = defalt;
729 else
730 histstring = Qnil;
732 /* Add the value to the appropriate history list, if any. */
733 if (SYMBOLP (Vminibuffer_history_variable)
734 && !NILP (histstring))
736 /* If the caller wanted to save the value read on a history list,
737 then do so if the value is not already the front of the list. */
738 Lisp_Object histval;
740 /* If variable is unbound, make it nil. */
741 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable), Qunbound))
742 Fset (Vminibuffer_history_variable, Qnil);
744 histval = Fsymbol_value (Vminibuffer_history_variable);
746 /* The value of the history variable must be a cons or nil. Other
747 values are unacceptable. We silently ignore these values. */
749 if (NILP (histval)
750 || (CONSP (histval)
751 /* Don't duplicate the most recent entry in the history. */
752 && NILP (Fequal (histstring, Fcar (histval)))))
754 Lisp_Object length;
756 if (history_delete_duplicates) Fdelete (histstring, histval);
757 histval = Fcons (histstring, histval);
758 Fset (Vminibuffer_history_variable, histval);
760 /* Truncate if requested. */
761 length = Fget (Vminibuffer_history_variable, Qhistory_length);
762 if (NILP (length)) length = Vhistory_length;
763 if (INTEGERP (length))
765 if (XINT (length) <= 0)
766 Fset (Vminibuffer_history_variable, Qnil);
767 else
769 Lisp_Object temp;
771 temp = Fnthcdr (Fsub1 (length), histval);
772 if (CONSP (temp)) Fsetcdr (temp, Qnil);
778 /* If Lisp form desired instead of string, parse it. */
779 if (expflag)
780 val = string_to_object (val, defalt);
782 /* The appropriate frame will get selected
783 in set-window-configuration. */
784 UNGCPRO;
785 return unbind_to (count, val);
788 /* Return a buffer to be used as the minibuffer at depth `depth'.
789 depth = 0 is the lowest allowed argument, and that is the value
790 used for nonrecursive minibuffer invocations */
792 Lisp_Object
793 get_minibuffer (depth)
794 int depth;
796 Lisp_Object tail, num, buf;
797 char name[24];
798 extern Lisp_Object nconc2 ();
800 XSETFASTINT (num, depth);
801 tail = Fnthcdr (num, Vminibuffer_list);
802 if (NILP (tail))
804 tail = Fcons (Qnil, Qnil);
805 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
807 buf = Fcar (tail);
808 if (NILP (buf) || NILP (XBUFFER (buf)->name))
810 sprintf (name, " *Minibuf-%d*", depth);
811 buf = Fget_buffer_create (build_string (name));
813 /* Although the buffer's name starts with a space, undo should be
814 enabled in it. */
815 Fbuffer_enable_undo (buf);
817 XSETCAR (tail, buf);
819 else
821 int count = SPECPDL_INDEX ();
822 /* `reset_buffer' blindly sets the list of overlays to NULL, so we
823 have to empty the list, otherwise we end up with overlays that
824 think they belong to this buffer while the buffer doesn't know about
825 them any more. */
826 delete_all_overlays (XBUFFER (buf));
827 reset_buffer (XBUFFER (buf));
828 record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
829 Fset_buffer (buf);
830 Fkill_all_local_variables ();
831 unbind_to (count, Qnil);
834 return buf;
837 static Lisp_Object
838 run_exit_minibuf_hook (data)
839 Lisp_Object data;
841 if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
842 && !NILP (Vrun_hooks))
843 safe_run_hooks (Qminibuffer_exit_hook);
845 return Qnil;
848 /* This function is called on exiting minibuffer, whether normally or
849 not, and it restores the current window, buffer, etc. */
851 static Lisp_Object
852 read_minibuf_unwind (data)
853 Lisp_Object data;
855 Lisp_Object old_deactivate_mark;
856 Lisp_Object window;
858 /* If this was a recursive minibuffer,
859 tie the minibuffer window back to the outer level minibuffer buffer. */
860 minibuf_level--;
862 window = minibuf_window;
863 /* To keep things predictable, in case it matters, let's be in the
864 minibuffer when we reset the relevant variables. */
865 Fset_buffer (XWINDOW (window)->buffer);
867 /* Restore prompt, etc, from outer minibuffer level. */
868 minibuf_prompt = Fcar (minibuf_save_list);
869 minibuf_save_list = Fcdr (minibuf_save_list);
870 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
871 minibuf_save_list = Fcdr (minibuf_save_list);
872 Vhelp_form = Fcar (minibuf_save_list);
873 minibuf_save_list = Fcdr (minibuf_save_list);
874 Vcurrent_prefix_arg = Fcar (minibuf_save_list);
875 minibuf_save_list = Fcdr (minibuf_save_list);
876 Vminibuffer_history_position = Fcar (minibuf_save_list);
877 minibuf_save_list = Fcdr (minibuf_save_list);
878 Vminibuffer_history_variable = Fcar (minibuf_save_list);
879 minibuf_save_list = Fcdr (minibuf_save_list);
880 Voverriding_local_map = Fcar (minibuf_save_list);
881 minibuf_save_list = Fcdr (minibuf_save_list);
882 #if 0
883 temp = Fcar (minibuf_save_list);
884 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
885 minibuf_window = temp;
886 #endif
887 minibuf_save_list = Fcdr (minibuf_save_list);
889 /* Erase the minibuffer we were using at this level. */
891 int count = SPECPDL_INDEX ();
892 /* Prevent error in erase-buffer. */
893 specbind (Qinhibit_read_only, Qt);
894 specbind (Qinhibit_modification_hooks, Qt);
895 old_deactivate_mark = Vdeactivate_mark;
896 Ferase_buffer ();
897 Vdeactivate_mark = old_deactivate_mark;
898 unbind_to (count, Qnil);
901 /* When we get to the outmost level, make sure we resize the
902 mini-window back to its normal size. */
903 if (minibuf_level == 0)
904 resize_mini_window (XWINDOW (window), 0);
906 /* Make sure minibuffer window is erased, not ignored. */
907 windows_or_buffers_changed++;
908 XSETFASTINT (XWINDOW (window)->last_modified, 0);
909 XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0);
910 return Qnil;
914 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
915 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
916 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
917 DEFAULT-VALUE. It normally should be nil in new code, except when
918 HIST is a cons. It is discussed in more detail below.
919 Third arg KEYMAP is a keymap to use whilst reading;
920 if omitted or nil, the default is `minibuffer-local-map'.
921 If fourth arg READ is non-nil, then interpret the result as a Lisp object
922 and return that object:
923 in other words, do `(car (read-from-string INPUT-STRING))'
924 Fifth arg HIST, if non-nil, specifies a history list and optionally
925 the initial position in the list. It can be a symbol, which is the
926 history list variable to use, or it can be a cons cell
927 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable
928 to use, and HISTPOS is the initial position for use by the minibuffer
929 history commands. For consistency, you should also specify that
930 element of the history as the value of INITIAL-CONTENTS. Positions
931 are counted starting from 1 at the beginning of the list.
932 Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
933 for history commands; but, unless READ is non-nil, `read-from-minibuffer'
934 does NOT return DEFAULT-VALUE if the user enters empty input! It returns
935 the empty string.
936 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
937 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 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
954 Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
955 Lisp_Object inherit_input_method;
957 Lisp_Object histvar, histpos, val;
958 struct gcpro gcpro1;
960 CHECK_STRING (prompt);
961 if (NILP (keymap))
962 keymap = Vminibuffer_local_map;
963 else
964 keymap = get_keymap (keymap, 1, 0);
966 if (SYMBOLP (hist))
968 histvar = hist;
969 histpos = Qnil;
971 else
973 histvar = Fcar_safe (hist);
974 histpos = Fcdr_safe (hist);
976 if (NILP (histvar))
977 histvar = Qminibuffer_history;
978 if (NILP (histpos))
979 XSETFASTINT (histpos, 0);
981 GCPRO1 (default_value);
982 val = read_minibuf (keymap, initial_contents, prompt,
983 Qnil, !NILP (read),
984 histvar, histpos, default_value,
985 minibuffer_allow_text_properties,
986 !NILP (inherit_input_method));
987 UNGCPRO;
988 return val;
991 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
992 doc: /* Return a Lisp object read using the minibuffer, unevaluated.
993 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
994 is a string to insert in the minibuffer before reading.
995 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
996 arguments are used as in `read-from-minibuffer') */)
997 (prompt, initial_contents)
998 Lisp_Object prompt, initial_contents;
1000 CHECK_STRING (prompt);
1001 return read_minibuf (Vminibuffer_local_map, initial_contents,
1002 prompt, Qnil, 1, Qminibuffer_history,
1003 make_number (0), Qnil, 0, 0);
1006 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
1007 doc: /* Return value of Lisp expression read using the minibuffer.
1008 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS
1009 is a string to insert in the minibuffer before reading.
1010 \(INITIAL-CONTENTS can also be a cons of a string and an integer. Such
1011 arguments are used as in `read-from-minibuffer') */)
1012 (prompt, initial_contents)
1013 Lisp_Object prompt, initial_contents;
1015 return Feval (Fread_minibuffer (prompt, initial_contents));
1018 /* Functions that use the minibuffer to read various things. */
1020 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
1021 doc: /* Read a string from the minibuffer, prompting with string PROMPT.
1022 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
1023 This argument has been superseded by DEFAULT-VALUE and should normally
1024 be nil in new code. It behaves as in `read-from-minibuffer'. See the
1025 documentation string of that function for details.
1026 The third arg HISTORY, if non-nil, specifies a history list
1027 and optionally the initial position in the list.
1028 See `read-from-minibuffer' for details of HISTORY argument.
1029 Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
1030 for history commands, and as the value to return if the user enters
1031 the 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 (prompt, initial_input, history, default_value, inherit_input_method)
1035 Lisp_Object prompt, initial_input, history, default_value;
1036 Lisp_Object inherit_input_method;
1038 Lisp_Object val;
1039 val = Fread_from_minibuffer (prompt, initial_input, Qnil,
1040 Qnil, history, default_value,
1041 inherit_input_method);
1042 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
1043 val = default_value;
1044 return val;
1047 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
1048 doc: /* Read a string from the terminal, not allowing blanks.
1049 Prompt with PROMPT. Whitespace terminates the input. If INITIAL is
1050 non-nil, it should be a string, which is used as initial input, with
1051 point positioned at the end, so that SPACE will accept the input.
1052 \(Actually, INITIAL can also be a cons of a string and an integer.
1053 Such values are treated as in `read-from-minibuffer', but are normally
1054 not useful in this function.)
1055 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1056 the current input method and the setting of`enable-multibyte-characters'. */)
1057 (prompt, initial, inherit_input_method)
1058 Lisp_Object prompt, initial, inherit_input_method;
1060 CHECK_STRING (prompt);
1061 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
1062 0, Qminibuffer_history, make_number (0), Qnil, 0,
1063 !NILP (inherit_input_method));
1066 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
1067 doc: /* Read the name of a command and return as a symbol.
1068 Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
1069 (prompt, default_value)
1070 Lisp_Object prompt, default_value;
1072 Lisp_Object name, default_string;
1074 if (NILP (default_value))
1075 default_string = Qnil;
1076 else if (SYMBOLP (default_value))
1077 default_string = SYMBOL_NAME (default_value);
1078 else
1079 default_string = default_value;
1081 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
1082 Qnil, Qnil, default_string, Qnil);
1083 if (NILP (name))
1084 return name;
1085 return Fintern (name, Qnil);
1088 #ifdef NOTDEF
1089 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
1090 doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
1091 Prompt with PROMPT. */)
1092 (prompt)
1093 Lisp_Object prompt;
1095 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
1096 Qnil);
1098 #endif /* NOTDEF */
1100 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
1101 doc: /* Read the name of a user variable and return it as a symbol.
1102 Prompt with PROMPT. By default, return DEFAULT-VALUE.
1103 A user variable is one for which `user-variable-p' returns non-nil. */)
1104 (prompt, default_value)
1105 Lisp_Object prompt, default_value;
1107 Lisp_Object name, default_string;
1109 if (NILP (default_value))
1110 default_string = Qnil;
1111 else if (SYMBOLP (default_value))
1112 default_string = SYMBOL_NAME (default_value);
1113 else
1114 default_string = default_value;
1116 name = Fcompleting_read (prompt, Vobarray,
1117 Quser_variable_p, Qt,
1118 Qnil, Qnil, default_string, Qnil);
1119 if (NILP (name))
1120 return name;
1121 return Fintern (name, Qnil);
1124 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
1125 doc: /* Read the name of a buffer and return as a string.
1126 Prompt with PROMPT.
1127 Optional second arg DEF is value to return if user enters an empty line.
1128 If optional third arg REQUIRE-MATCH is non-nil,
1129 only existing buffer names are allowed. */)
1130 (prompt, def, require_match)
1131 Lisp_Object prompt, def, require_match;
1133 Lisp_Object args[4];
1135 if (BUFFERP (def))
1136 def = XBUFFER (def)->name;
1138 if (NILP (Vread_buffer_function))
1140 if (!NILP (def))
1142 args[0] = build_string ("%s(default %s) ");
1143 args[1] = prompt;
1144 args[2] = def;
1145 prompt = Fformat (3, args);
1148 return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
1149 require_match, Qnil, Qbuffer_name_history,
1150 def, Qnil);
1152 else
1154 args[0] = Vread_buffer_function;
1155 args[1] = prompt;
1156 args[2] = def;
1157 args[3] = require_match;
1158 return Ffuncall(4, args);
1162 static Lisp_Object
1163 minibuf_conform_representation (string, basis)
1164 Lisp_Object string, basis;
1166 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1167 return string;
1169 if (STRING_MULTIBYTE (string))
1170 return Fstring_make_unibyte (string);
1171 else
1172 return Fstring_make_multibyte (string);
1175 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1176 doc: /* Return common substring of all completions of STRING in ALIST.
1177 Each car of each element of ALIST (or each element if it is not a cons cell)
1178 is tested to see if it begins with STRING.
1179 All that match are compared together; the longest initial sequence
1180 common to all matches is returned as a string.
1181 If there is no match at all, nil is returned.
1182 For a unique match which is exact, t is returned.
1184 If ALIST is a hash-table, all the string keys are the possible matches.
1185 If ALIST is an obarray, the names of all symbols in the obarray
1186 are the possible matches.
1188 ALIST can also be a function to do the completion itself.
1189 It receives three arguments: the values STRING, PREDICATE and nil.
1190 Whatever it returns becomes the value of `try-completion'.
1192 If optional third argument PREDICATE is non-nil,
1193 it is used to test each possible match.
1194 The match is a candidate only if PREDICATE returns non-nil.
1195 The argument given to PREDICATE is the alist element
1196 or the symbol from the obarray. If ALIST is a hash-table,
1197 predicate is called with two arguments: the key and the value.
1198 Additionally to this predicate, `completion-regexp-list'
1199 is used to further constrain the set of candidates. */)
1200 (string, alist, predicate)
1201 Lisp_Object string, alist, predicate;
1203 Lisp_Object bestmatch, tail, elt, eltstring;
1204 /* Size in bytes of BESTMATCH. */
1205 int bestmatchsize = 0;
1206 /* These are in bytes, too. */
1207 int compare, matchsize;
1208 int type = HASH_TABLE_P (alist) ? 3
1209 : VECTORP (alist) ? 2
1210 : NILP (alist) || (CONSP (alist)
1211 && (!SYMBOLP (XCAR (alist))
1212 || NILP (XCAR (alist))));
1213 int index = 0, obsize = 0;
1214 int matchcount = 0;
1215 int bindcount = -1;
1216 Lisp_Object bucket, zero, end, tem;
1217 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1219 CHECK_STRING (string);
1220 if (type == 0)
1221 return call3 (alist, string, predicate, Qnil);
1223 bestmatch = bucket = Qnil;
1225 /* If ALIST is not a list, set TAIL just for gc pro. */
1226 tail = alist;
1227 if (type == 2)
1229 obsize = XVECTOR (alist)->size;
1230 bucket = XVECTOR (alist)->contents[index];
1233 while (1)
1235 /* Get the next element of the alist, obarray, or hash-table. */
1236 /* Exit the loop if the elements are all used up. */
1237 /* elt gets the alist element or symbol.
1238 eltstring gets the name to check as a completion. */
1240 if (type == 1)
1242 if (!CONSP (tail))
1243 break;
1244 elt = XCAR (tail);
1245 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1246 tail = XCDR (tail);
1248 else if (type == 2)
1250 if (XFASTINT (bucket) != 0)
1252 elt = bucket;
1253 eltstring = Fsymbol_name (elt);
1254 if (XSYMBOL (bucket)->next)
1255 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1256 else
1257 XSETFASTINT (bucket, 0);
1259 else if (++index >= obsize)
1260 break;
1261 else
1263 bucket = XVECTOR (alist)->contents[index];
1264 continue;
1267 else /* if (type == 3) */
1269 while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
1270 && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
1271 index++;
1272 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
1273 break;
1274 else
1275 elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
1278 /* Is this element a possible completion? */
1280 if (STRINGP (eltstring)
1281 && SCHARS (string) <= SCHARS (eltstring)
1282 && (tem = Fcompare_strings (eltstring, make_number (0),
1283 make_number (SCHARS (string)),
1284 string, make_number (0), Qnil,
1285 completion_ignore_case ? Qt : Qnil),
1286 EQ (Qt, tem)))
1288 /* Yes. */
1289 Lisp_Object regexps;
1290 Lisp_Object zero;
1291 XSETFASTINT (zero, 0);
1293 /* Ignore this element if it fails to match all the regexps. */
1295 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1296 regexps = XCDR (regexps))
1298 if (bindcount < 0) {
1299 bindcount = SPECPDL_INDEX ();
1300 specbind (Qcase_fold_search,
1301 completion_ignore_case ? Qt : Qnil);
1303 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1304 if (NILP (tem))
1305 break;
1307 if (CONSP (regexps))
1308 continue;
1311 /* Ignore this element if there is a predicate
1312 and the predicate doesn't like it. */
1314 if (!NILP (predicate))
1316 if (EQ (predicate, Qcommandp))
1317 tem = Fcommandp (elt, Qnil);
1318 else
1320 if (bindcount >= 0) {
1321 unbind_to (bindcount, Qnil);
1322 bindcount = -1;
1324 GCPRO4 (tail, string, eltstring, bestmatch);
1325 tem = type == 3
1326 ? call2 (predicate, elt,
1327 HASH_VALUE (XHASH_TABLE (alist), index - 1))
1328 : call1 (predicate, elt);
1329 UNGCPRO;
1331 if (NILP (tem)) continue;
1334 /* Update computation of how much all possible completions match */
1336 if (NILP (bestmatch))
1338 matchcount = 1;
1339 bestmatch = eltstring;
1340 bestmatchsize = SCHARS (eltstring);
1342 else
1344 compare = min (bestmatchsize, SCHARS (eltstring));
1345 tem = Fcompare_strings (bestmatch, make_number (0),
1346 make_number (compare),
1347 eltstring, make_number (0),
1348 make_number (compare),
1349 completion_ignore_case ? Qt : Qnil);
1350 if (EQ (tem, Qt))
1351 matchsize = compare;
1352 else if (XINT (tem) < 0)
1353 matchsize = - XINT (tem) - 1;
1354 else
1355 matchsize = XINT (tem) - 1;
1357 if (matchsize < 0)
1358 /* When can this happen ? -stef */
1359 matchsize = compare;
1360 if (completion_ignore_case)
1362 /* If this is an exact match except for case,
1363 use it as the best match rather than one that is not an
1364 exact match. This way, we get the case pattern
1365 of the actual match. */
1366 if ((matchsize == SCHARS (eltstring)
1367 && matchsize < SCHARS (bestmatch))
1369 /* If there is more than one exact match ignoring case,
1370 and one of them is exact including case,
1371 prefer that one. */
1372 /* If there is no exact match ignoring case,
1373 prefer a match that does not change the case
1374 of the input. */
1375 ((matchsize == SCHARS (eltstring))
1377 (matchsize == SCHARS (bestmatch))
1378 && (tem = Fcompare_strings (eltstring, make_number (0),
1379 make_number (SCHARS (string)),
1380 string, make_number (0),
1381 Qnil,
1382 Qnil),
1383 EQ (Qt, tem))
1384 && (tem = Fcompare_strings (bestmatch, make_number (0),
1385 make_number (SCHARS (string)),
1386 string, make_number (0),
1387 Qnil,
1388 Qnil),
1389 ! EQ (Qt, tem))))
1390 bestmatch = eltstring;
1392 if (bestmatchsize != SCHARS (eltstring)
1393 || bestmatchsize != matchsize)
1394 /* Don't count the same string multiple times. */
1395 matchcount++;
1396 bestmatchsize = matchsize;
1397 if (matchsize <= SCHARS (string)
1398 && matchcount > 1)
1399 /* No need to look any further. */
1400 break;
1405 if (bindcount >= 0) {
1406 unbind_to (bindcount, Qnil);
1407 bindcount = -1;
1410 if (NILP (bestmatch))
1411 return Qnil; /* No completions found */
1412 /* If we are ignoring case, and there is no exact match,
1413 and no additional text was supplied,
1414 don't change the case of what the user typed. */
1415 if (completion_ignore_case && bestmatchsize == SCHARS (string)
1416 && SCHARS (bestmatch) > bestmatchsize)
1417 return minibuf_conform_representation (string, bestmatch);
1419 /* Return t if the supplied string is an exact match (counting case);
1420 it does not require any change to be made. */
1421 if (matchcount == 1 && bestmatchsize == SCHARS (string)
1422 && (tem = Fcompare_strings (bestmatch, make_number (0),
1423 make_number (bestmatchsize),
1424 string, make_number (0),
1425 make_number (bestmatchsize),
1426 Qnil),
1427 EQ (Qt, tem)))
1428 return Qt;
1430 XSETFASTINT (zero, 0); /* Else extract the part in which */
1431 XSETFASTINT (end, bestmatchsize); /* all completions agree */
1432 return Fsubstring (bestmatch, zero, end);
1435 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1436 doc: /* Search for partial matches to STRING in ALIST.
1437 Each car of each element of ALIST (or each element if it is not a cons cell)
1438 is tested to see if it begins with STRING.
1439 The value is a list of all the strings from ALIST that match.
1441 If ALIST is a hash-table, all the string keys are the possible matches.
1442 If ALIST is an obarray, the names of all symbols in the obarray
1443 are the possible matches.
1445 ALIST can also be a function to do the completion itself.
1446 It receives three arguments: the values STRING, PREDICATE and t.
1447 Whatever it returns becomes the value of `all-completions'.
1449 If optional third argument PREDICATE is non-nil,
1450 it is used to test each possible match.
1451 The match is a candidate only if PREDICATE returns non-nil.
1452 The argument given to PREDICATE is the alist element
1453 or the symbol from the obarray. If ALIST is a hash-table,
1454 predicate is called with two arguments: the key and the value.
1455 Additionally to this predicate, `completion-regexp-list'
1456 is used to further constrain the set of candidates.
1458 If the optional fourth argument HIDE-SPACES is non-nil,
1459 strings in ALIST that start with a space
1460 are ignored unless STRING itself starts with a space. */)
1461 (string, alist, predicate, hide_spaces)
1462 Lisp_Object string, alist, predicate, hide_spaces;
1464 Lisp_Object tail, elt, eltstring;
1465 Lisp_Object allmatches;
1466 int type = HASH_TABLE_P (alist) ? 3
1467 : VECTORP (alist) ? 2
1468 : NILP (alist) || (CONSP (alist)
1469 && (!SYMBOLP (XCAR (alist))
1470 || NILP (XCAR (alist))));
1471 int index = 0, obsize = 0;
1472 int bindcount = -1;
1473 Lisp_Object bucket, tem;
1474 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1476 CHECK_STRING (string);
1477 if (type == 0)
1478 return call3 (alist, string, predicate, Qt);
1479 allmatches = bucket = Qnil;
1481 /* If ALIST is not a list, set TAIL just for gc pro. */
1482 tail = alist;
1483 if (type == 2)
1485 obsize = XVECTOR (alist)->size;
1486 bucket = XVECTOR (alist)->contents[index];
1489 while (1)
1491 /* Get the next element of the alist, obarray, or hash-table. */
1492 /* Exit the loop if the elements are all used up. */
1493 /* elt gets the alist element or symbol.
1494 eltstring gets the name to check as a completion. */
1496 if (type == 1)
1498 if (!CONSP (tail))
1499 break;
1500 elt = XCAR (tail);
1501 eltstring = CONSP (elt) ? XCAR (elt) : elt;
1502 tail = XCDR (tail);
1504 else if (type == 2)
1506 if (XFASTINT (bucket) != 0)
1508 elt = bucket;
1509 eltstring = Fsymbol_name (elt);
1510 if (XSYMBOL (bucket)->next)
1511 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1512 else
1513 XSETFASTINT (bucket, 0);
1515 else if (++index >= obsize)
1516 break;
1517 else
1519 bucket = XVECTOR (alist)->contents[index];
1520 continue;
1523 else /* if (type == 3) */
1525 while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
1526 && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
1527 index++;
1528 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
1529 break;
1530 else
1531 elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
1534 /* Is this element a possible completion? */
1536 if (STRINGP (eltstring)
1537 && SCHARS (string) <= SCHARS (eltstring)
1538 /* If HIDE_SPACES, reject alternatives that start with space
1539 unless the input starts with space. */
1540 && ((SBYTES (string) > 0
1541 && SREF (string, 0) == ' ')
1542 || SREF (eltstring, 0) != ' '
1543 || NILP (hide_spaces))
1544 && (tem = Fcompare_strings (eltstring, make_number (0),
1545 make_number (SCHARS (string)),
1546 string, make_number (0),
1547 make_number (SCHARS (string)),
1548 completion_ignore_case ? Qt : Qnil),
1549 EQ (Qt, tem)))
1551 /* Yes. */
1552 Lisp_Object regexps;
1553 Lisp_Object zero;
1554 XSETFASTINT (zero, 0);
1556 /* Ignore this element if it fails to match all the regexps. */
1558 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1559 regexps = XCDR (regexps))
1561 if (bindcount < 0) {
1562 bindcount = SPECPDL_INDEX ();
1563 specbind (Qcase_fold_search,
1564 completion_ignore_case ? Qt : Qnil);
1566 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1567 if (NILP (tem))
1568 break;
1570 if (CONSP (regexps))
1571 continue;
1574 /* Ignore this element if there is a predicate
1575 and the predicate doesn't like it. */
1577 if (!NILP (predicate))
1579 if (EQ (predicate, Qcommandp))
1580 tem = Fcommandp (elt, Qnil);
1581 else
1583 if (bindcount >= 0) {
1584 unbind_to (bindcount, Qnil);
1585 bindcount = -1;
1587 GCPRO4 (tail, eltstring, allmatches, string);
1588 tem = type == 3
1589 ? call2 (predicate, elt,
1590 HASH_VALUE (XHASH_TABLE (alist), index - 1))
1591 : call1 (predicate, elt);
1592 UNGCPRO;
1594 if (NILP (tem)) continue;
1596 /* Ok => put it on the list. */
1597 allmatches = Fcons (eltstring, allmatches);
1601 if (bindcount >= 0) {
1602 unbind_to (bindcount, Qnil);
1603 bindcount = -1;
1606 return Fnreverse (allmatches);
1609 Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
1610 Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
1611 Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
1612 Lisp_Object Vminibuffer_completing_file_name;
1614 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1615 doc: /* Read a string in the minibuffer, with completion.
1616 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1617 TABLE can be an list of strings, an alist, an obarray or a hash table.
1618 TABLE can also be a function to do the completion itself.
1619 PREDICATE limits completion to a subset of TABLE.
1620 See `try-completion' and `all-completions' for more details
1621 on completion, TABLE, and PREDICATE.
1623 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
1624 the input is (or completes to) an element of TABLE or is null.
1625 If it is also not t, typing RET does not exit if it does non-null completion.
1626 If the input is null, `completing-read' returns DEF, or an empty string
1627 if DEF is nil, regardless of the value of REQUIRE-MATCH.
1629 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1630 with point positioned at the end.
1631 If it is (STRING . POSITION), the initial input is STRING, but point
1632 is placed at _zero-indexed_ position POSITION in STRING. (*Note*
1633 that this is different from `read-from-minibuffer' and related
1634 functions, which use one-indexing for POSITION.) This feature is
1635 deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1636 default value DEF instead. The user can yank the default value into
1637 the minibuffer easily using \\[next-history-element].
1639 HIST, if non-nil, specifies a history list and optionally the initial
1640 position in the list. It can be a symbol, which is the history list
1641 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In
1642 that case, HISTVAR is the history list variable to use, and HISTPOS
1643 is the initial position (the position in the list used by the
1644 minibuffer history commands). For consistency, you should also
1645 specify that element of the history as the value of
1646 INITIAL-INPUT. (This is the only case in which you should use
1647 INITIAL-INPUT instead of DEF.) Positions are counted starting from
1648 1 at the beginning of the list. The variable `history-length'
1649 controls the maximum length of a history list.
1651 DEF, if non-nil, is the default value.
1653 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1654 the current input method and the setting of `enable-multibyte-characters'.
1656 Completion ignores case if the ambient value of
1657 `completion-ignore-case' is non-nil. */)
1658 (prompt, table, predicate, require_match, initial_input, hist, def, inherit_input_method)
1659 Lisp_Object prompt, table, predicate, require_match, initial_input;
1660 Lisp_Object hist, def, inherit_input_method;
1662 Lisp_Object val, histvar, histpos, position;
1663 Lisp_Object init;
1664 int pos = 0;
1665 int count = SPECPDL_INDEX ();
1666 struct gcpro gcpro1;
1668 init = initial_input;
1669 GCPRO1 (def);
1671 specbind (Qminibuffer_completion_table, table);
1672 specbind (Qminibuffer_completion_predicate, predicate);
1673 specbind (Qminibuffer_completion_confirm,
1674 EQ (require_match, Qt) ? Qnil : require_match);
1675 last_exact_completion = Qnil;
1677 position = Qnil;
1678 if (!NILP (init))
1680 if (CONSP (init))
1682 position = Fcdr (init);
1683 init = Fcar (init);
1685 CHECK_STRING (init);
1686 if (!NILP (position))
1688 CHECK_NUMBER (position);
1689 /* Convert to distance from end of input. */
1690 pos = XINT (position) - SCHARS (init);
1694 if (SYMBOLP (hist))
1696 histvar = hist;
1697 histpos = Qnil;
1699 else
1701 histvar = Fcar_safe (hist);
1702 histpos = Fcdr_safe (hist);
1704 if (NILP (histvar))
1705 histvar = Qminibuffer_history;
1706 if (NILP (histpos))
1707 XSETFASTINT (histpos, 0);
1709 val = read_minibuf (NILP (require_match)
1710 ? Vminibuffer_local_completion_map
1711 : Vminibuffer_local_must_match_map,
1712 init, prompt, make_number (pos), 0,
1713 histvar, histpos, def, 0,
1714 !NILP (inherit_input_method));
1716 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
1717 val = def;
1719 RETURN_UNGCPRO (unbind_to (count, val));
1722 Lisp_Object Fminibuffer_completion_help ();
1723 Lisp_Object Fassoc_string ();
1725 /* Test whether TXT is an exact completion. */
1726 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1727 doc: /* Return non-nil if STRING is a valid completion.
1728 Takes the same arguments as `all-completions' and `try-completion'.
1729 If ALIST is a function, it is called with three arguments:
1730 the values STRING, PREDICATE and `lambda'. */)
1731 (string, alist, predicate)
1732 Lisp_Object string, alist, predicate;
1734 Lisp_Object regexps, tail, tem = Qnil;
1735 int i = 0;
1737 CHECK_STRING (string);
1739 if ((CONSP (alist) && (!SYMBOLP (XCAR (alist)) || NILP (XCAR (alist))))
1740 || NILP (alist))
1742 tem = Fassoc_string (string, alist, completion_ignore_case ? Qt : Qnil);
1743 if NILP (tem)
1744 return Qnil;
1746 else if (VECTORP (alist))
1748 /* Bypass intern-soft as that loses for nil. */
1749 tem = oblookup (alist,
1750 SDATA (string),
1751 SCHARS (string),
1752 SBYTES (string));
1753 if (!SYMBOLP (tem))
1755 if (STRING_MULTIBYTE (string))
1756 string = Fstring_make_unibyte (string);
1757 else
1758 string = Fstring_make_multibyte (string);
1760 tem = oblookup (alist,
1761 SDATA (string),
1762 SCHARS (string),
1763 SBYTES (string));
1766 if (completion_ignore_case && !SYMBOLP (tem))
1768 for (i = XVECTOR (alist)->size - 1; i >= 0; i--)
1770 tail = XVECTOR (alist)->contents[i];
1771 if (SYMBOLP (tail))
1772 while (1)
1774 if (EQ((Fcompare_strings (string, make_number (0), Qnil,
1775 Fsymbol_name (tail),
1776 make_number (0) , Qnil, Qt)),
1777 Qt))
1779 tem = tail;
1780 break;
1782 if (XSYMBOL (tail)->next == 0)
1783 break;
1784 XSETSYMBOL (tail, XSYMBOL (tail)->next);
1789 if (!SYMBOLP (tem))
1790 return Qnil;
1792 else if (HASH_TABLE_P (alist))
1794 struct Lisp_Hash_Table *h = XHASH_TABLE (alist);
1795 i = hash_lookup (h, string, NULL);
1796 if (i >= 0)
1797 tem = HASH_KEY (h, i);
1798 else
1799 for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1800 if (!NILP (HASH_HASH (h, i)) &&
1801 EQ (Fcompare_strings (string, make_number (0), Qnil,
1802 HASH_KEY (h, i), make_number (0) , Qnil,
1803 completion_ignore_case ? Qt : Qnil),
1804 Qt))
1806 tem = HASH_KEY (h, i);
1807 break;
1809 if (!STRINGP (tem))
1810 return Qnil;
1812 else
1813 return call3 (alist, string, predicate, Qlambda);
1815 /* Reject this element if it fails to match all the regexps. */
1816 if (CONSP (Vcompletion_regexp_list))
1818 int count = SPECPDL_INDEX ();
1819 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1820 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1821 regexps = XCDR (regexps))
1823 if (NILP (Fstring_match (XCAR (regexps),
1824 SYMBOLP (tem) ? string : tem,
1825 Qnil)))
1826 return unbind_to (count, Qnil);
1828 unbind_to (count, Qnil);
1831 /* Finally, check the predicate. */
1832 if (!NILP (predicate))
1834 return HASH_TABLE_P (alist)
1835 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (alist), i))
1836 : call1 (predicate, tem);
1838 else
1839 return Qt;
1842 /* returns:
1843 * 0 no possible completion
1844 * 1 was already an exact and unique completion
1845 * 3 was already an exact completion
1846 * 4 completed to an exact completion
1847 * 5 some completion happened
1848 * 6 no completion happened
1851 do_completion ()
1853 Lisp_Object completion, string, tem;
1854 int completedp;
1855 Lisp_Object last;
1856 struct gcpro gcpro1, gcpro2;
1858 completion = Ftry_completion (minibuffer_completion_contents (),
1859 Vminibuffer_completion_table,
1860 Vminibuffer_completion_predicate);
1861 last = last_exact_completion;
1862 last_exact_completion = Qnil;
1864 GCPRO2 (completion, last);
1866 if (NILP (completion))
1868 bitch_at_user ();
1869 temp_echo_area_glyphs (build_string (" [No match]"));
1870 UNGCPRO;
1871 return 0;
1874 if (EQ (completion, Qt)) /* exact and unique match */
1876 UNGCPRO;
1877 return 1;
1880 string = minibuffer_completion_contents ();
1882 /* COMPLETEDP should be true if some completion was done, which
1883 doesn't include simply changing the case of the entered string.
1884 However, for appearance, the string is rewritten if the case
1885 changes. */
1886 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qt);
1887 completedp = !EQ (tem, Qt);
1889 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qnil);
1890 if (!EQ (tem, Qt))
1891 /* Rewrite the user's input. */
1893 int prompt_end = XINT (Fminibuffer_prompt_end ());
1894 /* Some completion happened */
1896 if (! NILP (Vminibuffer_completing_file_name)
1897 && SREF (completion, SBYTES (completion) - 1) == '/'
1898 && PT < ZV
1899 && FETCH_CHAR (PT_BYTE) == '/')
1901 del_range (prompt_end, PT + 1);
1903 else
1904 del_range (prompt_end, PT);
1906 Finsert (1, &completion);
1908 if (! completedp)
1909 /* The case of the string changed, but that's all. We're not
1910 sure whether this is a unique completion or not, so try again
1911 using the real case (this shouldn't recurse again, because
1912 the next time try-completion will return either `t' or the
1913 exact string). */
1915 UNGCPRO;
1916 return do_completion ();
1920 /* It did find a match. Do we match some possibility exactly now? */
1921 tem = Ftest_completion (Fminibuffer_contents (),
1922 Vminibuffer_completion_table,
1923 Vminibuffer_completion_predicate);
1924 if (NILP (tem))
1926 /* not an exact match */
1927 UNGCPRO;
1928 if (completedp)
1929 return 5;
1930 else if (!NILP (Vcompletion_auto_help))
1931 Fminibuffer_completion_help ();
1932 else
1933 temp_echo_area_glyphs (build_string (" [Next char not unique]"));
1934 return 6;
1936 else if (completedp)
1938 UNGCPRO;
1939 return 4;
1941 /* If the last exact completion and this one were the same,
1942 it means we've already given a "Complete but not unique"
1943 message and the user's hit TAB again, so now we give him help. */
1944 last_exact_completion = completion;
1945 if (!NILP (last))
1947 tem = minibuffer_completion_contents ();
1948 if (!NILP (Fequal (tem, last)))
1949 Fminibuffer_completion_help ();
1951 UNGCPRO;
1952 return 3;
1955 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1957 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
1958 doc: /* Like `assoc' but specifically for strings.
1959 Unibyte strings are converted to multibyte for comparison.
1960 And case is ignored if CASE-FOLD is non-nil.
1961 As opposed to `assoc', it will also match an entry consisting of a single
1962 string rather than a cons cell whose car is a string. */)
1963 (key, list, case_fold)
1964 register Lisp_Object key;
1965 Lisp_Object list, case_fold;
1967 register Lisp_Object tail;
1969 for (tail = list; !NILP (tail); tail = Fcdr (tail))
1971 register Lisp_Object elt, tem, thiscar;
1972 elt = Fcar (tail);
1973 thiscar = CONSP (elt) ? XCAR (elt) : elt;
1974 if (!STRINGP (thiscar))
1975 continue;
1976 tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1977 key, make_number (0), Qnil,
1978 case_fold);
1979 if (EQ (tem, Qt))
1980 return elt;
1981 QUIT;
1983 return Qnil;
1986 DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "",
1987 doc: /* Complete the minibuffer contents as far as possible.
1988 Return nil if there is no valid completion, else t.
1989 If no characters can be completed, display a list of possible completions.
1990 If you repeat this command after it displayed such a list,
1991 scroll the window of possible completions. */)
1994 register int i;
1995 Lisp_Object window, tem;
1997 /* If the previous command was not this,
1998 mark the completion buffer obsolete. */
1999 if (! EQ (current_kboard->Vlast_command, Vthis_command))
2000 Vminibuf_scroll_window = Qnil;
2002 window = Vminibuf_scroll_window;
2003 /* If there's a fresh completion window with a live buffer,
2004 and this command is repeated, scroll that window. */
2005 if (! NILP (window) && ! NILP (XWINDOW (window)->buffer)
2006 && !NILP (XBUFFER (XWINDOW (window)->buffer)->name))
2008 struct buffer *obuf = current_buffer;
2010 Fset_buffer (XWINDOW (window)->buffer);
2011 tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil);
2012 if (! NILP (tem))
2013 /* If end is in view, scroll up to the beginning. */
2014 Fset_window_start (window, make_number (BEGV), Qnil);
2015 else
2016 /* Else scroll down one screen. */
2017 Fscroll_other_window (Qnil);
2019 set_buffer_internal (obuf);
2020 return Qnil;
2023 i = do_completion ();
2024 switch (i)
2026 case 0:
2027 return Qnil;
2029 case 1:
2030 if (PT != ZV)
2031 Fgoto_char (make_number (ZV));
2032 temp_echo_area_glyphs (build_string (" [Sole completion]"));
2033 break;
2035 case 3:
2036 if (PT != ZV)
2037 Fgoto_char (make_number (ZV));
2038 temp_echo_area_glyphs (build_string (" [Complete, but not unique]"));
2039 break;
2042 return Qt;
2045 /* Subroutines of Fminibuffer_complete_and_exit. */
2047 /* This one is called by internal_condition_case to do the real work. */
2049 Lisp_Object
2050 complete_and_exit_1 ()
2052 return make_number (do_completion ());
2055 /* This one is called by internal_condition_case if an error happens.
2056 Pretend the current value is an exact match. */
2058 Lisp_Object
2059 complete_and_exit_2 (ignore)
2060 Lisp_Object ignore;
2062 return make_number (1);
2065 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
2066 Sminibuffer_complete_and_exit, 0, 0, "",
2067 doc: /* If the minibuffer contents is a valid completion then exit.
2068 Otherwise try to complete it. If completion leads to a valid completion,
2069 a repetition of this command will exit. */)
2072 register int i;
2073 Lisp_Object val;
2075 /* Allow user to specify null string */
2076 if (XINT (Fminibuffer_prompt_end ()) == ZV)
2077 goto exit;
2079 if (!NILP (Ftest_completion (Fminibuffer_contents (),
2080 Vminibuffer_completion_table,
2081 Vminibuffer_completion_predicate)))
2082 goto exit;
2084 /* Call do_completion, but ignore errors. */
2085 SET_PT (ZV);
2086 val = internal_condition_case (complete_and_exit_1, Qerror,
2087 complete_and_exit_2);
2089 i = XFASTINT (val);
2090 switch (i)
2092 case 1:
2093 case 3:
2094 goto exit;
2096 case 4:
2097 if (!NILP (Vminibuffer_completion_confirm))
2099 temp_echo_area_glyphs (build_string (" [Confirm]"));
2100 return Qnil;
2102 else
2103 goto exit;
2105 default:
2106 return Qnil;
2108 exit:
2109 return Fthrow (Qexit, Qnil);
2110 /* NOTREACHED */
2113 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word,
2114 0, 0, "",
2115 doc: /* Complete the minibuffer contents at most a single word.
2116 After one word is completed as much as possible, a space or hyphen
2117 is added, provided that matches some possible completion.
2118 Return nil if there is no valid completion, else t. */)
2121 Lisp_Object completion, tem, tem1;
2122 register int i, i_byte;
2123 register const unsigned char *completion_string;
2124 struct gcpro gcpro1, gcpro2;
2125 int prompt_end_charpos = XINT (Fminibuffer_prompt_end ());
2127 /* We keep calling Fbuffer_string rather than arrange for GC to
2128 hold onto a pointer to one of the strings thus made. */
2130 completion = Ftry_completion (minibuffer_completion_contents (),
2131 Vminibuffer_completion_table,
2132 Vminibuffer_completion_predicate);
2133 if (NILP (completion))
2135 bitch_at_user ();
2136 temp_echo_area_glyphs (build_string (" [No match]"));
2137 return Qnil;
2139 if (EQ (completion, Qt))
2140 return Qnil;
2142 #if 0 /* How the below code used to look, for reference. */
2143 tem = Fminibuffer_contents ();
2144 b = SDATA (tem);
2145 i = ZV - 1 - SCHARS (completion);
2146 p = SDATA (completion);
2147 if (i > 0 ||
2148 0 <= scmp (b, p, ZV - 1))
2150 i = 1;
2151 /* Set buffer to longest match of buffer tail and completion head. */
2152 while (0 <= scmp (b + i, p, ZV - 1 - i))
2153 i++;
2154 del_range (1, i + 1);
2155 SET_PT (ZV);
2157 #else /* Rewritten code */
2159 int buffer_nchars, completion_nchars;
2161 CHECK_STRING (completion);
2162 tem = minibuffer_completion_contents ();
2163 GCPRO2 (completion, tem);
2164 /* If reading a file name,
2165 expand any $ENVVAR refs in the buffer and in TEM. */
2166 if (! NILP (Vminibuffer_completing_file_name))
2168 Lisp_Object substituted;
2169 substituted = Fsubstitute_in_file_name (tem);
2170 if (! EQ (substituted, tem))
2172 tem = substituted;
2173 del_range (prompt_end_charpos, PT);
2174 Finsert (1, &tem);
2177 buffer_nchars = SCHARS (tem); /* # chars in what we completed. */
2178 completion_nchars = SCHARS (completion);
2179 i = buffer_nchars - completion_nchars;
2180 if (i > 0
2182 (tem1 = Fcompare_strings (tem, make_number (0),
2183 make_number (buffer_nchars),
2184 completion, make_number (0),
2185 make_number (buffer_nchars),
2186 completion_ignore_case ? Qt : Qnil),
2187 ! EQ (tem1, Qt)))
2189 int start_pos;
2191 /* Make buffer (before point) contain the longest match
2192 of TEM's tail and COMPLETION's head. */
2193 if (i <= 0) i = 1;
2194 start_pos= i;
2195 buffer_nchars -= i;
2196 while (i > 0)
2198 tem1 = Fcompare_strings (tem, make_number (start_pos), Qnil,
2199 completion, make_number (0),
2200 make_number (buffer_nchars),
2201 completion_ignore_case ? Qt : Qnil);
2202 start_pos++;
2203 if (EQ (tem1, Qt))
2204 break;
2205 i++;
2206 buffer_nchars--;
2208 del_range (start_pos, start_pos + buffer_nchars);
2210 UNGCPRO;
2212 #endif /* Rewritten code */
2215 int prompt_end_bytepos;
2216 prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos);
2217 i = PT - prompt_end_charpos;
2218 i_byte = PT_BYTE - prompt_end_bytepos;
2221 /* If completion finds next char not unique,
2222 consider adding a space or a hyphen. */
2223 if (i == SCHARS (completion))
2225 GCPRO1 (completion);
2226 tem = Ftry_completion (concat2 (minibuffer_completion_contents (),
2227 build_string (" ")),
2228 Vminibuffer_completion_table,
2229 Vminibuffer_completion_predicate);
2230 UNGCPRO;
2232 if (STRINGP (tem))
2233 completion = tem;
2234 else
2236 GCPRO1 (completion);
2237 tem =
2238 Ftry_completion (concat2 (minibuffer_completion_contents (),
2239 build_string ("-")),
2240 Vminibuffer_completion_table,
2241 Vminibuffer_completion_predicate);
2242 UNGCPRO;
2244 if (STRINGP (tem))
2245 completion = tem;
2249 /* Now find first word-break in the stuff found by completion.
2250 i gets index in string of where to stop completing. */
2252 int len, c;
2253 int bytes = SBYTES (completion);
2254 completion_string = SDATA (completion);
2255 for (; i_byte < SBYTES (completion); i_byte += len, i++)
2257 c = STRING_CHAR_AND_LENGTH (completion_string + i_byte,
2258 bytes - i_byte,
2259 len);
2260 if (SYNTAX (c) != Sword)
2262 i_byte += len;
2263 i++;
2264 break;
2269 /* If got no characters, print help for user. */
2271 if (i == PT - prompt_end_charpos)
2273 if (!NILP (Vcompletion_auto_help))
2274 Fminibuffer_completion_help ();
2275 return Qnil;
2278 /* Otherwise insert in minibuffer the chars we got */
2280 if (! NILP (Vminibuffer_completing_file_name)
2281 && SREF (completion, SBYTES (completion) - 1) == '/'
2282 && PT < ZV
2283 && FETCH_CHAR (PT_BYTE) == '/')
2285 del_range (prompt_end_charpos, PT + 1);
2287 else
2288 del_range (prompt_end_charpos, PT);
2290 insert_from_string (completion, 0, 0, i, i_byte, 1);
2291 return Qt;
2294 DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list,
2295 1, 1, 0,
2296 doc: /* Display the list of completions, COMPLETIONS, using `standard-output'.
2297 Each element may be just a symbol or string
2298 or may be a list of two strings to be printed as if concatenated.
2299 If it is a list of two strings, the first is the actual completion
2300 alternative, the second serves as annotation.
2301 `standard-output' must be a buffer.
2302 The actual completion alternatives, as inserted, are given `mouse-face'
2303 properties of `highlight'.
2304 At the end, this runs the normal hook `completion-setup-hook'.
2305 It can find the completion buffer in `standard-output'. */)
2306 (completions)
2307 Lisp_Object completions;
2309 Lisp_Object tail, elt;
2310 register int i;
2311 int column = 0;
2312 struct gcpro gcpro1, gcpro2;
2313 struct buffer *old = current_buffer;
2314 int first = 1;
2316 /* Note that (when it matters) every variable
2317 points to a non-string that is pointed to by COMPLETIONS,
2318 except for ELT. ELT can be pointing to a string
2319 when terpri or Findent_to calls a change hook. */
2320 elt = Qnil;
2321 GCPRO2 (completions, elt);
2323 if (BUFFERP (Vstandard_output))
2324 set_buffer_internal (XBUFFER (Vstandard_output));
2326 if (NILP (completions))
2327 write_string ("There are no possible completions of what you have typed.",
2328 -1);
2329 else
2331 write_string ("Possible completions are:", -1);
2332 for (tail = completions, i = 0; !NILP (tail); tail = Fcdr (tail), i++)
2334 Lisp_Object tem, string;
2335 int length;
2336 Lisp_Object startpos, endpos;
2338 startpos = Qnil;
2340 elt = Fcar (tail);
2341 if (SYMBOLP (elt))
2342 elt = SYMBOL_NAME (elt);
2343 /* Compute the length of this element. */
2344 if (CONSP (elt))
2346 tem = XCAR (elt);
2347 CHECK_STRING (tem);
2348 length = SCHARS (tem);
2350 tem = Fcar (XCDR (elt));
2351 CHECK_STRING (tem);
2352 length += SCHARS (tem);
2354 else
2356 CHECK_STRING (elt);
2357 length = SCHARS (elt);
2360 /* This does a bad job for narrower than usual windows.
2361 Sadly, the window it will appear in is not known
2362 until after the text has been made. */
2364 if (BUFFERP (Vstandard_output))
2365 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2367 /* If the previous completion was very wide,
2368 or we have two on this line already,
2369 don't put another on the same line. */
2370 if (column > 33 || first
2371 /* If this is really wide, don't put it second on a line. */
2372 || (column > 0 && length > 45))
2374 Fterpri (Qnil);
2375 column = 0;
2377 /* Otherwise advance to column 35. */
2378 else
2380 if (BUFFERP (Vstandard_output))
2382 tem = Findent_to (make_number (35), make_number (2));
2384 column = XINT (tem);
2386 else
2390 write_string (" ", -1);
2391 column++;
2393 while (column < 35);
2397 if (BUFFERP (Vstandard_output))
2399 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2400 Fset_text_properties (startpos, endpos,
2401 Qnil, Vstandard_output);
2404 /* Output this element.
2405 If necessary, convert it to unibyte or to multibyte first. */
2406 if (CONSP (elt))
2407 string = Fcar (elt);
2408 else
2409 string = elt;
2410 if (NILP (current_buffer->enable_multibyte_characters)
2411 && STRING_MULTIBYTE (string))
2412 string = Fstring_make_unibyte (string);
2413 else if (!NILP (current_buffer->enable_multibyte_characters)
2414 && !STRING_MULTIBYTE (string))
2415 string = Fstring_make_multibyte (string);
2417 if (BUFFERP (Vstandard_output))
2419 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2421 Fprinc (string, Qnil);
2423 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2425 Fput_text_property (startpos, endpos,
2426 Qmouse_face, intern ("highlight"),
2427 Vstandard_output);
2429 else
2431 Fprinc (string, Qnil);
2434 /* Output the annotation for this element. */
2435 if (CONSP (elt))
2437 if (BUFFERP (Vstandard_output))
2439 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output)));
2441 Fprinc (Fcar (Fcdr (elt)), Qnil);
2443 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output)));
2445 Fset_text_properties (startpos, endpos, Qnil,
2446 Vstandard_output);
2448 else
2450 Fprinc (Fcar (Fcdr (elt)), Qnil);
2455 /* Update COLUMN for what we have output. */
2456 column += length;
2458 /* If output is to a buffer, recompute COLUMN in a way
2459 that takes account of character widths. */
2460 if (BUFFERP (Vstandard_output))
2462 tem = Fcurrent_column ();
2463 column = XINT (tem);
2466 first = 0;
2470 UNGCPRO;
2472 if (BUFFERP (Vstandard_output))
2473 set_buffer_internal (old);
2475 if (!NILP (Vrun_hooks))
2476 call1 (Vrun_hooks, intern ("completion-setup-hook"));
2478 return Qnil;
2481 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
2482 0, 0, "",
2483 doc: /* Display a list of possible completions of the current minibuffer contents. */)
2486 Lisp_Object completions;
2488 message ("Making completion list...");
2489 completions = Fall_completions (minibuffer_completion_contents (),
2490 Vminibuffer_completion_table,
2491 Vminibuffer_completion_predicate,
2492 Qt);
2493 clear_message (1, 0);
2495 if (NILP (completions))
2497 bitch_at_user ();
2498 temp_echo_area_glyphs (build_string (" [No completions]"));
2500 else
2501 internal_with_output_to_temp_buffer ("*Completions*",
2502 Fdisplay_completion_list,
2503 Fsort (completions, Qstring_lessp));
2504 return Qnil;
2507 DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "",
2508 doc: /* Terminate minibuffer input. */)
2511 if (INTEGERP (last_command_char))
2512 internal_self_insert (XINT (last_command_char), 0);
2513 else
2514 bitch_at_user ();
2516 return Fthrow (Qexit, Qnil);
2519 DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
2520 doc: /* Terminate this minibuffer argument. */)
2523 return Fthrow (Qexit, Qnil);
2526 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
2527 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
2530 return make_number (minibuf_level);
2533 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
2534 doc: /* Return the prompt string of the currently-active minibuffer.
2535 If no minibuffer is active, return nil. */)
2538 return Fcopy_sequence (minibuf_prompt);
2542 /* Temporarily display STRING at the end of the current
2543 minibuffer contents. This is used to display things like
2544 "[No Match]" when the user requests a completion for a prefix
2545 that has no possible completions, and other quick, unobtrusive
2546 messages. */
2548 void
2549 temp_echo_area_glyphs (string)
2550 Lisp_Object string;
2552 int osize = ZV;
2553 int osize_byte = ZV_BYTE;
2554 int opoint = PT;
2555 int opoint_byte = PT_BYTE;
2556 Lisp_Object oinhibit;
2557 oinhibit = Vinhibit_quit;
2559 /* Clear out any old echo-area message to make way for our new thing. */
2560 message (0);
2562 SET_PT_BOTH (osize, osize_byte);
2563 insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0);
2564 SET_PT_BOTH (opoint, opoint_byte);
2565 Vinhibit_quit = Qt;
2566 Fsit_for (make_number (2), Qnil, Qnil);
2567 del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
2568 SET_PT_BOTH (opoint, opoint_byte);
2569 if (!NILP (Vquit_flag))
2571 Vquit_flag = Qnil;
2572 Vunread_command_events = Fcons (make_number (quit_char), Qnil);
2574 Vinhibit_quit = oinhibit;
2577 DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message,
2578 1, 1, 0,
2579 doc: /* Temporarily display STRING at the end of the minibuffer.
2580 The text is displayed for two seconds,
2581 or until the next input event arrives, whichever comes first. */)
2582 (string)
2583 Lisp_Object string;
2585 CHECK_STRING (string);
2586 temp_echo_area_glyphs (string);
2587 return Qnil;
2590 void
2591 init_minibuf_once ()
2593 Vminibuffer_list = Qnil;
2594 staticpro (&Vminibuffer_list);
2597 void
2598 syms_of_minibuf ()
2600 minibuf_level = 0;
2601 minibuf_prompt = Qnil;
2602 staticpro (&minibuf_prompt);
2604 minibuf_save_list = Qnil;
2605 staticpro (&minibuf_save_list);
2607 Qread_file_name_internal = intern ("read-file-name-internal");
2608 staticpro (&Qread_file_name_internal);
2610 Qminibuffer_default = intern ("minibuffer-default");
2611 staticpro (&Qminibuffer_default);
2612 Fset (Qminibuffer_default, Qnil);
2614 Qminibuffer_completion_table = intern ("minibuffer-completion-table");
2615 staticpro (&Qminibuffer_completion_table);
2617 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
2618 staticpro (&Qminibuffer_completion_confirm);
2620 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
2621 staticpro (&Qminibuffer_completion_predicate);
2623 staticpro (&last_exact_completion);
2624 last_exact_completion = Qnil;
2626 staticpro (&last_minibuf_string);
2627 last_minibuf_string = Qnil;
2629 Quser_variable_p = intern ("user-variable-p");
2630 staticpro (&Quser_variable_p);
2632 Qminibuffer_history = intern ("minibuffer-history");
2633 staticpro (&Qminibuffer_history);
2635 Qbuffer_name_history = intern ("buffer-name-history");
2636 staticpro (&Qbuffer_name_history);
2637 Fset (Qbuffer_name_history, Qnil);
2639 Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
2640 staticpro (&Qminibuffer_setup_hook);
2642 Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
2643 staticpro (&Qminibuffer_exit_hook);
2645 Qhistory_length = intern ("history-length");
2646 staticpro (&Qhistory_length);
2648 Qcurrent_input_method = intern ("current-input-method");
2649 staticpro (&Qcurrent_input_method);
2651 Qactivate_input_method = intern ("activate-input-method");
2652 staticpro (&Qactivate_input_method);
2654 Qcase_fold_search = intern ("case-fold-search");
2655 staticpro (&Qcase_fold_search);
2657 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
2658 doc: /* If this is non-nil, `read-buffer' does its work by calling this function. */);
2659 Vread_buffer_function = Qnil;
2661 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
2662 doc: /* Normal hook run just after entry to minibuffer. */);
2663 Vminibuffer_setup_hook = Qnil;
2665 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook,
2666 doc: /* Normal hook run just after exit from minibuffer. */);
2667 Vminibuffer_exit_hook = Qnil;
2669 DEFVAR_LISP ("history-length", &Vhistory_length,
2670 doc: /* *Maximum length for history lists before truncation takes place.
2671 A number means that length; t means infinite. Truncation takes place
2672 just after a new element is inserted. Setting the history-length
2673 property of a history variable overrides this default. */);
2674 XSETFASTINT (Vhistory_length, 30);
2676 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
2677 doc: /* *Non-nil means to delete duplicates in history.
2678 If set to t when adding a new history element, all previous identical
2679 elements are deleted. */);
2680 history_delete_duplicates = 0;
2682 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
2683 doc: /* *Non-nil means automatically provide help for invalid completion input. */);
2684 Vcompletion_auto_help = Qt;
2686 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
2687 doc: /* Non-nil means don't consider case significant in completion.
2689 See also `read-file-name-completion-ignore-case' concerning case significance
2690 in completion when reading a file name. */);
2691 completion_ignore_case = 0;
2693 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
2694 doc: /* *Non-nil means to allow minibuffer commands while in the minibuffer.
2695 This variable makes a difference whenever the minibuffer window is active. */);
2696 enable_recursive_minibuffers = 0;
2698 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
2699 doc: /* Alist or obarray used for completion in the minibuffer.
2700 This becomes the ALIST argument to `try-completion' and `all-completions'.
2701 The value can also be a list of strings or a hash table.
2703 The value may alternatively be a function, which is given three arguments:
2704 STRING, the current buffer contents;
2705 PREDICATE, the predicate for filtering possible matches;
2706 CODE, which says what kind of things to do.
2707 CODE can be nil, t or `lambda'.
2708 nil means to return the best completion of STRING, or nil if there is none.
2709 t means to return a list of all possible completions of STRING.
2710 `lambda' means to return t if STRING is a valid completion as it stands. */);
2711 Vminibuffer_completion_table = Qnil;
2713 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
2714 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */);
2715 Vminibuffer_completion_predicate = Qnil;
2717 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
2718 doc: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
2719 Vminibuffer_completion_confirm = Qnil;
2721 DEFVAR_LISP ("minibuffer-completing-file-name",
2722 &Vminibuffer_completing_file_name,
2723 doc: /* Non-nil means completing file names. */);
2724 Vminibuffer_completing_file_name = Qnil;
2726 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
2727 doc: /* Value that `help-form' takes on inside the minibuffer. */);
2728 Vminibuffer_help_form = Qnil;
2730 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
2731 doc: /* History list symbol to add minibuffer values to.
2732 Each string of minibuffer input, as it appears on exit from the minibuffer,
2733 is added with
2734 (set minibuffer-history-variable
2735 (cons STRING (symbol-value minibuffer-history-variable))) */);
2736 XSETFASTINT (Vminibuffer_history_variable, 0);
2738 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position,
2739 doc: /* Current position of redoing in the history list. */);
2740 Vminibuffer_history_position = Qnil;
2742 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
2743 doc: /* *Non-nil means entering the minibuffer raises the minibuffer's frame.
2744 Some uses of the echo area also raise that frame (since they use it too). */);
2745 minibuffer_auto_raise = 0;
2747 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
2748 doc: /* List of regexps that should restrict possible completions.
2749 The basic completion functions only consider a completion acceptable
2750 if it matches all regular expressions in this list, with
2751 `case-fold-search' bound to the value of `completion-ignore-case'.
2752 See Info node `(elisp)Basic Completion', for a description of these
2753 functions. */);
2754 Vcompletion_regexp_list = Qnil;
2756 DEFVAR_BOOL ("minibuffer-allow-text-properties",
2757 &minibuffer_allow_text_properties,
2758 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2759 This also affects `read-string', but it does not affect `read-minibuffer',
2760 `read-no-blanks-input', or any of the functions that do minibuffer input
2761 with completion; they always discard text properties. */);
2762 minibuffer_allow_text_properties = 0;
2764 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties,
2765 doc: /* Text properties that are added to minibuffer prompts.
2766 These are in addition to the basic `field' property, and stickiness
2767 properties. */);
2768 /* We use `intern' here instead of Qread_only to avoid
2769 initialization-order problems. */
2770 Vminibuffer_prompt_properties
2771 = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
2773 defsubr (&Sset_minibuffer_window);
2774 defsubr (&Sread_from_minibuffer);
2775 defsubr (&Seval_minibuffer);
2776 defsubr (&Sread_minibuffer);
2777 defsubr (&Sread_string);
2778 defsubr (&Sread_command);
2779 defsubr (&Sread_variable);
2780 defsubr (&Sread_buffer);
2781 defsubr (&Sread_no_blanks_input);
2782 defsubr (&Sminibuffer_depth);
2783 defsubr (&Sminibuffer_prompt);
2785 defsubr (&Sminibufferp);
2786 defsubr (&Sminibuffer_prompt_end);
2787 defsubr (&Sminibuffer_contents);
2788 defsubr (&Sminibuffer_contents_no_properties);
2789 defsubr (&Sdelete_minibuffer_contents);
2791 defsubr (&Stry_completion);
2792 defsubr (&Sall_completions);
2793 defsubr (&Stest_completion);
2794 defsubr (&Sassoc_string);
2795 defsubr (&Scompleting_read);
2796 defsubr (&Sminibuffer_complete);
2797 defsubr (&Sminibuffer_complete_word);
2798 defsubr (&Sminibuffer_complete_and_exit);
2799 defsubr (&Sdisplay_completion_list);
2800 defsubr (&Sminibuffer_completion_help);
2802 defsubr (&Sself_insert_and_exit);
2803 defsubr (&Sexit_minibuffer);
2805 defsubr (&Sminibuffer_message);
2808 void
2809 keys_of_minibuf ()
2811 initial_define_key (Vminibuffer_local_map, Ctl ('g'),
2812 "abort-recursive-edit");
2813 initial_define_key (Vminibuffer_local_map, Ctl ('m'),
2814 "exit-minibuffer");
2815 initial_define_key (Vminibuffer_local_map, Ctl ('j'),
2816 "exit-minibuffer");
2818 initial_define_key (Vminibuffer_local_ns_map, ' ',
2819 "exit-minibuffer");
2820 initial_define_key (Vminibuffer_local_ns_map, '\t',
2821 "exit-minibuffer");
2822 initial_define_key (Vminibuffer_local_ns_map, '?',
2823 "self-insert-and-exit");
2825 initial_define_key (Vminibuffer_local_completion_map, '\t',
2826 "minibuffer-complete");
2827 initial_define_key (Vminibuffer_local_completion_map, ' ',
2828 "minibuffer-complete-word");
2829 initial_define_key (Vminibuffer_local_completion_map, '?',
2830 "minibuffer-completion-help");
2832 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
2833 "minibuffer-complete-and-exit");
2834 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
2835 "minibuffer-complete-and-exit");
2838 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
2839 (do not change this comment) */