1/* Minibuffer input and completion. 2 Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2001, 2002, 2003, 2004, 2005, 4 2006, 2007 Free Software Foundation, Inc. 5 6This file is part of GNU Emacs. 7 8GNU Emacs is free software; you can redistribute it and/or modify 9it under the terms of the GNU General Public License as published by 10the Free Software Foundation; either version 2, or (at your option) 11any later version. 12 13GNU Emacs is distributed in the hope that it will be useful, 14but WITHOUT ANY WARRANTY; without even the implied warranty of 15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16GNU General Public License for more details. 17 18You should have received a copy of the GNU General Public License 19along with GNU Emacs; see the file COPYING. If not, write to 20the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 21Boston, MA 02110-1301, USA. */ 22 23 24#include <config.h> 25#include <stdio.h> 26 27#include "lisp.h" 28#include "commands.h" 29#include "buffer.h" 30#include "charset.h" 31#include "dispextern.h" 32#include "keyboard.h" 33#include "frame.h" 34#include "window.h" 35#include "syntax.h" 36#include "intervals.h" 37#include "keymap.h" 38 39extern int quit_char; 40 41/* List of buffers for use as minibuffers. 42 The first element of the list is used for the outermost minibuffer 43 invocation, the next element is used for a recursive minibuffer 44 invocation, etc. The list is extended at the end as deeper 45 minibuffer recursions are encountered. */ 46 47Lisp_Object Vminibuffer_list; 48 49/* Data to remember during recursive minibuffer invocations */ 50 51Lisp_Object minibuf_save_list; 52 53/* Depth in minibuffer invocations. */ 54 55int minibuf_level; 56 57/* Nonzero means display completion help for invalid input. */ 58 59Lisp_Object Vcompletion_auto_help; 60 61/* The maximum length of a minibuffer history. */ 62 63Lisp_Object Qhistory_length, Vhistory_length; 64 65/* No duplicates in history. */ 66 67int history_delete_duplicates; 68 69/* Non-nil means add new input to history. */ 70 71Lisp_Object Vhistory_add_new_input; 72 73/* Fread_minibuffer leaves the input here as a string. */ 74 75Lisp_Object last_minibuf_string; 76 77/* Nonzero means let functions called when within a minibuffer 78 invoke recursive minibuffers (to read arguments, or whatever) */ 79 80int enable_recursive_minibuffers; 81 82/* Nonzero means don't ignore text properties 83 in Fread_from_minibuffer. */ 84 85int minibuffer_allow_text_properties; 86 87/* help-form is bound to this while in the minibuffer. */ 88 89Lisp_Object Vminibuffer_help_form; 90 91/* Variable which is the history list to add minibuffer values to. */ 92 93Lisp_Object Vminibuffer_history_variable; 94 95/* Current position in the history list (adjusted by M-n and M-p). */ 96 97Lisp_Object Vminibuffer_history_position; 98 99/* Text properties that are added to minibuffer prompts. 100 These are in addition to the basic `field' property, and stickiness 101 properties. */ 102 103Lisp_Object Vminibuffer_prompt_properties; 104 105Lisp_Object Qminibuffer_history, Qbuffer_name_history; 106 107Lisp_Object Qread_file_name_internal; 108 109/* Normal hooks for entry to and exit from minibuffer. */ 110 111Lisp_Object Qminibuffer_setup_hook, Vminibuffer_setup_hook; 112Lisp_Object Qminibuffer_exit_hook, Vminibuffer_exit_hook; 113 114/* Function to call to read a buffer name. */ 115Lisp_Object Vread_buffer_function; 116 117/* Nonzero means completion ignores case. */ 118 119int completion_ignore_case; 120 121/* List of regexps that should restrict possible completions. */ 122 123Lisp_Object Vcompletion_regexp_list; 124 125/* Nonzero means raise the minibuffer frame when the minibuffer 126 is entered. */ 127 128int minibuffer_auto_raise; 129 130/* If last completion attempt reported "Complete but not unique" 131 then this is the string completed then; otherwise this is nil. */ 132 133static Lisp_Object last_exact_completion; 134 135/* Keymap for reading expressions. */ 136Lisp_Object Vread_expression_map; 137 138Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table; 139Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate; 140Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm; 141Lisp_Object Vminibuffer_completing_file_name; 142 143Lisp_Object Quser_variable_p; 144 145Lisp_Object Qminibuffer_default; 146 147Lisp_Object Qcurrent_input_method, Qactivate_input_method; 148 149Lisp_Object Qcase_fold_search; 150 151Lisp_Object Qread_expression_history; 152 153extern Lisp_Object Voverriding_local_map; 154 155extern Lisp_Object Qmouse_face; 156 157extern Lisp_Object Qfield; 158 159/* Put minibuf on currently selected frame's minibuffer. 160 We do this whenever the user starts a new minibuffer 161 or when a minibuffer exits. */ 162 163void 164choose_minibuf_frame () 165{ 166 if (FRAMEP (selected_frame) 167 && FRAME_LIVE_P (XFRAME (selected_frame)) 168 && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window)) 169 { 170 struct frame *sf = XFRAME (selected_frame); 171 Lisp_Object buffer; 172 173 /* I don't think that any frames may validly have a null minibuffer 174 window anymore. */ 175 if (NILP (sf->minibuffer_window)) 176 abort (); 177 178 /* Under X, we come here with minibuf_window being the 179 minibuffer window of the unused termcap window created in 180 init_window_once. That window doesn't have a buffer. */ 181 buffer = XWINDOW (minibuf_window)->buffer; 182 if (BUFFERP (buffer)) 183 Fset_window_buffer (sf->minibuffer_window, buffer, Qnil); 184 minibuf_window = sf->minibuffer_window; 185 } 186 187 /* Make sure no other frame has a minibuffer as its selected window, 188 because the text would not be displayed in it, and that would be 189 confusing. Only allow the selected frame to do this, 190 and that only if the minibuffer is active. */ 191 { 192 Lisp_Object tail, frame; 193 194 FOR_EACH_FRAME (tail, frame) 195 if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame)))) 196 && !(EQ (frame, selected_frame) 197 && minibuf_level > 0)) 198 Fset_frame_selected_window (frame, Fframe_first_window (frame)); 199 } 200} 201 202Lisp_Object 203choose_minibuf_frame_1 (ignore) 204 Lisp_Object ignore; 205{ 206 choose_minibuf_frame (); 207 return Qnil; 208} 209 210DEFUN ("set-minibuffer-window", Fset_minibuffer_window, 211 Sset_minibuffer_window, 1, 1, 0, 212 doc: /* Specify which minibuffer window to use for the minibuffer. 213This affects where the minibuffer is displayed if you put text in it 214without invoking the usual minibuffer commands. */) 215 (window) 216 Lisp_Object window; 217{ 218 CHECK_WINDOW (window); 219 if (! MINI_WINDOW_P (XWINDOW (window))) 220 error ("Window is not a minibuffer window"); 221 222 minibuf_window = window; 223 224 return window; 225} 226 227 228/* Actual minibuffer invocation. */ 229 230static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object)); 231static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object)); 232static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object, 233 Lisp_Object, Lisp_Object, 234 int, Lisp_Object, 235 Lisp_Object, Lisp_Object, 236 int, int)); 237static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object, 238 Lisp_Object, Lisp_Object, 239 int, Lisp_Object, 240 Lisp_Object, Lisp_Object, 241 int, int)); 242static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object)); 243 244 245/* Read a Lisp object from VAL and return it. If VAL is an empty 246 string, and DEFALT is a string, read from DEFALT instead of VAL. */ 247 248static Lisp_Object 249string_to_object (val, defalt) 250 Lisp_Object val, defalt; 251{ 252 struct gcpro gcpro1, gcpro2; 253 Lisp_Object expr_and_pos; 254 int pos; 255 256 GCPRO2 (val, defalt); 257 258 if (STRINGP (val) && SCHARS (val) == 0 259 && STRINGP (defalt)) 260 val = defalt; 261 262 expr_and_pos = Fread_from_string (val, Qnil, Qnil); 263 pos = XINT (Fcdr (expr_and_pos)); 264 if (pos != SCHARS (val)) 265 { 266 /* Ignore trailing whitespace; any other trailing junk 267 is an error. */ 268 int i; 269 pos = string_char_to_byte (val, pos); 270 for (i = pos; i < SBYTES (val); i++) 271 { 272 int c = SREF (val, i); 273 if (c != ' ' && c != '\t' && c != '\n') 274 error ("Trailing garbage following expression"); 275 } 276 } 277 278 val = Fcar (expr_and_pos); 279 RETURN_UNGCPRO (val); 280} 281 282 283/* Like read_minibuf but reading from stdin. This function is called 284 from read_minibuf to do the job if noninteractive. */ 285 286static Lisp_Object 287read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag, 288 histvar, histpos, defalt, allow_props, 289 inherit_input_method) 290 Lisp_Object map; 291 Lisp_Object initial; 292 Lisp_Object prompt; 293 Lisp_Object backup_n; 294 int expflag; 295 Lisp_Object histvar; 296 Lisp_Object histpos; 297 Lisp_Object defalt; 298 int allow_props; 299 int inherit_input_method; 300{ 301 int size, len; 302 char *line, *s; 303 Lisp_Object val; 304 305 fprintf (stdout, "%s", SDATA (prompt)); 306 fflush (stdout); 307 308 val = Qnil; 309 size = 100; 310 len = 0; 311 line = (char *) xmalloc (size * sizeof *line); 312 while ((s = fgets (line + len, size - len, stdin)) != NULL 313 && (len = strlen (line), 314 len == size - 1 && line[len - 1] != '\n')) 315 { 316 size *= 2; 317 line = (char *) xrealloc (line, size); 318 } 319 320 if (s) 321 { 322 len = strlen (line); 323 324 if (len > 0 && line[len - 1] == '\n') 325 line[--len] = '\0'; 326 327 val = build_string (line); 328 xfree (line); 329 } 330 else 331 { 332 xfree (line); 333 error ("Error reading from stdin"); 334 } 335 336 /* If Lisp form desired instead of string, parse it. */ 337 if (expflag) 338 val = string_to_object (val, defalt); 339 340 return val; 341} 342 343DEFUN ("minibufferp", Fminibufferp, 344 Sminibufferp, 0, 1, 0, 345 doc: /* Return t if BUFFER is a minibuffer. 346No argument or nil as argument means use current buffer as BUFFER. 347BUFFER can be a buffer or a buffer name. */) 348 (buffer) 349 Lisp_Object buffer; 350{ 351 Lisp_Object tem; 352 353 if (NILP (buffer)) 354 buffer = Fcurrent_buffer (); 355 else if (STRINGP (buffer)) 356 buffer = Fget_buffer (buffer); 357 else 358 CHECK_BUFFER (buffer); 359 360 tem = Fmemq (buffer, Vminibuffer_list); 361 return ! NILP (tem) ? Qt : Qnil; 362} 363 364DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end, 365 Sminibuffer_prompt_end, 0, 0, 0, 366 doc: /* Return the buffer position of the end of the minibuffer prompt. 367Return (point-min) if current buffer is not a minibuffer. */) 368 () 369{ 370 /* This function is written to be most efficient when there's a prompt. */ 371 Lisp_Object beg, end, tem; 372 beg = make_number (BEGV); 373 374 tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list); 375 if (NILP (tem)) 376 return beg; 377 378 end = Ffield_end (beg, Qnil, Qnil); 379 380 if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil))) 381 return beg; 382 else 383 return end; 384} 385 386DEFUN ("minibuffer-contents", Fminibuffer_contents, 387 Sminibuffer_contents, 0, 0, 0, 388 doc: /* Return the user input in a minibuffer as a string. 389If the current buffer is not a minibuffer, return its entire contents. */) 390 () 391{ 392 int prompt_end = XINT (Fminibuffer_prompt_end ()); 393 return make_buffer_string (prompt_end, ZV, 1); 394} 395 396DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties, 397 Sminibuffer_contents_no_properties, 0, 0, 0, 398 doc: /* Return the user input in a minibuffer as a string, without text-properties. 399If the current buffer is not a minibuffer, return its entire contents. */) 400 () 401{ 402 int prompt_end = XINT (Fminibuffer_prompt_end ()); 403 return make_buffer_string (prompt_end, ZV, 0); 404} 405 406DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents, 407 Sminibuffer_completion_contents, 0, 0, 0, 408 doc: /* Return the user input in a minibuffer before point as a string. 409That is what completion commands operate on. 410If the current buffer is not a minibuffer, return its entire contents. */) 411 () 412{ 413 int prompt_end = XINT (Fminibuffer_prompt_end ()); 414 if (PT < prompt_end) 415 error ("Cannot do completion in the prompt"); 416 return make_buffer_string (prompt_end, PT, 1); 417} 418 419DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents, 420 Sdelete_minibuffer_contents, 0, 0, 0, 421 doc: /* Delete all user input in a minibuffer. 422If the current buffer is not a minibuffer, erase its entire contents. */) 423 () 424{ 425 int prompt_end = XINT (Fminibuffer_prompt_end ()); 426 if (prompt_end < ZV) 427 del_range (prompt_end, ZV); 428 return Qnil; 429} 430 431 432/* Read from the minibuffer using keymap MAP and initial contents INITIAL, 433 putting point minus BACKUP_N bytes from the end of INITIAL, 434 prompting with PROMPT (a string), using history list HISTVAR 435 with initial position HISTPOS. INITIAL should be a string or a 436 cons of a string and an integer. BACKUP_N should be <= 0, or 437 Qnil, which is equivalent to 0. If INITIAL is a cons, BACKUP_N is 438 ignored and replaced with an integer that puts point at one-indexed 439 position N in INITIAL, where N is the CDR of INITIAL, or at the 440 beginning of INITIAL if N <= 0. 441 442 Normally return the result as a string (the text that was read), 443 but if EXPFLAG is nonzero, read it and return the object read. 444 If HISTVAR is given, save the value read on that history only if it doesn't 445 match the front of that history list exactly. The value is pushed onto 446 the list as the string that was read. 447 448 DEFALT specifies the default value for the sake of history commands. 449 450 If ALLOW_PROPS is nonzero, we do not throw away text properties. 451 452 if INHERIT_INPUT_METHOD is nonzero, the minibuffer inherits the 453 current input method. */ 454 455static Lisp_Object 456read_minibuf (map, initial, prompt, backup_n, expflag, 457 histvar, histpos, defalt, allow_props, inherit_input_method) 458 Lisp_Object map; 459 Lisp_Object initial; 460 Lisp_Object prompt; 461 Lisp_Object backup_n; 462 int expflag; 463 Lisp_Object histvar; 464 Lisp_Object histpos; 465 Lisp_Object defalt; 466 int allow_props; 467 int inherit_input_method; 468{ 469 Lisp_Object val; 470 int count = SPECPDL_INDEX (); 471 Lisp_Object mini_frame, ambient_dir, minibuffer, input_method; 472 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; 473 Lisp_Object enable_multibyte; 474 int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0; 475 /* String to add to the history. */ 476 Lisp_Object histstring; 477 478 Lisp_Object empty_minibuf; 479 Lisp_Object dummy, frame; 480 481 extern Lisp_Object Qfront_sticky; 482 extern Lisp_Object Qrear_nonsticky; 483 484 specbind (Qminibuffer_default, defalt); 485 486 /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t 487 in previous recursive minibuffer, but was not set explicitly 488 to t for this invocation, so set it to nil in this minibuffer. 489 Save the old value now, before we change it. */ 490 specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name); 491 if (EQ (Vminibuffer_completing_file_name, Qlambda)) 492 Vminibuffer_completing_file_name = Qnil; 493 494 single_kboard_state (); 495#ifdef HAVE_X_WINDOWS 496 if (display_hourglass_p) 497 cancel_hourglass (); 498#endif 499 500 if (!NILP (initial)) 501 { 502 if (CONSP (initial)) 503 { 504 backup_n = Fcdr (initial); 505 initial = Fcar (initial); 506 CHECK_STRING (initial); 507 if (!NILP (backup_n)) 508 { 509 CHECK_NUMBER (backup_n); 510 /* Convert to distance from end of input. */ 511 if (XINT (backup_n) < 1) 512 /* A number too small means the beginning of the string. */ 513 pos = - SCHARS (initial); 514 else 515 pos = XINT (backup_n) - 1 - SCHARS (initial); 516 } 517 } 518 else 519 CHECK_STRING (initial); 520 } 521 val = Qnil; 522 ambient_dir = current_buffer->directory; 523 input_method = Qnil; 524 enable_multibyte = Qnil; 525 526 /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we 527 store them away before we can GC. Don't need to protect 528 BACKUP_N because we use the value only if it is an integer. */ 529 GCPRO5 (map, initial, val, ambient_dir, input_method); 530 531 if (!STRINGP (prompt)) 532 prompt = empty_string; 533 534 if (!enable_recursive_minibuffers 535 && minibuf_level > 0) 536 { 537 if (EQ (selected_window, minibuf_window)) 538 error ("Command attempted to use minibuffer while in minibuffer"); 539 else 540 /* If we're in another window, cancel the minibuffer that's active. */ 541 Fthrow (Qexit, 542 build_string ("Command attempted to use minibuffer while in minibuffer")); 543 } 544 545 if (noninteractive && NILP (Vexecuting_kbd_macro)) 546 { 547 val = read_minibuf_noninteractive (map, initial, prompt, 548 make_number (pos), 549 expflag, histvar, histpos, defalt, 550 allow_props, inherit_input_method); 551 UNGCPRO; 552 return unbind_to (count, val); 553 } 554 555 /* Choose the minibuffer window and frame, and take action on them. */ 556 557 choose_minibuf_frame (); 558 559 record_unwind_protect (choose_minibuf_frame_1, Qnil); 560 561 record_unwind_protect (Fset_window_configuration, 562 Fcurrent_window_configuration (Qnil)); 563 564 /* If the minibuffer window is on a different frame, save that 565 frame's configuration too. */ 566 mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window)); 567 if (!EQ (mini_frame, selected_frame)) 568 record_unwind_protect (Fset_window_configuration, 569 Fcurrent_window_configuration (mini_frame)); 570 571 /* If the minibuffer is on an iconified or invisible frame, 572 make it visible now. */ 573 Fmake_frame_visible (mini_frame); 574 575 if (minibuffer_auto_raise) 576 Fraise_frame (mini_frame); 577 578 /* We have to do this after saving the window configuration 579 since that is what restores the current buffer. */ 580 581 /* Arrange to restore a number of minibuffer-related variables. 582 We could bind each variable separately, but that would use lots of 583 specpdl slots. */ 584 minibuf_save_list 585 = Fcons (Voverriding_local_map, 586 Fcons (minibuf_window, 587 minibuf_save_list)); 588 minibuf_save_list 589 = Fcons (minibuf_prompt, 590 Fcons (make_number (minibuf_prompt_width), 591 Fcons (Vhelp_form, 592 Fcons (Vcurrent_prefix_arg, 593 Fcons (Vminibuffer_history_position, 594 Fcons (Vminibuffer_history_variable, 595 minibuf_save_list)))))); 596 597 record_unwind_protect (read_minibuf_unwind, Qnil); 598 minibuf_level++; 599 /* We are exiting the minibuffer one way or the other, so run the hook. 600 It should be run before unwinding the minibuf settings. Do it 601 separately from read_minibuf_unwind because we need to make sure that 602 read_minibuf_unwind is fully executed even if exit-minibuffer-hook 603 signals an error. --Stef */ 604 record_unwind_protect (run_exit_minibuf_hook, Qnil); 605 606 /* Now that we can restore all those variables, start changing them. */ 607 608 minibuf_prompt_width = 0; 609 minibuf_prompt = Fcopy_sequence (prompt); 610 Vminibuffer_history_position = histpos; 611 Vminibuffer_history_variable = histvar; 612 Vhelp_form = Vminibuffer_help_form; 613 /* If this minibuffer is reading a file name, that doesn't mean 614 recursive ones are. But we cannot set it to nil, because 615 completion code still need to know the minibuffer is completing a 616 file name. So use `lambda' as intermediate value meaning 617 "t" in this minibuffer, but "nil" in next minibuffer. */ 618 if (!NILP (Vminibuffer_completing_file_name)) 619 Vminibuffer_completing_file_name = Qlambda; 620 621 if (inherit_input_method) 622 { 623 /* `current-input-method' is buffer local. So, remember it in 624 INPUT_METHOD before changing the current buffer. */ 625 input_method = Fsymbol_value (Qcurrent_input_method); 626 enable_multibyte = current_buffer->enable_multibyte_characters; 627 } 628 629 /* Switch to the minibuffer. */ 630 631 minibuffer = get_minibuffer (minibuf_level); 632 Fset_buffer (minibuffer); 633 634 /* If appropriate, copy enable-multibyte-characters into the minibuffer. */ 635 if (inherit_input_method) 636 current_buffer->enable_multibyte_characters = enable_multibyte; 637 638 /* The current buffer's default directory is usually the right thing 639 for our minibuffer here. However, if you're typing a command at 640 a minibuffer-only frame when minibuf_level is zero, then buf IS 641 the current_buffer, so reset_buffer leaves buf's default 642 directory unchanged. This is a bummer when you've just started 643 up Emacs and buf's default directory is Qnil. Here's a hack; can 644 you think of something better to do? Find another buffer with a 645 better directory, and use that one instead. */ 646 if (STRINGP (ambient_dir)) 647 current_buffer->directory = ambient_dir; 648 else 649 { 650 Lisp_Object buf_list; 651 652 for (buf_list = Vbuffer_alist; 653 CONSP (buf_list); 654 buf_list = XCDR (buf_list)) 655 { 656 Lisp_Object other_buf; 657 658 other_buf = XCDR (XCAR (buf_list)); 659 if (STRINGP (XBUFFER (other_buf)->directory)) 660 { 661 current_buffer->directory = XBUFFER (other_buf)->directory; 662 break; 663 } 664 } 665 } 666 667 if (!EQ (mini_frame, selected_frame)) 668 Fredirect_frame_focus (selected_frame, mini_frame); 669 670 Vminibuf_scroll_window = selected_window; 671 if (minibuf_level == 1 || !EQ (minibuf_window, selected_window)) 672 minibuf_selected_window = selected_window; 673 674 /* Empty out the minibuffers of all frames other than the one 675 where we are going to display one now. 676 Set them to point to ` *Minibuf-0*', which is always empty. */ 677 empty_minibuf = Fget_buffer (build_string (" *Minibuf-0*")); 678 679 FOR_EACH_FRAME (dummy, frame) 680 { 681 Lisp_Object root_window = Fframe_root_window (frame); 682 Lisp_Object mini_window = XWINDOW (root_window)->next; 683 684 if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window) 685 && !NILP (Fwindow_minibuffer_p (mini_window))) 686 Fset_window_buffer (mini_window, empty_minibuf, Qnil); 687 } 688 689 /* Display this minibuffer in the proper window. */ 690 Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil); 691 Fselect_window (minibuf_window, Qnil); 692 XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0); 693 694 Fmake_local_variable (Qprint_escape_newlines); 695 print_escape_newlines = 1; 696 697 /* Erase the buffer. */ 698 { 699 int count1 = SPECPDL_INDEX (); 700 specbind (Qinhibit_read_only, Qt); 701 specbind (Qinhibit_modification_hooks, Qt); 702 Ferase_buffer (); 703 704 if (!NILP (current_buffer->enable_multibyte_characters) 705 && ! STRING_MULTIBYTE (minibuf_prompt)) 706 minibuf_prompt = Fstring_make_multibyte (minibuf_prompt); 707 708 /* Insert the prompt, record where it ends. */ 709 Finsert (1, &minibuf_prompt); 710 if (PT > BEG) 711 { 712 Fput_text_property (make_number (BEG), make_number (PT), 713 Qfront_sticky, Qt, Qnil); 714 Fput_text_property (make_number (BEG), make_number (PT), 715 Qrear_nonsticky, Qt, Qnil); 716 Fput_text_property (make_number (BEG), make_number (PT), 717 Qfield, Qt, Qnil); 718 Fadd_text_properties (make_number (BEG), make_number (PT), 719 Vminibuffer_prompt_properties, Qnil); 720 } 721 unbind_to (count1, Qnil); 722 } 723 724 minibuf_prompt_width = (int) current_column (); /* iftc */ 725 726 /* Put in the initial input. */ 727 if (!NILP (initial)) 728 { 729 Finsert (1, &initial); 730 Fforward_char (make_number (pos)); 731 } 732 733 clear_message (1, 1); 734 current_buffer->keymap = map; 735 736 /* Turn on an input method stored in INPUT_METHOD if any. */ 737 if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method))) 738 call1 (Qactivate_input_method, input_method); 739 740 /* Run our hook, but not if it is empty. 741 (run-hooks would do nothing if it is empty, 742 but it's important to save time here in the usual case.) */ 743 if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound) 744 && !NILP (Vrun_hooks)) 745 call1 (Vrun_hooks, Qminibuffer_setup_hook); 746 747 /* Don't allow the user to undo past this point. */ 748 current_buffer->undo_list = Qnil; 749 750 recursive_edit_1 (); 751 752 /* If cursor is on the minibuffer line, 753 show the user we have exited by putting it in column 0. */ 754 if (XWINDOW (minibuf_window)->cursor.vpos >= 0 755 && !noninteractive) 756 { 757 XWINDOW (minibuf_window)->cursor.hpos = 0; 758 XWINDOW (minibuf_window)->cursor.x = 0; 759 XWINDOW (minibuf_window)->must_be_updated_p = 1; 760 update_frame (XFRAME (selected_frame), 1, 1); 761 if (rif && rif->flush_display) 762 rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame)); 763 } 764 765 /* Make minibuffer contents into a string. */ 766 Fset_buffer (minibuffer); 767 if (allow_props) 768 val = Fminibuffer_contents (); 769 else 770 val = Fminibuffer_contents_no_properties (); 771 772 /* VAL is the string of minibuffer text. */ 773 774 last_minibuf_string = val; 775 776 /* Choose the string to add to the history. */ 777 if (SCHARS (val) != 0) 778 histstring = val; 779 else if (STRINGP (defalt)) 780 histstring = defalt; 781 else 782 histstring = Qnil; 783 784 /* Add the value to the appropriate history list, if any. */ 785 if (!NILP (Vhistory_add_new_input) 786 && SYMBOLP (Vminibuffer_history_variable) 787 && !NILP (histstring)) 788 { 789 /* If the caller wanted to save the value read on a history list, 790 then do so if the value is not already the front of the list. */ 791 Lisp_Object histval; 792 793 /* If variable is unbound, make it nil. */ 794 if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable), Qunbound)) 795 Fset (Vminibuffer_history_variable, Qnil); 796 797 histval = Fsymbol_value (Vminibuffer_history_variable); 798 799 /* The value of the history variable must be a cons or nil. Other 800 values are unacceptable. We silently ignore these values. */ 801 802 if (NILP (histval) 803 || (CONSP (histval) 804 /* Don't duplicate the most recent entry in the history. */ 805 && (NILP (Fequal (histstring, Fcar (histval)))))) 806 { 807 Lisp_Object length; 808 809 if (history_delete_duplicates) Fdelete (histstring, histval); 810 histval = Fcons (histstring, histval); 811 Fset (Vminibuffer_history_variable, histval); 812 813 /* Truncate if requested. */ 814 length = Fget (Vminibuffer_history_variable, Qhistory_length); 815 if (NILP (length)) length = Vhistory_length; 816 if (INTEGERP (length)) 817 { 818 if (XINT (length) <= 0) 819 Fset (Vminibuffer_history_variable, Qnil); 820 else 821 { 822 Lisp_Object temp; 823 824 temp = Fnthcdr (Fsub1 (length), histval); 825 if (CONSP (temp)) Fsetcdr (temp, Qnil); 826 } 827 } 828 } 829 } 830 831 /* If Lisp form desired instead of string, parse it. */ 832 if (expflag) 833 val = string_to_object (val, defalt); 834 835 /* The appropriate frame will get selected 836 in set-window-configuration. */ 837 UNGCPRO; 838 return unbind_to (count, val); 839} 840 841/* Return a buffer to be used as the minibuffer at depth `depth'. 842 depth = 0 is the lowest allowed argument, and that is the value 843 used for nonrecursive minibuffer invocations */ 844 845Lisp_Object 846get_minibuffer (depth) 847 int depth; 848{ 849 Lisp_Object tail, num, buf; 850 char name[24]; 851 extern Lisp_Object nconc2 (); 852 853 XSETFASTINT (num, depth); 854 tail = Fnthcdr (num, Vminibuffer_list); 855 if (NILP (tail)) 856 { 857 tail = Fcons (Qnil, Qnil); 858 Vminibuffer_list = nconc2 (Vminibuffer_list, tail); 859 } 860 buf = Fcar (tail); 861 if (NILP (buf) || NILP (XBUFFER (buf)->name)) 862 { 863 sprintf (name, " *Minibuf-%d*", depth); 864 buf = Fget_buffer_create (build_string (name)); 865 866 /* Although the buffer's name starts with a space, undo should be 867 enabled in it. */ 868 Fbuffer_enable_undo (buf); 869 870 XSETCAR (tail, buf); 871 } 872 else 873 { 874 int count = SPECPDL_INDEX (); 875 /* `reset_buffer' blindly sets the list of overlays to NULL, so we 876 have to empty the list, otherwise we end up with overlays that 877 think they belong to this buffer while the buffer doesn't know about 878 them any more. */ 879 delete_all_overlays (XBUFFER (buf)); 880 reset_buffer (XBUFFER (buf)); 881 record_unwind_protect (Fset_buffer, Fcurrent_buffer ()); 882 Fset_buffer (buf); 883 Fkill_all_local_variables (); 884 unbind_to (count, Qnil); 885 } 886 887 return buf; 888} 889 890static Lisp_Object 891run_exit_minibuf_hook (data) 892 Lisp_Object data; 893{ 894 if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound) 895 && !NILP (Vrun_hooks)) 896 safe_run_hooks (Qminibuffer_exit_hook); 897 898 return Qnil; 899} 900 901/* This function is called on exiting minibuffer, whether normally or 902 not, and it restores the current window, buffer, etc. */ 903 904static Lisp_Object 905read_minibuf_unwind (data) 906 Lisp_Object data; 907{ 908 Lisp_Object old_deactivate_mark; 909 Lisp_Object window; 910 911 /* If this was a recursive minibuffer, 912 tie the minibuffer window back to the outer level minibuffer buffer. */ 913 minibuf_level--; 914 915 window = minibuf_window; 916 /* To keep things predictable, in case it matters, let's be in the 917 minibuffer when we reset the relevant variables. */ 918 Fset_buffer (XWINDOW (window)->buffer); 919 920 /* Restore prompt, etc, from outer minibuffer level. */ 921 minibuf_prompt = Fcar (minibuf_save_list); 922 minibuf_save_list = Fcdr (minibuf_save_list); 923 minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list)); 924 minibuf_save_list = Fcdr (minibuf_save_list); 925 Vhelp_form = Fcar (minibuf_save_list); 926 minibuf_save_list = Fcdr (minibuf_save_list); 927 Vcurrent_prefix_arg = Fcar (minibuf_save_list); 928 minibuf_save_list = Fcdr (minibuf_save_list); 929 Vminibuffer_history_position = Fcar (minibuf_save_list); 930 minibuf_save_list = Fcdr (minibuf_save_list); 931 Vminibuffer_history_variable = Fcar (minibuf_save_list); 932 minibuf_save_list = Fcdr (minibuf_save_list); 933 Voverriding_local_map = Fcar (minibuf_save_list); 934 minibuf_save_list = Fcdr (minibuf_save_list); 935#if 0 936 temp = Fcar (minibuf_save_list); 937 if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp))))) 938 minibuf_window = temp; 939#endif 940 minibuf_save_list = Fcdr (minibuf_save_list); 941 942 /* Erase the minibuffer we were using at this level. */ 943 { 944 int count = SPECPDL_INDEX (); 945 /* Prevent error in erase-buffer. */ 946 specbind (Qinhibit_read_only, Qt); 947 specbind (Qinhibit_modification_hooks, Qt); 948 old_deactivate_mark = Vdeactivate_mark; 949 Ferase_buffer (); 950 Vdeactivate_mark = old_deactivate_mark; 951 unbind_to (count, Qnil); 952 } 953 954 /* When we get to the outmost level, make sure we resize the 955 mini-window back to its normal size. */ 956 if (minibuf_level == 0) 957 resize_mini_window (XWINDOW (window), 0); 958 959 /* Make sure minibuffer window is erased, not ignored. */ 960 windows_or_buffers_changed++; 961 XSETFASTINT (XWINDOW (window)->last_modified, 0); 962 XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0); 963 return Qnil; 964} 965 966 967DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0, 968 doc: /* Read a string from the minibuffer, prompting with string PROMPT. 969The optional second arg INITIAL-CONTENTS is an obsolete alternative to 970 DEFAULT-VALUE. It normally should be nil in new code, except when 971 HIST is a cons. It is discussed in more detail below. 972Third arg KEYMAP is a keymap to use whilst reading; 973 if omitted or nil, the default is `minibuffer-local-map'. 974If fourth arg READ is non-nil, then interpret the result as a Lisp object 975 and return that object: 976 in other words, do `(car (read-from-string INPUT-STRING))' 977Fifth arg HIST, if non-nil, specifies a history list and optionally 978 the initial position in the list. It can be a symbol, which is the 979 history list variable to use, or it can be a cons cell 980 (HISTVAR . HISTPOS). In that case, HISTVAR is the history list variable 981 to use, and HISTPOS is the initial position for use by the minibuffer 982 history commands. For consistency, you should also specify that 983 element of the history as the value of INITIAL-CONTENTS. Positions 984 are counted starting from 1 at the beginning of the list. 985Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available 986 for history commands; but, unless READ is non-nil, `read-from-minibuffer' 987 does NOT return DEFAULT-VALUE if the user enters empty input! It returns 988 the empty string. 989Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits 990 the current input method and the setting of `enable-multibyte-characters'. 991If the variable `minibuffer-allow-text-properties' is non-nil, 992 then the string which is returned includes whatever text properties 993 were present in the minibuffer. Otherwise the value has no text properties. 994 995The remainder of this documentation string describes the 996INITIAL-CONTENTS argument in more detail. It is only relevant when 997studying existing code, or when HIST is a cons. If non-nil, 998INITIAL-CONTENTS is a string to be inserted into the minibuffer before 999reading input. Normally, point is put at the end of that string. 1000However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial 1001input is STRING, but point is placed at _one-indexed_ position 1002POSITION in the minibuffer. Any integer value less than or equal to 1003one puts point at the beginning of the string. *Note* that this 1004behavior differs from the way such arguments are used in `completing-read' 1005and some related functions, which use zero-indexing for POSITION. */) 1006 (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method) 1007 Lisp_Object prompt, initial_contents, keymap, read, hist, default_value; 1008 Lisp_Object inherit_input_method; 1009{ 1010 Lisp_Object histvar, histpos, val; 1011 struct gcpro gcpro1; 1012 1013 CHECK_STRING (prompt); 1014 if (NILP (keymap)) 1015 keymap = Vminibuffer_local_map; 1016 else 1017 keymap = get_keymap (keymap, 1, 0); 1018 1019 if (SYMBOLP (hist)) 1020 { 1021 histvar = hist; 1022 histpos = Qnil; 1023 } 1024 else 1025 { 1026 histvar = Fcar_safe (hist); 1027 histpos = Fcdr_safe (hist); 1028 } 1029 if (NILP (histvar)) 1030 histvar = Qminibuffer_history; 1031 if (NILP (histpos)) 1032 XSETFASTINT (histpos, 0); 1033 1034 GCPRO1 (default_value); 1035 val = read_minibuf (keymap, initial_contents, prompt, 1036 Qnil, !NILP (read), 1037 histvar, histpos, default_value, 1038 minibuffer_allow_text_properties, 1039 !NILP (inherit_input_method)); 1040 UNGCPRO; 1041 return val; 1042} 1043 1044DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0, 1045 doc: /* Return a Lisp object read using the minibuffer, unevaluated. 1046Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS 1047is a string to insert in the minibuffer before reading. 1048\(INITIAL-CONTENTS can also be a cons of a string and an integer. Such 1049arguments are used as in `read-from-minibuffer'.) */) 1050 (prompt, initial_contents) 1051 Lisp_Object prompt, initial_contents; 1052{ 1053 CHECK_STRING (prompt); 1054 return read_minibuf (Vminibuffer_local_map, initial_contents, 1055 prompt, Qnil, 1, Qminibuffer_history, 1056 make_number (0), Qnil, 0, 0); 1057} 1058 1059DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0, 1060 doc: /* Return value of Lisp expression read using the minibuffer. 1061Prompt with PROMPT. If non-nil, optional second arg INITIAL-CONTENTS 1062is a string to insert in the minibuffer before reading. 1063\(INITIAL-CONTENTS can also be a cons of a string and an integer. Such 1064arguments are used as in `read-from-minibuffer'.) */) 1065 (prompt, initial_contents) 1066 Lisp_Object prompt, initial_contents; 1067{ 1068 return Feval (read_minibuf (Vread_expression_map, initial_contents, 1069 prompt, Qnil, 1, Qread_expression_history, 1070 make_number (0), Qnil, 0, 0)); 1071} 1072 1073/* Functions that use the minibuffer to read various things. */ 1074 1075DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0, 1076 doc: /* Read a string from the minibuffer, prompting with string PROMPT. 1077If non-nil, second arg INITIAL-INPUT is a string to insert before reading. 1078 This argument has been superseded by DEFAULT-VALUE and should normally 1079 be nil in new code. It behaves as in `read-from-minibuffer'. See the 1080 documentation string of that function for details. 1081The third arg HISTORY, if non-nil, specifies a history list 1082 and optionally the initial position in the list. 1083See `read-from-minibuffer' for details of HISTORY argument. 1084Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used 1085 for history commands, and as the value to return if the user enters 1086 the empty string. 1087Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits 1088 the current input method and the setting of `enable-multibyte-characters'. */) 1089 (prompt, initial_input, history, default_value, inherit_input_method) 1090 Lisp_Object prompt, initial_input, history, default_value; 1091 Lisp_Object inherit_input_method; 1092{ 1093 Lisp_Object val; 1094 val = Fread_from_minibuffer (prompt, initial_input, Qnil, 1095 Qnil, history, default_value, 1096 inherit_input_method); 1097 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value)) 1098 val = default_value; 1099 return val; 1100} 1101 1102DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0, 1103 doc: /* Read a string from the terminal, not allowing blanks. 1104Prompt with PROMPT. Whitespace terminates the input. If INITIAL is 1105non-nil, it should be a string, which is used as initial input, with 1106point positioned at the end, so that SPACE will accept the input. 1107\(Actually, INITIAL can also be a cons of a string and an integer. 1108Such values are treated as in `read-from-minibuffer', but are normally 1109not useful in this function.) 1110Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits 1111the current input method and the setting of`enable-multibyte-characters'. */) 1112 (prompt, initial, inherit_input_method) 1113 Lisp_Object prompt, initial, inherit_input_method; 1114{ 1115 CHECK_STRING (prompt); 1116 return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil, 1117 0, Qminibuffer_history, make_number (0), Qnil, 0, 1118 !NILP (inherit_input_method)); 1119} 1120 1121DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0, 1122 doc: /* Read the name of a command and return as a symbol. 1123Prompt with PROMPT. By default, return DEFAULT-VALUE. */) 1124 (prompt, default_value) 1125 Lisp_Object prompt, default_value; 1126{ 1127 Lisp_Object name, default_string; 1128 1129 if (NILP (default_value)) 1130 default_string = Qnil; 1131 else if (SYMBOLP (default_value)) 1132 default_string = SYMBOL_NAME (default_value); 1133 else 1134 default_string = default_value; 1135 1136 name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt, 1137 Qnil, Qnil, default_string, Qnil); 1138 if (NILP (name)) 1139 return name; 1140 return Fintern (name, Qnil); 1141} 1142 1143#ifdef NOTDEF 1144DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0, 1145 doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol. 1146Prompt with PROMPT. */) 1147 (prompt) 1148 Lisp_Object prompt; 1149{ 1150 return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil), 1151 Qnil); 1152} 1153#endif /* NOTDEF */ 1154 1155DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0, 1156 doc: /* Read the name of a user variable and return it as a symbol. 1157Prompt with PROMPT. By default, return DEFAULT-VALUE. 1158A user variable is one for which `user-variable-p' returns non-nil. */) 1159 (prompt, default_value) 1160 Lisp_Object prompt, default_value; 1161{ 1162 Lisp_Object name, default_string; 1163 1164 if (NILP (default_value)) 1165 default_string = Qnil; 1166 else if (SYMBOLP (default_value)) 1167 default_string = SYMBOL_NAME (default_value); 1168 else 1169 default_string = default_value; 1170 1171 name = Fcompleting_read (prompt, Vobarray, 1172 Quser_variable_p, Qt, 1173 Qnil, Qnil, default_string, Qnil); 1174 if (NILP (name)) 1175 return name; 1176 return Fintern (name, Qnil); 1177} 1178 1179DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0, 1180 doc: /* Read the name of a buffer and return as a string. 1181Prompt with PROMPT. 1182Optional second arg DEF is value to return if user enters an empty line. 1183If optional third arg REQUIRE-MATCH is non-nil, 1184 only existing buffer names are allowed. 1185The argument PROMPT should be a string ending with a colon and a space. */) 1186 (prompt, def, require_match) 1187 Lisp_Object prompt, def, require_match; 1188{ 1189 Lisp_Object args[4]; 1190 unsigned char *s; 1191 int len; 1192 1193 if (BUFFERP (def)) 1194 def = XBUFFER (def)->name; 1195 1196 if (NILP (Vread_buffer_function)) 1197 { 1198 if (!NILP (def)) 1199 { 1200 /* A default value was provided: we must change PROMPT, 1201 editing the default value in before the colon. To achieve 1202 this, we replace PROMPT with a substring that doesn't 1203 contain the terminal space and colon (if present). They 1204 are then added back using Fformat. */ 1205 1206 if (STRINGP (prompt)) 1207 { 1208 s = SDATA (prompt); 1209 len = strlen (s); 1210 if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ') 1211 len = len - 2; 1212 else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' ')) 1213 len--; 1214 1215 prompt = make_specified_string (s, -1, len, 1216 STRING_MULTIBYTE (prompt)); 1217 } 1218 1219 args[0] = build_string ("%s (default %s): "); 1220 args[1] = prompt; 1221 args[2] = def; 1222 prompt = Fformat (3, args); 1223 } 1224 1225 return Fcompleting_read (prompt, intern ("internal-complete-buffer"), 1226 Qnil, require_match, Qnil, Qbuffer_name_history, 1227 def, Qnil); 1228 } 1229 else 1230 { 1231 args[0] = Vread_buffer_function; 1232 args[1] = prompt; 1233 args[2] = def; 1234 args[3] = require_match; 1235 return Ffuncall(4, args); 1236 } 1237} 1238 1239static Lisp_Object 1240minibuf_conform_representation (string, basis) 1241 Lisp_Object string, basis; 1242{ 1243 if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis)) 1244 return string; 1245 1246 if (STRING_MULTIBYTE (string)) 1247 return Fstring_make_unibyte (string); 1248 else 1249 return Fstring_make_multibyte (string); 1250} 1251 1252DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0, 1253 doc: /* Return common substring of all completions of STRING in COLLECTION. 1254Test each possible completion specified by COLLECTION 1255to see if it begins with STRING. The possible completions may be 1256strings or symbols. Symbols are converted to strings before testing, 1257see `symbol-name'. 1258All that match STRING are compared together; the longest initial sequence 1259common to all these matches is the return value. 1260If there is no match at all, the return value is nil. 1261For a unique match which is exact, the return value is t. 1262 1263If COLLECTION is an alist, the keys (cars of elements) are the 1264possible completions. If an element is not a cons cell, then the 1265element itself is the possible completion. 1266If COLLECTION is a hash-table, all the keys that are strings or symbols 1267are the possible completions. 1268If COLLECTION is an obarray, the names of all symbols in the obarray 1269are the possible completions. 1270 1271COLLECTION can also be a function to do the completion itself. 1272It receives three arguments: the values STRING, PREDICATE and nil. 1273Whatever it returns becomes the value of `try-completion'. 1274 1275If optional third argument PREDICATE is non-nil, 1276it is used to test each possible match. 1277The match is a candidate only if PREDICATE returns non-nil. 1278The argument given to PREDICATE is the alist element 1279or the symbol from the obarray. If COLLECTION is a hash-table, 1280predicate is called with two arguments: the key and the value. 1281Additionally to this predicate, `completion-regexp-list' 1282is used to further constrain the set of candidates. */) 1283 (string, collection, predicate) 1284 Lisp_Object string, collection, predicate; 1285{ 1286 Lisp_Object bestmatch, tail, elt, eltstring; 1287 /* Size in bytes of BESTMATCH. */ 1288 int bestmatchsize = 0; 1289 /* These are in bytes, too. */ 1290 int compare, matchsize; 1291 int type = (HASH_TABLE_P (collection) ? 3 1292 : VECTORP (collection) ? 2 1293 : NILP (collection) || (CONSP (collection) 1294 && (!SYMBOLP (XCAR (collection)) 1295 || NILP (XCAR (collection))))); 1296 int index = 0, obsize = 0; 1297 int matchcount = 0; 1298 int bindcount = -1; 1299 Lisp_Object bucket, zero, end, tem; 1300 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; 1301 1302 CHECK_STRING (string); 1303 if (type == 0) 1304 return call3 (collection, string, predicate, Qnil); 1305 1306 bestmatch = bucket = Qnil; 1307 zero = make_number (0); 1308 1309 /* If COLLECTION is not a list, set TAIL just for gc pro. */ 1310 tail = collection; 1311 if (type == 2) 1312 { 1313 collection = check_obarray (collection); 1314 obsize = XVECTOR (collection)->size; 1315 bucket = XVECTOR (collection)->contents[index]; 1316 } 1317 1318 while (1) 1319 { 1320 /* Get the next element of the alist, obarray, or hash-table. */ 1321 /* Exit the loop if the elements are all used up. */ 1322 /* elt gets the alist element or symbol. 1323 eltstring gets the name to check as a completion. */ 1324 1325 if (type == 1) 1326 { 1327 if (!CONSP (tail)) 1328 break; 1329 elt = XCAR (tail); 1330 eltstring = CONSP (elt) ? XCAR (elt) : elt; 1331 tail = XCDR (tail); 1332 } 1333 else if (type == 2) 1334 { 1335 if (!EQ (bucket, zero)) 1336 { 1337 if (!SYMBOLP (bucket)) 1338 error ("Bad data in guts of obarray"); 1339 elt = bucket; 1340 eltstring = elt; 1341 if (XSYMBOL (bucket)->next) 1342 XSETSYMBOL (bucket, XSYMBOL (bucket)->next); 1343 else 1344 XSETFASTINT (bucket, 0); 1345 } 1346 else if (++index >= obsize) 1347 break; 1348 else 1349 { 1350 bucket = XVECTOR (collection)->contents[index]; 1351 continue; 1352 } 1353 } 1354 else /* if (type == 3) */ 1355 { 1356 while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection)) 1357 && NILP (HASH_HASH (XHASH_TABLE (collection), index))) 1358 index++; 1359 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection))) 1360 break; 1361 else 1362 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++); 1363 } 1364 1365 /* Is this element a possible completion? */ 1366 1367 if (SYMBOLP (eltstring)) 1368 eltstring = Fsymbol_name (eltstring); 1369 1370 if (STRINGP (eltstring) 1371 && SCHARS (string) <= SCHARS (eltstring) 1372 && (tem = Fcompare_strings (eltstring, zero, 1373 make_number (SCHARS (string)), 1374 string, zero, Qnil, 1375 completion_ignore_case ? Qt : Qnil), 1376 EQ (Qt, tem))) 1377 { 1378 /* Yes. */ 1379 Lisp_Object regexps; 1380 1381 /* Ignore this element if it fails to match all the regexps. */ 1382 { 1383 for (regexps = Vcompletion_regexp_list; CONSP (regexps); 1384 regexps = XCDR (regexps)) 1385 { 1386 if (bindcount < 0) { 1387 bindcount = SPECPDL_INDEX (); 1388 specbind (Qcase_fold_search, 1389 completion_ignore_case ? Qt : Qnil); 1390 } 1391 tem = Fstring_match (XCAR (regexps), eltstring, zero); 1392 if (NILP (tem)) 1393 break; 1394 } 1395 if (CONSP (regexps)) 1396 continue; 1397 } 1398 1399 /* Ignore this element if there is a predicate 1400 and the predicate doesn't like it. */ 1401 1402 if (!NILP (predicate)) 1403 { 1404 if (EQ (predicate, Qcommandp)) 1405 tem = Fcommandp (elt, Qnil); 1406 else 1407 { 1408 if (bindcount >= 0) { 1409 unbind_to (bindcount, Qnil); 1410 bindcount = -1; 1411 } 1412 GCPRO4 (tail, string, eltstring, bestmatch); 1413 tem = type == 3 1414 ? call2 (predicate, elt, 1415 HASH_VALUE (XHASH_TABLE (collection), index - 1)) 1416 : call1 (predicate, elt); 1417 UNGCPRO; 1418 } 1419 if (NILP (tem)) continue; 1420 } 1421 1422 /* Update computation of how much all possible completions match */ 1423 1424 if (NILP (bestmatch)) 1425 { 1426 matchcount = 1; 1427 bestmatch = eltstring; 1428 bestmatchsize = SCHARS (eltstring); 1429 } 1430 else 1431 { 1432 compare = min (bestmatchsize, SCHARS (eltstring)); 1433 tem = Fcompare_strings (bestmatch, zero, 1434 make_number (compare), 1435 eltstring, zero, 1436 make_number (compare), 1437 completion_ignore_case ? Qt : Qnil); 1438 if (EQ (tem, Qt)) 1439 matchsize = compare; 1440 else if (XINT (tem) < 0) 1441 matchsize = - XINT (tem) - 1; 1442 else 1443 matchsize = XINT (tem) - 1; 1444 1445 if (matchsize < 0) 1446 /* When can this happen ? -stef */ 1447 matchsize = compare; 1448 if (completion_ignore_case) 1449 { 1450 /* If this is an exact match except for case, 1451 use it as the best match rather than one that is not an 1452 exact match. This way, we get the case pattern 1453 of the actual match. */ 1454 if ((matchsize == SCHARS (eltstring) 1455 && matchsize < SCHARS (bestmatch)) 1456 || 1457 /* If there is more than one exact match ignoring case, 1458 and one of them is exact including case, 1459 prefer that one. */ 1460 /* If there is no exact match ignoring case, 1461 prefer a match that does not change the case 1462 of the input. */ 1463 ((matchsize == SCHARS (eltstring)) 1464 == 1465 (matchsize == SCHARS (bestmatch)) 1466 && (tem = Fcompare_strings (eltstring, zero, 1467 make_number (SCHARS (string)), 1468 string, zero, 1469 Qnil, 1470 Qnil), 1471 EQ (Qt, tem)) 1472 && (tem = Fcompare_strings (bestmatch, zero, 1473 make_number (SCHARS (string)), 1474 string, zero, 1475 Qnil, 1476 Qnil), 1477 ! EQ (Qt, tem)))) 1478 bestmatch = eltstring; 1479 } 1480 if (bestmatchsize != SCHARS (eltstring) 1481 || bestmatchsize != matchsize) 1482 /* Don't count the same string multiple times. */ 1483 matchcount++; 1484 bestmatchsize = matchsize; 1485 if (matchsize <= SCHARS (string) 1486 /* If completion-ignore-case is non-nil, don't 1487 short-circuit because we want to find the best 1488 possible match *including* case differences. */ 1489 && !completion_ignore_case 1490 && matchcount > 1) 1491 /* No need to look any further. */ 1492 break; 1493 } 1494 } 1495 } 1496 1497 if (bindcount >= 0) { 1498 unbind_to (bindcount, Qnil); 1499 bindcount = -1; 1500 } 1501 1502 if (NILP (bestmatch)) 1503 return Qnil; /* No completions found */ 1504 /* If we are ignoring case, and there is no exact match, 1505 and no additional text was supplied, 1506 don't change the case of what the user typed. */ 1507 if (completion_ignore_case && bestmatchsize == SCHARS (string) 1508 && SCHARS (bestmatch) > bestmatchsize) 1509 return minibuf_conform_representation (string, bestmatch); 1510 1511 /* Return t if the supplied string is an exact match (counting case); 1512 it does not require any change to be made. */ 1513 if (matchcount == 1 && bestmatchsize == SCHARS (string) 1514 && (tem = Fcompare_strings (bestmatch, make_number (0), 1515 make_number (bestmatchsize), 1516 string, make_number (0), 1517 make_number (bestmatchsize), 1518 Qnil), 1519 EQ (Qt, tem))) 1520 return Qt; 1521 1522 XSETFASTINT (zero, 0); /* Else extract the part in which */ 1523 XSETFASTINT (end, bestmatchsize); /* all completions agree */ 1524 return Fsubstring (bestmatch, zero, end); 1525} 1526 1527DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0, 1528 doc: /* Search for partial matches to STRING in COLLECTION. 1529Test each of the possible completions specified by COLLECTION 1530to see if it begins with STRING. The possible completions may be 1531strings or symbols. Symbols are converted to strings before testing, 1532see `symbol-name'. 1533The value is a list of all the possible completions that match STRING. 1534 1535If COLLECTION is an alist, the keys (cars of elements) are the 1536possible completions. If an element is not a cons cell, then the 1537element itself is the possible completion. 1538If COLLECTION is a hash-table, all the keys that are strings or symbols 1539are the possible completions. 1540If COLLECTION is an obarray, the names of all symbols in the obarray 1541are the possible completions. 1542 1543COLLECTION can also be a function to do the completion itself. 1544It receives three arguments: the values STRING, PREDICATE and t. 1545Whatever it returns becomes the value of `all-completions'. 1546 1547If optional third argument PREDICATE is non-nil, 1548it is used to test each possible match. 1549The match is a candidate only if PREDICATE returns non-nil. 1550The argument given to PREDICATE is the alist element 1551or the symbol from the obarray. If COLLECTION is a hash-table, 1552predicate is called with two arguments: the key and the value. 1553Additionally to this predicate, `completion-regexp-list' 1554is used to further constrain the set of candidates. 1555 1556If the optional fourth argument HIDE-SPACES is non-nil, 1557strings in COLLECTION that start with a space 1558are ignored unless STRING itself starts with a space. */) 1559 (string, collection, predicate, hide_spaces) 1560 Lisp_Object string, collection, predicate, hide_spaces; 1561{ 1562 Lisp_Object tail, elt, eltstring; 1563 Lisp_Object allmatches; 1564 int type = HASH_TABLE_P (collection) ? 3 1565 : VECTORP (collection) ? 2 1566 : NILP (collection) || (CONSP (collection) 1567 && (!SYMBOLP (XCAR (collection)) 1568 || NILP (XCAR (collection)))); 1569 int index = 0, obsize = 0; 1570 int bindcount = -1; 1571 Lisp_Object bucket, tem, zero; 1572 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; 1573 1574 CHECK_STRING (string); 1575 if (type == 0) 1576 return call3 (collection, string, predicate, Qt); 1577 allmatches = bucket = Qnil; 1578 zero = make_number (0); 1579 1580 /* If COLLECTION is not a list, set TAIL just for gc pro. */ 1581 tail = collection; 1582 if (type == 2) 1583 { 1584 obsize = XVECTOR (collection)->size; 1585 bucket = XVECTOR (collection)->contents[index]; 1586 } 1587 1588 while (1) 1589 { 1590 /* Get the next element of the alist, obarray, or hash-table. */ 1591 /* Exit the loop if the elements are all used up. */ 1592 /* elt gets the alist element or symbol. 1593 eltstring gets the name to check as a completion. */ 1594 1595 if (type == 1) 1596 { 1597 if (!CONSP (tail)) 1598 break; 1599 elt = XCAR (tail); 1600 eltstring = CONSP (elt) ? XCAR (elt) : elt; 1601 tail = XCDR (tail); 1602 } 1603 else if (type == 2) 1604 { 1605 if (!EQ (bucket, zero)) 1606 { 1607 elt = bucket; 1608 eltstring = elt; 1609 if (XSYMBOL (bucket)->next) 1610 XSETSYMBOL (bucket, XSYMBOL (bucket)->next); 1611 else 1612 XSETFASTINT (bucket, 0); 1613 } 1614 else if (++index >= obsize) 1615 break; 1616 else 1617 { 1618 bucket = XVECTOR (collection)->contents[index]; 1619 continue; 1620 } 1621 } 1622 else /* if (type == 3) */ 1623 { 1624 while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection)) 1625 && NILP (HASH_HASH (XHASH_TABLE (collection), index))) 1626 index++; 1627 if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection))) 1628 break; 1629 else 1630 elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++); 1631 } 1632 1633 /* Is this element a possible completion? */ 1634 1635 if (SYMBOLP (eltstring)) 1636 eltstring = Fsymbol_name (eltstring); 1637 1638 if (STRINGP (eltstring) 1639 && SCHARS (string) <= SCHARS (eltstring) 1640 /* If HIDE_SPACES, reject alternatives that start with space 1641 unless the input starts with space. */ 1642 && ((SBYTES (string) > 0 1643 && SREF (string, 0) == ' ') 1644 || SREF (eltstring, 0) != ' ' 1645 || NILP (hide_spaces)) 1646 && (tem = Fcompare_strings (eltstring, zero, 1647 make_number (SCHARS (string)), 1648 string, zero, 1649 make_number (SCHARS (string)), 1650 completion_ignore_case ? Qt : Qnil), 1651 EQ (Qt, tem))) 1652 { 1653 /* Yes. */ 1654 Lisp_Object regexps; 1655 Lisp_Object zero; 1656 XSETFASTINT (zero, 0); 1657 1658 /* Ignore this element if it fails to match all the regexps. */ 1659 { 1660 for (regexps = Vcompletion_regexp_list; CONSP (regexps); 1661 regexps = XCDR (regexps)) 1662 { 1663 if (bindcount < 0) { 1664 bindcount = SPECPDL_INDEX (); 1665 specbind (Qcase_fold_search, 1666 completion_ignore_case ? Qt : Qnil); 1667 } 1668 tem = Fstring_match (XCAR (regexps), eltstring, zero); 1669 if (NILP (tem)) 1670 break; 1671 } 1672 if (CONSP (regexps)) 1673 continue; 1674 } 1675 1676 /* Ignore this element if there is a predicate 1677 and the predicate doesn't like it. */ 1678 1679 if (!NILP (predicate)) 1680 { 1681 if (EQ (predicate, Qcommandp)) 1682 tem = Fcommandp (elt, Qnil); 1683 else 1684 { 1685 if (bindcount >= 0) { 1686 unbind_to (bindcount, Qnil); 1687 bindcount = -1; 1688 } 1689 GCPRO4 (tail, eltstring, allmatches, string); 1690 tem = type == 3 1691 ? call2 (predicate, elt, 1692 HASH_VALUE (XHASH_TABLE (collection), index - 1)) 1693 : call1 (predicate, elt); 1694 UNGCPRO; 1695 } 1696 if (NILP (tem)) continue; 1697 } 1698 /* Ok => put it on the list. */ 1699 allmatches = Fcons (eltstring, allmatches); 1700 } 1701 } 1702 1703 if (bindcount >= 0) { 1704 unbind_to (bindcount, Qnil); 1705 bindcount = -1; 1706 } 1707 1708 return Fnreverse (allmatches); 1709} 1710 1711DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0, 1712 doc: /* Read a string in the minibuffer, with completion. 1713PROMPT is a string to prompt with; normally it ends in a colon and a space. 1714COLLECTION can be a list of strings, an alist, an obarray or a hash table. 1715COLLECTION can also be a function to do the completion itself. 1716PREDICATE limits completion to a subset of COLLECTION. 1717See `try-completion' and `all-completions' for more details 1718 on completion, COLLECTION, and PREDICATE. 1719 1720If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless 1721 the input is (or completes to) an element of COLLECTION or is null. 1722 If it is also not t, typing RET does not exit if it does non-null completion. 1723If the input is null, `completing-read' returns DEF, or an empty string 1724 if DEF is nil, regardless of the value of REQUIRE-MATCH. 1725 1726If INITIAL-INPUT is non-nil, insert it in the minibuffer initially, 1727 with point positioned at the end. 1728 If it is (STRING . POSITION), the initial input is STRING, but point 1729 is placed at _zero-indexed_ position POSITION in STRING. (*Note* 1730 that this is different from `read-from-minibuffer' and related 1731 functions, which use one-indexing for POSITION.) This feature is 1732 deprecated--it is best to pass nil for INITIAL-INPUT and supply the 1733 default value DEF instead. The user can yank the default value into 1734 the minibuffer easily using \\[next-history-element]. 1735 1736HIST, if non-nil, specifies a history list and optionally the initial 1737 position in the list. It can be a symbol, which is the history list 1738 variable to use, or it can be a cons cell (HISTVAR . HISTPOS). In 1739 that case, HISTVAR is the history list variable to use, and HISTPOS 1740 is the initial position (the position in the list used by the 1741 minibuffer history commands). For consistency, you should also 1742 specify that element of the history as the value of 1743 INITIAL-INPUT. (This is the only case in which you should use 1744 INITIAL-INPUT instead of DEF.) Positions are counted starting from 1745 1 at the beginning of the list. The variable `history-length' 1746 controls the maximum length of a history list. 1747 1748DEF, if non-nil, is the default value. 1749 1750If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits 1751 the current input method and the setting of `enable-multibyte-characters'. 1752 1753Completion ignores case if the ambient value of 1754 `completion-ignore-case' is non-nil. */) 1755 (prompt, collection, predicate, require_match, initial_input, hist, def, inherit_input_method) 1756 Lisp_Object prompt, collection, predicate, require_match, initial_input; 1757 Lisp_Object hist, def, inherit_input_method; 1758{ 1759 Lisp_Object val, histvar, histpos, position; 1760 Lisp_Object init; 1761 int pos = 0; 1762 int count = SPECPDL_INDEX (); 1763 struct gcpro gcpro1; 1764 1765 init = initial_input; 1766 GCPRO1 (def); 1767 1768 specbind (Qminibuffer_completion_table, collection); 1769 specbind (Qminibuffer_completion_predicate, predicate); 1770 specbind (Qminibuffer_completion_confirm, 1771 EQ (require_match, Qt) ? Qnil : require_match); 1772 last_exact_completion = Qnil; 1773 1774 position = Qnil; 1775 if (!NILP (init)) 1776 { 1777 if (CONSP (init)) 1778 { 1779 position = Fcdr (init); 1780 init = Fcar (init); 1781 } 1782 CHECK_STRING (init); 1783 if (!NILP (position)) 1784 { 1785 CHECK_NUMBER (position); 1786 /* Convert to distance from end of input. */ 1787 pos = XINT (position) - SCHARS (init); 1788 } 1789 } 1790 1791 if (SYMBOLP (hist)) 1792 { 1793 histvar = hist; 1794 histpos = Qnil; 1795 } 1796 else 1797 { 1798 histvar = Fcar_safe (hist); 1799 histpos = Fcdr_safe (hist); 1800 } 1801 if (NILP (histvar)) 1802 histvar = Qminibuffer_history; 1803 if (NILP (histpos)) 1804 XSETFASTINT (histpos, 0); 1805 1806 val = read_minibuf (NILP (require_match) 1807 ? (NILP (Vminibuffer_completing_file_name) 1808 || EQ (Vminibuffer_completing_file_name, Qlambda) 1809 ? Vminibuffer_local_completion_map 1810 : Vminibuffer_local_filename_completion_map) 1811 : (NILP (Vminibuffer_completing_file_name) 1812 || EQ (Vminibuffer_completing_file_name, Qlambda) 1813 ? Vminibuffer_local_must_match_map 1814 : Vminibuffer_local_must_match_filename_map), 1815 init, prompt, make_number (pos), 0, 1816 histvar, histpos, def, 0, 1817 !NILP (inherit_input_method)); 1818 1819 if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def)) 1820 val = def; 1821 1822 RETURN_UNGCPRO (unbind_to (count, val)); 1823} 1824 1825Lisp_Object Fminibuffer_completion_help (); 1826Lisp_Object Fassoc_string (); 1827 1828/* Test whether TXT is an exact completion. */ 1829DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0, 1830 doc: /* Return non-nil if STRING is a valid completion. 1831Takes the same arguments as `all-completions' and `try-completion'. 1832If COLLECTION is a function, it is called with three arguments: 1833the values STRING, PREDICATE and `lambda'. */) 1834 (string, collection, predicate) 1835 Lisp_Object string, collection, predicate; 1836{ 1837 Lisp_Object regexps, tail, tem = Qnil; 1838 int i = 0; 1839 1840 CHECK_STRING (string); 1841 1842 if ((CONSP (collection) 1843 && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection)))) 1844 || NILP (collection)) 1845 { 1846 tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil); 1847 if (NILP (tem)) 1848 return Qnil; 1849 } 1850 else if (VECTORP (collection)) 1851 { 1852 /* Bypass intern-soft as that loses for nil. */ 1853 tem = oblookup (collection, 1854 SDATA (string), 1855 SCHARS (string), 1856 SBYTES (string)); 1857 if (!SYMBOLP (tem)) 1858 { 1859 if (STRING_MULTIBYTE (string)) 1860 string = Fstring_make_unibyte (string); 1861 else 1862 string = Fstring_make_multibyte (string); 1863 1864 tem = oblookup (collection, 1865 SDATA (string), 1866 SCHARS (string), 1867 SBYTES (string)); 1868 } 1869 1870 if (completion_ignore_case && !SYMBOLP (tem)) 1871 { 1872 for (i = XVECTOR (collection)->size - 1; i >= 0; i--) 1873 { 1874 tail = XVECTOR (collection)->contents[i]; 1875 if (SYMBOLP (tail)) 1876 while (1) 1877 { 1878 if (EQ((Fcompare_strings (string, make_number (0), Qnil, 1879 Fsymbol_name (tail), 1880 make_number (0) , Qnil, Qt)), 1881 Qt)) 1882 { 1883 tem = tail; 1884 break; 1885 } 1886 if (XSYMBOL (tail)->next == 0) 1887 break; 1888 XSETSYMBOL (tail, XSYMBOL (tail)->next); 1889 } 1890 } 1891 } 1892 1893 if (!SYMBOLP (tem)) 1894 return Qnil; 1895 } 1896 else if (HASH_TABLE_P (collection)) 1897 { 1898 struct Lisp_Hash_Table *h = XHASH_TABLE (collection); 1899 i = hash_lookup (h, string, NULL); 1900 if (i >= 0) 1901 tem = HASH_KEY (h, i); 1902 else 1903 for (i = 0; i < HASH_TABLE_SIZE (h); ++i) 1904 if (!NILP (HASH_HASH (h, i)) && 1905 EQ (Fcompare_strings (string, make_number (0), Qnil, 1906 HASH_KEY (h, i), make_number (0) , Qnil, 1907 completion_ignore_case ? Qt : Qnil), 1908 Qt)) 1909 { 1910 tem = HASH_KEY (h, i); 1911 break; 1912 } 1913 if (!STRINGP (tem)) 1914 return Qnil; 1915 } 1916 else 1917 return call3 (collection, string, predicate, Qlambda); 1918 1919 /* Reject this element if it fails to match all the regexps. */ 1920 if (CONSP (Vcompletion_regexp_list)) 1921 { 1922 int count = SPECPDL_INDEX (); 1923 specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil); 1924 for (regexps = Vcompletion_regexp_list; CONSP (regexps); 1925 regexps = XCDR (regexps)) 1926 { 1927 if (NILP (Fstring_match (XCAR (regexps), 1928 SYMBOLP (tem) ? string : tem, 1929 Qnil))) 1930 return unbind_to (count, Qnil); 1931 } 1932 unbind_to (count, Qnil); 1933 } 1934 1935 /* Finally, check the predicate. */ 1936 if (!NILP (predicate)) 1937 { 1938 return HASH_TABLE_P (collection) 1939 ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i)) 1940 : call1 (predicate, tem); 1941 } 1942 else 1943 return Qt; 1944} 1945 1946DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0, 1947 doc: /* Perform completion on buffer names. 1948If the argument FLAG is nil, invoke `try-completion', if it's t, invoke 1949`all-completions', otherwise invoke `test-completion'. 1950 1951The arguments STRING and PREDICATE are as in `try-completion', 1952`all-completions', and `test-completion'. */) 1953 (string, predicate, flag) 1954 Lisp_Object string, predicate, flag; 1955{ 1956 if (NILP (flag)) 1957 return Ftry_completion (string, Vbuffer_alist, predicate); 1958 else if (EQ (flag, Qt)) 1959 return Fall_completions (string, Vbuffer_alist, predicate, Qt); 1960 else /* assume `lambda' */ 1961 return Ftest_completion (string, Vbuffer_alist, predicate); 1962} 1963 1964/* returns: 1965 * 0 no possible completion 1966 * 1 was already an exact and unique completion 1967 * 3 was already an exact completion 1968 * 4 completed to an exact completion 1969 * 5 some completion happened 1970 * 6 no completion happened 1971 */ 1972int 1973do_completion () 1974{ 1975 Lisp_Object completion, string, tem; 1976 int completedp; 1977 Lisp_Object last; 1978 struct gcpro gcpro1, gcpro2; 1979 1980 completion = Ftry_completion (Fminibuffer_completion_contents (), 1981 Vminibuffer_completion_table, 1982 Vminibuffer_completion_predicate); 1983 last = last_exact_completion; 1984 last_exact_completion = Qnil; 1985 1986 GCPRO2 (completion, last); 1987 1988 if (NILP (completion)) 1989 { 1990 bitch_at_user (); 1991 temp_echo_area_glyphs (build_string (" [No match]")); 1992 UNGCPRO; 1993 return 0; 1994 } 1995 1996 if (EQ (completion, Qt)) /* exact and unique match */ 1997 { 1998 UNGCPRO; 1999 return 1; 2000 } 2001 2002 string = Fminibuffer_completion_contents (); 2003 2004 /* COMPLETEDP should be true if some completion was done, which 2005 doesn't include simply changing the case of the entered string. 2006 However, for appearance, the string is rewritten if the case 2007 changes. */ 2008 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qt); 2009 completedp = !EQ (tem, Qt); 2010 2011 tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qnil); 2012 if (!EQ (tem, Qt)) 2013 /* Rewrite the user's input. */ 2014 { 2015 int prompt_end = XINT (Fminibuffer_prompt_end ()); 2016 /* Some completion happened */ 2017 2018 if (! NILP (Vminibuffer_completing_file_name) 2019 && SREF (completion, SBYTES (completion) - 1) == '/' 2020 && PT < ZV 2021 && FETCH_CHAR (PT_BYTE) == '/') 2022 { 2023 del_range (prompt_end, PT + 1); 2024 } 2025 else 2026 del_range (prompt_end, PT); 2027 2028 Finsert (1, &completion); 2029 2030 if (! completedp) 2031 /* The case of the string changed, but that's all. We're not 2032 sure whether this is a unique completion or not, so try again 2033 using the real case (this shouldn't recurse again, because 2034 the next time try-completion will return either `t' or the 2035 exact string). */ 2036 { 2037 UNGCPRO; 2038 return do_completion (); 2039 } 2040 } 2041 2042 /* It did find a match. Do we match some possibility exactly now? */ 2043 tem = Ftest_completion (Fminibuffer_contents (), 2044 Vminibuffer_completion_table, 2045 Vminibuffer_completion_predicate); 2046 if (NILP (tem)) 2047 { 2048 /* not an exact match */ 2049 UNGCPRO; 2050 if (completedp) 2051 return 5; 2052 else if (!NILP (Vcompletion_auto_help)) 2053 Fminibuffer_completion_help (); 2054 else 2055 temp_echo_area_glyphs (build_string (" [Next char not unique]")); 2056 return 6; 2057 } 2058 else if (completedp) 2059 { 2060 UNGCPRO; 2061 return 4; 2062 } 2063 /* If the last exact completion and this one were the same, 2064 it means we've already given a "Complete but not unique" 2065 message and the user's hit TAB again, so now we give him help. */ 2066 last_exact_completion = completion; 2067 if (!NILP (last)) 2068 { 2069 tem = Fminibuffer_completion_contents (); 2070 if (!NILP (Fequal (tem, last))) 2071 Fminibuffer_completion_help (); 2072 } 2073 UNGCPRO; 2074 return 3; 2075} 2076 2077/* Like assoc but assumes KEY is a string, and ignores case if appropriate. */ 2078 2079DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0, 2080 doc: /* Like `assoc' but specifically for strings (and symbols). 2081Symbols are converted to strings, and unibyte strings are converted to 2082multibyte for comparison. 2083Case is ignored if optional arg CASE-FOLD is non-nil. 2084As opposed to `assoc', it will also match an entry consisting of a single 2085string rather than a cons cell whose car is a string. */) 2086 (key, list, case_fold) 2087 register Lisp_Object key; 2088 Lisp_Object list, case_fold; 2089{ 2090 register Lisp_Object tail; 2091 2092 if (SYMBOLP (key)) 2093 key = Fsymbol_name (key); 2094 2095 for (tail = list; !NILP (tail); tail = Fcdr (tail)) 2096 { 2097 register Lisp_Object elt, tem, thiscar; 2098 elt = Fcar (tail); 2099 thiscar = CONSP (elt) ? XCAR (elt) : elt; 2100 if (SYMBOLP (thiscar)) 2101 thiscar = Fsymbol_name (thiscar); 2102 else if (!STRINGP (thiscar)) 2103 continue; 2104 tem = Fcompare_strings (thiscar, make_number (0), Qnil, 2105 key, make_number (0), Qnil, 2106 case_fold); 2107 if (EQ (tem, Qt)) 2108 return elt; 2109 QUIT; 2110 } 2111 return Qnil; 2112} 2113 2114DEFUN ("minibuffer-complete", Fminibuffer_complete, Sminibuffer_complete, 0, 0, "", 2115 doc: /* Complete the minibuffer contents as far as possible. 2116Return nil if there is no valid completion, else t. 2117If no characters can be completed, display a list of possible completions. 2118If you repeat this command after it displayed such a list, 2119scroll the window of possible completions. */) 2120 () 2121{ 2122 register int i; 2123 Lisp_Object window, tem; 2124 2125 /* If the previous command was not this, 2126 mark the completion buffer obsolete. */ 2127 if (! EQ (current_kboard->Vlast_command, Vthis_command)) 2128 Vminibuf_scroll_window = Qnil; 2129 2130 window = Vminibuf_scroll_window; 2131 /* If there's a fresh completion window with a live buffer, 2132 and this command is repeated, scroll that window. */ 2133 if (! NILP (window) && ! NILP (XWINDOW (window)->buffer) 2134 && !NILP (XBUFFER (XWINDOW (window)->buffer)->name)) 2135 { 2136 struct buffer *obuf = current_buffer; 2137 2138 Fset_buffer (XWINDOW (window)->buffer); 2139 tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil); 2140 if (! NILP (tem)) 2141 /* If end is in view, scroll up to the beginning. */ 2142 Fset_window_start (window, make_number (BEGV), Qnil); 2143 else 2144 /* Else scroll down one screen. */ 2145 Fscroll_other_window (Qnil); 2146 2147 set_buffer_internal (obuf); 2148 return Qnil; 2149 } 2150 2151 i = do_completion (); 2152 switch (i) 2153 { 2154 case 0: 2155 return Qnil; 2156 2157 case 1: 2158 if (PT != ZV) 2159 Fgoto_char (make_number (ZV)); 2160 temp_echo_area_glyphs (build_string (" [Sole completion]")); 2161 break; 2162 2163 case 3: 2164 if (PT != ZV) 2165 Fgoto_char (make_number (ZV)); 2166 temp_echo_area_glyphs (build_string (" [Complete, but not unique]")); 2167 break; 2168 } 2169 2170 return Qt; 2171} 2172 2173/* Subroutines of Fminibuffer_complete_and_exit. */ 2174 2175/* This one is called by internal_condition_case to do the real work. */ 2176 2177Lisp_Object 2178complete_and_exit_1 () 2179{ 2180 return make_number (do_completion ()); 2181} 2182 2183/* This one is called by internal_condition_case if an error happens. 2184 Pretend the current value is an exact match. */ 2185 2186Lisp_Object 2187complete_and_exit_2 (ignore) 2188 Lisp_Object ignore; 2189{ 2190 return make_number (1); 2191} 2192 2193EXFUN (Fexit_minibuffer, 0) NO_RETURN; 2194 2195DEFUN ("minibuffer-complete-and-exit", Fminibuffer_complete_and_exit, 2196 Sminibuffer_complete_and_exit, 0, 0, "", 2197 doc: /* If the minibuffer contents is a valid completion then exit. 2198Otherwise try to complete it. If completion leads to a valid completion, 2199a repetition of this command will exit. */) 2200 () 2201{ 2202 register int i; 2203 Lisp_Object val, tem; 2204 2205 /* Allow user to specify null string */ 2206 if (XINT (Fminibuffer_prompt_end ()) == ZV) 2207 goto exit; 2208 2209 val = Fminibuffer_contents (); 2210 tem = Ftest_completion (val, 2211 Vminibuffer_completion_table, 2212 Vminibuffer_completion_predicate); 2213 if (!NILP (tem)) 2214 { 2215 if (completion_ignore_case) 2216 { /* Fixup case of the field, if necessary. */ 2217 Lisp_Object compl 2218 = Ftry_completion (val, 2219 Vminibuffer_completion_table, 2220 Vminibuffer_completion_predicate); 2221 if (STRINGP (compl) 2222 /* If it weren't for this piece of paranoia, I'd replace 2223 the whole thing with a call to do_completion. */ 2224 && EQ (Flength (val), Flength (compl))) 2225 { 2226 del_range (XINT (Fminibuffer_prompt_end ()), ZV); 2227 Finsert (1, &compl); 2228 } 2229 } 2230 goto exit; 2231 } 2232 2233 /* Call do_completion, but ignore errors. */ 2234 SET_PT (ZV); 2235 val = internal_condition_case (complete_and_exit_1, Qerror, 2236 complete_and_exit_2); 2237 2238 i = XFASTINT (val); 2239 switch (i) 2240 { 2241 case 1: 2242 case 3: 2243 goto exit; 2244 2245 case 4: 2246 if (!NILP (Vminibuffer_completion_confirm)) 2247 { 2248 temp_echo_area_glyphs (build_string (" [Confirm]")); 2249 return Qnil; 2250 } 2251 else 2252 goto exit; 2253 2254 default: 2255 return Qnil; 2256 } 2257 exit: 2258 return Fexit_minibuffer (); 2259 /* NOTREACHED */ 2260} 2261 2262DEFUN ("minibuffer-complete-word", Fminibuffer_complete_word, Sminibuffer_complete_word, 2263 0, 0, "", 2264 doc: /* Complete the minibuffer contents at most a single word. 2265After one word is completed as much as possible, a space or hyphen 2266is added, provided that matches some possible completion. 2267Return nil if there is no valid completion, else t. */) 2268 () 2269{ 2270 Lisp_Object completion, tem, tem1; 2271 register int i, i_byte; 2272 struct gcpro gcpro1, gcpro2; 2273 int prompt_end_charpos = XINT (Fminibuffer_prompt_end ()); 2274 2275 /* We keep calling Fbuffer_string rather than arrange for GC to 2276 hold onto a pointer to one of the strings thus made. */ 2277 2278 completion = Ftry_completion (Fminibuffer_completion_contents (), 2279 Vminibuffer_completion_table, 2280 Vminibuffer_completion_predicate); 2281 if (NILP (completion)) 2282 { 2283 bitch_at_user (); 2284 temp_echo_area_glyphs (build_string (" [No match]")); 2285 return Qnil; 2286 } 2287 if (EQ (completion, Qt)) 2288 return Qnil; 2289 2290#if 0 /* How the below code used to look, for reference. */ 2291 tem = Fminibuffer_contents (); 2292 b = SDATA (tem); 2293 i = ZV - 1 - SCHARS (completion); 2294 p = SDATA (completion); 2295 if (i > 0 || 2296 0 <= scmp (b, p, ZV - 1)) 2297 { 2298 i = 1; 2299 /* Set buffer to longest match of buffer tail and completion head. */ 2300 while (0 <= scmp (b + i, p, ZV - 1 - i)) 2301 i++; 2302 del_range (1, i + 1); 2303 SET_PT (ZV); 2304 } 2305#else /* Rewritten code */ 2306 { 2307 int buffer_nchars, completion_nchars; 2308 2309 CHECK_STRING (completion); 2310 tem = Fminibuffer_completion_contents (); 2311 GCPRO2 (completion, tem); 2312 /* If reading a file name, 2313 expand any $ENVVAR refs in the buffer and in TEM. */ 2314 if (! NILP (Vminibuffer_completing_file_name)) 2315 { 2316 Lisp_Object substituted; 2317 substituted = Fsubstitute_in_file_name (tem); 2318 if (! EQ (substituted, tem)) 2319 { 2320 tem = substituted; 2321 del_range (prompt_end_charpos, PT); 2322 Finsert (1, &tem); 2323 } 2324 } 2325 buffer_nchars = SCHARS (tem); /* # chars in what we completed. */ 2326 completion_nchars = SCHARS (completion); 2327 i = buffer_nchars - completion_nchars; 2328 if (i > 0 2329 || 2330 (tem1 = Fcompare_strings (tem, make_number (0), 2331 make_number (buffer_nchars), 2332 completion, make_number (0), 2333 make_number (buffer_nchars), 2334 completion_ignore_case ? Qt : Qnil), 2335 ! EQ (tem1, Qt))) 2336 { 2337 int start_pos; 2338 2339 /* Make buffer (before point) contain the longest match 2340 of TEM's tail and COMPLETION's head. */ 2341 if (i <= 0) i = 1; 2342 start_pos= i; 2343 buffer_nchars -= i; 2344 while (i > 0) 2345 { 2346 tem1 = Fcompare_strings (tem, make_number (start_pos), Qnil, 2347 completion, make_number (0), 2348 make_number (buffer_nchars), 2349 completion_ignore_case ? Qt : Qnil); 2350 start_pos++; 2351 if (EQ (tem1, Qt)) 2352 break; 2353 i++; 2354 buffer_nchars--; 2355 } 2356 del_range (start_pos, start_pos + buffer_nchars); 2357 } 2358 UNGCPRO; 2359 } 2360#endif /* Rewritten code */ 2361 2362 { 2363 int prompt_end_bytepos; 2364 prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos); 2365 i = PT - prompt_end_charpos; 2366 i_byte = PT_BYTE - prompt_end_bytepos; 2367 } 2368 2369 /* If completion finds next char not unique, 2370 consider adding a space or a hyphen. */ 2371 if (i == SCHARS (completion)) 2372 { 2373 GCPRO1 (completion); 2374 tem = Ftry_completion (concat2 (Fminibuffer_completion_contents (), 2375 build_string (" ")), 2376 Vminibuffer_completion_table, 2377 Vminibuffer_completion_predicate); 2378 UNGCPRO; 2379 2380 if (STRINGP (tem)) 2381 completion = tem; 2382 else 2383 { 2384 GCPRO1 (completion); 2385 tem = 2386 Ftry_completion (concat2 (Fminibuffer_completion_contents (), 2387 build_string ("-")), 2388 Vminibuffer_completion_table, 2389 Vminibuffer_completion_predicate); 2390 UNGCPRO; 2391 2392 if (STRINGP (tem)) 2393 completion = tem; 2394 } 2395 } 2396 2397 /* Now find first word-break in the stuff found by completion. 2398 i gets index in string of where to stop completing. */ 2399 { 2400 int len, c; 2401 int bytes = SBYTES (completion); 2402 register const unsigned char *completion_string = SDATA (completion); 2403 for (; i_byte < SBYTES (completion); i_byte += len, i++) 2404 { 2405 c = STRING_CHAR_AND_LENGTH (completion_string + i_byte, 2406 bytes - i_byte, 2407 len); 2408 if (SYNTAX (c) != Sword) 2409 { 2410 i_byte += len; 2411 i++; 2412 break; 2413 } 2414 } 2415 } 2416 2417 /* If got no characters, print help for user. */ 2418 2419 if (i == PT - prompt_end_charpos) 2420 { 2421 if (!NILP (Vcompletion_auto_help)) 2422 Fminibuffer_completion_help (); 2423 return Qnil; 2424 } 2425 2426 /* Otherwise insert in minibuffer the chars we got */ 2427 2428 if (! NILP (Vminibuffer_completing_file_name) 2429 && SREF (completion, SBYTES (completion) - 1) == '/' 2430 && PT < ZV 2431 && FETCH_CHAR (PT_BYTE) == '/') 2432 { 2433 del_range (prompt_end_charpos, PT + 1); 2434 } 2435 else 2436 del_range (prompt_end_charpos, PT); 2437 2438 insert_from_string (completion, 0, 0, i, i_byte, 1); 2439 return Qt; 2440} 2441 2442DEFUN ("display-completion-list", Fdisplay_completion_list, Sdisplay_completion_list, 2443 1, 2, 0, 2444 doc: /* Display the list of completions, COMPLETIONS, using `standard-output'. 2445Each element may be just a symbol or string 2446or may be a list of two strings to be printed as if concatenated. 2447If it is a list of two strings, the first is the actual completion 2448alternative, the second serves as annotation. 2449`standard-output' must be a buffer. 2450The actual completion alternatives, as inserted, are given `mouse-face' 2451properties of `highlight'. 2452At the end, this runs the normal hook `completion-setup-hook'. 2453It can find the completion buffer in `standard-output'. 2454The optional second arg COMMON-SUBSTRING is a string. 2455It is used to put faces, `completions-first-difference' and 2456`completions-common-part' on the completion buffer. The 2457`completions-common-part' face is put on the common substring 2458specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil 2459and the current buffer is not the minibuffer, the faces are not put. 2460Internally, COMMON-SUBSTRING is bound to `completion-common-substring' 2461during running `completion-setup-hook'. */) 2462 (completions, common_substring) 2463 Lisp_Object completions; 2464 Lisp_Object common_substring; 2465{ 2466 Lisp_Object tail, elt; 2467 register int i; 2468 int column = 0; 2469 struct gcpro gcpro1, gcpro2, gcpro3; 2470 struct buffer *old = current_buffer; 2471 int first = 1; 2472 2473 /* Note that (when it matters) every variable 2474 points to a non-string that is pointed to by COMPLETIONS, 2475 except for ELT. ELT can be pointing to a string 2476 when terpri or Findent_to calls a change hook. */ 2477 elt = Qnil; 2478 GCPRO3 (completions, elt, common_substring); 2479 2480 if (BUFFERP (Vstandard_output)) 2481 set_buffer_internal (XBUFFER (Vstandard_output)); 2482 2483 if (NILP (completions)) 2484 write_string ("There are no possible completions of what you have typed.", 2485 -1); 2486 else 2487 { 2488 write_string ("Possible completions are:", -1); 2489 for (tail = completions, i = 0; CONSP (tail); tail = XCDR (tail), i++) 2490 { 2491 Lisp_Object tem, string; 2492 int length; 2493 Lisp_Object startpos, endpos; 2494 2495 startpos = Qnil; 2496 2497 elt = XCAR (tail); 2498 if (SYMBOLP (elt)) 2499 elt = SYMBOL_NAME (elt); 2500 /* Compute the length of this element. */ 2501 if (CONSP (elt)) 2502 { 2503 tem = XCAR (elt); 2504 CHECK_STRING (tem); 2505 length = SCHARS (tem); 2506 2507 tem = Fcar (XCDR (elt)); 2508 CHECK_STRING (tem); 2509 length += SCHARS (tem); 2510 } 2511 else 2512 { 2513 CHECK_STRING (elt); 2514 length = SCHARS (elt); 2515 } 2516 2517 /* This does a bad job for narrower than usual windows. 2518 Sadly, the window it will appear in is not known 2519 until after the text has been made. */ 2520 2521 if (BUFFERP (Vstandard_output)) 2522 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output))); 2523 2524 /* If the previous completion was very wide, 2525 or we have two on this line already, 2526 don't put another on the same line. */ 2527 if (column > 33 || first 2528 /* If this is really wide, don't put it second on a line. */ 2529 || (column > 0 && length > 45)) 2530 { 2531 Fterpri (Qnil); 2532 column = 0; 2533 } 2534 /* Otherwise advance to column 35. */ 2535 else 2536 { 2537 if (BUFFERP (Vstandard_output)) 2538 { 2539 tem = Findent_to (make_number (35), make_number (2)); 2540 2541 column = XINT (tem); 2542 } 2543 else 2544 { 2545 do 2546 { 2547 write_string (" ", -1); 2548 column++; 2549 } 2550 while (column < 35); 2551 } 2552 } 2553 2554 if (BUFFERP (Vstandard_output)) 2555 { 2556 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output))); 2557 Fset_text_properties (startpos, endpos, 2558 Qnil, Vstandard_output); 2559 } 2560 2561 /* Output this element. 2562 If necessary, convert it to unibyte or to multibyte first. */ 2563 if (CONSP (elt)) 2564 string = Fcar (elt); 2565 else 2566 string = elt; 2567 if (NILP (current_buffer->enable_multibyte_characters) 2568 && STRING_MULTIBYTE (string)) 2569 string = Fstring_make_unibyte (string); 2570 else if (!NILP (current_buffer->enable_multibyte_characters) 2571 && !STRING_MULTIBYTE (string)) 2572 string = Fstring_make_multibyte (string); 2573 2574 if (BUFFERP (Vstandard_output)) 2575 { 2576 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output))); 2577 2578 Fprinc (string, Qnil); 2579 2580 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output))); 2581 2582 Fput_text_property (startpos, endpos, 2583 Qmouse_face, intern ("highlight"), 2584 Vstandard_output); 2585 } 2586 else 2587 { 2588 Fprinc (string, Qnil); 2589 } 2590 2591 /* Output the annotation for this element. */ 2592 if (CONSP (elt)) 2593 { 2594 if (BUFFERP (Vstandard_output)) 2595 { 2596 XSETINT (startpos, BUF_PT (XBUFFER (Vstandard_output))); 2597 2598 Fprinc (Fcar (Fcdr (elt)), Qnil); 2599 2600 XSETINT (endpos, BUF_PT (XBUFFER (Vstandard_output))); 2601 2602 Fset_text_properties (startpos, endpos, Qnil, 2603 Vstandard_output); 2604 } 2605 else 2606 { 2607 Fprinc (Fcar (Fcdr (elt)), Qnil); 2608 } 2609 } 2610 2611 2612 /* Update COLUMN for what we have output. */ 2613 column += length; 2614 2615 /* If output is to a buffer, recompute COLUMN in a way 2616 that takes account of character widths. */ 2617 if (BUFFERP (Vstandard_output)) 2618 { 2619 tem = Fcurrent_column (); 2620 column = XINT (tem); 2621 } 2622 2623 first = 0; 2624 } 2625 } 2626 2627 if (BUFFERP (Vstandard_output)) 2628 set_buffer_internal (old); 2629 2630 if (!NILP (Vrun_hooks)) 2631 { 2632 int count1 = SPECPDL_INDEX (); 2633 2634 specbind (intern ("completion-common-substring"), common_substring); 2635 call1 (Vrun_hooks, intern ("completion-setup-hook")); 2636 2637 unbind_to (count1, Qnil); 2638 } 2639 2640 UNGCPRO; 2641 2642 return Qnil; 2643} 2644 2645 2646static Lisp_Object 2647display_completion_list_1 (list) 2648 Lisp_Object list; 2649{ 2650 return Fdisplay_completion_list (list, Qnil); 2651} 2652 2653DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help, 2654 0, 0, "", 2655 doc: /* Display a list of possible completions of the current minibuffer contents. */) 2656 () 2657{ 2658 Lisp_Object completions; 2659 2660 message ("Making completion list..."); 2661 completions = Fall_completions (Fminibuffer_completion_contents (), 2662 Vminibuffer_completion_table, 2663 Vminibuffer_completion_predicate, 2664 Qt); 2665 clear_message (1, 0); 2666 2667 if (NILP (completions)) 2668 { 2669 bitch_at_user (); 2670 temp_echo_area_glyphs (build_string (" [No completions]")); 2671 } 2672 else 2673 { 2674 /* Sort and remove duplicates. */ 2675 Lisp_Object tmp = completions = Fsort (completions, Qstring_lessp); 2676 while (CONSP (tmp)) 2677 { 2678 if (CONSP (XCDR (tmp)) 2679 && !NILP (Fequal (XCAR (tmp), XCAR (XCDR (tmp))))) 2680 XSETCDR (tmp, XCDR (XCDR (tmp))); 2681 else 2682 tmp = XCDR (tmp); 2683 } 2684 internal_with_output_to_temp_buffer ("*Completions*", 2685 display_completion_list_1, 2686 completions); 2687 } 2688 return Qnil; 2689} 2690 2691DEFUN ("self-insert-and-exit", Fself_insert_and_exit, Sself_insert_and_exit, 0, 0, "", 2692 doc: /* Terminate minibuffer input. */) 2693 () 2694{ 2695 if (INTEGERP (last_command_char)) 2696 internal_self_insert (XINT (last_command_char), 0); 2697 else 2698 bitch_at_user (); 2699 2700 return Fexit_minibuffer (); 2701} 2702 2703DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "", 2704 doc: /* Terminate this minibuffer argument. */) 2705 () 2706{ 2707 /* If the command that uses this has made modifications in the minibuffer, 2708 we don't want them to cause deactivation of the mark in the original 2709 buffer. 2710 A better solution would be to make deactivate-mark buffer-local 2711 (or to turn it into a list of buffers, ...), but in the mean time, 2712 this should do the trick in most cases. */ 2713 Vdeactivate_mark = Qnil; 2714 Fthrow (Qexit, Qnil); 2715} 2716 2717DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0, 2718 doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */) 2719 () 2720{ 2721 return make_number (minibuf_level); 2722} 2723 2724DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0, 2725 doc: /* Return the prompt string of the currently-active minibuffer. 2726If no minibuffer is active, return nil. */) 2727 () 2728{ 2729 return Fcopy_sequence (minibuf_prompt); 2730} 2731 2732 2733/* Temporarily display STRING at the end of the current 2734 minibuffer contents. This is used to display things like 2735 "[No Match]" when the user requests a completion for a prefix 2736 that has no possible completions, and other quick, unobtrusive 2737 messages. */ 2738 2739extern Lisp_Object Vminibuffer_message_timeout; 2740 2741void 2742temp_echo_area_glyphs (string) 2743 Lisp_Object string; 2744{ 2745 int osize = ZV; 2746 int osize_byte = ZV_BYTE; 2747 int opoint = PT; 2748 int opoint_byte = PT_BYTE; 2749 Lisp_Object oinhibit; 2750 oinhibit = Vinhibit_quit; 2751 2752 /* Clear out any old echo-area message to make way for our new thing. */ 2753 message (0); 2754 2755 SET_PT_BOTH (osize, osize_byte); 2756 insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0); 2757 SET_PT_BOTH (opoint, opoint_byte); 2758 Vinhibit_quit = Qt; 2759 2760 if (NUMBERP (Vminibuffer_message_timeout)) 2761 sit_for (Vminibuffer_message_timeout, 0, 2); 2762 else 2763 sit_for (Qt, 0, 2); 2764 2765 del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1); 2766 SET_PT_BOTH (opoint, opoint_byte); 2767 if (!NILP (Vquit_flag)) 2768 { 2769 Vquit_flag = Qnil; 2770 Vunread_command_events = Fcons (make_number (quit_char), Qnil); 2771 } 2772 Vinhibit_quit = oinhibit; 2773} 2774 2775DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message, 2776 1, 1, 0, 2777 doc: /* Temporarily display STRING at the end of the minibuffer. 2778The text is displayed for a period controlled by `minibuffer-message-timeout', 2779or until the next input event arrives, whichever comes first. */) 2780 (string) 2781 Lisp_Object string; 2782{ 2783 CHECK_STRING (string); 2784 temp_echo_area_glyphs (string); 2785 return Qnil; 2786} 2787 2788void 2789init_minibuf_once () 2790{ 2791 Vminibuffer_list = Qnil; 2792 staticpro (&Vminibuffer_list); 2793} 2794 2795void 2796syms_of_minibuf () 2797{ 2798 minibuf_level = 0; 2799 minibuf_prompt = Qnil; 2800 staticpro (&minibuf_prompt); 2801 2802 minibuf_save_list = Qnil; 2803 staticpro (&minibuf_save_list); 2804 2805 Qread_file_name_internal = intern ("read-file-name-internal"); 2806 staticpro (&Qread_file_name_internal); 2807 2808 Qminibuffer_default = intern ("minibuffer-default"); 2809 staticpro (&Qminibuffer_default); 2810 Fset (Qminibuffer_default, Qnil); 2811 2812 Qminibuffer_completion_table = intern ("minibuffer-completion-table"); 2813 staticpro (&Qminibuffer_completion_table); 2814 2815 Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm"); 2816 staticpro (&Qminibuffer_completion_confirm); 2817 2818 Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate"); 2819 staticpro (&Qminibuffer_completion_predicate); 2820 2821 staticpro (&last_exact_completion); 2822 last_exact_completion = Qnil; 2823 2824 staticpro (&last_minibuf_string); 2825 last_minibuf_string = Qnil; 2826 2827 Quser_variable_p = intern ("user-variable-p"); 2828 staticpro (&Quser_variable_p); 2829 2830 Qminibuffer_history = intern ("minibuffer-history"); 2831 staticpro (&Qminibuffer_history); 2832 2833 Qbuffer_name_history = intern ("buffer-name-history"); 2834 staticpro (&Qbuffer_name_history); 2835 Fset (Qbuffer_name_history, Qnil); 2836 2837 Qminibuffer_setup_hook = intern ("minibuffer-setup-hook"); 2838 staticpro (&Qminibuffer_setup_hook); 2839 2840 Qminibuffer_exit_hook = intern ("minibuffer-exit-hook"); 2841 staticpro (&Qminibuffer_exit_hook); 2842 2843 Qhistory_length = intern ("history-length"); 2844 staticpro (&Qhistory_length); 2845 2846 Qcurrent_input_method = intern ("current-input-method"); 2847 staticpro (&Qcurrent_input_method); 2848 2849 Qactivate_input_method = intern ("activate-input-method"); 2850 staticpro (&Qactivate_input_method); 2851 2852 Qcase_fold_search = intern ("case-fold-search"); 2853 staticpro (&Qcase_fold_search); 2854 2855 Qread_expression_history = intern ("read-expression-history"); 2856 staticpro (&Qread_expression_history); 2857 2858 DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function, 2859 doc: /* If this is non-nil, `read-buffer' does its work by calling this function. */); 2860 Vread_buffer_function = Qnil; 2861 2862 DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook, 2863 doc: /* Normal hook run just after entry to minibuffer. */); 2864 Vminibuffer_setup_hook = Qnil; 2865 2866 DEFVAR_LISP ("minibuffer-exit-hook", &Vminibuffer_exit_hook, 2867 doc: /* Normal hook run just after exit from minibuffer. */); 2868 Vminibuffer_exit_hook = Qnil; 2869 2870 DEFVAR_LISP ("history-length", &Vhistory_length, 2871 doc: /* *Maximum length for history lists before truncation takes place. 2872A number means that length; t means infinite. Truncation takes place 2873just after a new element is inserted. Setting the `history-length' 2874property of a history variable overrides this default. */); 2875 XSETFASTINT (Vhistory_length, 30); 2876 2877 DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates, 2878 doc: /* *Non-nil means to delete duplicates in history. 2879If set to t when adding a new history element, all previous identical 2880elements are deleted from the history list. */); 2881 history_delete_duplicates = 0; 2882 2883 DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input, 2884 doc: /* *Non-nil means to add new elements in history. 2885If set to nil, minibuffer reading functions don't add new elements to the 2886history list, so it is possible to do this afterwards by calling 2887`add-to-history' explicitly. */); 2888 Vhistory_add_new_input = Qt; 2889 2890 DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help, 2891 doc: /* *Non-nil means automatically provide help for invalid completion input. 2892Under Partial Completion mode, a non-nil, non-t value has a special meaning; 2893see the doc string of `partial-completion-mode' for more details. */); 2894 Vcompletion_auto_help = Qt; 2895 2896 DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case, 2897 doc: /* Non-nil means don't consider case significant in completion. 2898 2899For file-name completion, the variable `read-file-name-completion-ignore-case' 2900controls the behavior, rather than this variable. */); 2901 completion_ignore_case = 0; 2902 2903 DEFVAR_BOOL ("enable-recursive-minibuffers", &enable_recursive_minibuffers, 2904 doc: /* *Non-nil means to allow minibuffer commands while in the minibuffer. 2905This variable makes a difference whenever the minibuffer window is active. */); 2906 enable_recursive_minibuffers = 0; 2907 2908 DEFVAR_LISP ("minibuffer-completion-table", &Vminibuffer_completion_table, 2909 doc: /* Alist or obarray used for completion in the minibuffer. 2910This becomes the ALIST argument to `try-completion' and `all-completions'. 2911The value can also be a list of strings or a hash table. 2912 2913The value may alternatively be a function, which is given three arguments: 2914 STRING, the current buffer contents; 2915 PREDICATE, the predicate for filtering possible matches; 2916 CODE, which says what kind of things to do. 2917CODE can be nil, t or `lambda': 2918 nil -- return the best completion of STRING, or nil if there is none. 2919 t -- return a list of all possible completions of STRING. 2920 lambda -- return t if STRING is a valid completion as it stands. */); 2921 Vminibuffer_completion_table = Qnil; 2922 2923 DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate, 2924 doc: /* Within call to `completing-read', this holds the PREDICATE argument. */); 2925 Vminibuffer_completion_predicate = Qnil; 2926 2927 DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm, 2928 doc: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */); 2929 Vminibuffer_completion_confirm = Qnil; 2930 2931 DEFVAR_LISP ("minibuffer-completing-file-name", 2932 &Vminibuffer_completing_file_name, 2933 doc: /* Non-nil and non-`lambda' means completing file names. */); 2934 Vminibuffer_completing_file_name = Qnil; 2935 2936 DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form, 2937 doc: /* Value that `help-form' takes on inside the minibuffer. */); 2938 Vminibuffer_help_form = Qnil; 2939 2940 DEFVAR_LISP ("minibuffer-history-variable", &Vminibuffer_history_variable, 2941 doc: /* History list symbol to add minibuffer values to. 2942Each string of minibuffer input, as it appears on exit from the minibuffer, 2943is added with 2944 (set minibuffer-history-variable 2945 (cons STRING (symbol-value minibuffer-history-variable))) */); 2946 XSETFASTINT (Vminibuffer_history_variable, 0); 2947 2948 DEFVAR_LISP ("minibuffer-history-position", &Vminibuffer_history_position, 2949 doc: /* Current position of redoing in the history list. */); 2950 Vminibuffer_history_position = Qnil; 2951 2952 DEFVAR_BOOL ("minibuffer-auto-raise", &minibuffer_auto_raise, 2953 doc: /* *Non-nil means entering the minibuffer raises the minibuffer's frame. 2954Some uses of the echo area also raise that frame (since they use it too). */); 2955 minibuffer_auto_raise = 0; 2956 2957 DEFVAR_LISP ("completion-regexp-list", &Vcompletion_regexp_list, 2958 doc: /* List of regexps that should restrict possible completions. 2959The basic completion functions only consider a completion acceptable 2960if it matches all regular expressions in this list, with 2961`case-fold-search' bound to the value of `completion-ignore-case'. 2962See Info node `(elisp)Basic Completion', for a description of these 2963functions. */); 2964 Vcompletion_regexp_list = Qnil; 2965 2966 DEFVAR_BOOL ("minibuffer-allow-text-properties", 2967 &minibuffer_allow_text_properties, 2968 doc: /* Non-nil means `read-from-minibuffer' should not discard text properties. 2969This also affects `read-string', but it does not affect `read-minibuffer', 2970`read-no-blanks-input', or any of the functions that do minibuffer input 2971with completion; they always discard text properties. */); 2972 minibuffer_allow_text_properties = 0; 2973 2974 DEFVAR_LISP ("minibuffer-prompt-properties", &Vminibuffer_prompt_properties, 2975 doc: /* Text properties that are added to minibuffer prompts. 2976These are in addition to the basic `field' property, and stickiness 2977properties. */); 2978 /* We use `intern' here instead of Qread_only to avoid 2979 initialization-order problems. */ 2980 Vminibuffer_prompt_properties 2981 = Fcons (intern ("read-only"), Fcons (Qt, Qnil)); 2982 2983 DEFVAR_LISP ("read-expression-map", &Vread_expression_map, 2984 doc: /* Minibuffer keymap used for reading Lisp expressions. */); 2985 Vread_expression_map = Qnil; 2986 2987 defsubr (&Sset_minibuffer_window); 2988 defsubr (&Sread_from_minibuffer); 2989 defsubr (&Seval_minibuffer); 2990 defsubr (&Sread_minibuffer); 2991 defsubr (&Sread_string); 2992 defsubr (&Sread_command); 2993 defsubr (&Sread_variable); 2994 defsubr (&Sinternal_complete_buffer); 2995 defsubr (&Sread_buffer); 2996 defsubr (&Sread_no_blanks_input); 2997 defsubr (&Sminibuffer_depth); 2998 defsubr (&Sminibuffer_prompt); 2999 3000 defsubr (&Sminibufferp); 3001 defsubr (&Sminibuffer_prompt_end); 3002 defsubr (&Sminibuffer_contents); 3003 defsubr (&Sminibuffer_contents_no_properties); 3004 defsubr (&Sminibuffer_completion_contents); 3005 defsubr (&Sdelete_minibuffer_contents); 3006 3007 defsubr (&Stry_completion); 3008 defsubr (&Sall_completions); 3009 defsubr (&Stest_completion); 3010 defsubr (&Sassoc_string); 3011 defsubr (&Scompleting_read); 3012 defsubr (&Sminibuffer_complete); 3013 defsubr (&Sminibuffer_complete_word); 3014 defsubr (&Sminibuffer_complete_and_exit); 3015 defsubr (&Sdisplay_completion_list); 3016 defsubr (&Sminibuffer_completion_help); 3017 3018 defsubr (&Sself_insert_and_exit); 3019 defsubr (&Sexit_minibuffer); 3020 3021 defsubr (&Sminibuffer_message); 3022} 3023 3024void 3025keys_of_minibuf () 3026{ 3027 initial_define_key (Vminibuffer_local_map, Ctl ('g'), 3028 "abort-recursive-edit"); 3029 initial_define_key (Vminibuffer_local_map, Ctl ('m'), 3030 "exit-minibuffer"); 3031 initial_define_key (Vminibuffer_local_map, Ctl ('j'), 3032 "exit-minibuffer"); 3033 3034 initial_define_key (Vminibuffer_local_ns_map, ' ', 3035 "exit-minibuffer"); 3036 initial_define_key (Vminibuffer_local_ns_map, '\t', 3037 "exit-minibuffer"); 3038 initial_define_key (Vminibuffer_local_ns_map, '?', 3039 "self-insert-and-exit"); 3040 3041 initial_define_key (Vminibuffer_local_completion_map, '\t', 3042 "minibuffer-complete"); 3043 initial_define_key (Vminibuffer_local_completion_map, ' ', 3044 "minibuffer-complete-word"); 3045 initial_define_key (Vminibuffer_local_completion_map, '?', 3046 "minibuffer-completion-help"); 3047 3048 Fdefine_key (Vminibuffer_local_filename_completion_map, 3049 build_string (" "), Qnil); 3050 3051 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'), 3052 "minibuffer-complete-and-exit"); 3053 initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'), 3054 "minibuffer-complete-and-exit"); 3055 3056 Fdefine_key (Vminibuffer_local_must_match_filename_map, 3057 build_string (" "), Qnil); 3058} 3059 3060/* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73 3061 (do not change this comment) */ 3062