(Vminibuffer_exit_hook): New variable.
[emacs.git] / src / minibuf.c
blobddb8ae7d70a489ec9db20d5230377bbedeb48094
1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 #include <config.h>
22 #include "lisp.h"
23 #include "commands.h"
24 #include "buffer.h"
25 #include "dispextern.h"
26 #include "frame.h"
27 #include "window.h"
28 #include "syntax.h"
30 #define min(a, b) ((a) < (b) ? (a) : (b))
32 extern int quit_char;
34 /* List of buffers for use as minibuffers.
35 The first element of the list is used for the outermost minibuffer invocation,
36 the next element is used for a recursive minibuffer invocation, etc.
37 The list is extended at the end as deeped minibuffer recursions are encountered. */
38 Lisp_Object Vminibuffer_list;
40 struct minibuf_save_data
42 char *prompt;
43 int prompt_width;
44 Lisp_Object help_form;
45 Lisp_Object current_prefix_arg;
46 Lisp_Object history_position;
47 Lisp_Object history_variable;
50 int minibuf_save_vector_size;
51 struct minibuf_save_data *minibuf_save_vector;
53 /* Depth in minibuffer invocations. */
54 int minibuf_level;
56 /* Nonzero means display completion help for invalid input */
57 int auto_help;
59 /* Fread_minibuffer leaves the input here as a string. */
60 Lisp_Object last_minibuf_string;
62 /* Nonzero means let functions called when within a minibuffer
63 invoke recursive minibuffers (to read arguments, or whatever) */
64 int enable_recursive_minibuffers;
66 /* help-form is bound to this while in the minibuffer. */
68 Lisp_Object Vminibuffer_help_form;
70 /* Variable which is the history list to add minibuffer values to. */
72 Lisp_Object Vminibuffer_history_variable;
74 /* Current position in the history list (adjusted by M-n and M-p). */
76 Lisp_Object Vminibuffer_history_position;
78 Lisp_Object Qminibuffer_history;
80 Lisp_Object Qread_file_name_internal;
82 /* Normal hooks for entry to and exit from minibuffer. */
84 Lisp_Object Qminibuffer_setup_hook, Vminibuffer_setup_hook;
85 Lisp_Object Qminibuffer_exit_hook, Vminibuffer_exit_hook;
87 /* Nonzero means completion ignores case. */
89 int completion_ignore_case;
91 /* List of regexps that should restrict possible completions. */
93 Lisp_Object Vcompletion_regexp_list;
95 /* Nonzero means raise the minibuffer frame when the minibuffer
96 is entered. */
98 int minibuffer_auto_raise;
100 /* If last completion attempt reported "Complete but not unique"
101 then this is the string completed then; otherwise this is nil. */
103 static Lisp_Object last_exact_completion;
105 Lisp_Object Quser_variable_p;
107 /* Non-nil means it is the window for C-M-v to scroll
108 when the minibuffer is selected. */
109 extern Lisp_Object Vminibuf_scroll_window;
111 /* Actual minibuffer invocation. */
113 void read_minibuf_unwind ();
114 Lisp_Object get_minibuffer ();
115 Lisp_Object read_minibuf ();
117 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
118 (a string), putting point minus BACKUP_N chars from the end of INITIAL,
119 prompting with PROMPT (a string), using history list HISTVAR
120 with initial position HISTPOS. (BACKUP_N should be <= 0.)
122 Normally return the result as a string (the text that was read),
123 but if EXPFLAG is non-nil, read it and return the object read.
124 If HISTVAR is given, save the value read on that history only if it doesn't
125 match the front of that history list exactly. The value is pushed onto
126 the list as the string that was read, or as the object that resulted iff
127 EXPFLAG is non-nil. */
129 Lisp_Object
130 read_minibuf (map, initial, prompt, backup_n, expflag, histvar, histpos)
131 Lisp_Object map;
132 Lisp_Object initial;
133 Lisp_Object prompt;
134 Lisp_Object backup_n;
135 int expflag;
136 Lisp_Object histvar;
137 Lisp_Object histpos;
139 register Lisp_Object val;
140 int count = specpdl_ptr - specpdl;
141 Lisp_Object mini_frame;
142 struct gcpro gcpro1, gcpro2;
144 if (XTYPE (prompt) != Lisp_String)
145 prompt = build_string ("");
147 /* Emacs in -batch mode calls minibuffer: print the prompt. */
148 if (noninteractive && XTYPE (prompt) == Lisp_String)
149 printf ("%s", XSTRING (prompt)->data);
151 if (!enable_recursive_minibuffers
152 && minibuf_level > 0
153 && (EQ (selected_window, minibuf_window)))
154 #if 0
155 || selected_frame != XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window)))
156 #endif
157 error ("Command attempted to use minibuffer while in minibuffer");
159 if (minibuf_level == minibuf_save_vector_size)
160 minibuf_save_vector =
161 (struct minibuf_save_data *)
162 xrealloc (minibuf_save_vector,
163 (minibuf_save_vector_size *= 2)
164 * sizeof (struct minibuf_save_data));
165 minibuf_save_vector[minibuf_level].prompt = minibuf_prompt;
166 minibuf_save_vector[minibuf_level].prompt_width = minibuf_prompt_width;
167 minibuf_prompt_width = 0;
168 /* >> Why is this done this way rather than binding these variables? */
169 minibuf_save_vector[minibuf_level].help_form = Vhelp_form;
170 minibuf_save_vector[minibuf_level].current_prefix_arg = Vcurrent_prefix_arg;
171 minibuf_save_vector[minibuf_level].history_position = Vminibuffer_history_position;
172 minibuf_save_vector[minibuf_level].history_variable = Vminibuffer_history_variable;
173 GCPRO2 (minibuf_save_vector[minibuf_level].help_form,
174 minibuf_save_vector[minibuf_level].current_prefix_arg);
176 record_unwind_protect (Fset_window_configuration,
177 Fcurrent_window_configuration (Qnil));
179 /* If the minibuffer window is on a different frame, save that
180 frame's configuration too. */
181 #ifdef MULTI_FRAME
182 XSET (mini_frame, Lisp_Frame, WINDOW_FRAME (XWINDOW (minibuf_window)));
183 if (XFRAME (mini_frame) != selected_frame)
184 record_unwind_protect (Fset_window_configuration,
185 Fcurrent_window_configuration (mini_frame));
187 /* If the minibuffer is on an iconified or invisible frame,
188 make it visible now. */
189 Fmake_frame_visible (mini_frame);
191 if (minibuffer_auto_raise)
192 Fraise_frame (mini_frame);
193 #endif
195 val = current_buffer->directory;
196 Fset_buffer (get_minibuffer (minibuf_level));
198 /* The current buffer's default directory is usually the right thing
199 for our minibuffer here. However, if you're typing a command at
200 a minibuffer-only frame when minibuf_level is zero, then buf IS
201 the current_buffer, so reset_buffer leaves buf's default
202 directory unchanged. This is a bummer when you've just started
203 up Emacs and buf's default directory is Qnil. Here's a hack; can
204 you think of something better to do? Find another buffer with a
205 better directory, and use that one instead. */
206 if (XTYPE (val) == Lisp_String)
207 current_buffer->directory = val;
208 else
210 Lisp_Object buf_list;
212 for (buf_list = Vbuffer_alist;
213 CONSP (buf_list);
214 buf_list = XCONS (buf_list)->cdr)
216 Lisp_Object other_buf;
218 other_buf = XCONS (XCONS (buf_list)->car)->cdr;
219 if (XTYPE (XBUFFER (other_buf)->directory) == Lisp_String)
221 current_buffer->directory = XBUFFER (other_buf)->directory;
222 break;
227 #ifdef MULTI_FRAME
228 if (XFRAME (mini_frame) != selected_frame)
229 Fredirect_frame_focus (Fselected_frame (), mini_frame);
230 #endif
231 Fmake_local_variable (Qprint_escape_newlines);
232 print_escape_newlines = 1;
234 record_unwind_protect (read_minibuf_unwind, Qnil);
236 Vminibuf_scroll_window = selected_window;
237 Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
238 Fselect_window (minibuf_window);
239 XFASTINT (XWINDOW (minibuf_window)->hscroll) = 0;
241 Ferase_buffer ();
242 minibuf_level++;
244 if (!NILP (initial))
246 Finsert (1, &initial);
247 if (!NILP (backup_n) && XTYPE (backup_n) == Lisp_Int)
248 Fforward_char (backup_n);
251 minibuf_prompt = (char *) alloca (XSTRING (prompt)->size + 1);
252 bcopy (XSTRING (prompt)->data, minibuf_prompt, XSTRING (prompt)->size + 1);
253 echo_area_glyphs = 0;
255 Vhelp_form = Vminibuffer_help_form;
256 current_buffer->keymap = map;
257 Vminibuffer_history_position = histpos;
258 Vminibuffer_history_variable = histvar;
260 /* Run our hook, but not if it is empty.
261 (run-hooks would do nothing if it is empty,
262 but it's important to save time here in the usual case. */
263 if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
264 && !NILP (Vrun_hooks))
265 call1 (Vrun_hooks, Qminibuffer_setup_hook);
267 /* ??? MCC did redraw_screen here if switching screens. */
268 recursive_edit_1 ();
270 if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
271 && !NILP (Vrun_hooks))
272 call1 (Vrun_hooks, Qminibuffer_exit_hook);
274 /* If cursor is on the minibuffer line,
275 show the user we have exited by putting it in column 0. */
276 if ((FRAME_CURSOR_Y (selected_frame)
277 >= XFASTINT (XWINDOW (minibuf_window)->top))
278 && !noninteractive)
280 FRAME_CURSOR_X (selected_frame) = 0;
281 update_frame (selected_frame, 1, 1);
284 /* Make minibuffer contents into a string */
285 val = make_buffer_string (1, Z);
286 bcopy (GAP_END_ADDR, XSTRING (val)->data + GPT - BEG, Z - GPT);
288 /* VAL is the string of minibuffer text. */
289 last_minibuf_string = val;
291 /* Add the value to the appropriate history list. */
292 if (XTYPE (Vminibuffer_history_variable) == Lisp_Symbol
293 && ! EQ (XSYMBOL (Vminibuffer_history_variable)->value, Qunbound))
295 /* If the caller wanted to save the value read on a history list,
296 then do so if the value is not already the front of the list. */
297 Lisp_Object histval;
298 histval = Fsymbol_value (Vminibuffer_history_variable);
300 /* The value of the history variable must be a cons or nil. Other
301 values are unacceptable. We silently ignore these values. */
302 if (NILP (histval)
303 || (CONSP (histval)
304 && NILP (Fequal (last_minibuf_string, Fcar (histval)))))
305 Fset (Vminibuffer_history_variable,
306 Fcons (last_minibuf_string, histval));
309 /* If Lisp form desired instead of string, parse it. */
310 if (expflag)
312 Lisp_Object expr_and_pos;
313 unsigned char *p;
315 expr_and_pos = Fread_from_string (val, Qnil, Qnil);
316 /* Ignore trailing whitespace; any other trailing junk is an error. */
317 for (p = XSTRING (val)->data + XINT (Fcdr (expr_and_pos)); *p; p++)
318 if (*p != ' ' && *p != '\t' && *p != '\n')
319 error ("Trailing garbage following expression");
320 val = Fcar (expr_and_pos);
323 UNGCPRO;
324 return unbind_to (count, val); /* The appropriate frame will get selected
325 in set-window-configuration. */
328 /* Return a buffer to be used as the minibuffer at depth `depth'.
329 depth = 0 is the lowest allowed argument, and that is the value
330 used for nonrecursive minibuffer invocations */
332 Lisp_Object
333 get_minibuffer (depth)
334 int depth;
336 Lisp_Object tail, num, buf;
337 char name[24];
338 extern Lisp_Object nconc2 ();
340 XFASTINT (num) = depth;
341 tail = Fnthcdr (num, Vminibuffer_list);
342 if (NILP (tail))
344 tail = Fcons (Qnil, Qnil);
345 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
347 buf = Fcar (tail);
348 if (NILP (buf) || NILP (XBUFFER (buf)->name))
350 sprintf (name, " *Minibuf-%d*", depth);
351 buf = Fget_buffer_create (build_string (name));
353 /* Although the buffer's name starts with a space, undo should be
354 enabled in it. */
355 Fbuffer_enable_undo (buf);
357 XCONS (tail)->car = buf;
359 else
360 reset_buffer (XBUFFER (buf));
362 return buf;
365 /* This function is called on exiting minibuffer, whether normally or not,
366 and it restores the current window, buffer, etc. */
368 void
369 read_minibuf_unwind (data)
370 Lisp_Object data;
372 /* Erase the minibuffer we were using at this level. */
373 Fset_buffer (XWINDOW (minibuf_window)->buffer);
375 /* Prevent error in erase-buffer. */
376 current_buffer->read_only = Qnil;
377 Ferase_buffer ();
379 /* If this was a recursive minibuffer,
380 tie the minibuffer window back to the outer level minibuffer buffer */
381 minibuf_level--;
382 /* Make sure minibuffer window is erased, not ignored */
383 windows_or_buffers_changed++;
384 XFASTINT (XWINDOW (minibuf_window)->last_modified) = 0;
386 /* Restore prompt from outer minibuffer */
387 minibuf_prompt = minibuf_save_vector[minibuf_level].prompt;
388 minibuf_prompt_width = minibuf_save_vector[minibuf_level].prompt_width;
389 Vhelp_form = minibuf_save_vector[minibuf_level].help_form;
390 Vcurrent_prefix_arg = minibuf_save_vector[minibuf_level].current_prefix_arg;
391 Vminibuffer_history_position
392 = minibuf_save_vector[minibuf_level].history_position;
393 Vminibuffer_history_variable
394 = minibuf_save_vector[minibuf_level].history_variable;
398 /* This comment supplies the doc string for read-from-minibuffer,
399 for make-docfile to see. We cannot put this in the real DEFUN
400 due to limits in the Unix cpp.
402 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 5, 0,
403 "Read a string from the minibuffer, prompting with string PROMPT.\n\
404 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
405 to be inserted into the minibuffer before reading input.\n\
406 If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
407 is STRING, but point is placed POSITION characters into the string.\n\
408 Third arg KEYMAP is a keymap to use whilst reading;\n\
409 if omitted or nil, the default is `minibuffer-local-map'.\n\
410 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
411 and return that object:\n\
412 in other words, do `(car (read-from-string INPUT-STRING))'\n\
413 Fifth arg HIST, if non-nil, specifies a history list\n\
414 and optionally the initial position in the list.\n\
415 It can be a symbol, which is the history list variable to use,\n\
416 or it can be a cons cell (HISTVAR . HISTPOS).\n\
417 In that case, HISTVAR is the history list variable to use,\n\
418 and HISTPOS is the initial position (the position in the list\n\
419 which INITIAL-CONTENTS corresponds to).\n\
420 Positions are counted starting from 1 at the beginning of the list."
423 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 5, 0,
424 0 /* See immediately above */)
425 (prompt, initial_contents, keymap, read, hist)
426 Lisp_Object prompt, initial_contents, keymap, read, hist;
428 int pos = 0;
429 Lisp_Object histvar, histpos, position;
430 position = Qnil;
432 CHECK_STRING (prompt, 0);
433 if (!NILP (initial_contents))
435 if (XTYPE (initial_contents) == Lisp_Cons)
437 position = Fcdr (initial_contents);
438 initial_contents = Fcar (initial_contents);
440 CHECK_STRING (initial_contents, 1);
441 if (!NILP (position))
443 CHECK_NUMBER (position, 0);
444 /* Convert to distance from end of input. */
445 pos = XINT (position) - 1 - XSTRING (initial_contents)->size;
449 if (NILP (keymap))
450 keymap = Vminibuffer_local_map;
451 else
452 keymap = get_keymap (keymap,2);
454 if (XTYPE (hist) == Lisp_Symbol)
456 histvar = hist;
457 histpos = Qnil;
459 else
461 histvar = Fcar_safe (hist);
462 histpos = Fcdr_safe (hist);
464 if (NILP (histvar))
465 histvar = Qminibuffer_history;
466 if (NILP (histpos))
467 XFASTINT (histpos) = 0;
469 return read_minibuf (keymap, initial_contents, prompt,
470 make_number (pos), !NILP (read), histvar, histpos);
473 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
474 "Return a Lisp object read using the minibuffer.\n\
475 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
476 is a string to insert in the minibuffer before reading.")
477 (prompt, initial_contents)
478 Lisp_Object prompt, initial_contents;
480 CHECK_STRING (prompt, 0);
481 if (!NILP (initial_contents))
482 CHECK_STRING (initial_contents, 1);
483 return read_minibuf (Vminibuffer_local_map, initial_contents,
484 prompt, Qnil, 1, Qminibuffer_history, make_number (0));
487 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
488 "Return value of Lisp expression read using the minibuffer.\n\
489 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
490 is a string to insert in the minibuffer before reading.")
491 (prompt, initial_contents)
492 Lisp_Object prompt, initial_contents;
494 return Feval (Fread_minibuffer (prompt, initial_contents));
497 /* Functions that use the minibuffer to read various things. */
499 DEFUN ("read-string", Fread_string, Sread_string, 1, 2, 0,
500 "Read a string from the minibuffer, prompting with string PROMPT.\n\
501 If non-nil second arg INITIAL-INPUT is a string to insert before reading.")
502 (prompt, initial_input)
503 Lisp_Object prompt, initial_input;
505 return Fread_from_minibuffer (prompt, initial_input, Qnil, Qnil, Qnil);
508 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 2, 0,
509 "Args PROMPT and INIT, strings. Read a string from the terminal, not allowing blanks.\n\
510 Prompt with PROMPT, and provide INIT as an initial value of the input string.")
511 (prompt, init)
512 Lisp_Object prompt, init;
514 CHECK_STRING (prompt, 0);
515 if (! NILP (init))
516 CHECK_STRING (init, 1);
518 return read_minibuf (Vminibuffer_local_ns_map, init, prompt, Qnil, 0,
519 Qminibuffer_history, make_number (0));
522 DEFUN ("read-command", Fread_command, Sread_command, 1, 1, 0,
523 "One arg PROMPT, a string. Read the name of a command and return as a symbol.\n\
524 Prompts with PROMPT.")
525 (prompt)
526 Lisp_Object prompt;
528 return Fintern (Fcompleting_read (prompt, Vobarray, Qcommandp, Qt, Qnil, Qnil),
529 Qnil);
532 #ifdef NOTDEF
533 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
534 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
535 Prompts with PROMPT.")
536 (prompt)
537 Lisp_Object prompt;
539 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil),
540 Qnil);
542 #endif /* NOTDEF */
544 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 1, 0,
545 "One arg PROMPT, a string. Read the name of a user variable and return\n\
546 it as a symbol. Prompts with PROMPT.\n\
547 A user variable is one whose documentation starts with a `*' character.")
548 (prompt)
549 Lisp_Object prompt;
551 return Fintern (Fcompleting_read (prompt, Vobarray,
552 Quser_variable_p, Qt, Qnil, Qnil),
553 Qnil);
556 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
557 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
558 Prompts with PROMPT.\n\
559 Optional second arg is value to return if user enters an empty line.\n\
560 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
561 (prompt, def, require_match)
562 Lisp_Object prompt, def, require_match;
564 Lisp_Object tem;
565 Lisp_Object args[3];
566 struct gcpro gcpro1;
568 if (XTYPE (def) == Lisp_Buffer)
569 def = XBUFFER (def)->name;
570 if (!NILP (def))
572 args[0] = build_string ("%s(default %s) ");
573 args[1] = prompt;
574 args[2] = def;
575 prompt = Fformat (3, args);
577 GCPRO1 (def);
578 tem = Fcompleting_read (prompt, Vbuffer_alist, Qnil, require_match, Qnil, Qnil);
579 UNGCPRO;
580 if (XSTRING (tem)->size)
581 return tem;
582 return def;
585 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
586 "Return common substring of all completions of STRING in ALIST.\n\
587 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
588 All that match are compared together; the longest initial sequence\n\
589 common to all matches is returned as a string.\n\
590 If there is no match at all, nil is returned.\n\
591 For an exact match, t is returned.\n\
593 ALIST can be an obarray instead of an alist.\n\
594 Then the print names of all symbols in the obarray are the possible matches.\n\
596 ALIST can also be a function to do the completion itself.\n\
597 It receives three arguments: the values STRING, PREDICATE and nil.\n\
598 Whatever it returns becomes the value of `try-completion'.\n\
600 If optional third argument PREDICATE is non-nil,\n\
601 it is used to test each possible match.\n\
602 The match is a candidate only if PREDICATE returns non-nil.\n\
603 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
604 (string, alist, pred)
605 Lisp_Object string, alist, pred;
607 Lisp_Object bestmatch, tail, elt, eltstring;
608 int bestmatchsize;
609 int compare, matchsize;
610 int list = CONSP (alist) || NILP (alist);
611 int index, obsize;
612 int matchcount = 0;
613 Lisp_Object bucket, zero, end, tem;
614 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
616 CHECK_STRING (string, 0);
617 if (!list && XTYPE (alist) != Lisp_Vector)
618 return call3 (alist, string, pred, Qnil);
620 bestmatch = Qnil;
622 /* If ALIST is not a list, set TAIL just for gc pro. */
623 tail = alist;
624 if (! list)
626 index = 0;
627 obsize = XVECTOR (alist)->size;
628 bucket = XVECTOR (alist)->contents[index];
631 while (1)
633 /* Get the next element of the alist or obarray. */
634 /* Exit the loop if the elements are all used up. */
635 /* elt gets the alist element or symbol.
636 eltstring gets the name to check as a completion. */
638 if (list)
640 if (NILP (tail))
641 break;
642 elt = Fcar (tail);
643 eltstring = Fcar (elt);
644 tail = Fcdr (tail);
646 else
648 if (XFASTINT (bucket) != 0)
650 elt = bucket;
651 eltstring = Fsymbol_name (elt);
652 if (XSYMBOL (bucket)->next)
653 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
654 else
655 XFASTINT (bucket) = 0;
657 else if (++index >= obsize)
658 break;
659 else
661 bucket = XVECTOR (alist)->contents[index];
662 continue;
666 /* Is this element a possible completion? */
668 if (XTYPE (eltstring) == Lisp_String
669 && XSTRING (string)->size <= XSTRING (eltstring)->size
670 && 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
671 XSTRING (string)->size))
673 /* Yes. */
674 Lisp_Object regexps;
675 Lisp_Object zero;
676 XFASTINT (zero) = 0;
678 /* Ignore this element if it fails to match all the regexps. */
679 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
680 regexps = XCONS (regexps)->cdr)
682 tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
683 if (NILP (tem))
684 break;
686 if (CONSP (regexps))
687 continue;
689 /* Ignore this element if there is a predicate
690 and the predicate doesn't like it. */
692 if (!NILP (pred))
694 if (EQ (pred, Qcommandp))
695 tem = Fcommandp (elt);
696 else
698 GCPRO4 (tail, string, eltstring, bestmatch);
699 tem = call1 (pred, elt);
700 UNGCPRO;
702 if (NILP (tem)) continue;
705 /* Update computation of how much all possible completions match */
707 matchcount++;
708 if (NILP (bestmatch))
709 bestmatch = eltstring, bestmatchsize = XSTRING (eltstring)->size;
710 else
712 compare = min (bestmatchsize, XSTRING (eltstring)->size);
713 matchsize = scmp (XSTRING (bestmatch)->data,
714 XSTRING (eltstring)->data,
715 compare);
716 if (matchsize < 0)
717 matchsize = compare;
718 if (completion_ignore_case)
720 /* If this is an exact match except for case,
721 use it as the best match rather than one that is not an
722 exact match. This way, we get the case pattern
723 of the actual match. */
724 if ((matchsize == XSTRING (eltstring)->size
725 && matchsize < XSTRING (bestmatch)->size)
727 /* If there is more than one exact match ignoring case,
728 and one of them is exact including case,
729 prefer that one. */
730 /* If there is no exact match ignoring case,
731 prefer a match that does not change the case
732 of the input. */
733 ((matchsize == XSTRING (eltstring)->size)
735 (matchsize == XSTRING (bestmatch)->size)
736 && !bcmp (XSTRING (eltstring)->data,
737 XSTRING (string)->data, XSTRING (string)->size)
738 && bcmp (XSTRING (bestmatch)->data,
739 XSTRING (string)->data, XSTRING (string)->size)))
740 bestmatch = eltstring;
742 bestmatchsize = matchsize;
747 if (NILP (bestmatch))
748 return Qnil; /* No completions found */
749 /* If we are ignoring case, and there is no exact match,
750 and no additional text was supplied,
751 don't change the case of what the user typed. */
752 if (completion_ignore_case && bestmatchsize == XSTRING (string)->size
753 && XSTRING (bestmatch)->size > bestmatchsize)
754 return string;
756 /* Return t if the supplied string is an exact match (counting case);
757 it does not require any change to be made. */
758 if (matchcount == 1 && bestmatchsize == XSTRING (string)->size
759 && !bcmp (XSTRING (bestmatch)->data, XSTRING (string)->data,
760 bestmatchsize))
761 return Qt;
763 XFASTINT (zero) = 0; /* Else extract the part in which */
764 XFASTINT (end) = bestmatchsize; /* all completions agree */
765 return Fsubstring (bestmatch, zero, end);
768 /* Compare exactly LEN chars of strings at S1 and S2,
769 ignoring case if appropriate.
770 Return -1 if strings match,
771 else number of chars that match at the beginning. */
773 scmp (s1, s2, len)
774 register char *s1, *s2;
775 int len;
777 register int l = len;
779 if (completion_ignore_case)
781 while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
782 l--;
784 else
786 while (l && *s1++ == *s2++)
787 l--;
789 if (l == 0)
790 return -1;
791 else return len - l;
794 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 3, 0,
795 "Search for partial matches to STRING in ALIST.\n\
796 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
797 The value is a list of all the strings from ALIST that match.\n\
798 ALIST can be an obarray instead of an alist.\n\
799 Then the print names of all symbols in the obarray are the possible matches.\n\
801 ALIST can also be a function to do the completion itself.\n\
802 It receives three arguments: the values STRING, PREDICATE and t.\n\
803 Whatever it returns becomes the value of `all-completion'.\n\
805 If optional third argument PREDICATE is non-nil,\n\
806 it is used to test each possible match.\n\
807 The match is a candidate only if PREDICATE returns non-nil.\n\
808 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
809 (string, alist, pred)
810 Lisp_Object string, alist, pred;
812 Lisp_Object tail, elt, eltstring;
813 Lisp_Object allmatches;
814 int list = CONSP (alist) || NILP (alist);
815 int index, obsize;
816 Lisp_Object bucket, tem;
817 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
819 CHECK_STRING (string, 0);
820 if (!list && XTYPE (alist) != Lisp_Vector)
822 return call3 (alist, string, pred, Qt);
824 allmatches = Qnil;
826 /* If ALIST is not a list, set TAIL just for gc pro. */
827 tail = alist;
828 if (! list)
830 index = 0;
831 obsize = XVECTOR (alist)->size;
832 bucket = XVECTOR (alist)->contents[index];
835 while (1)
837 /* Get the next element of the alist or obarray. */
838 /* Exit the loop if the elements are all used up. */
839 /* elt gets the alist element or symbol.
840 eltstring gets the name to check as a completion. */
842 if (list)
844 if (NILP (tail))
845 break;
846 elt = Fcar (tail);
847 eltstring = Fcar (elt);
848 tail = Fcdr (tail);
850 else
852 if (XFASTINT (bucket) != 0)
854 elt = bucket;
855 eltstring = Fsymbol_name (elt);
856 if (XSYMBOL (bucket)->next)
857 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
858 else
859 XFASTINT (bucket) = 0;
861 else if (++index >= obsize)
862 break;
863 else
865 bucket = XVECTOR (alist)->contents[index];
866 continue;
870 /* Is this element a possible completion? */
872 if (XTYPE (eltstring) == Lisp_String
873 && XSTRING (string)->size <= XSTRING (eltstring)->size
874 /* Reject alternatives that start with space
875 unless the input starts with space. */
876 && ((XSTRING (string)->size > 0 && XSTRING (string)->data[0] == ' ')
877 || XSTRING (eltstring)->data[0] != ' ')
878 && 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
879 XSTRING (string)->size))
881 /* Yes. */
882 Lisp_Object regexps;
883 Lisp_Object zero;
884 XFASTINT (zero) = 0;
886 /* Ignore this element if it fails to match all the regexps. */
887 for (regexps = Vcompletion_regexp_list; CONSP (regexps);
888 regexps = XCONS (regexps)->cdr)
890 tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
891 if (NILP (tem))
892 break;
894 if (CONSP (regexps))
895 continue;
897 /* Ignore this element if there is a predicate
898 and the predicate doesn't like it. */
900 if (!NILP (pred))
902 if (EQ (pred, Qcommandp))
903 tem = Fcommandp (elt);
904 else
906 GCPRO4 (tail, eltstring, allmatches, string);
907 tem = call1 (pred, elt);
908 UNGCPRO;
910 if (NILP (tem)) continue;
912 /* Ok => put it on the list. */
913 allmatches = Fcons (eltstring, allmatches);
917 return Fnreverse (allmatches);
920 Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
921 Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
922 Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
924 /* This comment supplies the doc string for completing-read,
925 for make-docfile to see. We cannot put this in the real DEFUN
926 due to limits in the Unix cpp.
928 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 6, 0,
929 "Read a string in the minibuffer, with completion.\n\
930 Args: PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST.\n\
931 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
932 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
933 PREDICATE limits completion to a subset of TABLE.\n\
934 See `try-completion' for more details on completion, TABLE, and PREDICATE.\n\
935 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
936 the input is (or completes to) an element of TABLE.\n\
937 If it is also not t, Return does not exit if it does non-null completion.\n\
938 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
939 If it is (STRING . POSITION), the initial input\n\
940 is STRING, but point is placed POSITION characters into the string.\n\
941 HIST, if non-nil, specifies a history list\n\
942 and optionally the initial position in the list.\n\
943 It can be a symbol, which is the history list variable to use,\n\
944 or it can be a cons cell (HISTVAR . HISTPOS).\n\
945 In that case, HISTVAR is the history list variable to use,\n\
946 and HISTPOS is the initial position (the position in the list\n\
947 which INITIAL-CONTENTS corresponds to).\n\
948 Positions are counted starting from 1 at the beginning of the list.\n\
949 Completion ignores case if the ambient value of\n\
950 `completion-ignore-case' is non-nil."
952 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 6, 0,
953 0 /* See immediately above */)
954 (prompt, table, pred, require_match, init, hist)
955 Lisp_Object prompt, table, pred, require_match, init, hist;
957 Lisp_Object val, histvar, histpos, position;
958 int pos = 0;
959 int count = specpdl_ptr - specpdl;
960 specbind (Qminibuffer_completion_table, table);
961 specbind (Qminibuffer_completion_predicate, pred);
962 specbind (Qminibuffer_completion_confirm,
963 EQ (require_match, Qt) ? Qnil : Qt);
964 last_exact_completion = Qnil;
966 position = Qnil;
967 if (!NILP (init))
969 if (XTYPE (init) == Lisp_Cons)
971 position = Fcdr (init);
972 init = Fcar (init);
974 CHECK_STRING (init, 0);
975 if (!NILP (position))
977 CHECK_NUMBER (position, 0);
978 /* Convert to distance from end of input. */
979 pos = XINT (position) - XSTRING (init)->size;
983 if (XTYPE (hist) == Lisp_Symbol)
985 histvar = hist;
986 histpos = Qnil;
988 else
990 histvar = Fcar_safe (hist);
991 histpos = Fcdr_safe (hist);
993 if (NILP (histvar))
994 histvar = Qminibuffer_history;
995 if (NILP (histpos))
996 XFASTINT (histpos) = 0;
998 val = read_minibuf (NILP (require_match)
999 ? Vminibuffer_local_completion_map
1000 : Vminibuffer_local_must_match_map,
1001 init, prompt, make_number (pos), 0,
1002 histvar, histpos);
1003 return unbind_to (count, val);
1006 /* Temporarily display the string M at the end of the current
1007 minibuffer contents. This is used to display things like
1008 "[No Match]" when the user requests a completion for a prefix
1009 that has no possible completions, and other quick, unobtrusive
1010 messages. */
1012 temp_echo_area_glyphs (m)
1013 char *m;
1015 int osize = ZV;
1016 Lisp_Object oinhibit;
1017 oinhibit = Vinhibit_quit;
1019 /* Clear out any old echo-area message to make way for our new thing. */
1020 message (0);
1022 SET_PT (osize);
1023 insert_string (m);
1024 SET_PT (osize);
1025 Vinhibit_quit = Qt;
1026 Fsit_for (make_number (2), Qnil, Qnil);
1027 del_range (PT, ZV);
1028 if (!NILP (Vquit_flag))
1030 Vquit_flag = Qnil;
1031 unread_command_events = Fcons (make_number (quit_char), Qnil);
1033 Vinhibit_quit = oinhibit;
1036 Lisp_Object Fminibuffer_completion_help ();
1037 Lisp_Object assoc_for_completion ();
1039 /* returns:
1040 * 0 no possible completion
1041 * 1 was already an exact and unique completion
1042 * 3 was already an exact completion
1043 * 4 completed to an exact completion
1044 * 5 some completion happened
1045 * 6 no completion happened
1048 do_completion ()
1050 Lisp_Object completion, tem;
1051 int completedp;
1052 Lisp_Object last;
1053 struct gcpro gcpro1, gcpro2;
1055 GCPRO2 (completion, last);
1056 completion = Ftry_completion (Fbuffer_string (), Vminibuffer_completion_table,
1057 Vminibuffer_completion_predicate);
1058 last = last_exact_completion;
1059 last_exact_completion = Qnil;
1061 if (NILP (completion))
1063 bitch_at_user ();
1064 temp_echo_area_glyphs (" [No match]");
1065 UNGCPRO;
1066 return 0;
1069 if (EQ (completion, Qt)) /* exact and unique match */
1071 UNGCPRO;
1072 return 1;
1075 /* compiler bug */
1076 tem = Fstring_equal (completion, Fbuffer_string());
1077 if (completedp = NILP (tem))
1079 Ferase_buffer (); /* Some completion happened */
1080 Finsert (1, &completion);
1083 /* It did find a match. Do we match some possibility exactly now? */
1084 if (CONSP (Vminibuffer_completion_table)
1085 || NILP (Vminibuffer_completion_table))
1086 tem = assoc_for_completion (Fbuffer_string (),
1087 Vminibuffer_completion_table);
1088 else if (XTYPE (Vminibuffer_completion_table) == Lisp_Vector)
1090 /* the primitive used by Fintern_soft */
1091 extern Lisp_Object oblookup ();
1093 tem = Fbuffer_string ();
1094 /* Bypass intern-soft as that loses for nil */
1095 tem = oblookup (Vminibuffer_completion_table,
1096 XSTRING (tem)->data, XSTRING (tem)->size);
1097 if (XTYPE (tem) != Lisp_Symbol)
1098 tem = Qnil;
1099 else if (!NILP (Vminibuffer_completion_predicate))
1100 tem = call1 (Vminibuffer_completion_predicate, tem);
1101 else
1102 tem = Qt;
1104 else
1105 tem = call3 (Vminibuffer_completion_table,
1106 Fbuffer_string (),
1107 Vminibuffer_completion_predicate,
1108 Qlambda);
1110 if (NILP (tem))
1112 /* not an exact match */
1113 UNGCPRO;
1114 if (completedp)
1115 return 5;
1116 else if (auto_help)
1117 Fminibuffer_completion_help ();
1118 else
1119 temp_echo_area_glyphs (" [Next char not unique]");
1120 return 6;
1122 else if (completedp)
1124 UNGCPRO;
1125 return 4;
1127 /* If the last exact completion and this one were the same,
1128 it means we've already given a "Complete but not unique"
1129 message and the user's hit TAB again, so now we give him help. */
1130 last_exact_completion = completion;
1131 if (!NILP (last))
1133 tem = Fbuffer_string ();
1134 if (!NILP (Fequal (tem, last)))
1135 Fminibuffer_completion_help ();
1137 UNGCPRO;
1138 return 3;
1141 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1143 Lisp_Object
1144 assoc_for_completion (key, list)
1145 register Lisp_Object key;
1146 Lisp_Object list;
1148 register Lisp_Object tail;
1150 if (completion_ignore_case)
1151 key = Fupcase (key);
1153 for (tail = list; !NILP (tail); tail = Fcdr (tail))
1155 register Lisp_Object elt, tem, thiscar;
1156 elt = Fcar (tail);
1157 if (!CONSP (elt)) continue;
1158 thiscar = Fcar (elt);
1159 if (XTYPE (thiscar) != Lisp_String)
1160 continue;
1161 if (completion_ignore_case)
1162 thiscar = Fupcase (thiscar);
1163 tem = Fequal (thiscar, key);
1164 if (!NILP (tem)) return elt;
1165 QUIT;
1167 return Qnil;
1170 DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "",
1171 "Complete the minibuffer contents as far as possible.\n\
1172 Return nil if there is no valid completion, else t.\n\
1173 If no characters can be completed, display a list of possible completions.\n\
1174 If you repeat this command after it displayed such a list,\n\
1175 scroll the window of possible completions.")
1178 register int i;
1179 Lisp_Object window, tem;
1181 /* If the previous command was not this, then mark the completion
1182 buffer obsolete. */
1183 if (! EQ (last_command, this_command))
1184 Vminibuf_scroll_window = Qnil;
1186 window = Vminibuf_scroll_window;
1187 /* If there's a fresh completion window with a live buffer,
1188 and this command is repeated, scroll that window. */
1189 if (! NILP (window) && ! NILP (XWINDOW (window)->buffer)
1190 && !NILP (XBUFFER (XWINDOW (window)->buffer)->name))
1192 struct buffer *obuf = current_buffer;
1194 Fset_buffer (XWINDOW (window)->buffer);
1195 tem = Fpos_visible_in_window_p (make_number (ZV), window);
1196 if (! NILP (tem))
1197 /* If end is in view, scroll up to the beginning. */
1198 Fset_window_start (window, BEGV);
1199 else
1200 /* Else scroll down one screen. */
1201 Fscroll_other_window (Qnil);
1203 set_buffer_internal (obuf);
1204 return Qnil;
1207 i = do_completion ();
1208 switch (i)
1210 case 0:
1211 return Qnil;
1213 case 1:
1214 temp_echo_area_glyphs (" [Sole completion]");
1215 break;
1217 case 3:
1218 temp_echo_area_glyphs (" [Complete, but not unique]");
1219 break;
1222 return Qt;
1225 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
1226 Sminibuffer_complete_and_exit, 0, 0, "",
1227 "Complete the minibuffer contents, and maybe exit.\n\
1228 Exit if the name is valid with no completion needed.\n\
1229 If name was completed to a valid match,\n\
1230 a repetition of this command will exit.")
1233 register int i;
1235 /* Allow user to specify null string */
1236 if (BEGV == ZV)
1237 goto exit;
1239 i = do_completion ();
1240 switch (i)
1242 case 1:
1243 case 3:
1244 goto exit;
1246 case 4:
1247 if (!NILP (Vminibuffer_completion_confirm))
1249 temp_echo_area_glyphs (" [Confirm]");
1250 return Qnil;
1252 else
1253 goto exit;
1255 default:
1256 return Qnil;
1258 exit:
1259 Fthrow (Qexit, Qnil);
1260 /* NOTREACHED */
1263 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word,
1264 0, 0, "",
1265 "Complete the minibuffer contents at most a single word.\n\
1266 After one word is completed as much as possible, a space or hyphen\n\
1267 is added, provided that matches some possible completion.\n\
1268 Return nil if there is no valid completion, else t.")
1271 Lisp_Object completion, tem;
1272 register int i;
1273 register unsigned char *completion_string;
1274 struct gcpro gcpro1;
1276 /* We keep calling Fbuffer_string rather than arrange for GC to
1277 hold onto a pointer to one of the strings thus made. */
1279 completion = Ftry_completion (Fbuffer_string (),
1280 Vminibuffer_completion_table,
1281 Vminibuffer_completion_predicate);
1282 if (NILP (completion))
1284 bitch_at_user ();
1285 temp_echo_area_glyphs (" [No match]");
1286 return Qnil;
1288 if (EQ (completion, Qt))
1289 return Qnil;
1291 #if 0 /* How the below code used to look, for reference. */
1292 tem = Fbuffer_string ();
1293 b = XSTRING (tem)->data;
1294 i = ZV - 1 - XSTRING (completion)->size;
1295 p = XSTRING (completion)->data;
1296 if (i > 0 ||
1297 0 <= scmp (b, p, ZV - 1))
1299 i = 1;
1300 /* Set buffer to longest match of buffer tail and completion head. */
1301 while (0 <= scmp (b + i, p, ZV - 1 - i))
1302 i++;
1303 del_range (1, i + 1);
1304 SET_PT (ZV);
1306 #else /* Rewritten code */
1308 register unsigned char *buffer_string;
1309 int buffer_length, completion_length;
1311 tem = Fbuffer_string ();
1312 /* If reading a file name,
1313 expand any $ENVVAR refs in the buffer and in TEM. */
1314 if (EQ (Vminibuffer_completion_table, Qread_file_name_internal))
1316 Lisp_Object substituted;
1317 substituted = Fsubstitute_in_file_name (tem);
1318 if (! EQ (substituted, tem))
1320 tem = substituted;
1321 Ferase_buffer ();
1322 insert_from_string (tem, 0, XSTRING (tem)->size, 0);
1325 buffer_string = XSTRING (tem)->data;
1326 completion_string = XSTRING (completion)->data;
1327 buffer_length = XSTRING (tem)->size; /* ie ZV - BEGV */
1328 completion_length = XSTRING (completion)->size;
1329 i = buffer_length - completion_length;
1330 /* Mly: I don't understand what this is supposed to do AT ALL */
1331 if (i > 0 ||
1332 0 <= scmp (buffer_string, completion_string, buffer_length))
1334 /* Set buffer to longest match of buffer tail and completion head. */
1335 if (i <= 0) i = 1;
1336 buffer_string += i;
1337 buffer_length -= i;
1338 while (0 <= scmp (buffer_string++, completion_string, buffer_length--))
1339 i++;
1340 del_range (1, i + 1);
1341 SET_PT (ZV);
1344 #endif /* Rewritten code */
1345 i = ZV - BEGV;
1347 /* If completion finds next char not unique,
1348 consider adding a space or a hyphen. */
1349 if (i == XSTRING (completion)->size)
1351 GCPRO1 (completion);
1352 tem = Ftry_completion (concat2 (Fbuffer_string (), build_string (" ")),
1353 Vminibuffer_completion_table,
1354 Vminibuffer_completion_predicate);
1355 UNGCPRO;
1357 if (XTYPE (tem) == Lisp_String)
1358 completion = tem;
1359 else
1361 GCPRO1 (completion);
1362 tem =
1363 Ftry_completion (concat2 (Fbuffer_string (), build_string ("-")),
1364 Vminibuffer_completion_table,
1365 Vminibuffer_completion_predicate);
1366 UNGCPRO;
1368 if (XTYPE (tem) == Lisp_String)
1369 completion = tem;
1373 /* Now find first word-break in the stuff found by completion.
1374 i gets index in string of where to stop completing. */
1376 completion_string = XSTRING (completion)->data;
1378 for (; i < XSTRING (completion)->size; i++)
1379 if (SYNTAX (completion_string[i]) != Sword) break;
1380 if (i < XSTRING (completion)->size)
1381 i = i + 1;
1383 /* If got no characters, print help for user. */
1385 if (i == ZV - BEGV)
1387 if (auto_help)
1388 Fminibuffer_completion_help ();
1389 return Qnil;
1392 /* Otherwise insert in minibuffer the chars we got */
1394 Ferase_buffer ();
1395 insert_from_string (completion, 0, i, 1);
1396 return Qt;
1399 DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list,
1400 1, 1, 0,
1401 "Display the list of completions, COMPLETIONS, using `standard-output'.\n\
1402 Each element may be just a symbol or string\n\
1403 or may be a list of two strings to be printed as if concatenated.\n\
1404 `standard-output' must be a buffer.\n\
1405 At the end, run the normal hook `completion-setup-hook'.\n\
1406 It can find the completion buffer in `standard-output'.")
1407 (completions)
1408 Lisp_Object completions;
1410 register Lisp_Object tail, elt;
1411 register int i;
1412 int column = 0;
1413 /* No GCPRO needed, since (when it matters) every variable
1414 points to a non-string that is pointed to by COMPLETIONS. */
1415 struct buffer *old = current_buffer;
1416 if (XTYPE (Vstandard_output) == Lisp_Buffer)
1417 set_buffer_internal (XBUFFER (Vstandard_output));
1419 if (NILP (completions))
1420 write_string ("There are no possible completions of what you have typed.",
1421 -1);
1422 else
1424 write_string ("Possible completions are:", -1);
1425 for (tail = completions, i = 0; !NILP (tail); tail = Fcdr (tail), i++)
1427 /* this needs fixing for the case of long completions
1428 and/or narrow windows */
1429 /* Sadly, the window it will appear in is not known
1430 until after the text has been made. */
1431 if (i & 1)
1433 if (XTYPE (Vstandard_output) == Lisp_Buffer)
1434 Findent_to (make_number (35), make_number (1));
1435 else
1439 write_string (" ", -1);
1440 column++;
1442 while (column < 35);
1445 else
1447 Fterpri (Qnil);
1448 column = 0;
1450 elt = Fcar (tail);
1451 if (CONSP (elt))
1453 if (XTYPE (Vstandard_output) != Lisp_Buffer)
1455 Lisp_Object tem;
1456 tem = Flength (Fcar (elt));
1457 column += XINT (tem);
1458 tem = Flength (Fcar (Fcdr (elt)));
1459 column += XINT (tem);
1461 Fprinc (Fcar (elt), Qnil);
1462 Fprinc (Fcar (Fcdr (elt)), Qnil);
1464 else
1466 if (XTYPE (Vstandard_output) != Lisp_Buffer)
1468 Lisp_Object tem;
1469 tem = Flength (elt);
1470 column += XINT (tem);
1472 Fprinc (elt, Qnil);
1477 if (XTYPE (Vstandard_output) == Lisp_Buffer)
1478 set_buffer_internal (old);
1480 if (!NILP (Vrun_hooks))
1481 call1 (Vrun_hooks, intern ("completion-setup-hook"));
1483 return Qnil;
1486 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
1487 0, 0, "",
1488 "Display a list of possible completions of the current minibuffer contents.")
1491 Lisp_Object completions;
1493 message ("Making completion list...");
1494 completions = Fall_completions (Fbuffer_string (),
1495 Vminibuffer_completion_table,
1496 Vminibuffer_completion_predicate);
1497 echo_area_glyphs = 0;
1499 if (NILP (completions))
1501 bitch_at_user ();
1502 temp_echo_area_glyphs (" [No completions]");
1504 else
1505 internal_with_output_to_temp_buffer ("*Completions*",
1506 Fdisplay_completion_list,
1507 Fsort (completions, Qstring_lessp));
1508 return Qnil;
1511 DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "",
1512 "Terminate minibuffer input.")
1515 if (XTYPE (last_command_char) == Lisp_Int)
1516 internal_self_insert (last_command_char, 0);
1517 else
1518 bitch_at_user ();
1520 Fthrow (Qexit, Qnil);
1523 DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
1524 "Terminate this minibuffer argument.")
1527 Fthrow (Qexit, Qnil);
1530 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
1531 "Return current depth of activations of minibuffer, a nonnegative integer.")
1534 return make_number (minibuf_level);
1537 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
1538 "Return the prompt string of the currently-active minibuffer.\n\
1539 If no minibuffer is active, return nil.")
1542 if (!minibuf_prompt)
1543 return Qnil;
1544 return build_string (minibuf_prompt);
1547 DEFUN ("minibuffer-prompt-width", Fminibuffer_prompt_width,
1548 Sminibuffer_prompt_width, 0, 0, 0,
1549 "Return the display width of the minibuffer prompt.")
1552 Lisp_Object width;
1553 XFASTINT (width) = minibuf_prompt_width;
1554 return width;
1557 init_minibuf_once ()
1559 Vminibuffer_list = Qnil;
1560 staticpro (&Vminibuffer_list);
1563 syms_of_minibuf ()
1565 minibuf_level = 0;
1566 minibuf_prompt = 0;
1567 minibuf_save_vector_size = 5;
1568 minibuf_save_vector = (struct minibuf_save_data *) malloc (5 * sizeof (struct minibuf_save_data));
1570 Qread_file_name_internal = intern ("read-file-name-internal");
1571 staticpro (&Qread_file_name_internal);
1573 Qminibuffer_completion_table = intern ("minibuffer-completion-table");
1574 staticpro (&Qminibuffer_completion_table);
1576 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
1577 staticpro (&Qminibuffer_completion_confirm);
1579 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
1580 staticpro (&Qminibuffer_completion_predicate);
1582 staticpro (&last_exact_completion);
1583 last_exact_completion = Qnil;
1585 staticpro (&last_minibuf_string);
1586 last_minibuf_string = Qnil;
1588 Quser_variable_p = intern ("user-variable-p");
1589 staticpro (&Quser_variable_p);
1591 Qminibuffer_history = intern ("minibuffer-history");
1592 staticpro (&Qminibuffer_history);
1594 Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
1595 staticpro (&Qminibuffer_setup_hook);
1597 Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
1598 staticpro (&Qminibuffer_exit_hook);
1600 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
1601 "Normal hook run just after entry to minibuffer.");
1602 Vminibuffer_setup_hook = Qnil;
1604 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook,
1605 "Normal hook run just after exit from minibuffer.");
1606 Vminibuffer_exit_hook = Qnil;
1608 DEFVAR_BOOL ("completion-auto-help", &auto_help,
1609 "*Non-nil means automatically provide help for invalid completion input.");
1610 auto_help = 1;
1612 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
1613 "Non-nil means don't consider case significant in completion.");
1614 completion_ignore_case = 0;
1616 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
1617 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
1618 More precisely, this variable makes a difference when the minibuffer window\n\
1619 is the selected window. If you are in some other window, minibuffer commands\n\
1620 are allowed even if a minibuffer is active.");
1621 enable_recursive_minibuffers = 0;
1623 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
1624 "Alist or obarray used for completion in the minibuffer.\n\
1625 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
1627 The value may alternatively be a function, which is given three arguments:\n\
1628 STRING, the current buffer contents;\n\
1629 PREDICATE, the predicate for filtering possible matches;\n\
1630 CODE, which says what kind of things to do.\n\
1631 CODE can be nil, t or `lambda'.\n\
1632 nil means to return the best completion of STRING, or nil if there is none.\n\
1633 t means to return a list of all possible completions of STRING.\n\
1634 `lambda' means to return t if STRING is a valid completion as it stands.");
1635 Vminibuffer_completion_table = Qnil;
1637 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
1638 "Within call to `completing-read', this holds the PREDICATE argument.");
1639 Vminibuffer_completion_predicate = Qnil;
1641 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
1642 "Non-nil => demand confirmation of completion before exiting minibuffer.");
1643 Vminibuffer_completion_confirm = Qnil;
1645 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
1646 "Value that `help-form' takes on inside the minibuffer.");
1647 Vminibuffer_help_form = Qnil;
1649 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable,
1650 "History list symbol to add minibuffer values to.\n\
1651 Each minibuffer output is added with\n\
1652 (set minibuffer-history-variable\n\
1653 (cons STRING (symbol-value minibuffer-history-variable)))");
1654 XFASTINT (Vminibuffer_history_variable) = 0;
1656 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position,
1657 "Current position of redoing in the history list.");
1658 Vminibuffer_history_position = Qnil;
1660 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise,
1661 "*Non-nil means entering the minibuffer raises the minibuffer's frame.");
1662 minibuffer_auto_raise = 0;
1664 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list,
1665 "List of regexps that should restrict possible completions.");
1666 Vcompletion_regexp_list = Qnil;
1668 defsubr (&Sread_from_minibuffer);
1669 defsubr (&Seval_minibuffer);
1670 defsubr (&Sread_minibuffer);
1671 defsubr (&Sread_string);
1672 defsubr (&Sread_command);
1673 defsubr (&Sread_variable);
1674 defsubr (&Sread_buffer);
1675 defsubr (&Sread_no_blanks_input);
1676 defsubr (&Sminibuffer_depth);
1677 defsubr (&Sminibuffer_prompt);
1678 defsubr (&Sminibuffer_prompt_width);
1680 defsubr (&Stry_completion);
1681 defsubr (&Sall_completions);
1682 defsubr (&Scompleting_read);
1683 defsubr (&Sminibuffer_complete);
1684 defsubr (&Sminibuffer_complete_word);
1685 defsubr (&Sminibuffer_complete_and_exit);
1686 defsubr (&Sdisplay_completion_list);
1687 defsubr (&Sminibuffer_completion_help);
1689 defsubr (&Sself_insert_and_exit);
1690 defsubr (&Sexit_minibuffer);
1694 keys_of_minibuf ()
1696 initial_define_key (Vminibuffer_local_map, Ctl ('g'),
1697 "abort-recursive-edit");
1698 initial_define_key (Vminibuffer_local_map, Ctl ('m'),
1699 "exit-minibuffer");
1700 initial_define_key (Vminibuffer_local_map, Ctl ('j'),
1701 "exit-minibuffer");
1703 initial_define_key (Vminibuffer_local_ns_map, Ctl ('g'),
1704 "abort-recursive-edit");
1705 initial_define_key (Vminibuffer_local_ns_map, Ctl ('m'),
1706 "exit-minibuffer");
1707 initial_define_key (Vminibuffer_local_ns_map, Ctl ('j'),
1708 "exit-minibuffer");
1710 initial_define_key (Vminibuffer_local_ns_map, ' ',
1711 "exit-minibuffer");
1712 initial_define_key (Vminibuffer_local_ns_map, '\t',
1713 "exit-minibuffer");
1714 initial_define_key (Vminibuffer_local_ns_map, '?',
1715 "self-insert-and-exit");
1717 initial_define_key (Vminibuffer_local_completion_map, Ctl ('g'),
1718 "abort-recursive-edit");
1719 initial_define_key (Vminibuffer_local_completion_map, Ctl ('m'),
1720 "exit-minibuffer");
1721 initial_define_key (Vminibuffer_local_completion_map, Ctl ('j'),
1722 "exit-minibuffer");
1724 initial_define_key (Vminibuffer_local_completion_map, '\t',
1725 "minibuffer-complete");
1726 initial_define_key (Vminibuffer_local_completion_map, ' ',
1727 "minibuffer-complete-word");
1728 initial_define_key (Vminibuffer_local_completion_map, '?',
1729 "minibuffer-completion-help");
1731 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('g'),
1732 "abort-recursive-edit");
1733 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
1734 "minibuffer-complete-and-exit");
1735 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
1736 "minibuffer-complete-and-exit");
1737 initial_define_key (Vminibuffer_local_must_match_map, '\t',
1738 "minibuffer-complete");
1739 initial_define_key (Vminibuffer_local_must_match_map, ' ',
1740 "minibuffer-complete-word");
1741 initial_define_key (Vminibuffer_local_must_match_map, '?',
1742 "minibuffer-completion-help");