*** empty log message ***

[bpt/emacs.git] / src / minibuf.c

diff --git a/src/minibuf.c b/src/minibuf.c
index 833f72c..0a1d737 100644 (file)
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1,12 +1,13 @@
 /* Minibuffer input and completion.
    Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
 /* Minibuffer input and completion.
    Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

-                 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+                 2001, 2002, 2003, 2004, 2005,
+                 2006, 2007 Free Software Foundation, Inc.

 
 This file is part of GNU Emacs.
 
 GNU Emacs is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 
 This file is part of GNU Emacs.
 
 GNU Emacs is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)

 any later version.
 
 GNU Emacs is distributed in the hope that it will be useful,
 any later version.
 
 GNU Emacs is distributed in the hope that it will be useful,


@@ -65,6 +66,10 @@ Lisp_Object Qhistory_length, Vhistory_length;
 
 int history_delete_duplicates;
 
 
 int history_delete_duplicates;
 

+/* Non-nil means add new input to history.  */
+
+Lisp_Object Vhistory_add_new_input;
+

 /* Fread_minibuffer leaves the input here as a string. */
 
 Lisp_Object last_minibuf_string;
 /* Fread_minibuffer leaves the input here as a string. */
 
 Lisp_Object last_minibuf_string;


@@ -127,7 +132,13 @@ int minibuffer_auto_raise;
 
 static Lisp_Object last_exact_completion;
 
 
 static Lisp_Object last_exact_completion;
 

-extern Lisp_Object Voverriding_local_map;
+/* Keymap for reading expressions.  */
+Lisp_Object Vread_expression_map;
+
+Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
+Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
+Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
+Lisp_Object Vminibuffer_completing_file_name;

 
 Lisp_Object Quser_variable_p;
 
 
 Lisp_Object Quser_variable_p;
 


@@ -137,6 +148,10 @@ Lisp_Object Qcurrent_input_method, Qactivate_input_method;
 
 Lisp_Object Qcase_fold_search;
 
 
 Lisp_Object Qcase_fold_search;
 

+Lisp_Object Qread_expression_history;
+
+extern Lisp_Object Voverriding_local_map;
+

 extern Lisp_Object Qmouse_face;
 
 extern Lisp_Object Qfield;
 extern Lisp_Object Qmouse_face;
 
 extern Lisp_Object Qfield;


@@ -218,7 +233,7 @@ static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
                                     Lisp_Object, Lisp_Object,
                                     int, Lisp_Object,
                                     Lisp_Object, Lisp_Object,
                                     Lisp_Object, Lisp_Object,
                                     int, Lisp_Object,
                                     Lisp_Object, Lisp_Object,

-                                    int, int, int));
+                                    int, int));

 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
                                                    Lisp_Object, Lisp_Object,
                                                    int, Lisp_Object,
 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
                                                    Lisp_Object, Lisp_Object,
                                                    int, Lisp_Object,


@@ -371,7 +386,7 @@ Return (point-min) if current buffer is not a minibuffer.  */)
 DEFUN ("minibuffer-contents", Fminibuffer_contents,
        Sminibuffer_contents, 0, 0, 0,
        doc: /* Return the user input in a minibuffer as a string.
 DEFUN ("minibuffer-contents", Fminibuffer_contents,
        Sminibuffer_contents, 0, 0, 0,
        doc: /* Return the user input in a minibuffer as a string.

-The current buffer must be a minibuffer.  */)
+If the current buffer is not a minibuffer, return its entire contents.  */)

      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());
      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());


@@ -381,17 +396,30 @@ The current buffer must be a minibuffer.  */)
 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
        Sminibuffer_contents_no_properties, 0, 0, 0,
        doc: /* Return the user input in a minibuffer as a string, without text-properties.
 DEFUN ("minibuffer-contents-no-properties", Fminibuffer_contents_no_properties,
        Sminibuffer_contents_no_properties, 0, 0, 0,
        doc: /* Return the user input in a minibuffer as a string, without text-properties.

-The current buffer must be a minibuffer.  */)
+If the current buffer is not a minibuffer, return its entire contents.  */)

      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 0);
 }
 
      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());
   return make_buffer_string (prompt_end, ZV, 0);
 }
 

+DEFUN ("minibuffer-completion-contents", Fminibuffer_completion_contents,
+       Sminibuffer_completion_contents, 0, 0, 0,
+       doc: /* Return the user input in a minibuffer before point as a string.
+That is what completion commands operate on.
+If the current buffer is not a minibuffer, return its entire contents.  */)
+     ()
+{
+  int prompt_end = XINT (Fminibuffer_prompt_end ());
+  if (PT < prompt_end)
+    error ("Cannot do completion in the prompt");
+  return make_buffer_string (prompt_end, PT, 1);
+}
+

 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents,
        Sdelete_minibuffer_contents, 0, 0, 0,
        doc: /* Delete all user input in a minibuffer.
 DEFUN ("delete-minibuffer-contents", Fdelete_minibuffer_contents,
        Sdelete_minibuffer_contents, 0, 0, 0,
        doc: /* Delete all user input in a minibuffer.

-The current buffer must be a minibuffer.  */)
+If the current buffer is not a minibuffer, erase its entire contents.  */)

      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());
      ()
 {
   int prompt_end = XINT (Fminibuffer_prompt_end ());


@@ -400,17 +428,6 @@ The current buffer must be a minibuffer.  */)
   return Qnil;
 }
 
   return Qnil;
 }
 

-/* Get the text in the minibuffer before point.
-   That is what completion commands operate on.  */
-
-Lisp_Object
-minibuffer_completion_contents ()
-{
-  int prompt_end = XINT (Fminibuffer_prompt_end ());
-  if (PT < prompt_end)
-    error ("Cannot do completion in the prompt");
-  return make_buffer_string (prompt_end, PT, 1);
-}

 \f
 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
    putting point minus BACKUP_N bytes from the end of INITIAL,
 \f
 /* Read from the minibuffer using keymap MAP and initial contents INITIAL,
    putting point minus BACKUP_N bytes from the end of INITIAL,


@@ -437,8 +454,7 @@ minibuffer_completion_contents ()
 
 static Lisp_Object
 read_minibuf (map, initial, prompt, backup_n, expflag,
 
 static Lisp_Object
 read_minibuf (map, initial, prompt, backup_n, expflag,

-             histvar, histpos, defalt, allow_props, inherit_input_method,
-             keep_all)
+             histvar, histpos, defalt, allow_props, inherit_input_method)

      Lisp_Object map;
      Lisp_Object initial;
      Lisp_Object prompt;
      Lisp_Object map;
      Lisp_Object initial;
      Lisp_Object prompt;


@@ -449,7 +465,6 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
      Lisp_Object defalt;
      int allow_props;
      int inherit_input_method;
      Lisp_Object defalt;
      int allow_props;
      int inherit_input_method;

-     int keep_all;

 {
   Lisp_Object val;
   int count = SPECPDL_INDEX ();
 {
   Lisp_Object val;
   int count = SPECPDL_INDEX ();


@@ -457,15 +472,25 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   Lisp_Object enable_multibyte;
   int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   Lisp_Object enable_multibyte;
   int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;

-

   /* String to add to the history.  */
   Lisp_Object histstring;
 
   /* String to add to the history.  */
   Lisp_Object histstring;
 

+  Lisp_Object empty_minibuf;
+  Lisp_Object dummy, frame;
+

   extern Lisp_Object Qfront_sticky;
   extern Lisp_Object Qrear_nonsticky;
 
   specbind (Qminibuffer_default, defalt);
 
   extern Lisp_Object Qfront_sticky;
   extern Lisp_Object Qrear_nonsticky;
 
   specbind (Qminibuffer_default, defalt);
 

+  /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t
+     in previous recursive minibuffer, but was not set explicitly
+     to t for this invocation, so set it to nil in this minibuffer.
+     Save the old value now, before we change it.  */
+  specbind (intern ("minibuffer-completing-file-name"), Vminibuffer_completing_file_name);
+  if (EQ (Vminibuffer_completing_file_name, Qlambda))
+    Vminibuffer_completing_file_name = Qnil;
+

   single_kboard_state ();
 #ifdef HAVE_X_WINDOWS
   if (display_hourglass_p)
   single_kboard_state ();
 #ifdef HAVE_X_WINDOWS
   if (display_hourglass_p)


@@ -517,7 +542,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
                build_string ("Command attempted to use minibuffer while in minibuffer"));
     }
 
                build_string ("Command attempted to use minibuffer while in minibuffer"));
     }
 

-  if (noninteractive)
+  if (noninteractive && NILP (Vexecuting_kbd_macro))

     {
       val = read_minibuf_noninteractive (map, initial, prompt,
                                         make_number (pos),
     {
       val = read_minibuf_noninteractive (map, initial, prompt,
                                         make_number (pos),


@@ -558,7 +583,8 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
      specpdl slots.  */
   minibuf_save_list
     = Fcons (Voverriding_local_map,
      specpdl slots.  */
   minibuf_save_list
     = Fcons (Voverriding_local_map,

-            Fcons (minibuf_window, minibuf_save_list));
+            Fcons (minibuf_window,
+                   minibuf_save_list));

   minibuf_save_list
     = Fcons (minibuf_prompt,
             Fcons (make_number (minibuf_prompt_width),
   minibuf_save_list
     = Fcons (minibuf_prompt,
             Fcons (make_number (minibuf_prompt_width),


@@ -584,6 +610,13 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   Vminibuffer_history_position = histpos;
   Vminibuffer_history_variable = histvar;
   Vhelp_form = Vminibuffer_help_form;
   Vminibuffer_history_position = histpos;
   Vminibuffer_history_variable = histvar;
   Vhelp_form = Vminibuffer_help_form;

+  /* If this minibuffer is reading a file name, that doesn't mean
+     recursive ones are.  But we cannot set it to nil, because
+     completion code still need to know the minibuffer is completing a
+     file name.  So use `lambda' as intermediate value meaning
+     "t" in this minibuffer, but "nil" in next minibuffer.  */
+  if (!NILP (Vminibuffer_completing_file_name))
+    Vminibuffer_completing_file_name = Qlambda;

 
   if (inherit_input_method)
     {
 
   if (inherit_input_method)
     {


@@ -598,6 +631,10 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   minibuffer = get_minibuffer (minibuf_level);
   Fset_buffer (minibuffer);
 
   minibuffer = get_minibuffer (minibuf_level);
   Fset_buffer (minibuffer);
 

+  /* If appropriate, copy enable-multibyte-characters into the minibuffer.  */
+  if (inherit_input_method)
+    current_buffer->enable_multibyte_characters = enable_multibyte;
+

   /* The current buffer's default directory is usually the right thing
      for our minibuffer here.  However, if you're typing a command at
      a minibuffer-only frame when minibuf_level is zero, then buf IS
   /* The current buffer's default directory is usually the right thing
      for our minibuffer here.  However, if you're typing a command at
      a minibuffer-only frame when minibuf_level is zero, then buf IS


@@ -633,6 +670,23 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   Vminibuf_scroll_window = selected_window;
   if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
     minibuf_selected_window = selected_window;
   Vminibuf_scroll_window = selected_window;
   if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
     minibuf_selected_window = selected_window;

+
+  /* Empty out the minibuffers of all frames other than the one
+     where we are going to display one now.
+     Set them to point to ` *Minibuf-0*', which is always empty.  */
+  empty_minibuf = Fget_buffer (build_string (" *Minibuf-0*"));
+
+  FOR_EACH_FRAME (dummy, frame)
+    {
+      Lisp_Object root_window = Fframe_root_window (frame);
+      Lisp_Object mini_window = XWINDOW (root_window)->next;
+
+      if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window)
+         && !NILP (Fwindow_minibuffer_p (mini_window)))
+       Fset_window_buffer (mini_window, empty_minibuf, Qnil);
+    }
+
+  /* Display this minibuffer in the proper window.  */

   Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
   Fselect_window (minibuf_window, Qnil);
   XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
   Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil);
   Fselect_window (minibuf_window, Qnil);
   XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);


@@ -646,33 +700,29 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
     specbind (Qinhibit_read_only, Qt);
     specbind (Qinhibit_modification_hooks, Qt);
     Ferase_buffer ();
     specbind (Qinhibit_read_only, Qt);
     specbind (Qinhibit_modification_hooks, Qt);
     Ferase_buffer ();

-    unbind_to (count1, Qnil);
-  }

 
 

-  if (!NILP (current_buffer->enable_multibyte_characters)
-      && ! STRING_MULTIBYTE (minibuf_prompt))
-    minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);
+    if (!NILP (current_buffer->enable_multibyte_characters)
+       && ! STRING_MULTIBYTE (minibuf_prompt))
+      minibuf_prompt = Fstring_make_multibyte (minibuf_prompt);

 
 

-  /* Insert the prompt, record where it ends.  */
-  Finsert (1, &minibuf_prompt);
-  if (PT > BEG)
-    {
-      Fput_text_property (make_number (BEG), make_number (PT),
-                         Qfront_sticky, Qt, Qnil);
-      Fput_text_property (make_number (BEG), make_number (PT),
-                         Qrear_nonsticky, Qt, Qnil);
-      Fput_text_property (make_number (BEG), make_number (PT),
-                         Qfield, Qt, Qnil);
-      Fadd_text_properties (make_number (BEG), make_number (PT),
-                           Vminibuffer_prompt_properties, Qnil);
-    }
+    /* Insert the prompt, record where it ends.  */
+    Finsert (1, &minibuf_prompt);
+    if (PT > BEG)
+      {
+       Fput_text_property (make_number (BEG), make_number (PT),
+                           Qfront_sticky, Qt, Qnil);
+       Fput_text_property (make_number (BEG), make_number (PT),
+                           Qrear_nonsticky, Qt, Qnil);
+       Fput_text_property (make_number (BEG), make_number (PT),
+                           Qfield, Qt, Qnil);
+       Fadd_text_properties (make_number (BEG), make_number (PT),
+                             Vminibuffer_prompt_properties, Qnil);
+      }
+    unbind_to (count1, Qnil);
+  }

 
   minibuf_prompt_width = (int) current_column (); /* iftc */
 
 
   minibuf_prompt_width = (int) current_column (); /* iftc */
 

-  /* If appropriate, copy enable-multibyte-characters into the minibuffer.  */
-  if (inherit_input_method)
-    current_buffer->enable_multibyte_characters = enable_multibyte;
-

   /* Put in the initial input.  */
   if (!NILP (initial))
     {
   /* Put in the initial input.  */
   if (!NILP (initial))
     {


@@ -724,7 +774,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   last_minibuf_string = val;
 
   /* Choose the string to add to the history.  */
   last_minibuf_string = val;
 
   /* Choose the string to add to the history.  */

-  if (SCHARS (val) != 0 || keep_all)
+  if (SCHARS (val) != 0)

     histstring = val;
   else if (STRINGP (defalt))
     histstring = defalt;
     histstring = val;
   else if (STRINGP (defalt))
     histstring = defalt;


@@ -732,7 +782,8 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
     histstring = Qnil;
 
   /* Add the value to the appropriate history list, if any.  */
     histstring = Qnil;
 
   /* Add the value to the appropriate history list, if any.  */

-  if (SYMBOLP (Vminibuffer_history_variable)
+  if (!NILP (Vhistory_add_new_input)
+      && SYMBOLP (Vminibuffer_history_variable)

       && !NILP (histstring))
     {
       /* If the caller wanted to save the value read on a history list,
       && !NILP (histstring))
     {
       /* If the caller wanted to save the value read on a history list,


@@ -751,8 +802,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
       if (NILP (histval)
          || (CONSP (histval)
              /* Don't duplicate the most recent entry in the history.  */
       if (NILP (histval)
          || (CONSP (histval)
              /* Don't duplicate the most recent entry in the history.  */

-             && (keep_all
-                 || NILP (Fequal (histstring, Fcar (histval))))))
+             && (NILP (Fequal (histstring, Fcar (histval))))))

        {
          Lisp_Object length;
 
        {
          Lisp_Object length;
 


@@ -914,7 +964,7 @@ read_minibuf_unwind (data)
 }
 \f
 
 }
 \f
 

-DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 8, 0,
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,

        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
   DEFAULT-VALUE.  It normally should be nil in new code, except when
        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
   DEFAULT-VALUE.  It normally should be nil in new code, except when


@@ -938,8 +988,6 @@ Sixth arg DEFAULT-VALUE is the default value.  If non-nil, it is available
   the empty string.
 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
  the current input method and the setting of `enable-multibyte-characters'.
   the empty string.
 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
  the current input method and the setting of `enable-multibyte-characters'.

-Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
- even empty or duplicate inputs.

 If the variable `minibuffer-allow-text-properties' is non-nil,
  then the string which is returned includes whatever text properties
  were present in the minibuffer.  Otherwise the value has no text properties.
 If the variable `minibuffer-allow-text-properties' is non-nil,
  then the string which is returned includes whatever text properties
  were present in the minibuffer.  Otherwise the value has no text properties.


@@ -955,9 +1003,9 @@ POSITION in the minibuffer.  Any integer value less than or equal to
 one puts point at the beginning of the string.  *Note* that this
 behavior differs from the way such arguments are used in `completing-read'
 and some related functions, which use zero-indexing for POSITION.  */)
 one puts point at the beginning of the string.  *Note* that this
 behavior differs from the way such arguments are used in `completing-read'
 and some related functions, which use zero-indexing for POSITION.  */)

-  (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method, keep_all)
+   (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)

      Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
      Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;

-     Lisp_Object inherit_input_method, keep_all;
+     Lisp_Object inherit_input_method;

 {
   Lisp_Object histvar, histpos, val;
   struct gcpro gcpro1;
 {
   Lisp_Object histvar, histpos, val;
   struct gcpro gcpro1;


@@ -988,8 +1036,7 @@ and some related functions, which use zero-indexing for POSITION.  */)
                      Qnil, !NILP (read),
                      histvar, histpos, default_value,
                      minibuffer_allow_text_properties,
                      Qnil, !NILP (read),
                      histvar, histpos, default_value,
                      minibuffer_allow_text_properties,

-                     !NILP (inherit_input_method),
-                     !NILP (keep_all));
+                     !NILP (inherit_input_method));

   UNGCPRO;
   return val;
 }
   UNGCPRO;
   return val;
 }


@@ -999,14 +1046,14 @@ DEFUN ("read-minibuffer", Fread_minibuffer, Sread_minibuffer, 1, 2, 0,
 Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
 is a string to insert in the minibuffer before reading.
 \(INITIAL-CONTENTS can also be a cons of a string and an integer.  Such
 Prompt with PROMPT.  If non-nil, optional second arg INITIAL-CONTENTS
 is a string to insert in the minibuffer before reading.
 \(INITIAL-CONTENTS can also be a cons of a string and an integer.  Such

-arguments are used as in `read-from-minibuffer')  */)
+arguments are used as in `read-from-minibuffer'.)  */)

      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_map, initial_contents,
                       prompt, Qnil, 1, Qminibuffer_history,
      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_map, initial_contents,
                       prompt, Qnil, 1, Qminibuffer_history,

-                      make_number (0), Qnil, 0, 0, 0);
+                      make_number (0), Qnil, 0, 0);

 }
 
 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
 }
 
 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,


@@ -1018,7 +1065,9 @@ arguments are used as in `read-from-minibuffer'.)  */)
      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {
      (prompt, initial_contents)
      Lisp_Object prompt, initial_contents;
 {

-  return Feval (Fread_minibuffer (prompt, initial_contents));
+  return Feval (read_minibuf (Vread_expression_map, initial_contents,
+                             prompt, Qnil, 1, Qread_expression_history,
+                             make_number (0), Qnil, 0, 0));

 }
 
 /* Functions that use the minibuffer to read various things. */
 }
 
 /* Functions that use the minibuffer to read various things. */


@@ -1044,7 +1093,7 @@ Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
   Lisp_Object val;
   val = Fread_from_minibuffer (prompt, initial_input, Qnil,
                               Qnil, history, default_value,
   Lisp_Object val;
   val = Fread_from_minibuffer (prompt, initial_input, Qnil,
                               Qnil, history, default_value,

-                              inherit_input_method, Qnil);
+                              inherit_input_method);

   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
     val = default_value;
   return val;
   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
     val = default_value;
   return val;


@@ -1066,7 +1115,7 @@ the current input method and the setting of`enable-multibyte-characters'.  */)
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
                       0, Qminibuffer_history, make_number (0), Qnil, 0,
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
                       0, Qminibuffer_history, make_number (0), Qnil, 0,

-                      !NILP (inherit_input_method), 0);
+                      !NILP (inherit_input_method));

 }
 
 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
 }
 
 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,


@@ -1173,8 +1222,8 @@ The argument PROMPT should be a string ending with a colon and a space.  */)
          prompt = Fformat (3, args);
        }
 
          prompt = Fformat (3, args);
        }
 

-      return Fcompleting_read (prompt, Vbuffer_alist, Qnil,
-                              require_match, Qnil, Qbuffer_name_history,
+      return Fcompleting_read (prompt, intern ("internal-complete-buffer"),
+                              Qnil, require_match, Qnil, Qbuffer_name_history,

                               def, Qnil);
     }
   else
                               def, Qnil);
     }
   else


@@ -1201,22 +1250,25 @@ minibuf_conform_representation (string, basis)
 }
 
 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,
 }
 
 DEFUN ("try-completion", Ftry_completion, Stry_completion, 2, 3, 0,

-       doc: /* Return common substring of all completions of STRING in ALIST.
-Each car of each element of ALIST (or each element if it is not a cons cell)
-is tested to see if it begins with STRING.  The possible matches may be
+       doc: /* Return common substring of all completions of STRING in COLLECTION.
+Test each possible completion specified by COLLECTION
+to see if it begins with STRING.  The possible completions may be

 strings or symbols.  Symbols are converted to strings before testing,
 see `symbol-name'.
 strings or symbols.  Symbols are converted to strings before testing,
 see `symbol-name'.

-All that match are compared together; the longest initial sequence
-common to all matches is returned as a string.
-If there is no match at all, nil is returned.
-For a unique match which is exact, t is returned.
-
-If ALIST is a hash-table, all the string and symbol keys are the
-possible matches.
-If ALIST is an obarray, the names of all symbols in the obarray
-are the possible matches.
-
-ALIST can also be a function to do the completion itself.
+All that match STRING are compared together; the longest initial sequence
+common to all these matches is the return value.
+If there is no match at all, the return value is nil.
+For a unique match which is exact, the return value is t.
+
+If COLLECTION is an alist, the keys (cars of elements) are the
+possible completions.  If an element is not a cons cell, then the
+element itself is the possible completion.
+If COLLECTION is a hash-table, all the keys that are strings or symbols
+are the possible completions.
+If COLLECTION is an obarray, the names of all symbols in the obarray
+are the possible completions.
+
+COLLECTION can also be a function to do the completion itself.

 It receives three arguments: the values STRING, PREDICATE and nil.
 Whatever it returns becomes the value of `try-completion'.
 
 It receives three arguments: the values STRING, PREDICATE and nil.
 Whatever it returns becomes the value of `try-completion'.
 


@@ -1224,23 +1276,23 @@ If optional third argument PREDICATE is non-nil,
 it is used to test each possible match.
 The match is a candidate only if PREDICATE returns non-nil.
 The argument given to PREDICATE is the alist element
 it is used to test each possible match.
 The match is a candidate only if PREDICATE returns non-nil.
 The argument given to PREDICATE is the alist element

-or the symbol from the obarray.  If ALIST is a hash-table,
+or the symbol from the obarray.  If COLLECTION is a hash-table,

 predicate is called with two arguments: the key and the value.
 Additionally to this predicate, `completion-regexp-list'
 is used to further constrain the set of candidates.  */)
 predicate is called with two arguments: the key and the value.
 Additionally to this predicate, `completion-regexp-list'
 is used to further constrain the set of candidates.  */)

-     (string, alist, predicate)
-     Lisp_Object string, alist, predicate;
+     (string, collection, predicate)
+     Lisp_Object string, collection, predicate;

 {
   Lisp_Object bestmatch, tail, elt, eltstring;
   /* Size in bytes of BESTMATCH.  */
   int bestmatchsize = 0;
   /* These are in bytes, too.  */
   int compare, matchsize;
 {
   Lisp_Object bestmatch, tail, elt, eltstring;
   /* Size in bytes of BESTMATCH.  */
   int bestmatchsize = 0;
   /* These are in bytes, too.  */
   int compare, matchsize;

-  int type = HASH_TABLE_P (alist) ? 3
-    : VECTORP (alist) ? 2
-    : NILP (alist) || (CONSP (alist)
-                      && (!SYMBOLP (XCAR (alist))
-                          || NILP (XCAR (alist))));
+  int type = (HASH_TABLE_P (collection) ? 3
+             : VECTORP (collection) ? 2
+             : NILP (collection) || (CONSP (collection)
+                                     && (!SYMBOLP (XCAR (collection))
+                                         || NILP (XCAR (collection)))));

   int index = 0, obsize = 0;
   int matchcount = 0;
   int bindcount = -1;
   int index = 0, obsize = 0;
   int matchcount = 0;
   int bindcount = -1;


@@ -1249,17 +1301,18 @@ is used to further constrain the set of candidates.  */)
 
   CHECK_STRING (string);
   if (type == 0)
 
   CHECK_STRING (string);
   if (type == 0)

-    return call3 (alist, string, predicate, Qnil);
+    return call3 (collection, string, predicate, Qnil);

 
   bestmatch = bucket = Qnil;
   zero = make_number (0);
 
 
   bestmatch = bucket = Qnil;
   zero = make_number (0);
 

-  /* If ALIST is not a list, set TAIL just for gc pro.  */
-  tail = alist;
+  /* If COLLECTION is not a list, set TAIL just for gc pro.  */
+  tail = collection;

   if (type == 2)
     {
   if (type == 2)
     {

-      obsize = XVECTOR (alist)->size;
-      bucket = XVECTOR (alist)->contents[index];
+      collection = check_obarray (collection);
+      obsize = XVECTOR (collection)->size;
+      bucket = XVECTOR (collection)->contents[index];

     }
 
   while (1)
     }
 
   while (1)


@@ -1281,6 +1334,8 @@ is used to further constrain the set of candidates.  */)
        {
          if (!EQ (bucket, zero))
            {
        {
          if (!EQ (bucket, zero))
            {

+             if (!SYMBOLP (bucket))
+               error ("Bad data in guts of obarray");

              elt = bucket;
              eltstring = elt;
              if (XSYMBOL (bucket)->next)
              elt = bucket;
              eltstring = elt;
              if (XSYMBOL (bucket)->next)


@@ -1292,19 +1347,19 @@ is used to further constrain the set of candidates.  */)
            break;
          else
            {
            break;
          else
            {

-             bucket = XVECTOR (alist)->contents[index];
+             bucket = XVECTOR (collection)->contents[index];

              continue;
            }
        }
       else /* if (type == 3) */
        {
              continue;
            }
        }
       else /* if (type == 3) */
        {

-         while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
-                && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
+         while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
+                && NILP (HASH_HASH (XHASH_TABLE (collection), index)))

            index++;
            index++;

-         if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
+         if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))

            break;
          else
            break;
          else

-           elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
+           elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);

        }
 
       /* Is this element a possible completion? */
        }
 
       /* Is this element a possible completion? */


@@ -1357,7 +1412,7 @@ is used to further constrain the set of candidates.  */)
                  GCPRO4 (tail, string, eltstring, bestmatch);
                  tem = type == 3
                    ? call2 (predicate, elt,
                  GCPRO4 (tail, string, eltstring, bestmatch);
                  tem = type == 3
                    ? call2 (predicate, elt,

-                            HASH_VALUE (XHASH_TABLE (alist), index - 1))
+                            HASH_VALUE (XHASH_TABLE (collection), index - 1))

                    : call1 (predicate, elt);
                  UNGCPRO;
                }
                    : call1 (predicate, elt);
                  UNGCPRO;
                }


@@ -1428,6 +1483,10 @@ is used to further constrain the set of candidates.  */)
                matchcount++;
              bestmatchsize = matchsize;
              if (matchsize <= SCHARS (string)
                matchcount++;
              bestmatchsize = matchsize;
              if (matchsize <= SCHARS (string)

+                 /* If completion-ignore-case is non-nil, don't
+                    short-circuit because we want to find the best
+                    possible match *including* case differences.  */
+                 && !completion_ignore_case

                  && matchcount > 1)
                /* No need to look any further.  */
                break;
                  && matchcount > 1)
                /* No need to look any further.  */
                break;


@@ -1466,19 +1525,22 @@ is used to further constrain the set of candidates.  */)
 }
 \f
 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
 }
 \f
 DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,

-       doc: /* Search for partial matches to STRING in ALIST.
-Each car of each element of ALIST (or each element if it is not a cons cell)
-is tested to see if it begins with STRING.  The possible matches may be
+       doc: /* Search for partial matches to STRING in COLLECTION.
+Test each of the possible completions specified by COLLECTION
+to see if it begins with STRING.  The possible completions may be

 strings or symbols.  Symbols are converted to strings before testing,
 see `symbol-name'.
 strings or symbols.  Symbols are converted to strings before testing,
 see `symbol-name'.

-The value is a list of all the strings from ALIST that match.
+The value is a list of all the possible completions that match STRING.

 
 

-If ALIST is a hash-table, all the string and symbol keys are the
-possible matches.
-If ALIST is an obarray, the names of all symbols in the obarray
-are the possible matches.
+If COLLECTION is an alist, the keys (cars of elements) are the
+possible completions.  If an element is not a cons cell, then the
+element itself is the possible completion.
+If COLLECTION is a hash-table, all the keys that are strings or symbols
+are the possible completions.
+If COLLECTION is an obarray, the names of all symbols in the obarray
+are the possible completions.

 
 

-ALIST can also be a function to do the completion itself.
+COLLECTION can also be a function to do the completion itself.

 It receives three arguments: the values STRING, PREDICATE and t.
 Whatever it returns becomes the value of `all-completions'.
 
 It receives three arguments: the values STRING, PREDICATE and t.
 Whatever it returns becomes the value of `all-completions'.
 


@@ -1486,24 +1548,24 @@ If optional third argument PREDICATE is non-nil,
 it is used to test each possible match.
 The match is a candidate only if PREDICATE returns non-nil.
 The argument given to PREDICATE is the alist element
 it is used to test each possible match.
 The match is a candidate only if PREDICATE returns non-nil.
 The argument given to PREDICATE is the alist element

-or the symbol from the obarray.  If ALIST is a hash-table,
+or the symbol from the obarray.  If COLLECTION is a hash-table,

 predicate is called with two arguments: the key and the value.
 Additionally to this predicate, `completion-regexp-list'
 is used to further constrain the set of candidates.
 
 If the optional fourth argument HIDE-SPACES is non-nil,
 predicate is called with two arguments: the key and the value.
 Additionally to this predicate, `completion-regexp-list'
 is used to further constrain the set of candidates.
 
 If the optional fourth argument HIDE-SPACES is non-nil,

-strings in ALIST that start with a space
+strings in COLLECTION that start with a space

 are ignored unless STRING itself starts with a space.  */)
 are ignored unless STRING itself starts with a space.  */)

-     (string, alist, predicate, hide_spaces)
-     Lisp_Object string, alist, predicate, hide_spaces;
+     (string, collection, predicate, hide_spaces)
+     Lisp_Object string, collection, predicate, hide_spaces;

 {
   Lisp_Object tail, elt, eltstring;
   Lisp_Object allmatches;
 {
   Lisp_Object tail, elt, eltstring;
   Lisp_Object allmatches;

-  int type = HASH_TABLE_P (alist) ? 3
-    : VECTORP (alist) ? 2
-    : NILP (alist) || (CONSP (alist)
-                      && (!SYMBOLP (XCAR (alist))
-                          || NILP (XCAR (alist))));
+  int type = HASH_TABLE_P (collection) ? 3
+    : VECTORP (collection) ? 2
+    : NILP (collection) || (CONSP (collection)
+                           && (!SYMBOLP (XCAR (collection))
+                               || NILP (XCAR (collection))));

   int index = 0, obsize = 0;
   int bindcount = -1;
   Lisp_Object bucket, tem, zero;
   int index = 0, obsize = 0;
   int bindcount = -1;
   Lisp_Object bucket, tem, zero;


@@ -1511,16 +1573,16 @@ are ignored unless STRING itself starts with a space.  */)
 
   CHECK_STRING (string);
   if (type == 0)
 
   CHECK_STRING (string);
   if (type == 0)

-    return call3 (alist, string, predicate, Qt);
+    return call3 (collection, string, predicate, Qt);

   allmatches = bucket = Qnil;
   zero = make_number (0);
 
   allmatches = bucket = Qnil;
   zero = make_number (0);
 

-  /* If ALIST is not a list, set TAIL just for gc pro.  */
-  tail = alist;
+  /* If COLLECTION is not a list, set TAIL just for gc pro.  */
+  tail = collection;

   if (type == 2)
     {
   if (type == 2)
     {

-      obsize = XVECTOR (alist)->size;
-      bucket = XVECTOR (alist)->contents[index];
+      obsize = XVECTOR (collection)->size;
+      bucket = XVECTOR (collection)->contents[index];

     }
 
   while (1)
     }
 
   while (1)


@@ -1553,19 +1615,19 @@ are ignored unless STRING itself starts with a space.  */)
            break;
          else
            {
            break;
          else
            {

-             bucket = XVECTOR (alist)->contents[index];
+             bucket = XVECTOR (collection)->contents[index];

              continue;
            }
        }
       else /* if (type == 3) */
        {
              continue;
            }
        }
       else /* if (type == 3) */
        {

-         while (index < HASH_TABLE_SIZE (XHASH_TABLE (alist))
-                && NILP (HASH_HASH (XHASH_TABLE (alist), index)))
+         while (index < HASH_TABLE_SIZE (XHASH_TABLE (collection))
+                && NILP (HASH_HASH (XHASH_TABLE (collection), index)))

            index++;
            index++;

-         if (index >= HASH_TABLE_SIZE (XHASH_TABLE (alist)))
+         if (index >= HASH_TABLE_SIZE (XHASH_TABLE (collection)))

            break;
          else
            break;
          else

-           elt = eltstring = HASH_KEY (XHASH_TABLE (alist), index++);
+           elt = eltstring = HASH_KEY (XHASH_TABLE (collection), index++);

        }
 
       /* Is this element a possible completion? */
        }
 
       /* Is this element a possible completion? */


@@ -1627,7 +1689,7 @@ are ignored unless STRING itself starts with a space.  */)
                  GCPRO4 (tail, eltstring, allmatches, string);
                  tem = type == 3
                    ? call2 (predicate, elt,
                  GCPRO4 (tail, eltstring, allmatches, string);
                  tem = type == 3
                    ? call2 (predicate, elt,

-                            HASH_VALUE (XHASH_TABLE (alist), index - 1))
+                            HASH_VALUE (XHASH_TABLE (collection), index - 1))

                    : call1 (predicate, elt);
                  UNGCPRO;
                }
                    : call1 (predicate, elt);
                  UNGCPRO;
                }


@@ -1646,22 +1708,17 @@ are ignored unless STRING itself starts with a space.  */)
   return Fnreverse (allmatches);
 }
 \f
   return Fnreverse (allmatches);
 }
 \f

-Lisp_Object Vminibuffer_completion_table, Qminibuffer_completion_table;
-Lisp_Object Vminibuffer_completion_predicate, Qminibuffer_completion_predicate;
-Lisp_Object Vminibuffer_completion_confirm, Qminibuffer_completion_confirm;
-Lisp_Object Vminibuffer_completing_file_name;
-

 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
        doc: /* Read a string in the minibuffer, with completion.
 PROMPT is a string to prompt with; normally it ends in a colon and a space.
 DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
        doc: /* Read a string in the minibuffer, with completion.
 PROMPT is a string to prompt with; normally it ends in a colon and a space.

-TABLE can be an list of strings, an alist, an obarray or a hash table.
-TABLE can also be a function to do the completion itself.
-PREDICATE limits completion to a subset of TABLE.
+COLLECTION can be a list of strings, an alist, an obarray or a hash table.
+COLLECTION can also be a function to do the completion itself.
+PREDICATE limits completion to a subset of COLLECTION.

 See `try-completion' and `all-completions' for more details
 See `try-completion' and `all-completions' for more details

- on completion, TABLE, and PREDICATE.
+ on completion, COLLECTION, and PREDICATE.

 
 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless
 
 If REQUIRE-MATCH is non-nil, the user is not allowed to exit unless

- the input is (or completes to) an element of TABLE or is null.
+ the input is (or completes to) an element of COLLECTION or is null.

  If it is also not t, typing RET does not exit if it does non-null completion.
 If the input is null, `completing-read' returns DEF, or an empty string
  if DEF is nil, regardless of the value of REQUIRE-MATCH.
  If it is also not t, typing RET does not exit if it does non-null completion.
 If the input is null, `completing-read' returns DEF, or an empty string
  if DEF is nil, regardless of the value of REQUIRE-MATCH.


@@ -1695,8 +1752,8 @@ If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
 
 Completion ignores case if the ambient value of
   `completion-ignore-case' is non-nil.  */)
 
 Completion ignores case if the ambient value of
   `completion-ignore-case' is non-nil.  */)

-     (prompt, table, predicate, require_match, initial_input, hist, def, inherit_input_method)
-     Lisp_Object prompt, table, predicate, require_match, initial_input;
+     (prompt, collection, predicate, require_match, initial_input, hist, def, inherit_input_method)
+     Lisp_Object prompt, collection, predicate, require_match, initial_input;

      Lisp_Object hist, def, inherit_input_method;
 {
   Lisp_Object val, histvar, histpos, position;
      Lisp_Object hist, def, inherit_input_method;
 {
   Lisp_Object val, histvar, histpos, position;


@@ -1708,7 +1765,7 @@ Completion ignores case if the ambient value of
   init = initial_input;
   GCPRO1 (def);
 
   init = initial_input;
   GCPRO1 (def);
 

-  specbind (Qminibuffer_completion_table, table);
+  specbind (Qminibuffer_completion_table, collection);

   specbind (Qminibuffer_completion_predicate, predicate);
   specbind (Qminibuffer_completion_confirm,
            EQ (require_match, Qt) ? Qnil : require_match);
   specbind (Qminibuffer_completion_predicate, predicate);
   specbind (Qminibuffer_completion_confirm,
            EQ (require_match, Qt) ? Qnil : require_match);


@@ -1747,11 +1804,17 @@ Completion ignores case if the ambient value of
     XSETFASTINT (histpos, 0);
 
   val = read_minibuf (NILP (require_match)
     XSETFASTINT (histpos, 0);
 
   val = read_minibuf (NILP (require_match)

-                     ? Vminibuffer_local_completion_map
-                     : Vminibuffer_local_must_match_map,
+                     ? (NILP (Vminibuffer_completing_file_name)
+                        || EQ (Vminibuffer_completing_file_name, Qlambda)
+                        ? Vminibuffer_local_completion_map
+                        : Vminibuffer_local_filename_completion_map)
+                     : (NILP (Vminibuffer_completing_file_name)
+                        || EQ (Vminibuffer_completing_file_name, Qlambda)
+                        ? Vminibuffer_local_must_match_map
+                        : Vminibuffer_local_must_match_filename_map),

                      init, prompt, make_number (pos), 0,
                      histvar, histpos, def, 0,
                      init, prompt, make_number (pos), 0,
                      histvar, histpos, def, 0,

-                     !NILP (inherit_input_method), 0);
+                     !NILP (inherit_input_method));

 
   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
     val = def;
 
   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
     val = def;


@@ -1766,27 +1829,28 @@ Lisp_Object Fassoc_string ();
 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
        doc: /* Return non-nil if STRING is a valid completion.
 Takes the same arguments as `all-completions' and `try-completion'.
 DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0,
        doc: /* Return non-nil if STRING is a valid completion.
 Takes the same arguments as `all-completions' and `try-completion'.

-If ALIST is a function, it is called with three arguments:
+If COLLECTION is a function, it is called with three arguments:

 the values STRING, PREDICATE and `lambda'.  */)
 the values STRING, PREDICATE and `lambda'.  */)

-       (string, alist, predicate)
-     Lisp_Object string, alist, predicate;
+       (string, collection, predicate)
+     Lisp_Object string, collection, predicate;

 {
   Lisp_Object regexps, tail, tem = Qnil;
   int i = 0;
 
   CHECK_STRING (string);
 
 {
   Lisp_Object regexps, tail, tem = Qnil;
   int i = 0;
 
   CHECK_STRING (string);
 

-  if ((CONSP (alist) && (!SYMBOLP (XCAR (alist)) || NILP (XCAR (alist))))
-      || NILP (alist))
+  if ((CONSP (collection)
+       && (!SYMBOLP (XCAR (collection)) || NILP (XCAR (collection))))
+      || NILP (collection))

     {
     {

-      tem = Fassoc_string (string, alist, completion_ignore_case ? Qt : Qnil);
+      tem = Fassoc_string (string, collection, completion_ignore_case ? Qt : Qnil);

       if (NILP (tem))
        return Qnil;
     }
       if (NILP (tem))
        return Qnil;
     }

-  else if (VECTORP (alist))
+  else if (VECTORP (collection))

     {
       /* Bypass intern-soft as that loses for nil.  */
     {
       /* Bypass intern-soft as that loses for nil.  */

-      tem = oblookup (alist,
+      tem = oblookup (collection,

                      SDATA (string),
                      SCHARS (string),
                      SBYTES (string));
                      SDATA (string),
                      SCHARS (string),
                      SBYTES (string));


@@ -1797,7 +1861,7 @@ the values STRING, PREDICATE and `lambda'.  */)
          else
            string = Fstring_make_multibyte (string);
 
          else
            string = Fstring_make_multibyte (string);
 

-         tem = oblookup (alist,
+         tem = oblookup (collection,

                          SDATA (string),
                          SCHARS (string),
                          SBYTES (string));
                          SDATA (string),
                          SCHARS (string),
                          SBYTES (string));


@@ -1805,9 +1869,9 @@ the values STRING, PREDICATE and `lambda'.  */)
 
       if (completion_ignore_case && !SYMBOLP (tem))
        {
 
       if (completion_ignore_case && !SYMBOLP (tem))
        {

-         for (i = XVECTOR (alist)->size - 1; i >= 0; i--)
+         for (i = XVECTOR (collection)->size - 1; i >= 0; i--)

            {
            {

-             tail = XVECTOR (alist)->contents[i];
+             tail = XVECTOR (collection)->contents[i];

              if (SYMBOLP (tail))
                while (1)
                  {
              if (SYMBOLP (tail))
                while (1)
                  {


@@ -1829,9 +1893,9 @@ the values STRING, PREDICATE and `lambda'.  */)
       if (!SYMBOLP (tem))
        return Qnil;
     }
       if (!SYMBOLP (tem))
        return Qnil;
     }

-  else if (HASH_TABLE_P (alist))
+  else if (HASH_TABLE_P (collection))

     {
     {

-      struct Lisp_Hash_Table *h = XHASH_TABLE (alist);
+      struct Lisp_Hash_Table *h = XHASH_TABLE (collection);

       i = hash_lookup (h, string, NULL);
       if (i >= 0)
        tem = HASH_KEY (h, i);
       i = hash_lookup (h, string, NULL);
       if (i >= 0)
        tem = HASH_KEY (h, i);


@@ -1850,7 +1914,7 @@ the values STRING, PREDICATE and `lambda'.  */)
        return Qnil;
     }
   else
        return Qnil;
     }
   else

-    return call3 (alist, string, predicate, Qlambda);
+    return call3 (collection, string, predicate, Qlambda);

 
   /* Reject this element if it fails to match all the regexps.  */
   if (CONSP (Vcompletion_regexp_list))
 
   /* Reject this element if it fails to match all the regexps.  */
   if (CONSP (Vcompletion_regexp_list))


@@ -1871,14 +1935,32 @@ the values STRING, PREDICATE and `lambda'.  */)
   /* Finally, check the predicate.  */
   if (!NILP (predicate))
     {
   /* Finally, check the predicate.  */
   if (!NILP (predicate))
     {

-      return HASH_TABLE_P (alist)
-       ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (alist), i))
+      return HASH_TABLE_P (collection)
+       ? call2 (predicate, tem, HASH_VALUE (XHASH_TABLE (collection), i))

        : call1 (predicate, tem);
     }
   else
     return Qt;
 }
 
        : call1 (predicate, tem);
     }
   else
     return Qt;
 }
 

+DEFUN ("internal-complete-buffer", Finternal_complete_buffer, Sinternal_complete_buffer, 3, 3, 0,
+       doc: /* Perform completion on buffer names.
+If the argument FLAG is nil, invoke `try-completion', if it's t, invoke
+`all-completions', otherwise invoke `test-completion'.
+
+The arguments STRING and PREDICATE are as in `try-completion',
+`all-completions', and `test-completion'. */)
+     (string, predicate, flag)
+     Lisp_Object string, predicate, flag;
+{
+  if (NILP (flag))
+    return Ftry_completion (string, Vbuffer_alist, predicate);
+  else if (EQ (flag, Qt))
+    return Fall_completions (string, Vbuffer_alist, predicate, Qt);
+  else                         /* assume `lambda' */
+    return Ftest_completion (string, Vbuffer_alist, predicate);
+}
+

 /* returns:
  * 0 no possible completion
  * 1 was already an exact and unique completion
 /* returns:
  * 0 no possible completion
  * 1 was already an exact and unique completion


@@ -1895,7 +1977,7 @@ do_completion ()
   Lisp_Object last;
   struct gcpro gcpro1, gcpro2;
 
   Lisp_Object last;
   struct gcpro gcpro1, gcpro2;
 

-  completion = Ftry_completion (minibuffer_completion_contents (),
+  completion = Ftry_completion (Fminibuffer_completion_contents (),

                                Vminibuffer_completion_table,
                                Vminibuffer_completion_predicate);
   last = last_exact_completion;
                                Vminibuffer_completion_table,
                                Vminibuffer_completion_predicate);
   last = last_exact_completion;


@@ -1917,7 +1999,7 @@ do_completion ()
       return 1;
     }
 
       return 1;
     }
 

-  string = minibuffer_completion_contents ();
+  string = Fminibuffer_completion_contents ();

 
   /* COMPLETEDP should be true if some completion was done, which
      doesn't include simply changing the case of the entered string.
 
   /* COMPLETEDP should be true if some completion was done, which
      doesn't include simply changing the case of the entered string.


@@ -1984,7 +2066,7 @@ do_completion ()
   last_exact_completion = completion;
   if (!NILP (last))
     {
   last_exact_completion = completion;
   if (!NILP (last))
     {

-      tem = minibuffer_completion_contents ();
+      tem = Fminibuffer_completion_contents ();

       if (!NILP (Fequal (tem, last)))
        Fminibuffer_completion_help ();
     }
       if (!NILP (Fequal (tem, last)))
        Fminibuffer_completion_help ();
     }


@@ -1995,9 +2077,10 @@ do_completion ()
 /* Like assoc but assumes KEY is a string, and ignores case if appropriate.  */
 
 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,
 /* Like assoc but assumes KEY is a string, and ignores case if appropriate.  */
 
 DEFUN ("assoc-string", Fassoc_string, Sassoc_string, 2, 3, 0,

-       doc: /* Like `assoc' but specifically for strings.
-Unibyte strings are converted to multibyte for comparison.
-And case is ignored if CASE-FOLD is non-nil.
+       doc: /* Like `assoc' but specifically for strings (and symbols).
+Symbols are converted to strings, and unibyte strings are converted to
+multibyte for comparison.
+Case is ignored if optional arg CASE-FOLD is non-nil.

 As opposed to `assoc', it will also match an entry consisting of a single
 string rather than a cons cell whose car is a string.  */)
        (key, list, case_fold)
 As opposed to `assoc', it will also match an entry consisting of a single
 string rather than a cons cell whose car is a string.  */)
        (key, list, case_fold)


@@ -2006,12 +2089,17 @@ string rather than a cons cell whose car is a string.  */)
 {
   register Lisp_Object tail;
 
 {
   register Lisp_Object tail;
 

+  if (SYMBOLP (key))
+    key = Fsymbol_name (key);
+

   for (tail = list; !NILP (tail); tail = Fcdr (tail))
     {
       register Lisp_Object elt, tem, thiscar;
       elt = Fcar (tail);
       thiscar = CONSP (elt) ? XCAR (elt) : elt;
   for (tail = list; !NILP (tail); tail = Fcdr (tail))
     {
       register Lisp_Object elt, tem, thiscar;
       elt = Fcar (tail);
       thiscar = CONSP (elt) ? XCAR (elt) : elt;

-      if (!STRINGP (thiscar))
+      if (SYMBOLP (thiscar))
+       thiscar = Fsymbol_name (thiscar);
+      else if (!STRINGP (thiscar))

        continue;
       tem = Fcompare_strings (thiscar, make_number (0), Qnil,
                              key, make_number (0), Qnil,
        continue;
       tem = Fcompare_strings (thiscar, make_number (0), Qnil,
                              key, make_number (0), Qnil,


@@ -2112,16 +2200,17 @@ a repetition of this command will exit.  */)
      ()
 {
   register int i;
      ()
 {
   register int i;

-  Lisp_Object val;
+  Lisp_Object val, tem;

 
   /* Allow user to specify null string */
   if (XINT (Fminibuffer_prompt_end ()) == ZV)
     goto exit;
 
   val = Fminibuffer_contents ();
 
   /* Allow user to specify null string */
   if (XINT (Fminibuffer_prompt_end ()) == ZV)
     goto exit;
 
   val = Fminibuffer_contents ();

-  if (!NILP (Ftest_completion (val,
-                              Vminibuffer_completion_table,
-                              Vminibuffer_completion_predicate)))
+  tem = Ftest_completion (val,
+                         Vminibuffer_completion_table,
+                         Vminibuffer_completion_predicate);
+  if (!NILP (tem))

     {
       if (completion_ignore_case)
        { /* Fixup case of the field, if necessary. */
     {
       if (completion_ignore_case)
        { /* Fixup case of the field, if necessary. */


@@ -2186,7 +2275,7 @@ Return nil if there is no valid completion, else t.  */)
   /* We keep calling Fbuffer_string rather than arrange for GC to
      hold onto a pointer to one of the strings thus made.  */
 
   /* We keep calling Fbuffer_string rather than arrange for GC to
      hold onto a pointer to one of the strings thus made.  */
 

-  completion = Ftry_completion (minibuffer_completion_contents (),
+  completion = Ftry_completion (Fminibuffer_completion_contents (),

                                Vminibuffer_completion_table,
                                Vminibuffer_completion_predicate);
   if (NILP (completion))
                                Vminibuffer_completion_table,
                                Vminibuffer_completion_predicate);
   if (NILP (completion))


@@ -2218,7 +2307,7 @@ Return nil if there is no valid completion, else t.  */)
     int buffer_nchars, completion_nchars;
 
     CHECK_STRING (completion);
     int buffer_nchars, completion_nchars;
 
     CHECK_STRING (completion);

-    tem = minibuffer_completion_contents ();
+    tem = Fminibuffer_completion_contents ();

     GCPRO2 (completion, tem);
     /* If reading a file name,
        expand any $ENVVAR refs in the buffer and in TEM.  */
     GCPRO2 (completion, tem);
     /* If reading a file name,
        expand any $ENVVAR refs in the buffer and in TEM.  */


@@ -2282,7 +2371,7 @@ Return nil if there is no valid completion, else t.  */)
   if (i == SCHARS (completion))
     {
       GCPRO1 (completion);
   if (i == SCHARS (completion))
     {
       GCPRO1 (completion);

-      tem = Ftry_completion (concat2 (minibuffer_completion_contents (),
+      tem = Ftry_completion (concat2 (Fminibuffer_completion_contents (),

                                      build_string (" ")),
                             Vminibuffer_completion_table,
                             Vminibuffer_completion_predicate);
                                      build_string (" ")),
                             Vminibuffer_completion_table,
                             Vminibuffer_completion_predicate);


@@ -2294,7 +2383,7 @@ Return nil if there is no valid completion, else t.  */)
        {
          GCPRO1 (completion);
          tem =
        {
          GCPRO1 (completion);
          tem =

-           Ftry_completion (concat2 (minibuffer_completion_contents (),
+           Ftry_completion (concat2 (Fminibuffer_completion_contents (),

                                      build_string ("-")),
                             Vminibuffer_completion_table,
                             Vminibuffer_completion_predicate);
                                      build_string ("-")),
                             Vminibuffer_completion_table,
                             Vminibuffer_completion_predicate);


@@ -2361,14 +2450,14 @@ alternative, the second serves as annotation.
 The actual completion alternatives, as inserted, are given `mouse-face'
 properties of `highlight'.
 At the end, this runs the normal hook `completion-setup-hook'.
 The actual completion alternatives, as inserted, are given `mouse-face'
 properties of `highlight'.
 At the end, this runs the normal hook `completion-setup-hook'.

-It can find the completion buffer in `standard-output'.  
-The optional second arg COMMON-SUBSTRING is a string. 
-It is used to put faces, `completions-first-difference` and
+It can find the completion buffer in `standard-output'.
+The optional second arg COMMON-SUBSTRING is a string.
+It is used to put faces, `completions-first-difference' and

 `completions-common-part' on the completion buffer. The
 `completions-common-part' face is put on the common substring
 `completions-common-part' on the completion buffer. The
 `completions-common-part' face is put on the common substring

-specified by COMMON-SUBSTRING. If COMMON-SUBSTRING is nil,
-the faces are not put. 
-Internally, COMMON-SUBSTRING is bound to `completion-common-substring' 
+specified by COMMON-SUBSTRING.  If COMMON-SUBSTRING is nil
+and the current buffer is not the minibuffer, the faces are not put.
+Internally, COMMON-SUBSTRING is bound to `completion-common-substring'

 during running `completion-setup-hook'. */)
      (completions, common_substring)
      Lisp_Object completions;
 during running `completion-setup-hook'. */)
      (completions, common_substring)
      Lisp_Object completions;


@@ -2397,7 +2486,7 @@ during running `completion-setup-hook'. */)
   else
     {
       write_string ("Possible completions are:", -1);
   else
     {
       write_string ("Possible completions are:", -1);

-      for (tail = completions, i = 0; !NILP (tail); tail = Fcdr (tail), i++)
+      for (tail = completions, i = 0; CONSP (tail); tail = XCDR (tail), i++)

        {
          Lisp_Object tem, string;
          int length;
        {
          Lisp_Object tem, string;
          int length;


@@ -2405,7 +2494,7 @@ during running `completion-setup-hook'. */)
 
          startpos = Qnil;
 
 
          startpos = Qnil;
 

-         elt = Fcar (tail);
+         elt = XCAR (tail);

          if (SYMBOLP (elt))
            elt = SYMBOL_NAME (elt);
          /* Compute the length of this element.  */
          if (SYMBOLP (elt))
            elt = SYMBOL_NAME (elt);
          /* Compute the length of this element.  */


@@ -2544,7 +2633,7 @@ during running `completion-setup-hook'. */)
 
       specbind (intern ("completion-common-substring"), common_substring);
       call1 (Vrun_hooks, intern ("completion-setup-hook"));
 
       specbind (intern ("completion-common-substring"), common_substring);
       call1 (Vrun_hooks, intern ("completion-setup-hook"));

-      
+

       unbind_to (count1, Qnil);
     }
 
       unbind_to (count1, Qnil);
     }
 


@@ -2553,6 +2642,14 @@ during running `completion-setup-hook'. */)
   return Qnil;
 }
 
   return Qnil;
 }
 

+
+static Lisp_Object
+display_completion_list_1 (list)
+     Lisp_Object list;
+{
+  return Fdisplay_completion_list (list, Qnil);
+}
+

 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
        0, 0, "",
        doc: /* Display a list of possible completions of the current minibuffer contents.  */)
 DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_completion_help,
        0, 0, "",
        doc: /* Display a list of possible completions of the current minibuffer contents.  */)


@@ -2561,7 +2658,7 @@ DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_co
   Lisp_Object completions;
 
   message ("Making completion list...");
   Lisp_Object completions;
 
   message ("Making completion list...");

-  completions = Fall_completions (minibuffer_completion_contents (),
+  completions = Fall_completions (Fminibuffer_completion_contents (),

                                  Vminibuffer_completion_table,
                                  Vminibuffer_completion_predicate,
                                  Qt);
                                  Vminibuffer_completion_table,
                                  Vminibuffer_completion_predicate,
                                  Qt);


@@ -2573,9 +2670,21 @@ DEFUN ("minibuffer-completion-help", Fminibuffer_completion_help, Sminibuffer_co
       temp_echo_area_glyphs (build_string (" [No completions]"));
     }
   else
       temp_echo_area_glyphs (build_string (" [No completions]"));
     }
   else

-    internal_with_output_to_temp_buffer ("*Completions*",
-                                        Fdisplay_completion_list,
-                                        Fsort (completions, Qstring_lessp));
+    {
+      /* Sort and remove duplicates.  */
+      Lisp_Object tmp = completions = Fsort (completions, Qstring_lessp);
+      while (CONSP (tmp))
+       {
+         if (CONSP (XCDR (tmp))
+             && !NILP (Fequal (XCAR (tmp), XCAR (XCDR (tmp)))))
+           XSETCDR (tmp, XCDR (XCDR (tmp)));
+         else
+           tmp = XCDR (tmp);
+       }
+      internal_with_output_to_temp_buffer ("*Completions*",
+                                          display_completion_list_1,
+                                          completions);
+    }

   return Qnil;
 }
 \f
   return Qnil;
 }
 \f


@@ -2627,6 +2736,8 @@ If no minibuffer is active, return nil.  */)
    that has no possible completions, and other quick, unobtrusive
    messages.  */
 
    that has no possible completions, and other quick, unobtrusive
    messages.  */
 

+extern Lisp_Object Vminibuffer_message_timeout;
+

 void
 temp_echo_area_glyphs (string)
      Lisp_Object string;
 void
 temp_echo_area_glyphs (string)
      Lisp_Object string;


@@ -2645,7 +2756,12 @@ temp_echo_area_glyphs (string)
   insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0);
   SET_PT_BOTH (opoint, opoint_byte);
   Vinhibit_quit = Qt;
   insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 0);
   SET_PT_BOTH (opoint, opoint_byte);
   Vinhibit_quit = Qt;

-  Fsit_for (make_number (2), Qnil, Qnil);
+
+  if (NUMBERP (Vminibuffer_message_timeout))
+    sit_for (Vminibuffer_message_timeout, 0, 2);
+  else
+    sit_for (Qt, 0, 2);
+

   del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
   SET_PT_BOTH (opoint, opoint_byte);
   if (!NILP (Vquit_flag))
   del_range_both (osize, osize_byte, ZV, ZV_BYTE, 1);
   SET_PT_BOTH (opoint, opoint_byte);
   if (!NILP (Vquit_flag))


@@ -2659,7 +2775,7 @@ temp_echo_area_glyphs (string)
 DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message,
        1, 1, 0,
        doc: /* Temporarily display STRING at the end of the minibuffer.
 DEFUN ("minibuffer-message", Fminibuffer_message, Sminibuffer_message,
        1, 1, 0,
        doc: /* Temporarily display STRING at the end of the minibuffer.

-The text is displayed for two seconds,
+The text is displayed for a period controlled by `minibuffer-message-timeout',

 or until the next input event arrives, whichever comes first.  */)
      (string)
      Lisp_Object string;
 or until the next input event arrives, whichever comes first.  */)
      (string)
      Lisp_Object string;


@@ -2736,6 +2852,9 @@ syms_of_minibuf ()
   Qcase_fold_search = intern ("case-fold-search");
   staticpro (&Qcase_fold_search);
 
   Qcase_fold_search = intern ("case-fold-search");
   staticpro (&Qcase_fold_search);
 

+  Qread_expression_history = intern ("read-expression-history");
+  staticpro (&Qread_expression_history);
+

   DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
               doc: /* If this is non-nil, `read-buffer' does its work by calling this function.  */);
   Vread_buffer_function = Qnil;
   DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
               doc: /* If this is non-nil, `read-buffer' does its work by calling this function.  */);
   Vread_buffer_function = Qnil;


@@ -2751,18 +2870,27 @@ syms_of_minibuf ()
   DEFVAR_LISP ("history-length", &Vhistory_length,
               doc: /* *Maximum length for history lists before truncation takes place.
 A number means that length; t means infinite.  Truncation takes place
   DEFVAR_LISP ("history-length", &Vhistory_length,
               doc: /* *Maximum length for history lists before truncation takes place.
 A number means that length; t means infinite.  Truncation takes place

-just after a new element is inserted.  Setting the history-length
+just after a new element is inserted.  Setting the `history-length'

 property of a history variable overrides this default.  */);
   XSETFASTINT (Vhistory_length, 30);
 
   DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
               doc: /* *Non-nil means to delete duplicates in history.
 If set to t when adding a new history element, all previous identical
 property of a history variable overrides this default.  */);
   XSETFASTINT (Vhistory_length, 30);
 
   DEFVAR_BOOL ("history-delete-duplicates", &history_delete_duplicates,
               doc: /* *Non-nil means to delete duplicates in history.
 If set to t when adding a new history element, all previous identical

-elements are deleted.  */);
+elements are deleted from the history list.  */);

   history_delete_duplicates = 0;
 
   history_delete_duplicates = 0;
 

+  DEFVAR_LISP ("history-add-new-input", &Vhistory_add_new_input,
+              doc: /* *Non-nil means to add new elements in history.
+If set to nil, minibuffer reading functions don't add new elements to the
+history list, so it is possible to do this afterwards by calling
+`add-to-history' explicitly.  */);
+  Vhistory_add_new_input = Qt;
+

   DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
   DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,

-              doc: /* *Non-nil means automatically provide help for invalid completion input.  */);
+              doc: /* *Non-nil means automatically provide help for invalid completion input.
+Under Partial Completion mode, a non-nil, non-t value has a special meaning;
+see the doc string of `partial-completion-mode' for more details.  */);

   Vcompletion_auto_help = Qt;
 
   DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
   Vcompletion_auto_help = Qt;
 
   DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,


@@ -2786,10 +2914,10 @@ The value may alternatively be a function, which is given three arguments:
   STRING, the current buffer contents;
   PREDICATE, the predicate for filtering possible matches;
   CODE, which says what kind of things to do.
   STRING, the current buffer contents;
   PREDICATE, the predicate for filtering possible matches;
   CODE, which says what kind of things to do.

-CODE can be nil, t or `lambda'.
-nil means to return the best completion of STRING, or nil if there is none.
-t means to return a list of all possible completions of STRING.
-`lambda' means to return t if STRING is a valid completion as it stands.  */);
+CODE can be nil, t or `lambda':
+  nil    -- return the best completion of STRING, or nil if there is none.
+  t      -- return a list of all possible completions of STRING.
+  lambda -- return t if STRING is a valid completion as it stands.  */);

   Vminibuffer_completion_table = Qnil;
 
   DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,
   Vminibuffer_completion_table = Qnil;
 
   DEFVAR_LISP ("minibuffer-completion-predicate", &Vminibuffer_completion_predicate,


@@ -2802,7 +2930,7 @@ t means to return a list of all possible completions of STRING.
 
   DEFVAR_LISP ("minibuffer-completing-file-name",
               &Vminibuffer_completing_file_name,
 
   DEFVAR_LISP ("minibuffer-completing-file-name",
               &Vminibuffer_completing_file_name,

-              doc: /* Non-nil means completing file names.  */);
+              doc: /* Non-nil and non-`lambda' means completing file names.  */);

   Vminibuffer_completing_file_name = Qnil;
 
   DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,
   Vminibuffer_completing_file_name = Qnil;
 
   DEFVAR_LISP ("minibuffer-help-form", &Vminibuffer_help_form,


@@ -2852,6 +2980,10 @@ properties.  */);
   Vminibuffer_prompt_properties
     = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
 
   Vminibuffer_prompt_properties
     = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
 

+  DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
+              doc: /* Minibuffer keymap used for reading Lisp expressions.  */);
+  Vread_expression_map = Qnil;
+

   defsubr (&Sset_minibuffer_window);
   defsubr (&Sread_from_minibuffer);
   defsubr (&Seval_minibuffer);
   defsubr (&Sset_minibuffer_window);
   defsubr (&Sread_from_minibuffer);
   defsubr (&Seval_minibuffer);


@@ -2859,6 +2991,7 @@ properties.  */);
   defsubr (&Sread_string);
   defsubr (&Sread_command);
   defsubr (&Sread_variable);
   defsubr (&Sread_string);
   defsubr (&Sread_command);
   defsubr (&Sread_variable);

+  defsubr (&Sinternal_complete_buffer);

   defsubr (&Sread_buffer);
   defsubr (&Sread_no_blanks_input);
   defsubr (&Sminibuffer_depth);
   defsubr (&Sread_buffer);
   defsubr (&Sread_no_blanks_input);
   defsubr (&Sminibuffer_depth);


@@ -2868,6 +3001,7 @@ properties.  */);
   defsubr (&Sminibuffer_prompt_end);
   defsubr (&Sminibuffer_contents);
   defsubr (&Sminibuffer_contents_no_properties);
   defsubr (&Sminibuffer_prompt_end);
   defsubr (&Sminibuffer_contents);
   defsubr (&Sminibuffer_contents_no_properties);

+  defsubr (&Sminibuffer_completion_contents);

   defsubr (&Sdelete_minibuffer_contents);
 
   defsubr (&Stry_completion);
   defsubr (&Sdelete_minibuffer_contents);
 
   defsubr (&Stry_completion);


@@ -2911,10 +3045,16 @@ keys_of_minibuf ()
   initial_define_key (Vminibuffer_local_completion_map, '?',
                      "minibuffer-completion-help");
 
   initial_define_key (Vminibuffer_local_completion_map, '?',
                      "minibuffer-completion-help");
 

+  Fdefine_key (Vminibuffer_local_filename_completion_map,
+              build_string (" "), Qnil);
+

   initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
                      "minibuffer-complete-and-exit");
   initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
                      "minibuffer-complete-and-exit");
   initial_define_key (Vminibuffer_local_must_match_map, Ctl ('m'),
                      "minibuffer-complete-and-exit");
   initial_define_key (Vminibuffer_local_must_match_map, Ctl ('j'),
                      "minibuffer-complete-and-exit");

+
+  Fdefine_key (Vminibuffer_local_must_match_filename_map,
+              build_string (" "), Qnil);

 }
 
 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
 }
 
 /* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73