src/minibuf.c

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