1 /* Minibuffer input and completion.
2 Copyright (C) 1985, 1986, 1992 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)
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. */
25 #include "dispextern.h"
30 #define min(a, b) ((a) < (b) ? (a) : (b))
32 /* List of buffers for use as minibuffers.
33 The first element of the list is used for the outermost minibuffer invocation,
34 the next element is used for a recursive minibuffer invocation, etc.
35 The list is extended at the end as deeped minibuffer recursions are encountered. */
36 Lisp_Object Vminibuffer_list
;
38 struct minibuf_save_data
42 Lisp_Object help_form
;
43 Lisp_Object current_prefix_arg
;
44 Lisp_Object history_position
;
45 Lisp_Object history_variable
;
48 int minibuf_save_vector_size
;
49 struct minibuf_save_data
*minibuf_save_vector
;
51 /* Depth in minibuffer invocations. */
54 /* Nonzero means display completion help for invalid input */
57 /* Fread_minibuffer leaves the input, as a string, here */
58 Lisp_Object last_minibuf_string
;
60 /* Nonzero means let functions called when within a minibuffer
61 invoke recursive minibuffers (to read arguments, or whatever) */
62 int enable_recursive_minibuffers
;
64 /* help-form is bound to this while in the minibuffer. */
66 Lisp_Object Vminibuffer_help_form
;
68 /* Variable which is the history list to add minibuffer values to. */
70 Lisp_Object Vminibuffer_history_variable
;
72 /* Current position in the history list (adjusted by M-n and M-p). */
74 Lisp_Object Vminibuffer_history_position
;
76 Lisp_Object Qminibuffer_history
;
78 /* Nonzero means completion ignores case. */
80 int completion_ignore_case
;
82 /* If last completion attempt reported "Complete but not unique"
83 then this is the string completed then; otherwise this is nil. */
85 static Lisp_Object last_exact_completion
;
87 Lisp_Object Quser_variable_p
;
90 /* Actual minibuffer invocation. */
92 void read_minibuf_unwind ();
93 Lisp_Object
get_minibuffer ();
94 Lisp_Object
read_minibuf ();
96 /* Read from the minibuffer using keymap MAP, initial contents INITIAL
97 (a string), putting point minus BACKUP_N chars from the end of INITIAL,
98 prompting with PROMPT (a string), using history list HISTVAR
99 with initial position HISTPOS. (BACKUP_N should be <= 0.)
101 Normally return the result as a string (the text that was read),
102 but if EXPFLAG is non-nil, read it and return the object read. */
105 read_minibuf (map
, initial
, prompt
, backup_n
, expflag
, histvar
, histpos
)
114 register Lisp_Object val
;
115 int count
= specpdl_ptr
- specpdl
;
116 Lisp_Object mini_frame
= WINDOW_FRAME (XWINDOW (minibuf_window
));
117 struct gcpro gcpro1
, gcpro2
;
119 if (XTYPE (prompt
) != Lisp_String
)
120 prompt
= build_string ("");
122 /* Emacs in -batch mode calls minibuffer: print the prompt. */
123 if (noninteractive
&& XTYPE (prompt
) == Lisp_String
)
124 printf ("%s", XSTRING (prompt
)->data
);
126 if (!enable_recursive_minibuffers
128 && (EQ (selected_window
, minibuf_window
)))
130 || selected_frame
!= XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)))
132 error ("Command attempted to use minibuffer while in minibuffer");
134 if (minibuf_level
== minibuf_save_vector_size
)
135 minibuf_save_vector
=
136 (struct minibuf_save_data
*)
137 xrealloc (minibuf_save_vector
,
138 (minibuf_save_vector_size
*= 2)
139 * sizeof (struct minibuf_save_data
));
140 minibuf_save_vector
[minibuf_level
].prompt
= minibuf_prompt
;
141 minibuf_save_vector
[minibuf_level
].prompt_width
= minibuf_prompt_width
;
142 minibuf_prompt_width
= 0;
143 /* >> Why is this done this way rather than binding these variables? */
144 minibuf_save_vector
[minibuf_level
].help_form
= Vhelp_form
;
145 minibuf_save_vector
[minibuf_level
].current_prefix_arg
= Vcurrent_prefix_arg
;
146 minibuf_save_vector
[minibuf_level
].history_position
= Vminibuffer_history_position
;
147 minibuf_save_vector
[minibuf_level
].history_variable
= Vminibuffer_history_variable
;
148 GCPRO2 (minibuf_save_vector
[minibuf_level
].help_form
,
149 minibuf_save_vector
[minibuf_level
].current_prefix_arg
);
151 record_unwind_protect (Fset_window_configuration
,
152 Fcurrent_window_configuration (Qnil
));
154 /* If the minibuffer window is on a different frame, save that
155 frame's configuration too. */
156 if (XFRAME (mini_frame
) != selected_frame
)
158 record_unwind_protect (Fset_window_configuration
,
159 Fcurrent_window_configuration (mini_frame
));
162 val
= current_buffer
->directory
;
163 Fset_buffer (get_minibuffer (minibuf_level
));
164 current_buffer
->directory
= val
;
165 Fmake_local_variable (Qprint_escape_newlines
);
166 print_escape_newlines
= 1;
169 /* If the minibuffer window is on another frame, shift this frame's
170 focus to that window, and arrange to put it back later. */
171 if (XFRAME (WINDOW_FRAME (XWINDOW (minibuf_window
)))
174 record_unwind_protect (read_minibuf_unwind
,
175 Fcons (Fselected_frame (),
176 FRAME_FOCUS_FRAME (selected_frame
)));
178 Fredirect_frame_focus (Fselected_frame (), mini_frame
);
181 record_unwind_protect (read_minibuf_unwind
, Qnil
);
183 record_unwind_protect (read_minibuf_unwind
, Qnil
);
186 Vminibuf_scroll_window
= selected_window
;
187 Fset_window_buffer (minibuf_window
, Fcurrent_buffer ());
188 Fselect_window (minibuf_window
);
189 XFASTINT (XWINDOW (minibuf_window
)->hscroll
) = 0;
196 Finsert (1, &initial
);
197 if (!NILP (backup_n
) && XTYPE (backup_n
) == Lisp_Int
)
198 Fforward_char (backup_n
);
201 minibuf_prompt
= (char *) alloca (XSTRING (prompt
)->size
+ 1);
202 bcopy (XSTRING (prompt
)->data
, minibuf_prompt
, XSTRING (prompt
)->size
+ 1);
203 echo_area_glyphs
= 0;
205 Vhelp_form
= Vminibuffer_help_form
;
206 current_buffer
->keymap
= map
;
207 Vminibuffer_history_position
= histpos
;
208 Vminibuffer_history_variable
= histvar
;
210 /* ??? MCC did redraw_screen here if switching screens. */
213 /* If cursor is on the minibuffer line,
214 show the user we have exited by putting it in column 0. */
215 if ((FRAME_CURSOR_Y (selected_frame
)
216 >= XFASTINT (XWINDOW (minibuf_window
)->top
))
219 FRAME_CURSOR_X (selected_frame
) = 0;
220 update_frame (selected_frame
, 1, 1);
223 /* Make minibuffer contents into a string */
224 val
= make_buffer_string (1, Z
);
225 bcopy (GAP_END_ADDR
, XSTRING (val
)->data
+ GPT
- BEG
, Z
- GPT
);
227 /* Add the value to the appropriate history list. */
228 if (XTYPE (Vminibuffer_history_variable
) == Lisp_Symbol
229 && XSYMBOL (Vminibuffer_history_variable
)->value
!= Qunbound
)
230 Fset (Vminibuffer_history_variable
,
231 Fcons (val
, Fsymbol_value (Vminibuffer_history_variable
)));
233 unbind_to (count
, Qnil
); /* The appropriate frame will get selected
234 in set-window-configuration. */
238 /* VAL is the string of minibuffer text. */
239 last_minibuf_string
= val
;
241 /* If Lisp form desired instead of string, parse it */
248 /* Return a buffer to be used as the minibuffer at depth `depth'.
249 depth = 0 is the lowest allowed argument, and that is the value
250 used for nonrecursive minibuffer invocations */
253 get_minibuffer (depth
)
256 Lisp_Object tail
, num
, buf
;
258 extern Lisp_Object
nconc2 ();
260 XFASTINT (num
) = depth
;
261 tail
= Fnthcdr (num
, Vminibuffer_list
);
264 tail
= Fcons (Qnil
, Qnil
);
265 Vminibuffer_list
= nconc2 (Vminibuffer_list
, tail
);
268 if (NILP (buf
) || NILP (XBUFFER (buf
)->name
))
270 sprintf (name
, " *Minibuf-%d*", depth
);
271 buf
= Fget_buffer_create (build_string (name
));
272 XCONS (tail
)->car
= buf
;
275 reset_buffer (XBUFFER (buf
));
279 /* This function is called on exiting minibuffer, whether normally or not,
280 and it restores the current window, buffer, etc. */
283 read_minibuf_unwind (data
)
286 /* Erase the minibuffer we were using at this level. */
287 Fset_buffer (XWINDOW (minibuf_window
)->buffer
);
289 /* Prevent error in erase-buffer. */
290 current_buffer
->read_only
= Qnil
;
293 /* If this was a recursive minibuffer,
294 tie the minibuffer window back to the outer level minibuffer buffer */
296 /* Make sure minibuffer window is erased, not ignored */
297 windows_or_buffers_changed
++;
298 XFASTINT (XWINDOW (minibuf_window
)->last_modified
) = 0;
300 /* Restore prompt from outer minibuffer */
301 minibuf_prompt
= minibuf_save_vector
[minibuf_level
].prompt
;
302 minibuf_prompt_width
= minibuf_save_vector
[minibuf_level
].prompt_width
;
303 Vhelp_form
= minibuf_save_vector
[minibuf_level
].help_form
;
304 Vcurrent_prefix_arg
= minibuf_save_vector
[minibuf_level
].current_prefix_arg
;
305 Vminibuffer_history_position
306 = minibuf_save_vector
[minibuf_level
].history_position
;
307 Vminibuffer_history_variable
308 = minibuf_save_vector
[minibuf_level
].history_variable
;
311 /* Redirect the focus of the frame that called the minibuffer. */
313 Fredirect_frame_focus (XCONS (data
)->car
, XCONS (data
)->cdr
);
317 DEFUN ("read-from-minibuffer", Fread_from_minibuffer
, Sread_from_minibuffer
, 1, 5, 0,
318 "Read a string from the minibuffer, prompting with string PROMPT.\n\
319 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
320 to be inserted into the minibuffer before reading input.\n\
321 If INITIAL-CONTENTS is (STRING . POSITION), the initial input\n\
322 is STRING, but point is placed POSITION characters into the string.\n\
323 Third arg KEYMAP is a keymap to use whilst reading;\n\
324 if omitted or nil, the default is `minibuffer-local-map'.\n\
325 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
326 and return that object:\n\
327 in other words, do `(car (read-from-string INPUT-STRING))'\n\
328 Fifth arg HIST, if non-nil, specifies a history list\n\
329 and optionally the initial position in the list.\n\
330 It can be a symbol, which is the history list variable to use,\n\
331 or it can be a cons cell (HISTVAR . HISTPOS).\n\
332 In that case, HISTVAR is the history list variable to use,\n\
333 and HISTPOS is the initial position (the position in the list\n\
334 which INITIAL-CONTENTS corresponds to).\n\
335 Positions are counted starting from 1 at the beginning of the list.")
336 (prompt
, initial_input
, keymap
, read
, hist
)
337 Lisp_Object prompt
, initial_input
, keymap
, read
, hist
;
340 Lisp_Object histvar
, histpos
, position
;
343 CHECK_STRING (prompt
, 0);
344 if (!NILP (initial_input
))
346 if (XTYPE (initial_input
) == Lisp_Cons
)
348 position
= Fcdr (initial_input
);
349 initial_input
= Fcar (initial_input
);
351 CHECK_STRING (initial_input
, 1);
352 if (!NILP (position
))
354 CHECK_NUMBER (position
, 0);
355 /* Convert to distance from end of input. */
356 pos
= XINT (position
) - 1 - XSTRING (initial_input
)->size
;
361 keymap
= Vminibuffer_local_map
;
363 keymap
= get_keymap (keymap
,2);
365 if (XTYPE (hist
) == Lisp_Symbol
)
372 histvar
= Fcar_safe (hist
);
373 histpos
= Fcdr_safe (hist
);
376 histvar
= Qminibuffer_history
;
378 XFASTINT (histpos
) = 0;
380 return read_minibuf (keymap
, initial_input
, prompt
,
381 make_number (pos
), !NILP (read
), histvar
, histpos
);
384 DEFUN ("read-minibuffer", Fread_minibuffer
, Sread_minibuffer
, 1, 2, 0,
385 "Return a Lisp object read using the minibuffer.\n\
386 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
387 is a string to insert in the minibuffer before reading.")
388 (prompt
, initial_contents
)
389 Lisp_Object prompt
, initial_contents
;
391 CHECK_STRING (prompt
, 0);
392 if (!NILP (initial_contents
))
393 CHECK_STRING (initial_contents
, 1)
394 return read_minibuf (Vminibuffer_local_map
, initial_contents
,
395 prompt
, Qnil
, 1, Qminibuffer_history
, make_number (0));
398 DEFUN ("eval-minibuffer", Feval_minibuffer
, Seval_minibuffer
, 1, 2, 0,
399 "Return value of Lisp expression read using the minibuffer.\n\
400 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
401 is a string to insert in the minibuffer before reading.")
402 (prompt
, initial_contents
)
403 Lisp_Object prompt
, initial_contents
;
405 return Feval (Fread_minibuffer (prompt
, initial_contents
));
408 /* Functions that use the minibuffer to read various things. */
410 DEFUN ("read-string", Fread_string
, Sread_string
, 1, 2, 0,
411 "Read a string from the minibuffer, prompting with string PROMPT.\n\
412 If non-nil second arg INITIAL-INPUT is a string to insert before reading.")
413 (prompt
, initial_input
)
414 Lisp_Object prompt
, initial_input
;
416 return Fread_from_minibuffer (prompt
, initial_input
, Qnil
, Qnil
, Qnil
);
419 DEFUN ("read-no-blanks-input", Fread_no_blanks_input
, Sread_no_blanks_input
, 2, 2, 0,
420 "Args PROMPT and INIT, strings. Read a string from the terminal, not allowing blanks.\n\
421 Prompt with PROMPT, and provide INIT as an initial value of the input string.")
423 Lisp_Object prompt
, init
;
425 CHECK_STRING (prompt
, 0);
427 CHECK_STRING (init
, 1);
429 return read_minibuf (Vminibuffer_local_ns_map
, init
, prompt
, Qnil
, 0,
430 Qminibuffer_history
, make_number (0));
433 DEFUN ("read-command", Fread_command
, Sread_command
, 1, 1, 0,
434 "One arg PROMPT, a string. Read the name of a command and return as a symbol.\n\
435 Prompts with PROMPT.")
439 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qcommandp
, Qt
, Qnil
, Qnil
),
444 DEFUN ("read-function", Fread_function
, Sread_function
, 1, 1, 0,
445 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
446 Prompts with PROMPT.")
450 return Fintern (Fcompleting_read (prompt
, Vobarray
, Qfboundp
, Qt
, Qnil
, Qnil
),
455 DEFUN ("read-variable", Fread_variable
, Sread_variable
, 1, 1, 0,
456 "One arg PROMPT, a string. Read the name of a user variable and return\n\
457 it as a symbol. Prompts with PROMPT.\n\
458 A user variable is one whose documentation starts with a `*' character.")
462 return Fintern (Fcompleting_read (prompt
, Vobarray
,
463 Quser_variable_p
, Qt
, Qnil
, Qnil
),
467 DEFUN ("read-buffer", Fread_buffer
, Sread_buffer
, 1, 3, 0,
468 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
469 Prompts with PROMPT.\n\
470 Optional second arg is value to return if user enters an empty line.\n\
471 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
472 (prompt
, def
, require_match
)
473 Lisp_Object prompt
, def
, require_match
;
479 if (XTYPE (def
) == Lisp_Buffer
)
480 def
= XBUFFER (def
)->name
;
483 args
[0] = build_string ("%s(default %s) ");
486 prompt
= Fformat (3, args
);
489 tem
= Fcompleting_read (prompt
, Vbuffer_alist
, Qnil
, require_match
, Qnil
, Qnil
);
491 if (XSTRING (tem
)->size
)
496 DEFUN ("try-completion", Ftry_completion
, Stry_completion
, 2, 3, 0,
497 "Return common substring of all completions of STRING in ALIST.\n\
498 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
499 All that match are compared together; the longest initial sequence\n\
500 common to all matches is returned as a string.\n\
501 If there is no match at all, nil is returned.\n\
502 For an exact match, t is returned.\n\
504 ALIST can be an obarray instead of an alist.\n\
505 Then the print names of all symbols in the obarray are the possible matches.\n\
507 ALIST can also be a function to do the completion itself.\n\
508 It receives three arguments: the values STRING, PREDICATE and nil.\n\
509 Whatever it returns becomes the value of `try-completion'.\n\
511 If optional third argument PREDICATE is non-nil,\n\
512 it is used to test each possible match.\n\
513 The match is a candidate only if PREDICATE returns non-nil.\n\
514 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
515 (string
, alist
, pred
)
516 Lisp_Object string
, alist
, pred
;
518 Lisp_Object bestmatch
, tail
, elt
, eltstring
;
520 int compare
, matchsize
;
521 int list
= CONSP (alist
) || NILP (alist
);
524 Lisp_Object bucket
, zero
, end
, tem
;
525 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
527 CHECK_STRING (string
, 0);
528 if (!list
&& XTYPE (alist
) != Lisp_Vector
)
529 return call3 (alist
, string
, pred
, Qnil
);
533 /* If ALIST is not a list, set TAIL just for gc pro. */
538 obsize
= XVECTOR (alist
)->size
;
539 bucket
= XVECTOR (alist
)->contents
[index
];
544 /* Get the next element of the alist or obarray. */
545 /* Exit the loop if the elements are all used up. */
546 /* elt gets the alist element or symbol.
547 eltstring gets the name to check as a completion. */
554 eltstring
= Fcar (elt
);
559 if (XFASTINT (bucket
) != 0)
562 eltstring
= Fsymbol_name (elt
);
563 if (XSYMBOL (bucket
)->next
)
564 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
566 XFASTINT (bucket
) = 0;
568 else if (++index
>= obsize
)
572 bucket
= XVECTOR (alist
)->contents
[index
];
577 /* Is this element a possible completion? */
579 if (XTYPE (eltstring
) == Lisp_String
&&
580 XSTRING (string
)->size
<= XSTRING (eltstring
)->size
&&
581 0 > scmp (XSTRING (eltstring
)->data
, XSTRING (string
)->data
,
582 XSTRING (string
)->size
))
585 /* Ignore this element if there is a predicate
586 and the predicate doesn't like it. */
590 if (EQ (pred
, Qcommandp
))
591 tem
= Fcommandp (elt
);
594 GCPRO4 (tail
, string
, eltstring
, bestmatch
);
595 tem
= call1 (pred
, elt
);
598 if (NILP (tem
)) continue;
601 /* Update computation of how much all possible completions match */
604 if (NILP (bestmatch
))
605 bestmatch
= eltstring
, bestmatchsize
= XSTRING (eltstring
)->size
;
608 compare
= min (bestmatchsize
, XSTRING (eltstring
)->size
);
609 matchsize
= scmp (XSTRING (bestmatch
)->data
,
610 XSTRING (eltstring
)->data
,
614 if (completion_ignore_case
)
616 /* If this is an exact match except for case,
617 use it as the best match rather than one that is not an
618 exact match. This way, we get the case pattern
619 of the actual match. */
620 if ((matchsize
== XSTRING (eltstring
)->size
621 && matchsize
< XSTRING (bestmatch
)->size
)
623 /* If there is more than one exact match ignoring case,
624 and one of them is exact including case,
626 /* If there is no exact match ignoring case,
627 prefer a match that does not change the case
629 ((matchsize
== XSTRING (eltstring
)->size
)
631 (matchsize
== XSTRING (bestmatch
)->size
)
632 && !bcmp (XSTRING (eltstring
)->data
,
633 XSTRING (string
)->data
, XSTRING (string
)->size
)
634 && bcmp (XSTRING (bestmatch
)->data
,
635 XSTRING (string
)->data
, XSTRING (string
)->size
)))
636 bestmatch
= eltstring
;
638 bestmatchsize
= matchsize
;
643 if (NILP (bestmatch
))
644 return Qnil
; /* No completions found */
645 /* If we are ignoring case, and there is no exact match,
646 and no additional text was supplied,
647 don't change the case of what the user typed. */
648 if (completion_ignore_case
&& bestmatchsize
== XSTRING (string
)->size
649 && XSTRING (bestmatch
)->size
> bestmatchsize
)
652 /* Return t if the supplied string is an exact match (counting case);
653 it does not require any change to be made. */
654 if (matchcount
== 1 && bestmatchsize
== XSTRING (string
)->size
655 && !bcmp (XSTRING (bestmatch
)->data
, XSTRING (string
)->data
,
659 XFASTINT (zero
) = 0; /* Else extract the part in which */
660 XFASTINT (end
) = bestmatchsize
; /* all completions agree */
661 return Fsubstring (bestmatch
, zero
, end
);
664 /* Compare exactly LEN chars of strings at S1 and S2,
665 ignoring case if appropriate.
666 Return -1 if strings match,
667 else number of chars that match at the beginning. */
670 register char *s1
, *s2
;
673 register int l
= len
;
675 if (completion_ignore_case
)
677 while (l
&& DOWNCASE (*s1
++) == DOWNCASE (*s2
++))
682 while (l
&& *s1
++ == *s2
++)
690 DEFUN ("all-completions", Fall_completions
, Sall_completions
, 2, 3, 0,
691 "Search for partial matches to STRING in ALIST.\n\
692 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
693 The value is a list of all the strings from ALIST that match.\n\
694 ALIST can be an obarray instead of an alist.\n\
695 Then the print names of all symbols in the obarray are the possible matches.\n\
697 ALIST can also be a function to do the completion itself.\n\
698 It receives three arguments: the values STRING, PREDICATE and t.\n\
699 Whatever it returns becomes the value of `all-completion'.\n\
701 If optional third argument PREDICATE is non-nil,\n\
702 it is used to test each possible match.\n\
703 The match is a candidate only if PREDICATE returns non-nil.\n\
704 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
705 (string
, alist
, pred
)
706 Lisp_Object string
, alist
, pred
;
708 Lisp_Object tail
, elt
, eltstring
;
709 Lisp_Object allmatches
;
710 int list
= CONSP (alist
) || NILP (alist
);
712 Lisp_Object bucket
, tem
;
713 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
715 CHECK_STRING (string
, 0);
716 if (!list
&& XTYPE (alist
) != Lisp_Vector
)
718 return call3 (alist
, string
, pred
, Qt
);
722 /* If ALIST is not a list, set TAIL just for gc pro. */
727 obsize
= XVECTOR (alist
)->size
;
728 bucket
= XVECTOR (alist
)->contents
[index
];
733 /* Get the next element of the alist or obarray. */
734 /* Exit the loop if the elements are all used up. */
735 /* elt gets the alist element or symbol.
736 eltstring gets the name to check as a completion. */
743 eltstring
= Fcar (elt
);
748 if (XFASTINT (bucket
) != 0)
751 eltstring
= Fsymbol_name (elt
);
752 if (XSYMBOL (bucket
)->next
)
753 XSETSYMBOL (bucket
, XSYMBOL (bucket
)->next
);
755 XFASTINT (bucket
) = 0;
757 else if (++index
>= obsize
)
761 bucket
= XVECTOR (alist
)->contents
[index
];
766 /* Is this element a possible completion? */
768 if (XTYPE (eltstring
) == Lisp_String
&&
769 XSTRING (string
)->size
<= XSTRING (eltstring
)->size
&&
770 XSTRING (eltstring
)->data
[0] != ' ' &&
771 0 > scmp (XSTRING (eltstring
)->data
, XSTRING (string
)->data
,
772 XSTRING (string
)->size
))
775 /* Ignore this element if there is a predicate
776 and the predicate doesn't like it. */
780 if (EQ (pred
, Qcommandp
))
781 tem
= Fcommandp (elt
);
784 GCPRO4 (tail
, eltstring
, allmatches
, string
);
785 tem
= call1 (pred
, elt
);
788 if (NILP (tem
)) continue;
790 /* Ok => put it on the list. */
791 allmatches
= Fcons (eltstring
, allmatches
);
795 return Fnreverse (allmatches
);
798 Lisp_Object Vminibuffer_completion_table
, Qminibuffer_completion_table
;
799 Lisp_Object Vminibuffer_completion_predicate
, Qminibuffer_completion_predicate
;
800 Lisp_Object Vminibuffer_completion_confirm
, Qminibuffer_completion_confirm
;
802 DEFUN ("completing-read", Fcompleting_read
, Scompleting_read
, 2, 6, 0,
803 "Read a string in the minibuffer, with completion.\n\
804 Args: PROMPT, TABLE, PREDICATE, REQUIRE-MATCH, INITIAL-INPUT, HIST.\n\
805 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
806 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
807 PREDICATE limits completion to a subset of TABLE.\n\
808 See `try-completion' for more details on completion, TABLE, and PREDICATE.\n\
809 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
810 the input is (or completes to) an element of TABLE.\n\
811 If it is also not t, Return does not exit if it does non-null completion.\n\
812 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
813 If it is (STRING . POSITION), the initial input\n\
814 is STRING, but point is placed POSITION characters into the string.\n\
815 HIST, if non-nil, specifies a history list\n\
816 and optionally the initial position in the list.\n\
817 It can be a symbol, which is the history list variable to use,\n\
818 or it can be a cons cell (HISTVAR . HISTPOS).\n\
819 In that case, HISTVAR is the history list variable to use,\n\
820 and HISTPOS is the initial position (the position in the list\n\
821 which INITIAL-CONTENTS corresponds to).\n\
822 Positions are counted starting from 1 at the beginning of the list.\n\
823 Completion ignores case if the ambient value of\n\
824 `completion-ignore-case' is non-nil.")
825 (prompt
, table
, pred
, require_match
, init
, hist
)
826 Lisp_Object prompt
, table
, pred
, require_match
, init
, hist
;
828 Lisp_Object val
, histvar
, histpos
, position
;
830 int count
= specpdl_ptr
- specpdl
;
831 specbind (Qminibuffer_completion_table
, table
);
832 specbind (Qminibuffer_completion_predicate
, pred
);
833 specbind (Qminibuffer_completion_confirm
,
834 EQ (require_match
, Qt
) ? Qnil
: Qt
);
835 last_exact_completion
= Qnil
;
840 if (XTYPE (init
) == Lisp_Cons
)
842 position
= Fcdr (init
);
845 CHECK_STRING (init
, 0);
846 if (!NILP (position
))
848 CHECK_NUMBER (position
, 0);
849 /* Convert to distance from end of input. */
850 pos
= XINT (position
) - 1 - XSTRING (init
)->size
;
854 if (XTYPE (hist
) == Lisp_Symbol
)
861 histvar
= Fcar_safe (hist
);
862 histpos
= Fcdr_safe (hist
);
865 histvar
= Qminibuffer_history
;
867 XFASTINT (histpos
) = 0;
869 val
= read_minibuf (NILP (require_match
)
870 ? Vminibuffer_local_completion_map
871 : Vminibuffer_local_must_match_map
,
872 init
, prompt
, make_number (pos
), 0,
874 return unbind_to (count
, val
);
877 /* Temporarily display the string M at the end of the current
878 minibuffer contents. This is used to display things like
879 "[No Match]" when the user requests a completion for a prefix
880 that has no possible completions, and other quick, unobtrusive
883 temp_echo_area_glyphs (m
)
886 /* It's not very modular to do things this way, but then it seems
887 to me that the whole echo_area_glyphs thing is a hack anyway. */
888 extern char *previous_echo_glyphs
;
891 Lisp_Object oinhibit
;
892 oinhibit
= Vinhibit_quit
;
894 /* Clear out any old echo-area message to make way for our new
896 echo_area_glyphs
= previous_echo_glyphs
= 0;
902 Fsit_for (make_number (2), Qnil
, Qnil
);
903 del_range (point
, ZV
);
904 if (!NILP (Vquit_flag
))
907 unread_command_char
= Ctl ('g');
909 Vinhibit_quit
= oinhibit
;
912 Lisp_Object
Fminibuffer_completion_help ();
913 Lisp_Object
assoc_for_completion ();
916 * 0 no possible completion
917 * 1 was already an exact and unique completion
918 * 3 was already an exact completion
919 * 4 completed to an exact completion
920 * 5 some completion happened
921 * 6 no completion happened
926 Lisp_Object completion
, tem
;
930 completion
= Ftry_completion (Fbuffer_string (), Vminibuffer_completion_table
,
931 Vminibuffer_completion_predicate
);
932 last
= last_exact_completion
;
933 last_exact_completion
= Qnil
;
935 if (NILP (completion
))
938 temp_echo_area_glyphs (" [No match]");
942 if (EQ (completion
, Qt
)) /* exact and unique match */
946 tem
= Fstring_equal (completion
, Fbuffer_string());
947 if (completedp
= NILP (tem
))
949 Ferase_buffer (); /* Some completion happened */
950 Finsert (1, &completion
);
953 /* It did find a match. Do we match some possibility exactly now? */
954 if (CONSP (Vminibuffer_completion_table
)
955 || NILP (Vminibuffer_completion_table
))
956 tem
= assoc_for_completion (Fbuffer_string (),
957 Vminibuffer_completion_table
);
958 else if (XTYPE (Vminibuffer_completion_table
) == Lisp_Vector
)
960 /* the primitive used by Fintern_soft */
961 extern Lisp_Object
oblookup ();
963 tem
= Fbuffer_string ();
964 /* Bypass intern-soft as that loses for nil */
965 tem
= oblookup (Vminibuffer_completion_table
,
966 XSTRING (tem
)->data
, XSTRING (tem
)->size
);
967 if (XTYPE (tem
) != Lisp_Symbol
)
969 else if (!NILP (Vminibuffer_completion_predicate
))
970 tem
= call1 (Vminibuffer_completion_predicate
, tem
);
975 tem
= call3 (Vminibuffer_completion_table
,
977 Vminibuffer_completion_predicate
,
981 { /* not an exact match */
985 Fminibuffer_completion_help ();
987 temp_echo_area_glyphs (" [Next char not unique]");
992 /* If the last exact completion and this one were the same,
993 it means we've already given a "Complete but not unique"
994 message and the user's hit TAB again, so now we give him help. */
995 last_exact_completion
= completion
;
998 tem
= Fbuffer_string ();
999 if (!NILP (Fequal (tem
, last
)))
1000 Fminibuffer_completion_help ();
1005 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
1008 assoc_for_completion (key
, list
)
1009 register Lisp_Object key
;
1012 register Lisp_Object tail
;
1014 if (completion_ignore_case
)
1015 key
= Fupcase (key
);
1017 for (tail
= list
; !NILP (tail
); tail
= Fcdr (tail
))
1019 register Lisp_Object elt
, tem
, thiscar
;
1021 if (!CONSP (elt
)) continue;
1022 thiscar
= Fcar (elt
);
1023 if (XTYPE (thiscar
) != Lisp_String
)
1025 if (completion_ignore_case
)
1026 thiscar
= Fupcase (thiscar
);
1027 tem
= Fequal (thiscar
, key
);
1028 if (!NILP (tem
)) return elt
;
1034 DEFUN ("minibuffer-complete", Fminibuffer_complete
, Sminibuffer_complete
, 0, 0, "",
1035 "Complete the minibuffer contents as far as possible.")
1038 register int i
= do_completion ();
1045 temp_echo_area_glyphs (" [Sole completion]");
1049 temp_echo_area_glyphs (" [Complete, but not unique]");
1056 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit
,
1057 Sminibuffer_complete_and_exit
, 0, 0, "",
1058 "Complete the minibuffer contents, and maybe exit.\n\
1059 Exit if the name is valid with no completion needed.\n\
1060 If name was completed to a valid match,\n\
1061 a repetition of this command will exit.")
1066 /* Allow user to specify null string */
1070 i
= do_completion ();
1078 if (!NILP (Vminibuffer_completion_confirm
))
1080 temp_echo_area_glyphs (" [Confirm]");
1090 Fthrow (Qexit
, Qnil
);
1094 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word
, Sminibuffer_complete_word
,
1096 "Complete the minibuffer contents at most a single word.\n\
1097 After one word is completed as much as possible, a space or hyphen\n\
1098 is added, provided that matches some possible completion.")
1101 Lisp_Object completion
, tem
;
1103 register unsigned char *completion_string
;
1104 /* We keep calling Fbuffer_string
1105 rather than arrange for GC to hold onto a pointer to
1106 one of the strings thus made. */
1108 completion
= Ftry_completion (Fbuffer_string (),
1109 Vminibuffer_completion_table
,
1110 Vminibuffer_completion_predicate
);
1111 if (NILP (completion
))
1114 temp_echo_area_glyphs (" [No match]");
1117 if (EQ (completion
, Qt
))
1120 #if 0 /* How the below code used to look, for reference */
1121 tem
= Fbuffer_string ();
1122 b
= XSTRING (tem
)->data
;
1123 i
= ZV
- 1 - XSTRING (completion
)->size
;
1124 p
= XSTRING (completion
)->data
;
1126 0 <= scmp (b
, p
, ZV
- 1))
1129 /* Set buffer to longest match of buffer tail and completion head. */
1130 while (0 <= scmp (b
+ i
, p
, ZV
- 1 - i
))
1132 del_range (1, i
+ 1);
1135 #else /* Rewritten code */
1137 register unsigned char *buffer_string
;
1138 int buffer_length
, completion_length
;
1140 tem
= Fbuffer_string ();
1141 buffer_string
= XSTRING (tem
)->data
;
1142 completion_string
= XSTRING (completion
)->data
;
1143 buffer_length
= XSTRING (tem
)->size
; /* ie ZV - BEGV */
1144 completion_length
= XSTRING (completion
)->size
;
1145 i
= buffer_length
- completion_length
;
1146 /* Mly: I don't understand what this is supposed to do AT ALL */
1148 0 <= scmp (buffer_string
, completion_string
, buffer_length
))
1150 /* Set buffer to longest match of buffer tail and completion head. */
1154 while (0 <= scmp (buffer_string
++, completion_string
, buffer_length
--))
1156 del_range (1, i
+ 1);
1160 #endif /* Rewritten code */
1163 /* If completion finds next char not unique,
1164 consider adding a space or a hyphen */
1165 if (i
== XSTRING (completion
)->size
)
1167 tem
= Ftry_completion (concat2 (Fbuffer_string (), build_string (" ")),
1168 Vminibuffer_completion_table
,
1169 Vminibuffer_completion_predicate
);
1170 if (XTYPE (tem
) == Lisp_String
)
1174 tem
= Ftry_completion (concat2 (Fbuffer_string (), build_string ("-")),
1175 Vminibuffer_completion_table
,
1176 Vminibuffer_completion_predicate
);
1177 if (XTYPE (tem
) == Lisp_String
)
1182 /* Now find first word-break in the stuff found by completion.
1183 i gets index in string of where to stop completing. */
1184 completion_string
= XSTRING (completion
)->data
;
1186 for (; i
< XSTRING (completion
)->size
; i
++)
1187 if (SYNTAX (completion_string
[i
]) != Sword
) break;
1188 if (i
< XSTRING (completion
)->size
)
1191 /* If got no characters, print help for user. */
1196 Fminibuffer_completion_help ();
1200 /* Otherwise insert in minibuffer the chars we got */
1203 insert_from_string (completion
, 0, i
);
1207 DEFUN ("display-completion-list", Fdisplay_completion_list
, Sdisplay_completion_list
,
1209 "Display the list of completions, COMPLETIONS, using `standard-output'.\n\
1210 Each element may be just a symbol or string\n\
1211 or may be a list of two strings to be printed as if concatenated.")
1213 Lisp_Object completions
;
1215 register Lisp_Object tail
, elt
;
1218 /* No GCPRO needed, since (when it matters) every variable
1219 points to a non-string that is pointed to by COMPLETIONS. */
1220 struct buffer
*old
= current_buffer
;
1221 if (XTYPE (Vstandard_output
) == Lisp_Buffer
)
1222 set_buffer_internal (XBUFFER (Vstandard_output
));
1224 if (NILP (completions
))
1225 write_string ("There are no possible completions of what you have typed.", -1);
1228 write_string ("Possible completions are:", -1);
1229 for (tail
= completions
, i
= 0; !NILP (tail
); tail
= Fcdr (tail
), i
++)
1231 /* this needs fixing for the case of long completions
1232 and/or narrow windows */
1233 /* Sadly, the window it will appear in is not known
1234 until after the text has been made. */
1237 if (XTYPE (Vstandard_output
) == Lisp_Buffer
)
1238 Findent_to (make_number (35), make_number (1));
1243 write_string (" ", -1);
1246 while (column
< 35);
1257 if (XTYPE (Vstandard_output
) != Lisp_Buffer
)
1260 tem
= Flength (Fcar (elt
));
1261 column
+= XINT (tem
);
1262 tem
= Flength (Fcar (Fcdr (elt
)));
1263 column
+= XINT (tem
);
1265 Fprinc (Fcar (elt
), Qnil
);
1266 Fprinc (Fcar (Fcdr (elt
)), Qnil
);
1270 if (XTYPE (Vstandard_output
) != Lisp_Buffer
)
1273 tem
= Flength (elt
, Qt
);
1274 column
+= XINT (tem
);
1281 if (XTYPE (Vstandard_output
) == Lisp_Buffer
)
1282 set_buffer_internal (old
);
1286 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help
, Sminibuffer_completion_help
,
1288 "Display a list of possible completions of the current minibuffer contents.")
1291 Lisp_Object completions
;
1293 message ("Making completion list...");
1294 completions
= Fall_completions (Fbuffer_string (),
1295 Vminibuffer_completion_table
,
1296 Vminibuffer_completion_predicate
);
1297 echo_area_glyphs
= 0;
1299 if (NILP (completions
))
1302 temp_echo_area_glyphs (" [No completions]");
1305 internal_with_output_to_temp_buffer ("*Completions*",
1306 Fdisplay_completion_list
,
1307 Fsort (completions
, Qstring_lessp
));
1311 DEFUN ("self-insert-and-exit", Fself_insert_and_exit
, Sself_insert_and_exit
, 0, 0, "",
1312 "Terminate minibuffer input.")
1315 if (XTYPE (last_command_char
) == Lisp_Int
)
1316 internal_self_insert (last_command_char
, 0);
1320 Fthrow (Qexit
, Qnil
);
1323 DEFUN ("exit-minibuffer", Fexit_minibuffer
, Sexit_minibuffer
, 0, 0, "",
1324 "Terminate this minibuffer argument.")
1327 Fthrow (Qexit
, Qnil
);
1330 DEFUN ("minibuffer-depth", Fminibuffer_depth
, Sminibuffer_depth
, 0, 0, 0,
1331 "Return current depth of activations of minibuffer, a nonnegative integer.")
1334 return make_number (minibuf_level
);
1338 init_minibuf_once ()
1340 Vminibuffer_list
= Qnil
;
1341 staticpro (&Vminibuffer_list
);
1348 minibuf_save_vector_size
= 5;
1349 minibuf_save_vector
= (struct minibuf_save_data
*) malloc (5 * sizeof (struct minibuf_save_data
));
1351 Qminibuffer_completion_table
= intern ("minibuffer-completion-table");
1352 staticpro (&Qminibuffer_completion_table
);
1354 Qminibuffer_completion_confirm
= intern ("minibuffer-completion-confirm");
1355 staticpro (&Qminibuffer_completion_confirm
);
1357 Qminibuffer_completion_predicate
= intern ("minibuffer-completion-predicate");
1358 staticpro (&Qminibuffer_completion_predicate
);
1360 staticpro (&last_minibuf_string
);
1361 last_minibuf_string
= Qnil
;
1363 Quser_variable_p
= intern ("user-variable-p");
1364 staticpro (&Quser_variable_p
);
1366 Qminibuffer_history
= intern ("minibuffer-history");
1367 staticpro (&Qminibuffer_history
);
1369 DEFVAR_BOOL ("completion-auto-help", &auto_help
,
1370 "*Non-nil means automatically provide help for invalid completion input.");
1373 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case
,
1374 "Non-nil means don't consider case significant in completion.");
1375 completion_ignore_case
= 0;
1377 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers
,
1378 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
1379 More precisely, this variable makes a difference when the minibuffer window\n\
1380 is the selected window. If you are in some other window, minibuffer commands\n\
1381 are allowed even if a minibuffer is active.");
1382 enable_recursive_minibuffers
= 0;
1384 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table
,
1385 "Alist or obarray used for completion in the minibuffer.\n\
1386 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
1388 The value may alternatively be a function, which is given three arguments:\n\
1389 STRING, the current buffer contents;\n\
1390 PREDICATE, the predicate for filtering possible matches;\n\
1391 CODE, which says what kind of things to do.\n\
1392 CODE can be nil, t or `lambda'.\n\
1393 nil means to return the best completion of STRING, or nil if there is none.\n\
1394 t means to return a list of all possible completions of STRING.\n\
1395 `lambda' means to return t if STRING is a valid completion as it stands.");
1396 Vminibuffer_completion_table
= Qnil
;
1398 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate
,
1399 "Within call to `completing-read', this holds the PREDICATE argument.");
1400 Vminibuffer_completion_predicate
= Qnil
;
1402 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm
,
1403 "Non-nil => demand confirmation of completion before exiting minibuffer.");
1404 Vminibuffer_completion_confirm
= Qnil
;
1406 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form
,
1407 "Value that `help-form' takes on inside the minibuffer.");
1408 Vminibuffer_help_form
= Qnil
;
1410 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable
,
1411 "History list symbol to add minibuffer values to.\n\
1412 Each minibuffer output is added with\n\
1413 (set minibuffer-history-variable\n\
1414 (cons STRING (symbol-value minibuffer-history-variable)))");
1415 XFASTINT (Vminibuffer_history_variable
) = 0;
1417 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position
,
1418 "Current position of redoing in the history list.");
1419 Vminibuffer_history_position
= Qnil
;
1421 defsubr (&Sread_from_minibuffer
);
1422 defsubr (&Seval_minibuffer
);
1423 defsubr (&Sread_minibuffer
);
1424 defsubr (&Sread_string
);
1425 defsubr (&Sread_command
);
1426 defsubr (&Sread_variable
);
1427 defsubr (&Sread_buffer
);
1428 defsubr (&Sread_no_blanks_input
);
1429 defsubr (&Sminibuffer_depth
);
1431 defsubr (&Stry_completion
);
1432 defsubr (&Sall_completions
);
1433 defsubr (&Scompleting_read
);
1434 defsubr (&Sminibuffer_complete
);
1435 defsubr (&Sminibuffer_complete_word
);
1436 defsubr (&Sminibuffer_complete_and_exit
);
1437 defsubr (&Sdisplay_completion_list
);
1438 defsubr (&Sminibuffer_completion_help
);
1440 defsubr (&Sself_insert_and_exit
);
1441 defsubr (&Sexit_minibuffer
);
1447 initial_define_key (Vminibuffer_local_map
, Ctl ('g'),
1448 "abort-recursive-edit");
1449 initial_define_key (Vminibuffer_local_map
, Ctl ('m'),
1451 initial_define_key (Vminibuffer_local_map
, Ctl ('j'),
1454 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('g'),
1455 "abort-recursive-edit");
1456 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('m'),
1458 initial_define_key (Vminibuffer_local_ns_map
, Ctl ('j'),
1461 initial_define_key (Vminibuffer_local_ns_map
, ' ',
1463 initial_define_key (Vminibuffer_local_ns_map
, '\t',
1465 initial_define_key (Vminibuffer_local_ns_map
, '?',
1466 "self-insert-and-exit");
1468 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('g'),
1469 "abort-recursive-edit");
1470 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('m'),
1472 initial_define_key (Vminibuffer_local_completion_map
, Ctl ('j'),
1475 initial_define_key (Vminibuffer_local_completion_map
, '\t',
1476 "minibuffer-complete");
1477 initial_define_key (Vminibuffer_local_completion_map
, ' ',
1478 "minibuffer-complete-word");
1479 initial_define_key (Vminibuffer_local_completion_map
, '?',
1480 "minibuffer-completion-help");
1482 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('g'),
1483 "abort-recursive-edit");
1484 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('m'),
1485 "minibuffer-complete-and-exit");
1486 initial_define_key (Vminibuffer_local_must_match_map
, Ctl ('j'),
1487 "minibuffer-complete-and-exit");
1488 initial_define_key (Vminibuffer_local_must_match_map
, '\t',
1489 "minibuffer-complete");
1490 initial_define_key (Vminibuffer_local_must_match_map
, ' ',
1491 "minibuffer-complete-word");
1492 initial_define_key (Vminibuffer_local_must_match_map
, '?',
1493 "minibuffer-completion-help");