src/minibuf.c

   1 /* Minibuffer input and completion.
   2
   3 Copyright (C) 1985-1986, 1993-2015 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include <config.h>
  22 #include <errno.h>
  23 #include <stdio.h>
  24
  25 #include <binary-io.h>
  26
  27 #include "lisp.h"
  28 #include "commands.h"
  29 #include "character.h"
  30 #include "buffer.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 #include "termhooks.h"
  39 #include "systty.h"
  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
  47 Lisp_Object Vminibuffer_list;
  48
  49 /* Data to remember during recursive minibuffer invocations.  */
  50
  51 static Lisp_Object minibuf_save_list;
  52
  53 /* Depth in minibuffer invocations.  */
  54
  55 EMACS_INT minibuf_level;
  56
  57 /* Fread_minibuffer leaves the input here as a string.  */
  58
  59 Lisp_Object last_minibuf_string;
  60
  61 /* Prompt to display in front of the mini-buffer contents.  */
  62
  63 static Lisp_Object minibuf_prompt;
  64
  65 /* Width of current mini-buffer prompt.  Only set after display_line
  66    of the line that contains the prompt.  */
  67
  68 static ptrdiff_t minibuf_prompt_width;
  69
  70 \f
  71 /* Put minibuf on currently selected frame's minibuffer.
  72    We do this whenever the user starts a new minibuffer
  73    or when a minibuffer exits.  */
  74
  75 static void
  76 choose_minibuf_frame (void)
  77 {
  78   if (FRAMEP (selected_frame)
  79       && FRAME_LIVE_P (XFRAME (selected_frame))
  80       && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
  81     {
  82       struct frame *sf = XFRAME (selected_frame);
  83       Lisp_Object buffer;
  84
  85       /* I don't think that any frames may validly have a null minibuffer
  86          window anymore.  */
  87       if (NILP (sf->minibuffer_window))
  88         emacs_abort ();
  89
  90       /* Under X, we come here with minibuf_window being the
  91          minibuffer window of the unused termcap window created in
  92          init_window_once.  That window doesn't have a buffer.  */
  93       buffer = XWINDOW (minibuf_window)->contents;
  94       if (BUFFERP (buffer))
  95         /* Use set_window_buffer instead of Fset_window_buffer (see
  96            discussion of bug#11984, bug#12025, bug#12026).  */
  97         set_window_buffer (sf->minibuffer_window, buffer, 0, 0);
  98       minibuf_window = sf->minibuffer_window;
  99     }
 100
 101   /* Make sure no other frame has a minibuffer as its selected window,
 102      because the text would not be displayed in it, and that would be
 103      confusing.  Only allow the selected frame to do this,
 104      and that only if the minibuffer is active.  */
 105   {
 106     Lisp_Object tail, frame;
 107
 108     FOR_EACH_FRAME (tail, frame)
 109       if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
 110           && !(EQ (frame, selected_frame)
 111                && minibuf_level > 0))
 112         Fset_frame_selected_window (frame, Fframe_first_window (frame), Qnil);
 113   }
 114 }
 115
 116 DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
 117        Sactive_minibuffer_window, 0, 0, 0,
 118        doc: /* Return the currently active minibuffer window, or nil if none.  */)
 119      (void)
 120 {
 121   return minibuf_level ? minibuf_window : Qnil;
 122 }
 123
 124 DEFUN ("set-minibuffer-window", Fset_minibuffer_window,
 125        Sset_minibuffer_window, 1, 1, 0,
 126        doc: /* Specify which minibuffer window to use for the minibuffer.
 127 This affects where the minibuffer is displayed if you put text in it
 128 without invoking the usual minibuffer commands.  */)
 129   (Lisp_Object window)
 130 {
 131   CHECK_WINDOW (window);
 132   if (! MINI_WINDOW_P (XWINDOW (window)))
 133     error ("Window is not a minibuffer window");
 134
 135   minibuf_window = window;
 136
 137   return window;
 138 }
 139
 140 \f
 141 /* Actual minibuffer invocation.  */
 142
 143 static void read_minibuf_unwind (void);
 144 static void run_exit_minibuf_hook (void);
 145
 146
 147 /* Read a Lisp object from VAL and return it.  If VAL is an empty
 148    string, and DEFALT is a string, read from DEFALT instead of VAL.  */
 149
 150 static Lisp_Object
 151 string_to_object (Lisp_Object val, Lisp_Object defalt)
 152 {
 153   struct gcpro gcpro1, gcpro2;
 154   Lisp_Object expr_and_pos;
 155   ptrdiff_t pos;
 156
 157   GCPRO2 (val, defalt);
 158
 159   if (STRINGP (val) && SCHARS (val) == 0)
 160     {
 161       if (STRINGP (defalt))
 162         val = defalt;
 163       else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
 164         val = XCAR (defalt);
 165     }
 166
 167   expr_and_pos = Fread_from_string (val, Qnil, Qnil);
 168   pos = XINT (Fcdr (expr_and_pos));
 169   if (pos != SCHARS (val))
 170     {
 171       /* Ignore trailing whitespace; any other trailing junk
 172          is an error.  */
 173       ptrdiff_t i;
 174       pos = string_char_to_byte (val, pos);
 175       for (i = pos; i < SBYTES (val); i++)
 176         {
 177           int c = SREF (val, i);
 178           if (c != ' ' && c != '\t' && c != '\n')
 179             error ("Trailing garbage following expression");
 180         }
 181     }
 182
 183   val = Fcar (expr_and_pos);
 184   RETURN_UNGCPRO (val);
 185 }
 186
 187
 188 /* Like read_minibuf but reading from stdin.  This function is called
 189    from read_minibuf to do the job if noninteractive.  */
 190
 191 static Lisp_Object
 192 read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
 193                              Lisp_Object prompt, Lisp_Object backup_n,
 194                              bool expflag,
 195                              Lisp_Object histvar, Lisp_Object histpos,
 196                              Lisp_Object defalt,
 197                              bool allow_props, bool inherit_input_method)
 198 {
 199   ptrdiff_t size, len;
 200   char *line;
 201   Lisp_Object val;
 202   int c;
 203   unsigned char hide_char = 0;
 204   struct emacs_tty etty;
 205   bool etty_valid;
 206
 207   /* Check, whether we need to suppress echoing.  */
 208   if (CHARACTERP (Vread_hide_char))
 209     hide_char = XFASTINT (Vread_hide_char);
 210
 211   /* Manipulate tty.  */
 212   if (hide_char)
 213     {
 214       etty_valid = emacs_get_tty (fileno (stdin), &etty) == 0;
 215       if (etty_valid)
 216         set_binary_mode (fileno (stdin), O_BINARY);
 217       suppress_echo_on_tty (fileno (stdin));
 218     }
 219
 220   fwrite (SDATA (prompt), 1, SBYTES (prompt), stdout);
 221   fflush (stdout);
 222
 223   val = Qnil;
 224   size = 100;
 225   len = 0;
 226   line = xmalloc (size);
 227
 228   while ((c = getchar ()) != '\n' && c != '\r')
 229     {
 230       if (c == EOF)
 231         {
 232           if (errno != EINTR)
 233             break;
 234         }
 235       else
 236         {
 237           if (hide_char)
 238             fprintf (stdout, "%c", hide_char);
 239           if (len == size)
 240             {
 241               if (STRING_BYTES_BOUND / 2 < size)
 242                 memory_full (SIZE_MAX);
 243               size *= 2;
 244               line = xrealloc (line, size);
 245             }
 246           line[len++] = c;
 247         }
 248     }
 249
 250   /* Reset tty.  */
 251   if (hide_char)
 252     {
 253       fprintf (stdout, "\n");
 254       if (etty_valid)
 255         {
 256           emacs_set_tty (fileno (stdin), &etty, 0);
 257           set_binary_mode (fileno (stdin), O_TEXT);
 258         }
 259     }
 260
 261   if (len || c == '\n' || c == '\r')
 262     {
 263       val = make_string (line, len);
 264       xfree (line);
 265     }
 266   else
 267     {
 268       xfree (line);
 269       error ("Error reading from stdin");
 270     }
 271
 272   /* If Lisp form desired instead of string, parse it.  */
 273   if (expflag)
 274     val = string_to_object (val, CONSP (defalt) ? XCAR (defalt) : defalt);
 275
 276   return val;
 277 }
 278 \f
 279 DEFUN ("minibufferp", Fminibufferp,
 280        Sminibufferp, 0, 1, 0,
 281        doc: /* Return t if BUFFER is a minibuffer.
 282 No argument or nil as argument means use current buffer as BUFFER.
 283 BUFFER can be a buffer or a buffer name.  */)
 284   (Lisp_Object buffer)
 285 {
 286   Lisp_Object tem;
 287
 288   if (NILP (buffer))
 289     buffer = Fcurrent_buffer ();
 290   else if (STRINGP (buffer))
 291     buffer = Fget_buffer (buffer);
 292   else
 293     CHECK_BUFFER (buffer);
 294
 295   tem = Fmemq (buffer, Vminibuffer_list);
 296   return ! NILP (tem) ? Qt : Qnil;
 297 }
 298
 299 DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
 300        Sminibuffer_prompt_end, 0, 0, 0,
 301        doc: /* Return the buffer position of the end of the minibuffer prompt.
 302 Return (point-min) if current buffer is not a minibuffer.  */)
 303   (void)
 304 {
 305   /* This function is written to be most efficient when there's a prompt.  */
 306   Lisp_Object beg, end, tem;
 307   beg = make_number (BEGV);
 308
 309   tem = Fmemq (Fcurrent_buffer (), Vminibuffer_list);
 310   if (NILP (tem))
 311     return beg;
 312
 313   end = Ffield_end (beg, Qnil, Qnil);
 314
 315   if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
 316     return beg;
 317   else
 318     return end;
 319 }
 320
 321 DEFUN ("minibuffer-contents", Fminibuffer_contents,
 322        Sminibuffer_contents, 0, 0, 0,
 323        doc: /* Return the user input in a minibuffer as a string.
 324 If the current buffer is not a minibuffer, return its entire contents.  */)
 325   (void)
 326 {
 327   ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
 328   return make_buffer_string (prompt_end, ZV, 1);
 329 }
 330
 331 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
 332        Sminibuffer_contents_no_properties, 0, 0, 0,
 333        doc: /* Return the user input in a minibuffer as a string, without text-properties.
 334 If the current buffer is not a minibuffer, return its entire contents.  */)
 335   (void)
 336 {
 337   ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
 338   return make_buffer_string (prompt_end, ZV, 0);
 339 }
 340
 341 DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
 342        Sminibuffer_completion_contents, 0, 0, 0,
 343        doc: /* Return the user input in a minibuffer before point as a string.
 344 That is what completion commands operate on.
 345 If the current buffer is not a minibuffer, return its entire contents.  */)
 346   (void)
 347 {
 348   ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
 349   if (PT < prompt_end)
 350     error ("Cannot do completion in the prompt");
 351   return make_buffer_string (prompt_end, PT, 1);
 352 }
 353
 354 \f
 355 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
 356    putting point minus BACKUP_N bytes from the end of INITIAL,
 357    prompting with PROMPT (a string), using history list HISTVAR
 358    with initial position HISTPOS.  INITIAL should be a string or a
 359    cons of a string and an integer.  BACKUP_N should be <= 0, or
 360    Qnil, which is equivalent to 0.  If INITIAL is a cons, BACKUP_N is
 361    ignored and replaced with an integer that puts point at one-indexed
 362    position N in INITIAL, where N is the CDR of INITIAL, or at the
 363    beginning of INITIAL if N <= 0.
 364
 365    Normally return the result as a string (the text that was read),
 366    but if EXPFLAG, read it and return the object read.
 367    If HISTVAR is given, save the value read on that history only if it doesn't
 368    match the front of that history list exactly.  The value is pushed onto
 369    the list as the string that was read.
 370
 371    DEFALT specifies the default value for the sake of history commands.
 372
 373    If ALLOW_PROPS, do not throw away text properties.
 374
 375    if INHERIT_INPUT_METHOD, the minibuffer inherits the
 376    current input method.  */
 377
 378 static Lisp_Object
 379 read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
 380               bool expflag,
 381               Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
 382               bool allow_props, bool inherit_input_method)
 383 {
 384   Lisp_Object val;
 385   ptrdiff_t count = SPECPDL_INDEX ();
 386   Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
 387   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 388   Lisp_Object enable_multibyte;
 389   EMACS_INT pos = 0;
 390   /* String to add to the history.  */
 391   Lisp_Object histstring;
 392   Lisp_Object histval;
 393
 394   Lisp_Object empty_minibuf;
 395   Lisp_Object dummy, frame;
 396
 397   specbind (Qminibuffer_default, defalt);
 398   specbind (Qinhibit_read_only, Qnil);
 399
 400   /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
 401      in previous recursive minibuffer, but was not set explicitly
 402      to t for this invocation, so set it to nil in this minibuffer.
 403      Save the old value now, before we change it.  */
 404   specbind (intern ("minibuffer-completing-file-name"),
 405             Vminibuffer_completing_file_name);
 406   if (EQ (Vminibuffer_completing_file_name, Qlambda))
 407     Vminibuffer_completing_file_name = Qnil;
 408
 409 #ifdef HAVE_WINDOW_SYSTEM
 410   if (display_hourglass_p)
 411     cancel_hourglass ();
 412 #endif
 413
 414   if (!NILP (initial))
 415     {
 416       if (CONSP (initial))
 417         {
 418           Lisp_Object backup_n = XCDR (initial);
 419           initial = XCAR (initial);
 420           CHECK_STRING (initial);
 421           if (!NILP (backup_n))
 422             {
 423               CHECK_NUMBER (backup_n);
 424               /* Convert to distance from end of input.  */
 425               if (XINT (backup_n) < 1)
 426                 /* A number too small means the beginning of the string.  */
 427                 pos =  - SCHARS (initial);
 428               else
 429                 pos = XINT (backup_n) - 1 - SCHARS (initial);
 430             }
 431         }
 432       else
 433         CHECK_STRING (initial);
 434     }
 435   val = Qnil;
 436   ambient_dir = BVAR (current_buffer, directory);
 437   input_method = Qnil;
 438   enable_multibyte = Qnil;
 439
 440   /* Don't need to protect PROMPT, HISTVAR, and HISTPOS because we
 441      store them away before we can GC.  Don't need to protect
 442      BACKUP_N because we use the value only if it is an integer.  */
 443   GCPRO5 (map, initial, val, ambient_dir, input_method);
 444
 445   if (!STRINGP (prompt))
 446     prompt = empty_unibyte_string;
 447
 448   if (!enable_recursive_minibuffers
 449       && minibuf_level > 0)
 450     {
 451       if (EQ (selected_window, minibuf_window))
 452         error ("Command attempted to use minibuffer while in minibuffer");
 453       else
 454         /* If we're in another window, cancel the minibuffer that's active.  */
 455         Fthrow (Qexit,
 456                 build_string ("Command attempted to use minibuffer while in minibuffer"));
 457     }
 458
 459   if ((noninteractive
 460        /* In case we are running as a daemon, only do this before
 461           detaching from the terminal.  */
 462        || (IS_DAEMON && DAEMON_RUNNING))
 463       && NILP (Vexecuting_kbd_macro))
 464     {
 465       val = read_minibuf_noninteractive (map, initial, prompt,
 466                                          make_number (pos),
 467                                          expflag, histvar, histpos, defalt,
 468                                          allow_props, inherit_input_method);
 469       UNGCPRO;
 470       return unbind_to (count, val);
 471     }
 472
 473   /* Choose the minibuffer window and frame, and take action on them.  */
 474
 475   /* Prepare for restoring the current buffer since choose_minibuf_frame
 476      calling Fset_frame_selected_window may change it (Bug#12766).  */
 477   record_unwind_protect (restore_buffer, Fcurrent_buffer ());
 478
 479   choose_minibuf_frame ();
 480
 481   record_unwind_protect_void (choose_minibuf_frame);
 482
 483   record_unwind_protect (restore_window_configuration,
 484                          Fcurrent_window_configuration (Qnil));
 485
 486   /* If the minibuffer window is on a different frame, save that
 487      frame's configuration too.  */
 488   mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
 489   if (!EQ (mini_frame, selected_frame))
 490     record_unwind_protect (restore_window_configuration,
 491                            Fcurrent_window_configuration (mini_frame));
 492
 493   /* If the minibuffer is on an iconified or invisible frame,
 494      make it visible now.  */
 495   Fmake_frame_visible (mini_frame);
 496
 497   if (minibuffer_auto_raise)
 498     Fraise_frame (mini_frame);
 499
 500   temporarily_switch_to_single_kboard (XFRAME (mini_frame));
 501
 502   /* We have to do this after saving the window configuration
 503      since that is what restores the current buffer.  */
 504
 505   /* Arrange to restore a number of minibuffer-related variables.
 506      We could bind each variable separately, but that would use lots of
 507      specpdl slots.  */
 508   minibuf_save_list
 509     = Fcons (Voverriding_local_map,
 510              Fcons (minibuf_window,
 511                     minibuf_save_list));
 512   minibuf_save_list
 513     = Fcons (minibuf_prompt,
 514              Fcons (make_number (minibuf_prompt_width),
 515                     Fcons (Vhelp_form,
 516                            Fcons (Vcurrent_prefix_arg,
 517                                   Fcons (Vminibuffer_history_position,
 518                                          Fcons (Vminibuffer_history_variable,
 519                                                 minibuf_save_list))))));
 520
 521   record_unwind_protect_void (read_minibuf_unwind);
 522   minibuf_level++;
 523   /* We are exiting the minibuffer one way or the other, so run the hook.
 524      It should be run before unwinding the minibuf settings.  Do it
 525      separately from read_minibuf_unwind because we need to make sure that
 526      read_minibuf_unwind is fully executed even if exit-minibuffer-hook
 527      signals an error.  --Stef  */
 528   record_unwind_protect_void (run_exit_minibuf_hook);
 529
 530   /* Now that we can restore all those variables, start changing them.  */
 531
 532   minibuf_prompt_width = 0;
 533   minibuf_prompt = Fcopy_sequence (prompt);
 534   Vminibuffer_history_position = histpos;
 535   Vminibuffer_history_variable = histvar;
 536   Vhelp_form = Vminibuffer_help_form;
 537   /* If this minibuffer is reading a file name, that doesn't mean
 538      recursive ones are.  But we cannot set it to nil, because
 539      completion code still need to know the minibuffer is completing a
 540      file name.  So use `lambda' as intermediate value meaning
 541      "t" in this minibuffer, but "nil" in next minibuffer.  */
 542   if (!NILP (Vminibuffer_completing_file_name))
 543     Vminibuffer_completing_file_name = Qlambda;
 544
 545   /* If variable is unbound, make it nil.  */
 546   histval = find_symbol_value (Vminibuffer_history_variable);
 547   if (EQ (histval, Qunbound))
 548     {
 549       Fset (Vminibuffer_history_variable, Qnil);
 550       histval = Qnil;
 551     }
 552
 553   if (inherit_input_method)
 554     {
 555       /* `current-input-method' is buffer local.  So, remember it in
 556          INPUT_METHOD before changing the current buffer.  */
 557       input_method = Fsymbol_value (Qcurrent_input_method);
 558       enable_multibyte = BVAR (current_buffer, enable_multibyte_characters);
 559     }
 560
 561   /* Switch to the minibuffer.  */
 562
 563   minibuffer = get_minibuffer (minibuf_level);
 564   Fset_buffer (minibuffer);
 565
 566   /* Defeat (setq-default truncate-lines t), since truncated lines do
 567      not work correctly in minibuffers.  (Bug#5715, etc)  */
 568   bset_truncate_lines (current_buffer, Qnil);
 569
 570   /* If appropriate, copy enable-multibyte-characters into the minibuffer.  */
 571   if (inherit_input_method)
 572     bset_enable_multibyte_characters (current_buffer, enable_multibyte);
 573
 574   /* The current buffer's default directory is usually the right thing
 575      for our minibuffer here.  However, if you're typing a command at
 576      a minibuffer-only frame when minibuf_level is zero, then buf IS
 577      the current_buffer, so reset_buffer leaves buf's default
 578      directory unchanged.  This is a bummer when you've just started
 579      up Emacs and buf's default directory is Qnil.  Here's a hack; can
 580      you think of something better to do?  Find another buffer with a
 581      better directory, and use that one instead.  */
 582   if (STRINGP (ambient_dir))
 583     bset_directory (current_buffer, ambient_dir);
 584   else
 585     {
 586       Lisp_Object tail, buf;
 587
 588       FOR_EACH_LIVE_BUFFER (tail, buf)
 589         if (STRINGP (BVAR (XBUFFER (buf), directory)))
 590           {
 591             bset_directory (current_buffer,
 592                             BVAR (XBUFFER (buf), directory));
 593             break;
 594           }
 595     }
 596
 597   if (!EQ (mini_frame, selected_frame))
 598     Fredirect_frame_focus (selected_frame, mini_frame);
 599
 600   Vminibuf_scroll_window = selected_window;
 601   if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
 602     minibuf_selected_window = selected_window;
 603
 604   /* Empty out the minibuffers of all frames other than the one
 605      where we are going to display one now.
 606      Set them to point to ` *Minibuf-0*', which is always empty.  */
 607   empty_minibuf = get_minibuffer (0);
 608
 609   FOR_EACH_FRAME (dummy, frame)
 610     {
 611       Lisp_Object root_window = Fframe_root_window (frame);
 612       Lisp_Object mini_window = XWINDOW (root_window)->next;
 613
 614       if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
 615           && !NILP (Fwindow_minibuffer_p (mini_window)))
 616         /* Use set_window_buffer instead of Fset_window_buffer (see
 617            discussion of bug#11984, bug#12025, bug#12026).  */
 618         set_window_buffer (mini_window, empty_minibuf, 0, 0);
 619     }
 620
 621   /* Display this minibuffer in the proper window.  */
 622   /* Use set_window_buffer instead of Fset_window_buffer (see
 623      discussion of bug#11984, bug#12025, bug#12026).  */
 624   set_window_buffer (minibuf_window, Fcurrent_buffer (), 0, 0);
 625   Fselect_window (minibuf_window, Qnil);
 626   XWINDOW (minibuf_window)->hscroll = 0;
 627   XWINDOW (minibuf_window)->suspend_auto_hscroll = 0;
 628
 629   Fmake_local_variable (Qprint_escape_newlines);
 630   print_escape_newlines = 1;
 631
 632   /* Erase the buffer.  */
 633   {
 634     ptrdiff_t count1 = SPECPDL_INDEX ();
 635     specbind (Qinhibit_read_only, Qt);
 636     specbind (Qinhibit_modification_hooks, Qt);
 637     Ferase_buffer ();
 638
 639     if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
 640         && ! STRING_MULTIBYTE (minibuf_prompt))
 641       minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
 642
 643     /* Insert the prompt, record where it ends.  */
 644     Finsert (1, &minibuf_prompt);
 645     if (PT > BEG)
 646       {
 647         Fput_text_property (make_number (BEG), make_number (PT),
 648                             Qfront_sticky, Qt, Qnil);
 649         Fput_text_property (make_number (BEG), make_number (PT),
 650                             Qrear_nonsticky, Qt, Qnil);
 651         Fput_text_property (make_number (BEG), make_number (PT),
 652                             Qfield, Qt, Qnil);
 653         Fadd_text_properties (make_number (BEG), make_number (PT),
 654                               Vminibuffer_prompt_properties, Qnil);
 655       }
 656     unbind_to (count1, Qnil);
 657   }
 658
 659   minibuf_prompt_width = current_column ();
 660
 661   /* Put in the initial input.  */
 662   if (!NILP (initial))
 663     {
 664       Finsert (1, &initial);
 665       Fforward_char (make_number (pos));
 666     }
 667
 668   clear_message (1, 1);
 669   bset_keymap (current_buffer, map);
 670
 671   /* Turn on an input method stored in INPUT_METHOD if any.  */
 672   if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method)))
 673     call1 (Qactivate_input_method, input_method);
 674
 675   run_hook (Qminibuffer_setup_hook);
 676
 677   /* Don't allow the user to undo past this point.  */
 678   bset_undo_list (current_buffer, Qnil);
 679
 680   recursive_edit_1 ();
 681
 682   /* If cursor is on the minibuffer line,
 683      show the user we have exited by putting it in column 0.  */
 684   if (XWINDOW (minibuf_window)->cursor.vpos >= 0
 685       && !noninteractive)
 686     {
 687       XWINDOW (minibuf_window)->cursor.hpos = 0;
 688       XWINDOW (minibuf_window)->cursor.x = 0;
 689       XWINDOW (minibuf_window)->must_be_updated_p = true;
 690       update_frame (XFRAME (selected_frame), true, true);
 691       flush_frame (XFRAME (XWINDOW (minibuf_window)->frame));
 692     }
 693
 694   /* Make minibuffer contents into a string.  */
 695   Fset_buffer (minibuffer);
 696   if (allow_props)
 697     val = Fminibuffer_contents ();
 698   else
 699     val = Fminibuffer_contents_no_properties ();
 700
 701   /* VAL is the string of minibuffer text.  */
 702
 703   last_minibuf_string = val;
 704
 705   /* Choose the string to add to the history.  */
 706   if (SCHARS (val) != 0)
 707     histstring = val;
 708   else if (STRINGP (defalt))
 709     histstring = defalt;
 710   else if (CONSP (defalt) && STRINGP (XCAR (defalt)))
 711     histstring = XCAR (defalt);
 712   else
 713     histstring = Qnil;
 714
 715   /* Add the value to the appropriate history list, if any.  */
 716   if (!NILP (Vhistory_add_new_input)
 717       && SYMBOLP (Vminibuffer_history_variable)
 718       && !NILP (histstring))
 719     {
 720       /* If the caller wanted to save the value read on a history list,
 721          then do so if the value is not already the front of the list.  */
 722
 723       /* The value of the history variable must be a cons or nil.  Other
 724          values are unacceptable.  We silently ignore these values.  */
 725
 726       if (NILP (histval)
 727           || (CONSP (histval)
 728               /* Don't duplicate the most recent entry in the history.  */
 729               && (NILP (Fequal (histstring, Fcar (histval))))))
 730         {
 731           Lisp_Object length;
 732
 733           if (history_delete_duplicates) Fdelete (histstring, histval);
 734           histval = Fcons (histstring, histval);
 735           Fset (Vminibuffer_history_variable, histval);
 736
 737           /* Truncate if requested.  */
 738           length = Fget (Vminibuffer_history_variable, Qhistory_length);
 739           if (NILP (length)) length = Vhistory_length;
 740           if (INTEGERP (length))
 741             {
 742               if (XINT (length) <= 0)
 743                 Fset (Vminibuffer_history_variable, Qnil);
 744               else
 745                 {
 746                   Lisp_Object temp;
 747
 748                   temp = Fnthcdr (Fsub1 (length), histval);
 749                   if (CONSP (temp)) Fsetcdr (temp, Qnil);
 750                 }
 751             }
 752         }
 753     }
 754
 755   /* If Lisp form desired instead of string, parse it.  */
 756   if (expflag)
 757     val = string_to_object (val, defalt);
 758
 759   /* The appropriate frame will get selected
 760      in set-window-configuration.  */
 761   UNGCPRO;
 762   return unbind_to (count, val);
 763 }
 764
 765 /* Return a buffer to be used as the minibuffer at depth `depth'.
 766  depth = 0 is the lowest allowed argument, and that is the value
 767  used for nonrecursive minibuffer invocations.  */
 768
 769 Lisp_Object
 770 get_minibuffer (EMACS_INT depth)
 771 {
 772   Lisp_Object tail, num, buf;
 773   char name[sizeof " *Minibuf-*" + INT_STRLEN_BOUND (EMACS_INT)];
 774
 775   XSETFASTINT (num, depth);
 776   tail = Fnthcdr (num, Vminibuffer_list);
 777   if (NILP (tail))
 778     {
 779       tail = list1 (Qnil);
 780       Vminibuffer_list = nconc2 (Vminibuffer_list, tail);
 781     }
 782   buf = Fcar (tail);
 783   if (NILP (buf) || !BUFFER_LIVE_P (XBUFFER (buf)))
 784     {
 785       buf = Fget_buffer_create
 786         (make_formatted_string (name, " *Minibuf-%"pI"d*", depth));
 787
 788       /* Although the buffer's name starts with a space, undo should be
 789          enabled in it.  */
 790       Fbuffer_enable_undo (buf);
 791
 792       XSETCAR (tail, buf);
 793     }
 794   else
 795     {
 796       ptrdiff_t count = SPECPDL_INDEX ();
 797       /* We have to empty both overlay lists.  Otherwise we end
 798          up with overlays that think they belong to this buffer
 799          while the buffer doesn't know about them any more.  */
 800       delete_all_overlays (XBUFFER (buf));
 801       reset_buffer (XBUFFER (buf));
 802       record_unwind_current_buffer ();
 803       Fset_buffer (buf);
 804       if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode"))))
 805         call0 (intern ("minibuffer-inactive-mode"));
 806       else
 807         Fkill_all_local_variables ();
 808       unbind_to (count, Qnil);
 809     }
 810
 811   return buf;
 812 }
 813
 814 static void
 815 run_exit_minibuf_hook (void)
 816 {
 817   safe_run_hooks (Qminibuffer_exit_hook);
 818 }
 819
 820 /* This function is called on exiting minibuffer, whether normally or
 821    not, and it restores the current window, buffer, etc.  */
 822
 823 static void
 824 read_minibuf_unwind (void)
 825 {
 826   Lisp_Object old_deactivate_mark;
 827   Lisp_Object window;
 828
 829   /* If this was a recursive minibuffer,
 830      tie the minibuffer window back to the outer level minibuffer buffer.  */
 831   minibuf_level--;
 832
 833   window = minibuf_window;
 834   /* To keep things predictable, in case it matters, let's be in the
 835      minibuffer when we reset the relevant variables.  */
 836   Fset_buffer (XWINDOW (window)->contents);
 837
 838   /* Restore prompt, etc, from outer minibuffer level.  */
 839   minibuf_prompt = Fcar (minibuf_save_list);
 840   minibuf_save_list = Fcdr (minibuf_save_list);
 841   minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
 842   minibuf_save_list = Fcdr (minibuf_save_list);
 843   Vhelp_form = Fcar (minibuf_save_list);
 844   minibuf_save_list = Fcdr (minibuf_save_list);
 845   Vcurrent_prefix_arg = Fcar (minibuf_save_list);
 846   minibuf_save_list = Fcdr (minibuf_save_list);
 847   Vminibuffer_history_position = Fcar (minibuf_save_list);
 848   minibuf_save_list = Fcdr (minibuf_save_list);
 849   Vminibuffer_history_variable = Fcar (minibuf_save_list);
 850   minibuf_save_list = Fcdr (minibuf_save_list);
 851   Voverriding_local_map = Fcar (minibuf_save_list);
 852   minibuf_save_list = Fcdr (minibuf_save_list);
 853 #if 0
 854   temp = Fcar (minibuf_save_list);
 855   if (FRAME_LIVE_P (XFRAME (WINDOW_FRAME (XWINDOW (temp)))))
 856     minibuf_window = temp;
 857 #endif
 858   minibuf_save_list = Fcdr (minibuf_save_list);
 859
 860   /* Erase the minibuffer we were using at this level.  */
 861   {
 862     ptrdiff_t count = SPECPDL_INDEX ();
 863     /* Prevent error in erase-buffer.  */
 864     specbind (Qinhibit_read_only, Qt);
 865     specbind (Qinhibit_modification_hooks, Qt);
 866     old_deactivate_mark = Vdeactivate_mark;
 867     Ferase_buffer ();
 868     Vdeactivate_mark = old_deactivate_mark;
 869     unbind_to (count, Qnil);
 870   }
 871
 872   /* When we get to the outmost level, make sure we resize the
 873      mini-window back to its normal size.  */
 874   if (minibuf_level == 0)
 875     resize_mini_window (XWINDOW (window), 0);
 876
 877   /* In case the previous minibuffer displayed in this miniwindow is
 878      dead, we may keep displaying this buffer (tho it's inactive), so reset it,
 879      to make sure we don't leave around bindings and stuff which only
 880      made sense during the read_minibuf invocation.  */
 881   call0 (intern ("minibuffer-inactive-mode"));
 882 }
 883 \f
 884
 885 DEFUN ("read-from-minibuffer", Fread_from_minibuffer,
 886        Sread_from_minibuffer, 1, 7, 0,
 887        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 888 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
 889   DEFAULT-VALUE.  It normally should be nil in new code, except when
 890   HIST is a cons.  It is discussed in more detail below.
 891
 892 Third arg KEYMAP is a keymap to use whilst reading;
 893   if omitted or nil, the default is `minibuffer-local-map'.
 894
 895 If fourth arg READ is non-nil, interpret the result as a Lisp object
 896   and return that object:
 897   in other words, do `(car (read-from-string INPUT-STRING))'
 898
 899 Fifth arg HIST, if non-nil, specifies a history list and optionally
 900   the initial position in the list.  It can be a symbol, which is the
 901   history list variable to use, or a cons cell (HISTVAR . HISTPOS).
 902   In that case, HISTVAR is the history list variable to use, and
 903   HISTPOS is the initial position for use by the minibuffer history
 904   commands.  For consistency, you should also specify that element of
 905   the history as the value of INITIAL-CONTENTS.  Positions are counted
 906   starting from 1 at the beginning of the list.
 907
 908 Sixth arg DEFAULT-VALUE, if non-nil, should be a string, which is used
 909   as the default to `read' if READ is non-nil and the user enters
 910   empty input.  But if READ is nil, this function does _not_ return
 911   DEFAULT-VALUE for empty input!  Instead, it returns the empty string.
 912
 913   Whatever the value of READ, DEFAULT-VALUE is made available via the
 914   minibuffer history commands.  DEFAULT-VALUE can also be a list of
 915   strings, in which case all the strings are available in the history,
 916   and the first string is the default to `read' if READ is non-nil.
 917
 918 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
 919  the current input method and the setting of `enable-multibyte-characters'.
 920
 921 If the variable `minibuffer-allow-text-properties' is non-nil,
 922  then the string which is returned includes whatever text properties
 923  were present in the minibuffer.  Otherwise the value has no text properties.
 924
 925 The remainder of this documentation string describes the
 926 INITIAL-CONTENTS argument in more detail.  It is only relevant when
 927 studying existing code, or when HIST is a cons.  If non-nil,
 928 INITIAL-CONTENTS is a string to be inserted into the minibuffer before
 929 reading input.  Normally, point is put at the end of that string.
 930 However, if INITIAL-CONTENTS is \(STRING . POSITION), the initial
 931 input is STRING, but point is placed at _one-indexed_ position
 932 POSITION in the minibuffer.  Any integer value less than or equal to
 933 one puts point at the beginning of the string.  *Note* that this
 934 behavior differs from the way such arguments are used in `completing-read'
 935 and some related functions, which use zero-indexing for POSITION.  */)
 936   (Lisp_Object prompt, Lisp_Object initial_contents, Lisp_Object keymap, Lisp_Object read, Lisp_Object hist, Lisp_Object default_value, Lisp_Object inherit_input_method)
 937 {
 938   Lisp_Object histvar, histpos, val;
 939   struct gcpro gcpro1;
 940
 941   CHECK_STRING (prompt);
 942   if (NILP (keymap))
 943     keymap = Vminibuffer_local_map;
 944   else
 945     keymap = get_keymap (keymap, 1, 0);
 946
 947   if (SYMBOLP (hist))
 948     {
 949       histvar = hist;
 950       histpos = Qnil;
 951     }
 952   else
 953     {
 954       histvar = Fcar_safe (hist);
 955       histpos = Fcdr_safe (hist);
 956     }
 957   if (NILP (histvar))
 958     histvar = Qminibuffer_history;
 959   if (NILP (histpos))
 960     XSETFASTINT (histpos, 0);
 961
 962   GCPRO1 (default_value);
 963   val = read_minibuf (keymap, initial_contents, prompt,
 964                       !NILP (read),
 965                       histvar, histpos, default_value,
 966                       minibuffer_allow_text_properties,
 967                       !NILP (inherit_input_method));
 968   UNGCPRO;
 969   return val;
 970 }
 971
 972 /* Functions that use the minibuffer to read various things.  */
 973
 974 DEFUN ("read-string", Fread_string, Sread_string, 1, 5, 0,
 975        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 976 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
 977   This argument has been superseded by DEFAULT-VALUE and should normally be nil
 978   in new code.  It behaves as INITIAL-CONTENTS in `read-from-minibuffer' (which
 979   see).
 980 The third arg HISTORY, if non-nil, specifies a history list
 981   and optionally the initial position in the list.
 982 See `read-from-minibuffer' for details of HISTORY argument.
 983 Fourth arg DEFAULT-VALUE is the default value or the list of default values.
 984  If non-nil, it is used for history commands, and as the value (or the first
 985  element of the list of default values) to return if the user enters the
 986  empty string.
 987 Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
 988  the current input method and the setting of `enable-multibyte-characters'.  */)
 989   (Lisp_Object prompt, Lisp_Object initial_input, Lisp_Object history, Lisp_Object default_value, Lisp_Object inherit_input_method)
 990 {
 991   Lisp_Object val;
 992   ptrdiff_t count = SPECPDL_INDEX ();
 993
 994   /* Just in case we're in a recursive minibuffer, make it clear that the
 995      previous minibuffer's completion table does not apply to the new
 996      minibuffer.
 997      FIXME: `minibuffer-completion-table' should be buffer-local instead.  */
 998   specbind (Qminibuffer_completion_table, Qnil);
 999
1000   val = Fread_from_minibuffer (prompt, initial_input, Qnil,
1001                                Qnil, history, default_value,
1002                                inherit_input_method);
1003   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
1004     val = CONSP (default_value) ? XCAR (default_value) : default_value;
1005   return unbind_to (count, val);
1006 }
1007
1008 DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0,
1009        doc: /* Read a string from the terminal, not allowing blanks.
1010 Prompt with PROMPT.  Whitespace terminates the input.  If INITIAL is
1011 non-nil, it should be a string, which is used as initial input, with
1012 point positioned at the end, so that SPACE will accept the input.
1013 \(Actually, INITIAL can also be a cons of a string and an integer.
1014 Such values are treated as in `read-from-minibuffer', but are normally
1015 not useful in this function.)
1016 Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
1017 the current input method and the setting of`enable-multibyte-characters'.  */)
1018   (Lisp_Object prompt, Lisp_Object initial, Lisp_Object inherit_input_method)
1019 {
1020   CHECK_STRING (prompt);
1021   return read_minibuf (Vminibuffer_local_ns_map, initial, prompt,
1022                        0, Qminibuffer_history, make_number (0), Qnil, 0,
1023                        !NILP (inherit_input_method));
1024 }
1025
1026 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
1027        doc: /* Read the name of a command and return as a symbol.
1028 Prompt with PROMPT.  By default, return DEFAULT-VALUE or its first element
1029 if it is a list.  */)
1030   (Lisp_Object prompt, Lisp_Object default_value)
1031 {
1032   Lisp_Object name, default_string;
1033
1034   if (NILP (default_value))
1035     default_string = Qnil;
1036   else if (SYMBOLP (default_value))
1037     default_string = SYMBOL_NAME (default_value);
1038   else
1039     default_string = default_value;
1040
1041   name = Fcompleting_read (prompt, Vobarray, Qcommandp, Qt,
1042                            Qnil, Qnil, default_string, Qnil);
1043   if (NILP (name))
1044     return name;
1045   return Fintern (name, Qnil);
1046 }
1047
1048 #ifdef NOTDEF
1049 DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
1050        doc: /* One arg PROMPT, a string.  Read the name of a function and return as a symbol.
1051 Prompt with PROMPT.  */)
1052   (Lisp_Object prompt)
1053 {
1054   return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
1055                   Qnil);
1056 }
1057 #endif /* NOTDEF */
1058
1059 DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
1060        doc: /* Read the name of a user option and return it as a symbol.
1061 Prompt with PROMPT.  By default, return DEFAULT-VALUE or its first element
1062 if it is a list.
1063 A user option, or customizable variable, is one for which
1064 `custom-variable-p' returns non-nil.  */)
1065   (Lisp_Object prompt, Lisp_Object default_value)
1066 {
1067   Lisp_Object name, default_string;
1068
1069   if (NILP (default_value))
1070     default_string = Qnil;
1071   else if (SYMBOLP (default_value))
1072     default_string = SYMBOL_NAME (default_value);
1073   else
1074     default_string = default_value;
1075
1076   name = Fcompleting_read (prompt, Vobarray,
1077                            Qcustom_variable_p, Qt,
1078                            Qnil, Qnil, default_string, Qnil);
1079   if (NILP (name))
1080     return name;
1081   return Fintern (name, Qnil);
1082 }
1083
1084 DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 4, 0,
1085        doc: /* Read the name of a buffer and return as a string.
1086 Prompt with PROMPT.
1087 Optional second arg DEF is value to return if user enters an empty line.
1088  If DEF is a list of default values, return its first element.
1089 Optional third arg REQUIRE-MATCH determines whether non-existing
1090  buffer names are allowed.  It has the same meaning as the
1091  REQUIRE-MATCH argument of `completing-read'.
1092 The argument PROMPT should be a string ending with a colon and a space.
1093 If `read-buffer-completion-ignore-case' is non-nil, completion ignores
1094 case while reading the buffer name.
1095 If `read-buffer-function' is non-nil, this works by calling it as a
1096 function, instead of the usual behavior.
1097 Optional arg PREDICATE if non-nil is a function limiting the buffers that can
1098 be considered.  */)
1099   (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match,
1100    Lisp_Object predicate)
1101 {
1102   Lisp_Object result;
1103   char *s;
1104   ptrdiff_t len;
1105   ptrdiff_t count = SPECPDL_INDEX ();
1106
1107   if (BUFFERP (def))
1108     def = BVAR (XBUFFER (def), name);
1109
1110   specbind (Qcompletion_ignore_case,
1111             read_buffer_completion_ignore_case ? Qt : Qnil);
1112
1113   if (NILP (Vread_buffer_function))
1114     {
1115       if (!NILP (def))
1116         {
1117           /* A default value was provided: we must change PROMPT,
1118              editing the default value in before the colon.  To achieve
1119              this, we replace PROMPT with a substring that doesn't
1120              contain the terminal space and colon (if present).  They
1121              are then added back using Fformat.  */
1122
1123           if (STRINGP (prompt))
1124             {
1125               s = SSDATA (prompt);
1126               len = SBYTES (prompt);
1127               if (len >= 2 && s[len - 2] == ':' && s[len - 1] == ' ')
1128                 len = len - 2;
1129               else if (len >= 1 && (s[len - 1] == ':' || s[len - 1] == ' '))
1130                 len--;
1131
1132               prompt = make_specified_string (s, -1, len,
1133                                               STRING_MULTIBYTE (prompt));
1134             }
1135
1136           AUTO_STRING (format, "%s (default %s): ");
1137           prompt = CALLN (Fformat, format, prompt,
1138                           CONSP (def) ? XCAR (def) : def);
1139         }
1140
1141       result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
1142                                  predicate, require_match, Qnil,
1143                                  Qbuffer_name_history, def, Qnil);
1144     }
1145   else
1146     result = (NILP (predicate)
1147               /* Partial backward compatibility for older read_buffer_functions
1148                  which don't expect a `predicate' argument.  */
1149               ? call3 (Vread_buffer_function, prompt, def, require_match)
1150               : call4 (Vread_buffer_function, prompt, def, require_match,
1151                        predicate));
1152   return unbind_to (count, result);
1153 }
1154 \f
1155 static Lisp_Object
1156 minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
1157 {
1158   if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
1159     return string;
1160
1161   if (STRING_MULTIBYTE (string))
1162     return Fstring_make_unibyte (string);
1163   else
1164     return Fstring_make_multibyte (string);
1165 }
1166
1167 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
1168        doc: /* Return common substring of all completions of STRING in COLLECTION.
1169 Test each possible completion specified by COLLECTION
1170 to see if it begins with STRING.  The possible completions may be
1171 strings or symbols.  Symbols are converted to strings before testing,
1172 see `symbol-name'.
1173 All that match STRING are compared together; the longest initial sequence
1174 common to all these matches is the return value.
1175 If there is no match at all, the return value is nil.
1176 For a unique match which is exact, the return value is t.
1177
1178 If COLLECTION is an alist, the keys (cars of elements) are the
1179 possible completions.  If an element is not a cons cell, then the
1180 element itself is the possible completion.
1181 If COLLECTION is a hash-table, all the keys that are strings or symbols
1182 are the possible completions.
1183 If COLLECTION is an obarray, the names of all symbols in the obarray
1184 are the possible completions.
1185
1186 COLLECTION can also be a function to do the completion itself.
1187 It receives three arguments: the values STRING, PREDICATE and nil.
1188 Whatever it returns becomes the value of `try-completion'.
1189
1190 If optional third argument PREDICATE is non-nil,
1191 it is used to test each possible match.
1192 The match is a candidate only if PREDICATE returns non-nil.
1193 The argument given to PREDICATE is the alist element
1194 or the symbol from the obarray.  If COLLECTION is a hash-table,
1195 predicate is called with two arguments: the key and the value.
1196 Additionally to this predicate, `completion-regexp-list'
1197 is used to further constrain the set of candidates.  */)
1198   (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1199 {
1200   Lisp_Object bestmatch, tail, elt, eltstring;
1201   /* Size in bytes of BESTMATCH.  */
1202   ptrdiff_t bestmatchsize = 0;
1203   /* These are in bytes, too.  */
1204   ptrdiff_t compare, matchsize;
1205   enum { function_table, list_table, obarray_table, hash_table}
1206     type = (HASH_TABLE_P (collection) ? hash_table
1207             : VECTORP (collection) ? obarray_table
1208             : ((NILP (collection)
1209                 || (CONSP (collection) && !FUNCTIONP (collection)))
1210                ? list_table : function_table));
1211   ptrdiff_t idx = 0, obsize = 0;
1212   int matchcount = 0;
1213   ptrdiff_t bindcount = -1;
1214   Lisp_Object bucket, zero, end, tem;
1215   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1216
1217   CHECK_STRING (string);
1218   if (type == function_table)
1219     return call3 (collection, string, predicate, Qnil);
1220
1221   bestmatch = bucket = Qnil;
1222   zero = make_number (0);
1223
1224   /* If COLLECTION is not a list, set TAIL just for gc pro.  */
1225   tail = collection;
1226   if (type == obarray_table)
1227     {
1228       collection = check_obarray (collection);
1229       obsize = ASIZE (collection);
1230       bucket = AREF (collection, idx);
1231     }
1232
1233   while (1)
1234     {
1235       /* Get the next element of the alist, obarray, or hash-table.  */
1236       /* Exit the loop if the elements are all used up.  */
1237       /* elt gets the alist element or symbol.
1238          eltstring gets the name to check as a completion.  */
1239
1240       if (type == list_table)
1241         {
1242           if (!CONSP (tail))
1243             break;
1244           elt = XCAR (tail);
1245           eltstring = CONSP (elt) ? XCAR (elt) : elt;
1246           tail = XCDR (tail);
1247         }
1248       else if (type == obarray_table)
1249         {
1250           if (!EQ (bucket, zero))
1251             {
1252               if (!SYMBOLP (bucket))
1253                 error ("Bad data in guts of obarray");
1254               elt = bucket;
1255               eltstring = elt;
1256               if (XSYMBOL (bucket)->next)
1257                 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1258               else
1259                 XSETFASTINT (bucket, 0);
1260             }
1261           else if (++idx >= obsize)
1262             break;
1263           else
1264             {
1265               bucket = AREF (collection, idx);
1266               continue;
1267             }
1268         }
1269       else /* if (type == hash_table) */
1270         {
1271           while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1272                  && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1273             idx++;
1274           if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1275             break;
1276           else
1277             elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1278         }
1279
1280       /* Is this element a possible completion?  */
1281
1282       if (SYMBOLP (eltstring))
1283         eltstring = Fsymbol_name (eltstring);
1284
1285       if (STRINGP (eltstring)
1286           && SCHARS (string) <= SCHARS (eltstring)
1287           && (tem = Fcompare_strings (eltstring, zero,
1288                                       make_number (SCHARS (string)),
1289                                       string, zero, Qnil,
1290                                       completion_ignore_case ? Qt : Qnil),
1291               EQ (Qt, tem)))
1292         {
1293           /* Yes.  */
1294           Lisp_Object regexps;
1295
1296           /* Ignore this element if it fails to match all the regexps.  */
1297           {
1298             for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1299                  regexps = XCDR (regexps))
1300               {
1301                 if (bindcount < 0) {
1302                   bindcount = SPECPDL_INDEX ();
1303                   specbind (Qcase_fold_search,
1304                             completion_ignore_case ? Qt : Qnil);
1305                 }
1306                 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1307                 if (NILP (tem))
1308                   break;
1309               }
1310             if (CONSP (regexps))
1311               continue;
1312           }
1313
1314           /* Ignore this element if there is a predicate
1315              and the predicate doesn't like it.  */
1316
1317           if (!NILP (predicate))
1318             {
1319               if (EQ (predicate, Qcommandp))
1320                 tem = Fcommandp (elt, Qnil);
1321               else
1322                 {
1323                   if (bindcount >= 0)
1324                     {
1325                       unbind_to (bindcount, Qnil);
1326                       bindcount = -1;
1327                     }
1328                   GCPRO4 (tail, string, eltstring, bestmatch);
1329                   tem = (type == hash_table
1330                          ? call2 (predicate, elt,
1331                                   HASH_VALUE (XHASH_TABLE (collection),
1332                                               idx - 1))
1333                          : call1 (predicate, elt));
1334                   UNGCPRO;
1335                 }
1336               if (NILP (tem)) continue;
1337             }
1338
1339           /* Update computation of how much all possible completions match */
1340
1341           if (NILP (bestmatch))
1342             {
1343               matchcount = 1;
1344               bestmatch = eltstring;
1345               bestmatchsize = SCHARS (eltstring);
1346             }
1347           else
1348             {
1349               compare = min (bestmatchsize, SCHARS (eltstring));
1350               tem = Fcompare_strings (bestmatch, zero,
1351                                       make_number (compare),
1352                                       eltstring, zero,
1353                                       make_number (compare),
1354                                       completion_ignore_case ? Qt : Qnil);
1355               matchsize = EQ (tem, Qt) ? compare : eabs (XINT (tem)) - 1;
1356
1357               if (completion_ignore_case)
1358                 {
1359                   /* If this is an exact match except for case,
1360                      use it as the best match rather than one that is not an
1361                      exact match.  This way, we get the case pattern
1362                      of the actual match.  */
1363                   if ((matchsize == SCHARS (eltstring)
1364                        && matchsize < SCHARS (bestmatch))
1365                       ||
1366                       /* If there is more than one exact match ignoring case,
1367                          and one of them is exact including case,
1368                          prefer that one.  */
1369                       /* If there is no exact match ignoring case,
1370                          prefer a match that does not change the case
1371                          of the input.  */
1372                       ((matchsize == SCHARS (eltstring))
1373                        ==
1374                        (matchsize == SCHARS (bestmatch))
1375                        && (tem = Fcompare_strings (eltstring, zero,
1376                                                    make_number (SCHARS (string)),
1377                                                    string, zero,
1378                                                    Qnil,
1379                                                    Qnil),
1380                            EQ (Qt, tem))
1381                        && (tem = Fcompare_strings (bestmatch, zero,
1382                                                    make_number (SCHARS (string)),
1383                                                    string, zero,
1384                                                    Qnil,
1385                                                    Qnil),
1386                            ! EQ (Qt, tem))))
1387                     bestmatch = eltstring;
1388                 }
1389               if (bestmatchsize != SCHARS (eltstring)
1390                   || bestmatchsize != matchsize)
1391                 /* Don't count the same string multiple times.  */
1392                 matchcount += matchcount <= 1;
1393               bestmatchsize = matchsize;
1394               if (matchsize <= SCHARS (string)
1395                   /* If completion-ignore-case is non-nil, don't
1396                      short-circuit because we want to find the best
1397                      possible match *including* case differences.  */
1398                   && !completion_ignore_case
1399                   && matchcount > 1)
1400                 /* No need to look any further.  */
1401                 break;
1402             }
1403         }
1404     }
1405
1406   if (bindcount >= 0) {
1407     unbind_to (bindcount, Qnil);
1408     bindcount = -1;
1409   }
1410
1411   if (NILP (bestmatch))
1412     return Qnil;                /* No completions found.  */
1413   /* If we are ignoring case, and there is no exact match,
1414      and no additional text was supplied,
1415      don't change the case of what the user typed.  */
1416   if (completion_ignore_case && bestmatchsize == SCHARS (string)
1417       && SCHARS (bestmatch) > bestmatchsize)
1418     return minibuf_conform_representation (string, bestmatch);
1419
1420   /* Return t if the supplied string is an exact match (counting case);
1421      it does not require any change to be made.  */
1422   if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
1423     return Qt;
1424
1425   XSETFASTINT (zero, 0);                /* Else extract the part in which */
1426   XSETFASTINT (end, bestmatchsize);     /* all completions agree.  */
1427   return Fsubstring (bestmatch, zero, end);
1428 }
1429 \f
1430 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
1431        doc: /* Search for partial matches to STRING in COLLECTION.
1432 Test each of the possible completions specified by COLLECTION
1433 to see if it begins with STRING.  The possible completions may be
1434 strings or symbols.  Symbols are converted to strings before testing,
1435 see `symbol-name'.
1436 The value is a list of all the possible completions that match STRING.
1437
1438 If COLLECTION is an alist, the keys (cars of elements) are the
1439 possible completions.  If an element is not a cons cell, then the
1440 element itself is the possible completion.
1441 If COLLECTION is a hash-table, all the keys that are strings or symbols
1442 are the possible completions.
1443 If COLLECTION is an obarray, the names of all symbols in the obarray
1444 are the possible completions.
1445
1446 COLLECTION can also be a function to do the completion itself.
1447 It receives three arguments: the values STRING, PREDICATE and t.
1448 Whatever it returns becomes the value of `all-completions'.
1449
1450 If optional third argument PREDICATE is non-nil,
1451 it is used to test each possible match.
1452 The match is a candidate only if PREDICATE returns non-nil.
1453 The argument given to PREDICATE is the alist element
1454 or the symbol from the obarray.  If COLLECTION is a hash-table,
1455 predicate is called with two arguments: the key and the value.
1456 Additionally to this predicate, `completion-regexp-list'
1457 is used to further constrain the set of candidates.
1458
1459 An obsolete optional fourth argument HIDE-SPACES is still accepted for
1460 backward compatibility.  If non-nil, strings in COLLECTION that start
1461 with a space are ignored unless STRING itself starts with a space.  */)
1462   (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate, Lisp_Object hide_spaces)
1463 {
1464   Lisp_Object tail, elt, eltstring;
1465   Lisp_Object allmatches;
1466   int type = HASH_TABLE_P (collection) ? 3
1467     : VECTORP (collection) ? 2
1468     : NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection));
1469   ptrdiff_t idx = 0, obsize = 0;
1470   ptrdiff_t bindcount = -1;
1471   Lisp_Object bucket, tem, zero;
1472   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1473
1474   CHECK_STRING (string);
1475   if (type == 0)
1476     return call3 (collection, string, predicate, Qt);
1477   allmatches = bucket = Qnil;
1478   zero = make_number (0);
1479
1480   /* If COLLECTION is not a list, set TAIL just for gc pro.  */
1481   tail = collection;
1482   if (type == 2)
1483     {
1484       collection = check_obarray (collection);
1485       obsize = ASIZE (collection);
1486       bucket = AREF (collection, idx);
1487     }
1488
1489   while (1)
1490     {
1491       /* Get the next element of the alist, obarray, or hash-table.  */
1492       /* Exit the loop if the elements are all used up.  */
1493       /* elt gets the alist element or symbol.
1494          eltstring gets the name to check as a completion.  */
1495
1496       if (type == 1)
1497         {
1498           if (!CONSP (tail))
1499             break;
1500           elt = XCAR (tail);
1501           eltstring = CONSP (elt) ? XCAR (elt) : elt;
1502           tail = XCDR (tail);
1503         }
1504       else if (type == 2)
1505         {
1506           if (!EQ (bucket, zero))
1507             {
1508               if (!SYMBOLP (bucket))
1509                 error ("Bad data in guts of obarray");
1510               elt = bucket;
1511               eltstring = elt;
1512               if (XSYMBOL (bucket)->next)
1513                 XSETSYMBOL (bucket, XSYMBOL (bucket)->next);
1514               else
1515                 XSETFASTINT (bucket, 0);
1516             }
1517           else if (++idx >= obsize)
1518             break;
1519           else
1520             {
1521               bucket = AREF (collection, idx);
1522               continue;
1523             }
1524         }
1525       else /* if (type == 3) */
1526         {
1527           while (idx < HASH_TABLE_SIZE (XHASH_TABLE (collection))
1528                  && NILP (HASH_HASH (XHASH_TABLE (collection), idx)))
1529             idx++;
1530           if (idx >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))
1531             break;
1532           else
1533             elt = eltstring = HASH_KEY (XHASH_TABLE (collection), idx++);
1534         }
1535
1536       /* Is this element a possible completion?  */
1537
1538       if (SYMBOLP (eltstring))
1539         eltstring = Fsymbol_name (eltstring);
1540
1541       if (STRINGP (eltstring)
1542           && SCHARS (string) <= SCHARS (eltstring)
1543           /* If HIDE_SPACES, reject alternatives that start with space
1544              unless the input starts with space.  */
1545           && (NILP (hide_spaces)
1546               || (SBYTES (string) > 0
1547                   && SREF (string, 0) == ' ')
1548               || SREF (eltstring, 0) != ' ')
1549           && (tem = Fcompare_strings (eltstring, zero,
1550                                       make_number (SCHARS (string)),
1551                                       string, zero,
1552                                       make_number (SCHARS (string)),
1553                                       completion_ignore_case ? Qt : Qnil),
1554               EQ (Qt, tem)))
1555         {
1556           /* Yes.  */
1557           Lisp_Object regexps;
1558
1559           /* Ignore this element if it fails to match all the regexps.  */
1560           {
1561             for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1562                  regexps = XCDR (regexps))
1563               {
1564                 if (bindcount < 0) {
1565                   bindcount = SPECPDL_INDEX ();
1566                   specbind (Qcase_fold_search,
1567                             completion_ignore_case ? Qt : Qnil);
1568                 }
1569                 tem = Fstring_match (XCAR (regexps), eltstring, zero);
1570                 if (NILP (tem))
1571                   break;
1572               }
1573             if (CONSP (regexps))
1574               continue;
1575           }
1576
1577           /* Ignore this element if there is a predicate
1578              and the predicate doesn't like it.  */
1579
1580           if (!NILP (predicate))
1581             {
1582               if (EQ (predicate, Qcommandp))
1583                 tem = Fcommandp (elt, Qnil);
1584               else
1585                 {
1586                   if (bindcount >= 0) {
1587                     unbind_to (bindcount, Qnil);
1588                     bindcount = -1;
1589                   }
1590                   GCPRO4 (tail, eltstring, allmatches, string);
1591                   tem = type == 3
1592                     ? call2 (predicate, elt,
1593                              HASH_VALUE (XHASH_TABLE (collection), idx - 1))
1594                     : call1 (predicate, elt);
1595                   UNGCPRO;
1596                 }
1597               if (NILP (tem)) continue;
1598             }
1599           /* Ok => put it on the list.  */
1600           allmatches = Fcons (eltstring, allmatches);
1601         }
1602     }
1603
1604   if (bindcount >= 0) {
1605     unbind_to (bindcount, Qnil);
1606     bindcount = -1;
1607   }
1608
1609   return Fnreverse (allmatches);
1610 }
1611 \f
1612 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
1613        doc: /* Read a string in the minibuffer, with completion.
1614 PROMPT is a string to prompt with; normally it ends in a colon and a space.
1615 COLLECTION can be a list of strings, an alist, an obarray or a hash table.
1616 COLLECTION can also be a function to do the completion itself.
1617 PREDICATE limits completion to a subset of COLLECTION.
1618 See `try-completion' and `all-completions' for more details
1619  on completion, COLLECTION, and PREDICATE.
1620
1621 REQUIRE-MATCH can take the following values:
1622 - t means that the user is not allowed to exit unless
1623   the input is (or completes to) an element of COLLECTION or is null.
1624 - nil means that the user can exit with any input.
1625 - `confirm' means that the user can exit with any input, but she needs
1626   to confirm her choice if the input is not an element of COLLECTION.
1627 - `confirm-after-completion' means that the user can exit with any
1628   input, but she needs to confirm her choice if she called
1629   `minibuffer-complete' right before `minibuffer-complete-and-exit'
1630   and the input is not an element of COLLECTION.
1631 - anything else behaves like t except that typing RET does not exit if it
1632   does non-null completion.
1633
1634 If the input is null, `completing-read' returns DEF, or the first element
1635 of the list of default values, or an empty string if DEF is nil,
1636 regardless of the value of REQUIRE-MATCH.
1637
1638 If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
1639   with point positioned at the end.
1640   If it is (STRING . POSITION), the initial input is STRING, but point
1641   is placed at _zero-indexed_ position POSITION in STRING.  (*Note*
1642   that this is different from `read-from-minibuffer' and related
1643   functions, which use one-indexing for POSITION.)  This feature is
1644   deprecated--it is best to pass nil for INITIAL-INPUT and supply the
1645   default value DEF instead.  The user can yank the default value into
1646   the minibuffer easily using \\<minibuffer-local-map>\\[next-history-element].
1647
1648 HIST, if non-nil, specifies a history list and optionally the initial
1649   position in the list.  It can be a symbol, which is the history list
1650   variable to use, or it can be a cons cell (HISTVAR . HISTPOS).  In
1651   that case, HISTVAR is the history list variable to use, and HISTPOS
1652   is the initial position (the position in the list used by the
1653   minibuffer history commands).  For consistency, you should also
1654   specify that element of the history as the value of
1655   INITIAL-INPUT.  (This is the only case in which you should use
1656   INITIAL-INPUT instead of DEF.)  Positions are counted starting from
1657   1 at the beginning of the list.  The variable `history-length'
1658   controls the maximum length of a history list.
1659
1660 DEF, if non-nil, is the default value or the list of default values.
1661
1662 If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
1663   the current input method and the setting of `enable-multibyte-characters'.
1664
1665 Completion ignores case if the ambient value of
1666   `completion-ignore-case' is non-nil.
1667
1668 See also `completing-read-function'.  */)
1669   (Lisp_Object prompt, Lisp_Object collection, Lisp_Object predicate, Lisp_Object require_match, Lisp_Object initial_input, Lisp_Object hist, Lisp_Object def, Lisp_Object inherit_input_method)
1670 {
1671   return CALLN (Ffuncall,
1672                 Fsymbol_value (intern ("completing-read-function")),
1673                 prompt, collection, predicate, require_match, initial_input,
1674                 hist, def, inherit_input_method);
1675 }
1676 \f
1677 /* Test whether TXT is an exact completion.  */
1678 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
1679        doc: /* Return non-nil if STRING is a valid completion.
1680 Takes the same arguments as `all-completions' and `try-completion'.
1681 If COLLECTION is a function, it is called with three arguments:
1682 the values STRING, PREDICATE and `lambda'.  */)
1683   (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
1684 {
1685   Lisp_Object regexps, tail, tem = Qnil;
1686   ptrdiff_t i = 0;
1687
1688   CHECK_STRING (string);
1689
1690   if (NILP (collection) || (CONSP (collection) && !FUNCTIONP (collection)))
1691     {
1692       tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);
1693       if (NILP (tem))
1694         return Qnil;
1695     }
1696   else if (VECTORP (collection))
1697     {
1698       /* Bypass intern-soft as that loses for nil.  */
1699       tem = oblookup (collection,
1700                       SSDATA (string),
1701                       SCHARS (string),
1702                       SBYTES (string));
1703       if (!SYMBOLP (tem))
1704         {
1705           if (STRING_MULTIBYTE (string))
1706             string = Fstring_make_unibyte (string);
1707           else
1708             string = Fstring_make_multibyte (string);
1709
1710           tem = oblookup (collection,
1711                           SSDATA (string),
1712                           SCHARS (string),
1713                           SBYTES (string));
1714         }
1715
1716       if (completion_ignore_case && !SYMBOLP (tem))
1717         {
1718           for (i = ASIZE (collection) - 1; i >= 0; i--)
1719             {
1720               tail = AREF (collection, i);
1721               if (SYMBOLP (tail))
1722                 while (1)
1723                   {
1724                     if (EQ (Fcompare_strings (string, make_number (0), Qnil,
1725                                               Fsymbol_name (tail),
1726                                               make_number (0) , Qnil, Qt),
1727                            Qt))
1728                       {
1729                         tem = tail;
1730                         break;
1731                       }
1732                     if (XSYMBOL (tail)->next == 0)
1733                       break;
1734                     XSETSYMBOL (tail, XSYMBOL (tail)->next);
1735                   }
1736             }
1737         }
1738
1739       if (!SYMBOLP (tem))
1740         return Qnil;
1741     }
1742   else if (HASH_TABLE_P (collection))
1743     {
1744       struct Lisp_Hash_Table *h = XHASH_TABLE (collection);
1745       Lisp_Object key = Qnil;
1746       i = hash_lookup (h, string, NULL);
1747       if (i >= 0)
1748         tem = HASH_KEY (h, i);
1749       else
1750         for (i = 0; i < HASH_TABLE_SIZE (h); ++i)
1751           if (!NILP (HASH_HASH (h, i))
1752               && (key = HASH_KEY (h, i),
1753                   SYMBOLP (key) ? key = Fsymbol_name (key) : key,
1754                   STRINGP (key))
1755               && EQ (Fcompare_strings (string, make_number (0), Qnil,
1756                                        key, make_number (0) , Qnil,
1757                                        completion_ignore_case ? Qt : Qnil),
1758                      Qt))
1759             {
1760               tem = key;
1761               break;
1762             }
1763       if (!STRINGP (tem))
1764         return Qnil;
1765     }
1766   else
1767     return call3 (collection, string, predicate, Qlambda);
1768
1769   /* Reject this element if it fails to match all the regexps.  */
1770   if (CONSP (Vcompletion_regexp_list))
1771     {
1772       ptrdiff_t count = SPECPDL_INDEX ();
1773       specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
1774       for (regexps = Vcompletion_regexp_list; CONSP (regexps);
1775            regexps = XCDR (regexps))
1776         {
1777           if (NILP (Fstring_match (XCAR (regexps),
1778                                    SYMBOLP (tem) ? string : tem,
1779                                    Qnil)))
1780             return unbind_to (count, Qnil);
1781         }
1782       unbind_to (count, Qnil);
1783     }
1784
1785   /* Finally, check the predicate.  */
1786   if (!NILP (predicate))
1787     {
1788       return HASH_TABLE_P (collection)
1789         ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))
1790         : call1 (predicate, tem);
1791     }
1792   else
1793     return Qt;
1794 }
1795
1796 DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
1797        doc: /* Perform completion on buffer names.
1798 STRING and PREDICATE have the same meanings as in `try-completion',
1799 `all-completions', and `test-completion'.
1800
1801 If FLAG is nil, invoke `try-completion'; if it is t, invoke
1802 `all-completions'; otherwise invoke `test-completion'.  */)
1803   (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag)
1804 {
1805   if (NILP (flag))
1806     return Ftry_completion (string, Vbuffer_alist, predicate);
1807   else if (EQ (flag, Qt))
1808     {
1809       Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
1810       if (SCHARS (string) > 0)
1811         return res;
1812       else
1813         { /* Strip out internal buffers.  */
1814           Lisp_Object bufs = res;
1815           /* First, look for a non-internal buffer in `res'.  */
1816           while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
1817             bufs = XCDR (bufs);
1818           if (NILP (bufs))
1819             return (EQ (Flength (res), Flength (Vbuffer_alist))
1820                     /* If all bufs are internal don't strip them out.  */
1821                     ? res : bufs);
1822           res = bufs;
1823           while (CONSP (XCDR (bufs)))
1824             if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
1825               XSETCDR (bufs, XCDR (XCDR (bufs)));
1826             else
1827               bufs = XCDR (bufs);
1828           return res;
1829         }
1830     }
1831   else if (EQ (flag, Qlambda))
1832     return Ftest_completion (string, Vbuffer_alist, predicate);
1833   else if (EQ (flag, Qmetadata))
1834     return list2 (Qmetadata, Fcons (Qcategory, Qbuffer));
1835   else
1836     return Qnil;
1837 }
1838
1839 /* Like assoc but assumes KEY is a string, and ignores case if appropriate.  */
1840
1841 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
1842        doc: /* Like `assoc' but specifically for strings (and symbols).
1843
1844 This returns the first element of LIST whose car matches the string or
1845 symbol KEY, or nil if no match exists.  When performing the
1846 comparison, symbols are first converted to strings, and unibyte
1847 strings to multibyte.  If the optional arg CASE-FOLD is non-nil, case
1848 is ignored.
1849
1850 Unlike `assoc', KEY can also match an entry in LIST consisting of a
1851 single string, rather than a cons cell whose car is a string.  */)
1852   (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
1853 {
1854   register Lisp_Object tail;
1855
1856   if (SYMBOLP (key))
1857     key = Fsymbol_name (key);
1858
1859   for (tail = list; CONSP (tail); tail = XCDR (tail))
1860     {
1861       register Lisp_Object elt, tem, thiscar;
1862       elt = XCAR (tail);
1863       thiscar = CONSP (elt) ? XCAR (elt) : elt;
1864       if (SYMBOLP (thiscar))
1865         thiscar = Fsymbol_name (thiscar);
1866       else if (!STRINGP (thiscar))
1867         continue;
1868       tem = Fcompare_strings (thiscar, make_number (0), Qnil,
1869                               key, make_number (0), Qnil,
1870                               case_fold);
1871       if (EQ (tem, Qt))
1872         return elt;
1873       QUIT;
1874     }
1875   return Qnil;
1876 }
1877
1878 \f
1879 DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
1880        doc: /* Return current depth of activations of minibuffer, a nonnegative integer.  */)
1881   (void)
1882 {
1883   return make_number (minibuf_level);
1884 }
1885
1886 DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
1887        doc: /* Return the prompt string of the currently-active minibuffer.
1888 If no minibuffer is active, return nil.  */)
1889   (void)
1890 {
1891   return Fcopy_sequence (minibuf_prompt);
1892 }
1893
1894 \f
1895 void
1896 init_minibuf_once (void)
1897 {
1898   Vminibuffer_list = Qnil;
1899   staticpro (&Vminibuffer_list);
1900 }
1901
1902 void
1903 syms_of_minibuf (void)
1904 {
1905   minibuf_level = 0;
1906   minibuf_prompt = Qnil;
1907   staticpro (&minibuf_prompt);
1908
1909   minibuf_save_list = Qnil;
1910   staticpro (&minibuf_save_list);
1911
1912   DEFSYM (Qcompletion_ignore_case, "completion-ignore-case");
1913   DEFSYM (Qread_file_name_internal, "read-file-name-internal");
1914   DEFSYM (Qminibuffer_default, "minibuffer-default");
1915   Fset (Qminibuffer_default, Qnil);
1916
1917   DEFSYM (Qminibuffer_completion_table, "minibuffer-completion-table");
1918   DEFSYM (Qminibuffer_completion_confirm, "minibuffer-completion-confirm");
1919   DEFSYM (Qminibuffer_completion_predicate, "minibuffer-completion-predicate");
1920
1921   staticpro (&last_minibuf_string);
1922   last_minibuf_string = Qnil;
1923
1924   DEFSYM (Qminibuffer_history, "minibuffer-history");
1925   DEFSYM (Qbuffer_name_history, "buffer-name-history");
1926   Fset (Qbuffer_name_history, Qnil);
1927
1928   DEFSYM (Qcustom_variable_p, "custom-variable-p");
1929
1930   /* Normal hooks for entry to and exit from minibuffer.  */
1931   DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
1932   DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
1933
1934   /* The maximum length of a minibuffer history.  */
1935   DEFSYM (Qhistory_length, "history-length");
1936
1937   DEFSYM (Qcurrent_input_method, "current-input-method");
1938   DEFSYM (Qactivate_input_method, "activate-input-method");
1939   DEFSYM (Qcase_fold_search, "case-fold-search");
1940   DEFSYM (Qmetadata, "metadata");
1941
1942   DEFVAR_LISP ("read-expression-history", Vread_expression_history,
1943                doc: /* A history list for arguments that are Lisp expressions to evaluate.
1944 For example, `eval-expression' uses this.  */);
1945   Vread_expression_history = Qnil;
1946
1947   DEFSYM (Qread_expression_history, "read-expression-history");
1948
1949   DEFVAR_LISP ("read-buffer-function", Vread_buffer_function,
1950                doc: /* If this is non-nil, `read-buffer' does its work by calling this function.
1951 The function is called with the arguments passed to `read-buffer'.  */);
1952   Vread_buffer_function = Qnil;
1953
1954   DEFVAR_BOOL ("read-buffer-completion-ignore-case",
1955                read_buffer_completion_ignore_case,
1956                doc: /* Non-nil means completion ignores case when reading a buffer name.  */);
1957   read_buffer_completion_ignore_case = 0;
1958
1959   DEFVAR_LISP ("minibuffer-setup-hook", Vminibuffer_setup_hook,
1960                doc: /* Normal hook run just after entry to minibuffer.  */);
1961   Vminibuffer_setup_hook = Qnil;
1962
1963   DEFVAR_LISP ("minibuffer-exit-hook", Vminibuffer_exit_hook,
1964                doc: /* Normal hook run just after exit from minibuffer.  */);
1965   Vminibuffer_exit_hook = Qnil;
1966
1967   DEFVAR_LISP ("history-length", Vhistory_length,
1968                doc: /* Maximum length of history lists before truncation takes place.
1969 A number means truncate to that length; truncation deletes old
1970 elements, and is done just after inserting a new element.
1971 A value of t means no truncation.
1972
1973 This variable only affects history lists that don't specify their own
1974 maximum lengths.  Setting the `history-length' property of a history
1975 variable overrides this default.  */);
1976   XSETFASTINT (Vhistory_length, 100);
1977
1978   DEFVAR_BOOL ("history-delete-duplicates", history_delete_duplicates,
1979                doc: /* Non-nil means to delete duplicates in history.
1980 If set to t when adding a new history element, all previous identical
1981 elements are deleted from the history list.  */);
1982   history_delete_duplicates = 0;
1983
1984   DEFVAR_LISP ("history-add-new-input", Vhistory_add_new_input,
1985                doc: /* Non-nil means to add new elements in history.
1986 If set to nil, minibuffer reading functions don't add new elements to the
1987 history list, so it is possible to do this afterwards by calling
1988 `add-to-history' explicitly.  */);
1989   Vhistory_add_new_input = Qt;
1990
1991   DEFVAR_BOOL ("completion-ignore-case", completion_ignore_case,
1992                doc: /* Non-nil means don't consider case significant in completion.
1993 For file-name completion, `read-file-name-completion-ignore-case'
1994 controls the behavior, rather than this variable.
1995 For buffer name completion, `read-buffer-completion-ignore-case'
1996 controls the behavior, rather than this variable.  */);
1997   completion_ignore_case = 0;
1998
1999   DEFVAR_BOOL ("enable-recursive-minibuffers", enable_recursive_minibuffers,
2000                doc: /* Non-nil means to allow minibuffer commands while in the minibuffer.
2001 This variable makes a difference whenever the minibuffer window is active. */);
2002   enable_recursive_minibuffers = 0;
2003
2004   DEFVAR_LISP ("minibuffer-completion-table", Vminibuffer_completion_table,
2005                doc: /* Alist or obarray used for completion in the minibuffer.
2006 This becomes the ALIST argument to `try-completion' and `all-completions'.
2007 The value can also be a list of strings or a hash table.
2008
2009 The value may alternatively be a function, which is given three arguments:
2010   STRING, the current buffer contents;
2011   PREDICATE, the predicate for filtering possible matches;
2012   CODE, which says what kind of things to do.
2013 CODE can be nil, t or `lambda':
2014   nil    -- return the best completion of STRING, or nil if there is none.
2015   t      -- return a list of all possible completions of STRING.
2016   lambda -- return t if STRING is a valid completion as it stands.  */);
2017   Vminibuffer_completion_table = Qnil;
2018
2019   DEFVAR_LISP ("minibuffer-completion-predicate", Vminibuffer_completion_predicate,
2020                doc: /* Within call to `completing-read', this holds the PREDICATE argument.  */);
2021   Vminibuffer_completion_predicate = Qnil;
2022
2023   DEFVAR_LISP ("minibuffer-completion-confirm", Vminibuffer_completion_confirm,
2024                doc: /* Whether to demand confirmation of completion before exiting minibuffer.
2025 If nil, confirmation is not required.
2026 If the value is `confirm', the user may exit with an input that is not
2027  a valid completion alternative, but Emacs asks for confirmation.
2028 If the value is `confirm-after-completion', the user may exit with an
2029  input that is not a valid completion alternative, but Emacs asks for
2030  confirmation if the user submitted the input right after any of the
2031  completion commands listed in `minibuffer-confirm-exit-commands'.  */);
2032   Vminibuffer_completion_confirm = Qnil;
2033
2034   DEFVAR_LISP ("minibuffer-completing-file-name",
2035                Vminibuffer_completing_file_name,
2036                doc: /* Non-nil means completing file names.  */);
2037   Vminibuffer_completing_file_name = Qnil;
2038
2039   DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form,
2040                doc: /* Value that `help-form' takes on inside the minibuffer.  */);
2041   Vminibuffer_help_form = Qnil;
2042
2043   DEFVAR_LISP ("minibuffer-history-variable", Vminibuffer_history_variable,
2044                doc: /* History list symbol to add minibuffer values to.
2045 Each string of minibuffer input, as it appears on exit from the minibuffer,
2046 is added with
2047   (set minibuffer-history-variable
2048   (cons STRING (symbol-value minibuffer-history-variable)))  */);
2049   XSETFASTINT (Vminibuffer_history_variable, 0);
2050
2051   DEFVAR_LISP ("minibuffer-history-position", Vminibuffer_history_position,
2052                doc: /* Current position of redoing in the history list.  */);
2053   Vminibuffer_history_position = Qnil;
2054
2055   DEFVAR_BOOL ("minibuffer-auto-raise", minibuffer_auto_raise,
2056                doc: /* Non-nil means entering the minibuffer raises the minibuffer's frame.
2057 Some uses of the echo area also raise that frame (since they use it too).  */);
2058   minibuffer_auto_raise = 0;
2059
2060   DEFVAR_LISP ("completion-regexp-list", Vcompletion_regexp_list,
2061                doc: /* List of regexps that should restrict possible completions.
2062 The basic completion functions only consider a completion acceptable
2063 if it matches all regular expressions in this list, with
2064 `case-fold-search' bound to the value of `completion-ignore-case'.
2065 See Info node `(elisp)Basic Completion', for a description of these
2066 functions.  */);
2067   Vcompletion_regexp_list = Qnil;
2068
2069   DEFVAR_BOOL ("minibuffer-allow-text-properties",
2070                minibuffer_allow_text_properties,
2071                doc: /* Non-nil means `read-from-minibuffer' should not discard text properties.
2072 This also affects `read-string', but it does not affect `read-minibuffer',
2073 `read-no-blanks-input', or any of the functions that do minibuffer input
2074 with completion; they always discard text properties.  */);
2075   minibuffer_allow_text_properties = 0;
2076
2077   DEFVAR_LISP ("minibuffer-prompt-properties", Vminibuffer_prompt_properties,
2078                doc: /* Text properties that are added to minibuffer prompts.
2079 These are in addition to the basic `field' property, and stickiness
2080 properties.  */);
2081   Vminibuffer_prompt_properties = list2 (Qread_only, Qt);
2082
2083   DEFVAR_LISP ("read-hide-char", Vread_hide_char,
2084                doc: /* Whether to hide input characters in noninteractive mode.
2085 It must be a character, which will be used to mask the input
2086 characters.  This variable should never be set globally.  */);
2087   Vread_hide_char = Qnil;
2088
2089   defsubr (&Sactive_minibuffer_window);
2090   defsubr (&Sset_minibuffer_window);
2091   defsubr (&Sread_from_minibuffer);
2092   defsubr (&Sread_string);
2093   defsubr (&Sread_command);
2094   defsubr (&Sread_variable);
2095   defsubr (&Sinternal_complete_buffer);
2096   defsubr (&Sread_buffer);
2097   defsubr (&Sread_no_blanks_input);
2098   defsubr (&Sminibuffer_depth);
2099   defsubr (&Sminibuffer_prompt);
2100
2101   defsubr (&Sminibufferp);
2102   defsubr (&Sminibuffer_prompt_end);
2103   defsubr (&Sminibuffer_contents);
2104   defsubr (&Sminibuffer_contents_no_properties);
2105   defsubr (&Sminibuffer_completion_contents);
2106
2107   defsubr (&Stry_completion);
2108   defsubr (&Sall_completions);
2109   defsubr (&Stest_completion);
2110   defsubr (&Sassoc_string);
2111   defsubr (&Scompleting_read);
2112 }