284
|
1 /* Minibuffer input and completion.
|
|
2 Copyright (C) 1985, 1986 Free Software Foundation, Inc.
|
|
3
|
|
4 This file is part of GNU Emacs.
|
|
5
|
|
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 1, or (at your option)
|
|
9 any later version.
|
|
10
|
|
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.
|
|
15
|
|
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. */
|
|
19
|
|
20
|
|
21 #include "config.h"
|
|
22 #include "lisp.h"
|
|
23 #include "commands.h"
|
|
24 #include "buffer.h"
|
|
25 #include "dispextern.h"
|
|
26 #include "screen.h"
|
|
27 #include "window.h"
|
|
28 #include "syntax.h"
|
|
29
|
|
30 #define min(a, b) ((a) < (b) ? (a) : (b))
|
|
31
|
|
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;
|
|
37
|
|
38 struct minibuf_save_data
|
|
39 {
|
|
40 char *prompt;
|
|
41 int prompt_width;
|
|
42 Lisp_Object help_form;
|
|
43 Lisp_Object current_prefix_arg;
|
|
44 };
|
|
45
|
|
46 int minibuf_save_vector_size;
|
|
47 struct minibuf_save_data *minibuf_save_vector;
|
|
48
|
|
49 /* Depth in minibuffer invocations. */
|
|
50 int minibuf_level;
|
|
51
|
|
52 /* Nonzero means display completion help for invalid input */
|
|
53 int auto_help;
|
|
54
|
|
55 /* Fread_minibuffer leaves the input, as a string, here */
|
|
56 Lisp_Object last_minibuf_string;
|
|
57
|
|
58 /* Nonzero means let functions called when within a minibuffer
|
|
59 invoke recursive minibuffers (to read arguments, or whatever) */
|
|
60 int enable_recursive_minibuffers;
|
|
61
|
|
62 /* help-form is bound to this while in the minibuffer. */
|
|
63
|
|
64 Lisp_Object Vminibuffer_help_form;
|
|
65
|
|
66 /* Nonzero means completion ignores case. */
|
|
67
|
|
68 int completion_ignore_case;
|
|
69
|
|
70 /* If last completion attempt reported "Complete but not unique"
|
|
71 then this is the string completed then; otherwise this is nil. */
|
|
72
|
|
73 static Lisp_Object last_exact_completion;
|
|
74
|
|
75 Lisp_Object Quser_variable_p;
|
|
76
|
|
77 /* Width in columns of current minibuffer prompt. */
|
|
78
|
|
79 extern int minibuf_prompt_width;
|
|
80
|
|
81 #ifdef MULTI_SCREEN
|
|
82
|
|
83 extern Lisp_Object Vglobal_minibuffer_screen;
|
|
84 #endif
|
|
85
|
|
86 /* Actual minibuffer invocation. */
|
|
87
|
|
88 void read_minibuf_unwind ();
|
|
89 Lisp_Object get_minibuffer ();
|
|
90 Lisp_Object read_minibuf ();
|
|
91
|
|
92 Lisp_Object
|
|
93 read_minibuf (map, initial, prompt, backup_n, expflag)
|
|
94 Lisp_Object map;
|
|
95 Lisp_Object initial;
|
|
96 Lisp_Object prompt;
|
|
97 Lisp_Object backup_n;
|
|
98 int expflag;
|
|
99 {
|
|
100 register Lisp_Object val;
|
|
101 int count = specpdl_ptr - specpdl;
|
|
102 struct gcpro gcpro1, gcpro2;
|
|
103 Lisp_Object prev_screen = Qnil;
|
|
104
|
|
105 if (XTYPE (prompt) != Lisp_String)
|
|
106 prompt = build_string ("");
|
|
107
|
|
108 /* Emacs in -batch mode calls minibuffer: print the prompt. */
|
|
109 if (noninteractive && XTYPE (prompt) == Lisp_String)
|
|
110 printf ("%s", XSTRING (prompt)->data);
|
|
111
|
|
112 if (!enable_recursive_minibuffers
|
|
113 && minibuf_level > 0
|
|
114 && (EQ (selected_window, minibuf_window)))
|
|
115 #if 0
|
|
116 || selected_screen != XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)))
|
|
117 #endif
|
|
118 error ("Command attempted to use minibuffer while in minibuffer");
|
|
119
|
|
120 if (minibuf_level == minibuf_save_vector_size)
|
|
121 minibuf_save_vector =
|
|
122 (struct minibuf_save_data *)
|
|
123 xrealloc (minibuf_save_vector,
|
|
124 (minibuf_save_vector_size *= 2)
|
|
125 * sizeof (struct minibuf_save_data));
|
|
126 minibuf_save_vector[minibuf_level].prompt = minibuf_prompt;
|
|
127 minibuf_save_vector[minibuf_level].prompt_width = minibuf_prompt_width;
|
|
128 minibuf_prompt_width = 0;
|
|
129 /* >> Why is this done this way rather than binding these variables? */
|
|
130 minibuf_save_vector[minibuf_level].help_form = Vhelp_form;
|
|
131 minibuf_save_vector[minibuf_level].current_prefix_arg = Vcurrent_prefix_arg;
|
|
132 GCPRO2 (minibuf_save_vector[minibuf_level].help_form,
|
|
133 minibuf_save_vector[minibuf_level].current_prefix_arg);
|
|
134
|
|
135 record_unwind_protect (Fset_window_configuration,
|
345
|
136 Fcurrent_window_configuration (Qnil));
|
|
137
|
|
138 /* If the minibuffer window is on a different screen, save that
|
|
139 screen's configuration too. */
|
|
140 if (XSCREEN (WINDOW_SCREEN (XWINDOW (minibuf_window)))
|
|
141 != selected_screen)
|
|
142 record_unwind_protect (Fset_window_configuration,
|
|
143 Fcurrent_window_configuration (WINDOW_SCREEN (XWINDOW (minibuf_window))));
|
284
|
144
|
|
145 val = current_buffer->directory;
|
|
146 Fset_buffer (get_minibuffer (minibuf_level));
|
|
147 current_buffer->directory = val;
|
|
148 Fmake_local_variable (Qprint_escape_newlines);
|
|
149 print_escape_newlines = 1;
|
|
150
|
|
151 Vminibuf_scroll_window = selected_window;
|
|
152 Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
|
|
153 Fselect_window (minibuf_window);
|
|
154 XFASTINT (XWINDOW (minibuf_window)->hscroll) = 0;
|
|
155
|
|
156 Ferase_buffer ();
|
|
157 minibuf_level++;
|
|
158 record_unwind_protect (read_minibuf_unwind, Qnil);
|
|
159
|
|
160 if (!NULL (initial))
|
|
161 {
|
|
162 Finsert (1, &initial);
|
|
163 if (!NULL (backup_n) && XTYPE (backup_n) == Lisp_Int)
|
|
164 Fforward_char (backup_n);
|
|
165 }
|
|
166
|
|
167 minibuf_prompt = (char *) alloca (XSTRING (prompt)->size + 1);
|
|
168 bcopy (XSTRING (prompt)->data, minibuf_prompt, XSTRING (prompt)->size + 1);
|
|
169 echo_area_glyphs = 0;
|
|
170
|
|
171 Vhelp_form = Vminibuffer_help_form;
|
|
172 current_buffer->keymap = map;
|
|
173
|
|
174 /* ??? MCC did redraw_screen here if switching screens. */
|
|
175 recursive_edit_1 ();
|
|
176
|
|
177 /* If cursor is on the minibuffer line,
|
|
178 show the user we have exited by putting it in column 0. */
|
|
179 if ((SCREEN_CURSOR_Y (selected_screen)
|
|
180 >= XFASTINT (XWINDOW (minibuf_window)->top))
|
|
181 && !noninteractive)
|
|
182 {
|
|
183 SCREEN_CURSOR_X (selected_screen) = 0;
|
|
184 update_screen (selected_screen, 1, 1);
|
|
185 }
|
|
186
|
|
187 /* Make minibuffer contents into a string */
|
|
188 val = make_string (BEG_ADDR, Z - BEG);
|
|
189 bcopy (GAP_END_ADDR, XSTRING (val)->data + GPT - BEG, Z - GPT);
|
|
190 unbind_to (count, Qnil); /* The appropriate screen will get selected
|
|
191 from set-window-configuration. */
|
|
192
|
|
193 UNGCPRO;
|
|
194
|
|
195 /* VAL is the string of minibuffer text. */
|
|
196
|
|
197 last_minibuf_string = val;
|
|
198
|
|
199 /* If Lisp form desired instead of string, parse it */
|
|
200 if (expflag)
|
|
201 val = Fread (val);
|
|
202
|
|
203 return val;
|
|
204 }
|
|
205
|
|
206 /* Return a buffer to be used as the minibuffer at depth `depth'.
|
|
207 depth = 0 is the lowest allowed argument, and that is the value
|
|
208 used for nonrecursive minibuffer invocations */
|
|
209
|
|
210 Lisp_Object
|
|
211 get_minibuffer (depth)
|
|
212 int depth;
|
|
213 {
|
|
214 Lisp_Object tail, num, buf;
|
|
215 char name[14];
|
|
216 extern Lisp_Object nconc2 ();
|
|
217
|
|
218 XFASTINT (num) = depth;
|
|
219 tail = Fnthcdr (num, Vminibuffer_list);
|
|
220 if (NULL (tail))
|
|
221 {
|
|
222 tail = Fcons (Qnil, Qnil);
|
|
223 Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
|
|
224 }
|
|
225 buf = Fcar (tail);
|
|
226 if (NULL (buf) || NULL (XBUFFER (buf)->name))
|
|
227 {
|
|
228 sprintf (name, " *Minibuf-%d*", depth);
|
|
229 buf = Fget_buffer_create (build_string (name));
|
|
230 XCONS (tail)->car = buf;
|
|
231 }
|
|
232 else
|
|
233 reset_buffer (XBUFFER (buf));
|
|
234 return buf;
|
|
235 }
|
|
236
|
|
237 /* This function is called on exiting minibuffer, whether normally or not,
|
|
238 and it restores the current window, buffer, etc. */
|
|
239
|
|
240 void
|
|
241 read_minibuf_unwind ()
|
|
242 {
|
|
243 /* Erase the minibuffer we were using at this level. */
|
|
244 Fset_buffer (XWINDOW (minibuf_window)->buffer);
|
|
245
|
|
246 /* Prevent error in erase-buffer. */
|
|
247 current_buffer->read_only = Qnil;
|
|
248 Ferase_buffer ();
|
|
249
|
|
250 /* If this was a recursive minibuffer,
|
|
251 tie the minibuffer window back to the outer level minibuffer buffer */
|
|
252 minibuf_level--;
|
|
253 /* Make sure minibuffer window is erased, not ignored */
|
|
254 windows_or_buffers_changed++;
|
|
255 XFASTINT (XWINDOW (minibuf_window)->last_modified) = 0;
|
|
256
|
|
257 /* Restore prompt from outer minibuffer */
|
|
258 minibuf_prompt = minibuf_save_vector[minibuf_level].prompt;
|
|
259 minibuf_prompt_width = minibuf_save_vector[minibuf_level].prompt_width;
|
|
260 Vhelp_form = minibuf_save_vector[minibuf_level].help_form;
|
|
261 Vcurrent_prefix_arg = minibuf_save_vector[minibuf_level].current_prefix_arg;
|
|
262 }
|
|
263
|
|
264 DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 5, 0,
|
|
265 "Read a string from the minibuffer, prompting with string PROMPT.\n\
|
|
266 If optional second arg INITIAL-CONTENTS is non-nil, it is a string\n\
|
|
267 to be inserted into the minibuffer before reading input.\n\
|
|
268 Third arg KEYMAP is a keymap to use whilst reading;\n\
|
|
269 if omitted or nil, the default is `minibuffer-local-map'.\n\
|
|
270 If fourth arg READ is non-nil, then interpret the result as a lisp object\n\
|
|
271 and return that object:\n\
|
|
272 in other words, do `(car (read-from-string INPUT-STRING))'\n\
|
|
273 Fifth arg POSITION, if non-nil, is where to put point\n\
|
|
274 in the minibuffer after inserting INITIAL-CONTENTS.")
|
|
275 (prompt, initial_input, keymap, read, position)
|
|
276 Lisp_Object prompt, initial_input, keymap, read, position;
|
|
277 {
|
|
278 int pos = 0;
|
|
279
|
|
280 CHECK_STRING (prompt, 0);
|
|
281 if (!NULL (initial_input))
|
|
282 {
|
|
283 CHECK_STRING (initial_input, 1);
|
|
284 if (!NULL (position))
|
|
285 {
|
|
286 CHECK_NUMBER (position, 0);
|
|
287 /* Convert to distance from end of input. */
|
|
288 pos = XINT (position) - 1 - XSTRING (initial_input)->size;
|
|
289 }
|
|
290 }
|
|
291
|
|
292 if (NULL (keymap))
|
|
293 keymap = Vminibuffer_local_map;
|
|
294 else
|
|
295 keymap = get_keymap (keymap,2);
|
|
296 return read_minibuf (keymap, initial_input, prompt,
|
|
297 pos, !NULL (read));
|
|
298 }
|
|
299
|
|
300 DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
|
|
301 "Return a Lisp object read using the minibuffer.\n\
|
|
302 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
|
|
303 is a string to insert in the minibuffer before reading.")
|
|
304 (prompt, initial_contents)
|
|
305 Lisp_Object prompt, initial_contents;
|
|
306 {
|
|
307 CHECK_STRING (prompt, 0);
|
|
308 if (!NULL (initial_contents))
|
|
309 CHECK_STRING (initial_contents, 1)
|
|
310 return read_minibuf (Vminibuffer_local_map, initial_contents, prompt, Qnil, 1);
|
|
311 }
|
|
312
|
|
313 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
|
|
314 "Return value of Lisp expression read using the minibuffer.\n\
|
|
315 Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS\n\
|
|
316 is a string to insert in the minibuffer before reading.")
|
|
317 (prompt, initial_contents)
|
|
318 Lisp_Object prompt, initial_contents;
|
|
319 {
|
|
320 return Feval (Fread_minibuffer (prompt, initial_contents));
|
|
321 }
|
|
322
|
|
323 /* Functions that use the minibuffer to read various things. */
|
|
324
|
|
325 DEFUN ("read-string", Fread_string, Sread_string, 1, 2, 0,
|
|
326 "Read a string from the minibuffer, prompting with string PROMPT.\n\
|
|
327 If non-nil second arg INITIAL-INPUT is a string to insert before reading.")
|
|
328 (prompt, initial_input)
|
|
329 Lisp_Object prompt, initial_input;
|
|
330 {
|
|
331 return Fread_from_minibuffer (prompt, initial_input, Qnil, Qnil, Qnil);
|
|
332 }
|
|
333
|
|
334 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 2, 1, 0,
|
|
335 "Args PROMPT and INIT, strings. Read a string from the terminal, not allowing blanks.\n\
|
|
336 Prompt with PROMPT, and provide INIT as an initial value of the input string.")
|
|
337 (prompt, init)
|
|
338 Lisp_Object prompt, init;
|
|
339 {
|
|
340 CHECK_STRING (prompt, 0);
|
|
341 if (! NULL (init))
|
|
342 CHECK_STRING (init, 1);
|
|
343
|
|
344 return read_minibuf (Vminibuffer_local_ns_map, init, prompt, Qnil, 0);
|
|
345 }
|
|
346
|
|
347 DEFUN ("read-command", Fread_command, Sread_command, 1, 1, 0,
|
|
348 "One arg PROMPT, a string. Read the name of a command and return as a symbol.\n\
|
|
349 Prompts with PROMPT.")
|
|
350 (prompt)
|
|
351 Lisp_Object prompt;
|
|
352 {
|
|
353 return Fintern (Fcompleting_read (prompt, Vobarray, Qcommandp, Qt, Qnil, Qnil),
|
|
354 Qnil);
|
|
355 }
|
|
356
|
|
357 #ifdef NOTDEF
|
|
358 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
|
|
359 "One arg PROMPT, a string. Read the name of a function and return as a symbol.\n\
|
|
360 Prompts with PROMPT.")
|
|
361 (prompt)
|
|
362 Lisp_Object prompt;
|
|
363 {
|
|
364 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil),
|
|
365 Qnil);
|
|
366 }
|
|
367 #endif /* NOTDEF */
|
|
368
|
|
369 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 1, 0,
|
|
370 "One arg PROMPT, a string. Read the name of a user variable and return\n\
|
|
371 it as a symbol. Prompts with PROMPT.\n\
|
|
372 A user variable is one whose documentation starts with a `*' character.")
|
|
373 (prompt)
|
|
374 Lisp_Object prompt;
|
|
375 {
|
|
376 return Fintern (Fcompleting_read (prompt, Vobarray,
|
|
377 Quser_variable_p, Qt, Qnil, Qnil),
|
|
378 Qnil);
|
|
379 }
|
|
380
|
|
381 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
|
|
382 "One arg PROMPT, a string. Read the name of a buffer and return as a string.\n\
|
|
383 Prompts with PROMPT.\n\
|
|
384 Optional second arg is value to return if user enters an empty line.\n\
|
|
385 If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed.")
|
|
386 (prompt, def, require_match)
|
|
387 Lisp_Object prompt, def, require_match;
|
|
388 {
|
|
389 Lisp_Object tem;
|
|
390 Lisp_Object args[3];
|
|
391 struct gcpro gcpro1;
|
|
392
|
|
393 if (XTYPE (def) == Lisp_Buffer)
|
|
394 def = XBUFFER (def)->name;
|
|
395 if (!NULL (def))
|
|
396 {
|
|
397 args[0] = build_string ("%s(default %s) ");
|
|
398 args[1] = prompt;
|
|
399 args[2] = def;
|
|
400 prompt = Fformat (3, args);
|
|
401 }
|
|
402 GCPRO1 (def);
|
|
403 tem = Fcompleting_read (prompt, Vbuffer_alist, Qnil, require_match, Qnil, Qnil);
|
|
404 UNGCPRO;
|
|
405 if (XSTRING (tem)->size)
|
|
406 return tem;
|
|
407 return def;
|
|
408 }
|
|
409
|
|
410 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
|
|
411 "Return common substring of all completions of STRING in ALIST.\n\
|
|
412 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
|
|
413 All that match are compared together; the longest initial sequence\n\
|
|
414 common to all matches is returned as a string.\n\
|
|
415 If there is no match at all, nil is returned.\n\
|
|
416 For an exact match, t is returned.\n\
|
|
417 \n\
|
|
418 ALIST can be an obarray instead of an alist.\n\
|
|
419 Then the print names of all symbols in the obarray are the possible matches.\n\
|
|
420 \n\
|
|
421 ALIST can also be a function to do the completion itself.\n\
|
|
422 It receives three arguments: the values STRING, PREDICATE and nil.\n\
|
|
423 Whatever it returns becomes the value of `try-completion'.\n\
|
|
424 \n\
|
|
425 If optional third argument PREDICATE is non-nil,\n\
|
|
426 it is used to test each possible match.\n\
|
|
427 The match is a candidate only if PREDICATE returns non-nil.\n\
|
|
428 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
|
|
429 (string, alist, pred)
|
|
430 Lisp_Object string, alist, pred;
|
|
431 {
|
|
432 Lisp_Object bestmatch, tail, elt, eltstring;
|
|
433 int bestmatchsize;
|
|
434 int compare, matchsize;
|
|
435 int list = CONSP (alist) || NULL (alist);
|
|
436 int index, obsize;
|
|
437 int matchcount = 0;
|
|
438 Lisp_Object bucket, zero, end, tem;
|
|
439 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
|
|
440
|
|
441 CHECK_STRING (string, 0);
|
|
442 if (!list && XTYPE (alist) != Lisp_Vector)
|
|
443 return call3 (alist, string, pred, Qnil);
|
|
444
|
|
445 bestmatch = Qnil;
|
|
446
|
|
447 /* If ALIST is not a list, set TAIL just for gc pro. */
|
|
448 tail = alist;
|
|
449 if (! list)
|
|
450 {
|
|
451 index = 0;
|
|
452 obsize = XVECTOR (alist)->size;
|
|
453 bucket = XVECTOR (alist)->contents[index];
|
|
454 }
|
|
455
|
|
456 while (1)
|
|
457 {
|
|
458 /* Get the next element of the alist or obarray. */
|
|
459 /* Exit the loop if the elements are all used up. */
|
|
460 /* elt gets the alist element or symbol.
|
|
461 eltstring gets the name to check as a completion. */
|
|
462
|
|
463 if (list)
|
|
464 {
|
|
465 if (NULL (tail))
|
|
466 break;
|
|
467 elt = Fcar (tail);
|
|
468 eltstring = Fcar (elt);
|
|
469 tail = Fcdr (tail);
|
|
470 }
|
|
471 else
|
|
472 {
|
|
473 if (XFASTINT (bucket) != 0)
|
|
474 {
|
|
475 elt = bucket;
|
|
476 eltstring = Fsymbol_name (elt);
|
|
477 if (XSYMBOL (bucket)->next)
|
|
478 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
|
|
479 else
|
|
480 XFASTINT (bucket) = 0;
|
|
481 }
|
|
482 else if (++index >= obsize)
|
|
483 break;
|
|
484 else
|
|
485 {
|
|
486 bucket = XVECTOR (alist)->contents[index];
|
|
487 continue;
|
|
488 }
|
|
489 }
|
|
490
|
|
491 /* Is this element a possible completion? */
|
|
492
|
|
493 if (XTYPE (eltstring) == Lisp_String &&
|
|
494 XSTRING (string)->size <= XSTRING (eltstring)->size &&
|
|
495 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
|
|
496 XSTRING (string)->size))
|
|
497 {
|
|
498 /* Yes. */
|
|
499 /* Ignore this element if there is a predicate
|
|
500 and the predicate doesn't like it. */
|
|
501
|
|
502 if (!NULL (pred))
|
|
503 {
|
|
504 if (EQ (pred, Qcommandp))
|
|
505 tem = Fcommandp (elt);
|
|
506 else
|
|
507 {
|
|
508 GCPRO4 (tail, string, eltstring, bestmatch);
|
|
509 tem = call1 (pred, elt);
|
|
510 UNGCPRO;
|
|
511 }
|
|
512 if (NULL (tem)) continue;
|
|
513 }
|
|
514
|
|
515 /* Update computation of how much all possible completions match */
|
|
516
|
|
517 matchcount++;
|
|
518 if (NULL (bestmatch))
|
|
519 bestmatch = eltstring, bestmatchsize = XSTRING (eltstring)->size;
|
|
520 else
|
|
521 {
|
|
522 compare = min (bestmatchsize, XSTRING (eltstring)->size);
|
|
523 matchsize = scmp (XSTRING (bestmatch)->data,
|
|
524 XSTRING (eltstring)->data,
|
|
525 compare);
|
330
|
526 if (matchsize < 0)
|
|
527 matchsize = compare;
|
|
528 if (completion_ignore_case)
|
|
529 {
|
|
530 /* If this is an exact match except for case,
|
|
531 use it as the best match rather than one that is not an
|
|
532 exact match. This way, we get the case pattern
|
|
533 of the actual match. */
|
|
534 if ((matchsize == XSTRING (eltstring)->size
|
|
535 && matchsize < XSTRING (bestmatch)->size)
|
|
536 ||
|
|
537 /* If there is more than one exact match ignoring case,
|
|
538 and one of them is exact including case,
|
|
539 prefer that one. */
|
|
540 /* If there is no exact match ignoring case,
|
|
541 prefer a match that does not change the case
|
|
542 of the input. */
|
|
543 ((matchsize == XSTRING (eltstring)->size)
|
|
544 ==
|
|
545 (matchsize == XSTRING (bestmatch)->size)
|
|
546 && !bcmp (XSTRING (eltstring)->data,
|
|
547 XSTRING (string)->data, XSTRING (string)->size)
|
|
548 && bcmp (XSTRING (bestmatch)->data,
|
|
549 XSTRING (string)->data, XSTRING (string)->size)))
|
|
550 bestmatch = eltstring;
|
|
551 }
|
|
552 bestmatchsize = matchsize;
|
284
|
553 }
|
|
554 }
|
|
555 }
|
|
556
|
|
557 if (NULL (bestmatch))
|
|
558 return Qnil; /* No completions found */
|
330
|
559 /* If we are ignoring case, and there is no exact match,
|
|
560 and no additional text was supplied,
|
|
561 don't change the case of what the user typed. */
|
|
562 if (completion_ignore_case && bestmatchsize == XSTRING (string)->size
|
|
563 && XSTRING (bestmatch)->size > bestmatchsize)
|
|
564 return string;
|
|
565
|
|
566 /* Return t if the supplied string is an exact match (counting case);
|
|
567 it does not require any change to be made. */
|
|
568 if (matchcount == 1 && bestmatchsize == XSTRING (string)->size
|
|
569 && !bcmp (XSTRING (bestmatch)->data, XSTRING (string)->data,
|
|
570 bestmatchsize))
|
284
|
571 return Qt;
|
|
572
|
|
573 XFASTINT (zero) = 0; /* Else extract the part in which */
|
|
574 XFASTINT (end) = bestmatchsize; /* all completions agree */
|
|
575 return Fsubstring (bestmatch, zero, end);
|
|
576 }
|
|
577
|
|
578 /* Compare exactly LEN chars of strings at S1 and S2,
|
|
579 ignoring case if appropriate.
|
|
580 Return -1 if strings match,
|
|
581 else number of chars that match at the beginning. */
|
|
582
|
|
583 scmp (s1, s2, len)
|
|
584 register char *s1, *s2;
|
|
585 int len;
|
|
586 {
|
|
587 register int l = len;
|
|
588
|
|
589 if (completion_ignore_case)
|
|
590 {
|
|
591 while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
|
|
592 l--;
|
|
593 }
|
|
594 else
|
|
595 {
|
|
596 while (l && *s1++ == *s2++)
|
|
597 l--;
|
|
598 }
|
|
599 if (l == 0)
|
|
600 return -1;
|
|
601 else return len - l;
|
|
602 }
|
|
603
|
|
604 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 3, 0,
|
|
605 "Search for partial matches to STRING in ALIST.\n\
|
|
606 Each car of each element of ALIST is tested to see if it begins with STRING.\n\
|
|
607 The value is a list of all the strings from ALIST that match.\n\
|
|
608 ALIST can be an obarray instead of an alist.\n\
|
|
609 Then the print names of all symbols in the obarray are the possible matches.\n\
|
|
610 \n\
|
|
611 ALIST can also be a function to do the completion itself.\n\
|
|
612 It receives three arguments: the values STRING, PREDICATE and t.\n\
|
|
613 Whatever it returns becomes the value of `all-completion'.\n\
|
|
614 \n\
|
|
615 If optional third argument PREDICATE is non-nil,\n\
|
|
616 it is used to test each possible match.\n\
|
|
617 The match is a candidate only if PREDICATE returns non-nil.\n\
|
|
618 The argument given to PREDICATE is the alist element or the symbol from the obarray.")
|
|
619 (string, alist, pred)
|
|
620 Lisp_Object string, alist, pred;
|
|
621 {
|
|
622 Lisp_Object tail, elt, eltstring;
|
|
623 Lisp_Object allmatches;
|
|
624 int list = CONSP (alist) || NULL (alist);
|
|
625 int index, obsize;
|
|
626 Lisp_Object bucket, tem;
|
|
627 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
|
|
628
|
|
629 CHECK_STRING (string, 0);
|
|
630 if (!list && XTYPE (alist) != Lisp_Vector)
|
|
631 {
|
|
632 return call3 (alist, string, pred, Qt);
|
|
633 }
|
|
634 allmatches = Qnil;
|
|
635
|
|
636 /* If ALIST is not a list, set TAIL just for gc pro. */
|
|
637 tail = alist;
|
|
638 if (! list)
|
|
639 {
|
|
640 index = 0;
|
|
641 obsize = XVECTOR (alist)->size;
|
|
642 bucket = XVECTOR (alist)->contents[index];
|
|
643 }
|
|
644
|
|
645 while (1)
|
|
646 {
|
|
647 /* Get the next element of the alist or obarray. */
|
|
648 /* Exit the loop if the elements are all used up. */
|
|
649 /* elt gets the alist element or symbol.
|
|
650 eltstring gets the name to check as a completion. */
|
|
651
|
|
652 if (list)
|
|
653 {
|
|
654 if (NULL (tail))
|
|
655 break;
|
|
656 elt = Fcar (tail);
|
|
657 eltstring = Fcar (elt);
|
|
658 tail = Fcdr (tail);
|
|
659 }
|
|
660 else
|
|
661 {
|
|
662 if (XFASTINT (bucket) != 0)
|
|
663 {
|
|
664 elt = bucket;
|
|
665 eltstring = Fsymbol_name (elt);
|
|
666 if (XSYMBOL (bucket)->next)
|
|
667 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
|
|
668 else
|
|
669 XFASTINT (bucket) = 0;
|
|
670 }
|
|
671 else if (++index >= obsize)
|
|
672 break;
|
|
673 else
|
|
674 {
|
|
675 bucket = XVECTOR (alist)->contents[index];
|
|
676 continue;
|
|
677 }
|
|
678 }
|
|
679
|
|
680 /* Is this element a possible completion? */
|
|
681
|
|
682 if (XTYPE (eltstring) == Lisp_String &&
|
|
683 XSTRING (string)->size <= XSTRING (eltstring)->size &&
|
|
684 XSTRING (eltstring)->data[0] != ' ' &&
|
|
685 0 > scmp (XSTRING (eltstring)->data, XSTRING (string)->data,
|
|
686 XSTRING (string)->size))
|
|
687 {
|
|
688 /* Yes. */
|
|
689 /* Ignore this element if there is a predicate
|
|
690 and the predicate doesn't like it. */
|
|
691
|
|
692 if (!NULL (pred))
|
|
693 {
|
|
694 if (EQ (pred, Qcommandp))
|
|
695 tem = Fcommandp (elt);
|
|
696 else
|
|
697 {
|
|
698 GCPRO4 (tail, eltstring, allmatches, string);
|
|
699 tem = call1 (pred, elt);
|
|
700 UNGCPRO;
|
|
701 }
|
|
702 if (NULL (tem)) continue;
|
|
703 }
|
|
704 /* Ok => put it on the list. */
|
|
705 allmatches = Fcons (eltstring, allmatches);
|
|
706 }
|
|
707 }
|
|
708
|
|
709 return Fnreverse (allmatches);
|
|
710 }
|
|
711
|
|
712 Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
|
|
713 Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
|
|
714 Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
|
|
715
|
|
716 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 6, 0,
|
|
717 "Read a string in the minibuffer, with completion.\n\
|
|
718 Args are PROMPT, TABLE, PREDICATE, REQUIRE-MATCH and INITIAL-INPUT.\n\
|
|
719 PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
|
|
720 TABLE is an alist whose elements' cars are strings, or an obarray.\n\
|
|
721 PREDICATE limits completion to a subset of TABLE.\n\
|
|
722 See `try-completion' for more details on completion, TABLE, and PREDICATE.\n\
|
|
723 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless\n\
|
|
724 the input is (or completes to) an element of TABLE.\n\
|
|
725 If it is also not t, Return does not exit if it does non-null completion.\n\
|
|
726 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.\n\
|
|
727 Case is ignored if ambient value of `completion-ignore-case' is non-nil.\n\
|
|
728 If BACKUP-N is specified, point should be placed that many spaces from\n\
|
|
729 the end of the buffer. This is useful when providing default values,\n\
|
|
730 because you can put point before the last component of a filename or any\n\
|
|
731 other component that is likely to be deleted.")
|
|
732 (prompt, table, pred, require_match, init, backup_n)
|
|
733 Lisp_Object prompt, table, pred, require_match, init, backup_n;
|
|
734 {
|
|
735 Lisp_Object val;
|
|
736 int count = specpdl_ptr - specpdl;
|
|
737 specbind (Qminibuffer_completion_table, table);
|
|
738 specbind (Qminibuffer_completion_predicate, pred);
|
|
739 specbind (Qminibuffer_completion_confirm,
|
|
740 EQ (require_match, Qt) ? Qnil : Qt);
|
|
741 last_exact_completion = Qnil;
|
|
742 val = read_minibuf (NULL (require_match)
|
|
743 ? Vminibuffer_local_completion_map
|
|
744 : Vminibuffer_local_must_match_map,
|
|
745 init, prompt, backup_n, 0);
|
|
746 return unbind_to (count, val);
|
|
747 }
|
|
748
|
|
749 /* Temporarily display the string M at the end of the current
|
|
750 minibuffer contents. This is used to display things like
|
|
751 "[No Match]" when the user requests a completion for a prefix
|
|
752 that has no possible completions, and other quick, unobtrusive
|
|
753 messages. */
|
|
754
|
|
755 temp_echo_area_glyphs (m)
|
|
756 char *m;
|
|
757 {
|
|
758 /* It's not very modular to do things this way, but then it seems
|
|
759 to me that the whole echo_area_glyphs thing is a hack anyway. */
|
|
760 extern char *previous_echo_glyphs;
|
|
761
|
|
762 int osize = ZV;
|
|
763 Lisp_Object oinhibit;
|
|
764 oinhibit = Vinhibit_quit;
|
|
765
|
|
766 /* Clear out any old echo-area message to make way for our new
|
|
767 thing. */
|
|
768 echo_area_glyphs = previous_echo_glyphs = 0;
|
|
769
|
|
770 SET_PT (osize);
|
|
771 insert_string (m);
|
|
772 SET_PT (osize);
|
|
773 Vinhibit_quit = Qt;
|
|
774 Fsit_for (make_number (2), Qnil, Qnil);
|
|
775 del_range (point, ZV);
|
|
776 if (!NULL (Vquit_flag))
|
|
777 {
|
|
778 Vquit_flag = Qnil;
|
|
779 unread_command_char = Ctl ('g');
|
|
780 }
|
|
781 Vinhibit_quit = oinhibit;
|
|
782 }
|
|
783
|
|
784 Lisp_Object Fminibuffer_completion_help ();
|
330
|
785 Lisp_Object assoc_for_completion ();
|
284
|
786
|
|
787 /* returns:
|
|
788 * 0 no possible completion
|
|
789 * 1 was already an exact and unique completion
|
|
790 * 3 was already an exact completion
|
|
791 * 4 completed to an exact completion
|
|
792 * 5 some completion happened
|
|
793 * 6 no completion happened
|
|
794 */
|
|
795 int
|
|
796 do_completion ()
|
|
797 {
|
|
798 Lisp_Object completion, tem;
|
|
799 int completedp;
|
|
800 Lisp_Object last;
|
|
801
|
|
802 completion = Ftry_completion (Fbuffer_string (), Vminibuffer_completion_table,
|
|
803 Vminibuffer_completion_predicate);
|
|
804 last = last_exact_completion;
|
|
805 last_exact_completion = Qnil;
|
|
806
|
|
807 if (NULL (completion))
|
|
808 {
|
|
809 bitch_at_user ();
|
|
810 temp_echo_area_glyphs (" [No match]");
|
|
811 return 0;
|
|
812 }
|
|
813
|
|
814 if (EQ (completion, Qt)) /* exact and unique match */
|
|
815 return 1;
|
|
816
|
|
817 /* compiler bug */
|
|
818 tem = Fstring_equal (completion, Fbuffer_string());
|
|
819 if (completedp = NULL (tem))
|
|
820 {
|
|
821 Ferase_buffer (); /* Some completion happened */
|
|
822 Finsert (1, &completion);
|
|
823 }
|
|
824
|
|
825 /* It did find a match. Do we match some possibility exactly now? */
|
|
826 if (CONSP (Vminibuffer_completion_table)
|
|
827 || NULL (Vminibuffer_completion_table))
|
330
|
828 tem = assoc_for_completion (Fbuffer_string (),
|
|
829 Vminibuffer_completion_table);
|
284
|
830 else if (XTYPE (Vminibuffer_completion_table) == Lisp_Vector)
|
|
831 {
|
|
832 /* the primitive used by Fintern_soft */
|
|
833 extern Lisp_Object oblookup ();
|
|
834
|
|
835 tem = Fbuffer_string ();
|
|
836 /* Bypass intern-soft as that loses for nil */
|
|
837 tem = oblookup (Vminibuffer_completion_table,
|
|
838 XSTRING (tem)->data, XSTRING (tem)->size);
|
|
839 if (XTYPE (tem) != Lisp_Symbol)
|
|
840 tem = Qnil;
|
|
841 else if (!NULL (Vminibuffer_completion_predicate))
|
|
842 tem = call1 (Vminibuffer_completion_predicate, tem);
|
|
843 else
|
|
844 tem = Qt;
|
|
845 }
|
|
846 else
|
|
847 tem = call3 (Vminibuffer_completion_table,
|
|
848 Fbuffer_string (),
|
|
849 Vminibuffer_completion_predicate,
|
|
850 Qlambda);
|
|
851
|
|
852 if (NULL (tem))
|
|
853 { /* not an exact match */
|
|
854 if (completedp)
|
|
855 return 5;
|
|
856 else if (auto_help)
|
|
857 Fminibuffer_completion_help ();
|
|
858 else
|
|
859 temp_echo_area_glyphs (" [Next char not unique]");
|
|
860 return 6;
|
|
861 }
|
|
862 else if (completedp)
|
|
863 return 4;
|
|
864 /* If the last exact completion and this one were the same,
|
|
865 it means we've already given a "Complete but not unique"
|
330
|
866 message and the user's hit TAB again, so now we give him help. */
|
284
|
867 last_exact_completion = completion;
|
|
868 if (!NULL (last))
|
|
869 {
|
|
870 tem = Fbuffer_string ();
|
|
871 if (!NULL (Fequal (tem, last)))
|
|
872 Fminibuffer_completion_help ();
|
|
873 }
|
|
874 return 3;
|
|
875 }
|
|
876
|
330
|
877 /* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
|
|
878
|
|
879 Lisp_Object
|
|
880 assoc_for_completion (key, list)
|
|
881 register Lisp_Object key;
|
|
882 Lisp_Object list;
|
|
883 {
|
|
884 register Lisp_Object tail;
|
|
885
|
|
886 if (completion_ignore_case)
|
|
887 key = Fupcase (key);
|
|
888
|
|
889 for (tail = list; !NULL (tail); tail = Fcdr (tail))
|
|
890 {
|
|
891 register Lisp_Object elt, tem, thiscar;
|
|
892 elt = Fcar (tail);
|
|
893 if (!CONSP (elt)) continue;
|
|
894 thiscar = Fcar (elt);
|
|
895 if (XTYPE (thiscar) != Lisp_String)
|
|
896 continue;
|
|
897 if (completion_ignore_case)
|
|
898 thiscar = Fupcase (thiscar);
|
|
899 tem = Fequal (thiscar, key);
|
|
900 if (!NULL (tem)) return elt;
|
|
901 QUIT;
|
|
902 }
|
|
903 return Qnil;
|
|
904 }
|
284
|
905
|
|
906 DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "",
|
|
907 "Complete the minibuffer contents as far as possible.")
|
|
908 ()
|
|
909 {
|
|
910 register int i = do_completion ();
|
|
911 switch (i)
|
|
912 {
|
|
913 case 0:
|
|
914 return Qnil;
|
|
915
|
|
916 case 1:
|
|
917 temp_echo_area_glyphs (" [Sole completion]");
|
|
918 break;
|
|
919
|
|
920 case 3:
|
|
921 temp_echo_area_glyphs (" [Complete, but not unique]");
|
|
922 break;
|
|
923 }
|
|
924
|
|
925 return Qt;
|
|
926 }
|
|
927
|
|
928 DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit,
|
|
929 Sminibuffer_complete_and_exit, 0, 0, "",
|
|
930 "Complete the minibuffer contents, and maybe exit.\n\
|
|
931 Exit if the name is valid with no completion needed.\n\
|
|
932 If name was completed to a valid match,\n\
|
|
933 a repetition of this command will exit.")
|
|
934 ()
|
|
935 {
|
|
936 register int i;
|
|
937
|
|
938 /* Allow user to specify null string */
|
|
939 if (BEGV == ZV)
|
|
940 goto exit;
|
|
941
|
|
942 i = do_completion ();
|
|
943 switch (i)
|
|
944 {
|
|
945 case 1:
|
|
946 case 3:
|
|
947 goto exit;
|
|
948
|
|
949 case 4:
|
|
950 if (!NULL (Vminibuffer_completion_confirm))
|
|
951 {
|
|
952 temp_echo_area_glyphs (" [Confirm]");
|
|
953 return Qnil;
|
|
954 }
|
|
955 else
|
|
956 goto exit;
|
|
957
|
|
958 default:
|
|
959 return Qnil;
|
|
960 }
|
|
961 exit:
|
|
962 Fthrow (Qexit, Qnil);
|
|
963 /* NOTREACHED */
|
|
964 }
|
|
965
|
|
966 DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word,
|
|
967 0, 0, "",
|
|
968 "Complete the minibuffer contents at most a single word.\n\
|
|
969 After one word is completed as much as possible, a space or hyphen\n\
|
|
970 is added, provided that matches some possible completion.")
|
|
971 ()
|
|
972 {
|
|
973 Lisp_Object completion, tem;
|
|
974 register int i;
|
|
975 register unsigned char *completion_string;
|
|
976 /* We keep calling Fbuffer_string
|
|
977 rather than arrange for GC to hold onto a pointer to
|
|
978 one of the strings thus made. */
|
|
979
|
|
980 completion = Ftry_completion (Fbuffer_string (),
|
|
981 Vminibuffer_completion_table,
|
|
982 Vminibuffer_completion_predicate);
|
|
983 if (NULL (completion))
|
|
984 {
|
|
985 bitch_at_user ();
|
|
986 temp_echo_area_glyphs (" [No match]");
|
|
987 return Qnil;
|
|
988 }
|
|
989 if (EQ (completion, Qt))
|
|
990 return Qnil;
|
|
991
|
|
992 #if 0 /* How the below code used to look, for reference */
|
|
993 tem = Fbuffer_string ();
|
|
994 b = XSTRING (tem)->data;
|
|
995 i = ZV - 1 - XSTRING (completion)->size;
|
|
996 p = XSTRING (completion)->data;
|
|
997 if (i > 0 ||
|
|
998 0 <= scmp (b, p, ZV - 1))
|
|
999 {
|
|
1000 i = 1;
|
|
1001 /* Set buffer to longest match of buffer tail and completion head. */
|
|
1002 while (0 <= scmp (b + i, p, ZV - 1 - i))
|
|
1003 i++;
|
|
1004 del_range (1, i + 1);
|
|
1005 SET_PT (ZV);
|
|
1006 }
|
|
1007 #else /* Rewritten code */
|
|
1008 {
|
|
1009 register unsigned char *buffer_string;
|
|
1010 int buffer_length, completion_length;
|
|
1011
|
|
1012 tem = Fbuffer_string ();
|
|
1013 buffer_string = XSTRING (tem)->data;
|
|
1014 completion_string = XSTRING (completion)->data;
|
|
1015 buffer_length = XSTRING (tem)->size; /* ie ZV - BEGV */
|
|
1016 completion_length = XSTRING (completion)->size;
|
|
1017 i = buffer_length - completion_length;
|
|
1018 /* Mly: I don't understand what this is supposed to do AT ALL */
|
|
1019 if (i > 0 ||
|
|
1020 0 <= scmp (buffer_string, completion_string, buffer_length))
|
|
1021 {
|
|
1022 /* Set buffer to longest match of buffer tail and completion head. */
|
|
1023 if (i <= 0) i = 1;
|
|
1024 buffer_string += i;
|
|
1025 buffer_length -= i;
|
|
1026 while (0 <= scmp (buffer_string++, completion_string, buffer_length--))
|
|
1027 i++;
|
|
1028 del_range (1, i + 1);
|
|
1029 SET_PT (ZV);
|
|
1030 }
|
|
1031 }
|
|
1032 #endif /* Rewritten code */
|
|
1033 i = ZV - BEGV;
|
|
1034
|
|
1035 /* If completion finds next char not unique,
|
|
1036 consider adding a space or a hyphen */
|
|
1037 if (i == XSTRING (completion)->size)
|
|
1038 {
|
|
1039 tem = Ftry_completion (concat2 (Fbuffer_string (), build_string (" ")),
|
|
1040 Vminibuffer_completion_table,
|
|
1041 Vminibuffer_completion_predicate);
|
|
1042 if (XTYPE (tem) == Lisp_String)
|
|
1043 completion = tem;
|
|
1044 else
|
|
1045 {
|
|
1046 tem = Ftry_completion (concat2 (Fbuffer_string (), build_string ("-")),
|
|
1047 Vminibuffer_completion_table,
|
|
1048 Vminibuffer_completion_predicate);
|
|
1049 if (XTYPE (tem) == Lisp_String)
|
|
1050 completion = tem;
|
|
1051 }
|
|
1052 }
|
|
1053
|
|
1054 /* Now find first word-break in the stuff found by completion.
|
|
1055 i gets index in string of where to stop completing. */
|
|
1056 completion_string = XSTRING (completion)->data;
|
|
1057
|
|
1058 for (; i < XSTRING (completion)->size; i++)
|
|
1059 if (SYNTAX (completion_string[i]) != Sword) break;
|
|
1060 if (i < XSTRING (completion)->size)
|
|
1061 i = i + 1;
|
|
1062
|
|
1063 /* If got no characters, print help for user. */
|
|
1064
|
|
1065 if (i == ZV - BEGV)
|
|
1066 {
|
|
1067 if (auto_help)
|
|
1068 Fminibuffer_completion_help ();
|
|
1069 return Qnil;
|
|
1070 }
|
|
1071
|
|
1072 /* Otherwise insert in minibuffer the chars we got */
|
|
1073
|
|
1074 Ferase_buffer ();
|
|
1075 insert_from_string (completion, 0, i);
|
|
1076 return Qt;
|
|
1077 }
|
|
1078
|
|
1079 DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list,
|
|
1080 1, 1, 0,
|
|
1081 "Display in a buffer the list of completions, COMPLETIONS.\n\
|
|
1082 Each element may be just a symbol or string\n\
|
|
1083 or may be a list of two strings to be printed as if concatenated.")
|
|
1084 (completions)
|
|
1085 Lisp_Object completions;
|
|
1086 {
|
|
1087 register Lisp_Object tail, elt;
|
|
1088 register int i;
|
|
1089 struct buffer *old = current_buffer;
|
|
1090 /* No GCPRO needed, since (when it matters) every variable
|
|
1091 points to a non-string that is pointed to by COMPLETIONS. */
|
|
1092
|
|
1093 set_buffer_internal (XBUFFER (Vstandard_output));
|
|
1094
|
|
1095 if (NULL (completions))
|
|
1096 insert_string ("There are no possible completions of what you have typed.");
|
|
1097 else
|
|
1098 {
|
|
1099 insert_string ("Possible completions are:");
|
|
1100 for (tail = completions, i = 0; !NULL (tail); tail = Fcdr (tail), i++)
|
|
1101 {
|
|
1102 /* this needs fixing for the case of long completions
|
|
1103 and/or narrow windows */
|
|
1104 /* Sadly, the window it will appear in is not known
|
|
1105 until after the text has been made. */
|
|
1106 if (i & 1)
|
|
1107 Findent_to (make_number (35), make_number (1));
|
|
1108 else
|
|
1109 Fterpri (Qnil);
|
|
1110 elt = Fcar (tail);
|
|
1111 if (CONSP (elt))
|
|
1112 {
|
|
1113 Fprinc (Fcar (elt), Qnil);
|
|
1114 Fprinc (Fcar (Fcdr (elt)), Qnil);
|
|
1115 }
|
|
1116 else
|
|
1117 Fprinc (elt, Qnil);
|
|
1118 }
|
|
1119 }
|
|
1120 set_buffer_internal (old);
|
|
1121 return Qnil;
|
|
1122 }
|
|
1123
|
|
1124 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
|
|
1125 0, 0, "",
|
|
1126 "Display a list of possible completions of the current minibuffer contents.")
|
|
1127 ()
|
|
1128 {
|
|
1129 Lisp_Object completions;
|
|
1130
|
|
1131 message ("Making completion list...");
|
|
1132 completions = Fall_completions (Fbuffer_string (),
|
|
1133 Vminibuffer_completion_table,
|
|
1134 Vminibuffer_completion_predicate);
|
|
1135 echo_area_glyphs = 0;
|
|
1136
|
|
1137 if (NULL (completions))
|
|
1138 {
|
|
1139 bitch_at_user ();
|
|
1140 temp_echo_area_glyphs (" [No completions]");
|
|
1141 }
|
|
1142 else
|
|
1143 internal_with_output_to_temp_buffer ("*Completions*",
|
|
1144 Fdisplay_completion_list,
|
|
1145 Fsort (completions, Qstring_lessp));
|
|
1146 return Qnil;
|
|
1147 }
|
|
1148
|
|
1149 DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "",
|
|
1150 "Terminate minibuffer input.")
|
|
1151 ()
|
|
1152 {
|
|
1153 if (XTYPE (last_command_char) == Lisp_Int)
|
|
1154 internal_self_insert (last_command_char, 0);
|
|
1155 else
|
|
1156 bitch_at_user ();
|
|
1157
|
|
1158 Fthrow (Qexit, Qnil);
|
|
1159 }
|
|
1160
|
|
1161 DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
|
|
1162 "Terminate this minibuffer argument.")
|
|
1163 ()
|
|
1164 {
|
|
1165 Fthrow (Qexit, Qnil);
|
|
1166 }
|
|
1167
|
|
1168 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
|
|
1169 "Return current depth of activations of minibuffer, a nonnegative integer.")
|
|
1170 ()
|
|
1171 {
|
|
1172 return make_number (minibuf_level);
|
|
1173 }
|
|
1174
|
|
1175
|
|
1176 init_minibuf_once ()
|
|
1177 {
|
|
1178 Vminibuffer_list = Qnil;
|
|
1179 staticpro (&Vminibuffer_list);
|
|
1180 }
|
|
1181
|
|
1182 syms_of_minibuf ()
|
|
1183 {
|
|
1184 minibuf_level = 0;
|
|
1185 minibuf_prompt = 0;
|
|
1186 minibuf_save_vector_size = 5;
|
|
1187 minibuf_save_vector = (struct minibuf_save_data *) malloc (5 * sizeof (struct minibuf_save_data));
|
|
1188
|
|
1189 Qminibuffer_completion_table = intern ("minibuffer-completion-table");
|
|
1190 staticpro (&Qminibuffer_completion_table);
|
|
1191
|
|
1192 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
|
|
1193 staticpro (&Qminibuffer_completion_confirm);
|
|
1194
|
|
1195 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
|
|
1196 staticpro (&Qminibuffer_completion_predicate);
|
|
1197
|
|
1198 staticpro (&last_minibuf_string);
|
|
1199 last_minibuf_string = Qnil;
|
|
1200
|
|
1201 Quser_variable_p = intern ("user-variable-p");
|
|
1202 staticpro (&Quser_variable_p);
|
|
1203
|
|
1204
|
|
1205
|
|
1206 DEFVAR_BOOL ("completion-auto-help", &auto_help,
|
|
1207 "*Non-nil means automatically provide help for invalid completion input.");
|
|
1208 auto_help = 1;
|
|
1209
|
|
1210 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
|
|
1211 "Non-nil means don't consider case significant in completion.");
|
|
1212 completion_ignore_case = 0;
|
|
1213
|
|
1214 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers,
|
|
1215 "*Non-nil means to allow minibuffer commands while in the minibuffer.\n\
|
|
1216 More precisely, this variable makes a difference when the minibuffer window\n\
|
|
1217 is the selected window. If you are in some other window, minibuffer commands\n\
|
|
1218 are allowed even if a minibuffer is active.");
|
|
1219 enable_recursive_minibuffers = 0;
|
|
1220
|
|
1221 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table,
|
|
1222 "Alist or obarray used for completion in the minibuffer.\n\
|
|
1223 This becomes the ALIST argument to `try-completion' and `all-completion'.\n\
|
|
1224 \n\
|
|
1225 The value may alternatively be a function, which is given three arguments:\n\
|
|
1226 STRING, the current buffer contents;\n\
|
|
1227 PREDICATE, the predicate for filtering possible matches;\n\
|
|
1228 CODE, which says what kind of things to do.\n\
|
|
1229 CODE can be nil, t or `lambda'.\n\
|
|
1230 nil means to return the best completion of STRING, or nil if there is none.\n\
|
|
1231 t means to return a list of all possible completions of STRING.\n\
|
|
1232 `lambda' means to return t if STRING is a valid completion as it stands.");
|
|
1233 Vminibuffer_completion_table = Qnil;
|
|
1234
|
|
1235 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
|
|
1236 "Within call to `completing-read', this holds the PREDICATE argument.");
|
|
1237 Vminibuffer_completion_predicate = Qnil;
|
|
1238
|
|
1239 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
|
|
1240 "Non-nil => demand confirmation of completion before exiting minibuffer.");
|
|
1241 Vminibuffer_completion_confirm = Qnil;
|
|
1242
|
|
1243 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
|
|
1244 "Value that `help-form' takes on inside the minibuffer.");
|
|
1245 Vminibuffer_help_form = Qnil;
|
|
1246
|
|
1247 defsubr (&Sread_from_minibuffer);
|
|
1248 defsubr (&Seval_minibuffer);
|
|
1249 defsubr (&Sread_minibuffer);
|
|
1250 defsubr (&Sread_string);
|
|
1251 defsubr (&Sread_command);
|
|
1252 defsubr (&Sread_variable);
|
|
1253 defsubr (&Sread_buffer);
|
|
1254 defsubr (&Sread_no_blanks_input);
|
|
1255 defsubr (&Sminibuffer_depth);
|
|
1256
|
|
1257 defsubr (&Stry_completion);
|
|
1258 defsubr (&Sall_completions);
|
|
1259 defsubr (&Scompleting_read);
|
|
1260 defsubr (&Sminibuffer_complete);
|
|
1261 defsubr (&Sminibuffer_complete_word);
|
|
1262 defsubr (&Sminibuffer_complete_and_exit);
|
|
1263 defsubr (&Sdisplay_completion_list);
|
|
1264 defsubr (&Sminibuffer_completion_help);
|
|
1265
|
|
1266 defsubr (&Sself_insert_and_exit);
|
|
1267 defsubr (&Sexit_minibuffer);
|
|
1268
|
|
1269 }
|
|
1270
|
|
1271 keys_of_minibuf ()
|
|
1272 {
|
|
1273 initial_define_key (Vminibuffer_local_map, Ctl ('g'),
|
|
1274 "abort-recursive-edit");
|
|
1275 initial_define_key (Vminibuffer_local_map, Ctl ('m'),
|
|
1276 "exit-minibuffer");
|
|
1277 initial_define_key (Vminibuffer_local_map, Ctl ('j'),
|
|
1278 "exit-minibuffer");
|
|
1279
|
|
1280 initial_define_key (Vminibuffer_local_ns_map, Ctl ('g'),
|
|
1281 "abort-recursive-edit");
|
|
1282 initial_define_key (Vminibuffer_local_ns_map, Ctl ('m'),
|
|
1283 "exit-minibuffer");
|
|
1284 initial_define_key (Vminibuffer_local_ns_map, Ctl ('j'),
|
|
1285 "exit-minibuffer");
|
|
1286
|
|
1287 initial_define_key (Vminibuffer_local_ns_map, ' ',
|
|
1288 "exit-minibuffer");
|
|
1289 initial_define_key (Vminibuffer_local_ns_map, '\t',
|
|
1290 "exit-minibuffer");
|
|
1291 initial_define_key (Vminibuffer_local_ns_map, '?',
|
|
1292 "self-insert-and-exit");
|
|
1293
|
|
1294 initial_define_key (Vminibuffer_local_completion_map, Ctl ('g'),
|
|
1295 "abort-recursive-edit");
|
|
1296 initial_define_key (Vminibuffer_local_completion_map, Ctl ('m'),
|
|
1297 "exit-minibuffer");
|
|
1298 initial_define_key (Vminibuffer_local_completion_map, Ctl ('j'),
|
|
1299 "exit-minibuffer");
|
|
1300
|
|
1301 initial_define_key (Vminibuffer_local_completion_map, '\t',
|
|
1302 "minibuffer-complete");
|
|
1303 initial_define_key (Vminibuffer_local_completion_map, ' ',
|
|
1304 "minibuffer-complete-word");
|
|
1305 initial_define_key (Vminibuffer_local_completion_map, '?',
|
|
1306 "minibuffer-completion-help");
|
|
1307
|
|
1308 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('g'),
|
|
1309 "abort-recursive-edit");
|
|
1310 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
|
|
1311 "minibuffer-complete-and-exit");
|
|
1312 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
|
|
1313 "minibuffer-complete-and-exit");
|
|
1314 initial_define_key (Vminibuffer_local_must_match_map, '\t',
|
|
1315 "minibuffer-complete");
|
|
1316 initial_define_key (Vminibuffer_local_must_match_map, ' ',
|
|
1317 "minibuffer-complete-word");
|
|
1318 initial_define_key (Vminibuffer_local_must_match_map, '?',
|
|
1319 "minibuffer-completion-help");
|
|
1320 }
|