X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/efc00ab16e2890b75d7224434ac43fe944ade4dd..cb5b02667a8dcfc00d990103b2fb3236259bd627:/src/minibuf.c diff --git a/src/minibuf.c b/src/minibuf.c index e9bc36303f..6f9c61dcfb 100644 --- a/src/minibuf.c +++ b/src/minibuf.c @@ -21,10 +21,10 @@ along with GNU Emacs. If not, see . */ #include #include #include -#include #include "lisp.h" #include "commands.h" +#include "character.h" #include "buffer.h" #include "dispextern.h" #include "keyboard.h" @@ -109,14 +109,16 @@ choose_minibuf_frame (void) /* I don't think that any frames may validly have a null minibuffer window anymore. */ if (NILP (sf->minibuffer_window)) - abort (); + emacs_abort (); /* Under X, we come here with minibuf_window being the minibuffer window of the unused termcap window created in init_window_once. That window doesn't have a buffer. */ buffer = XWINDOW (minibuf_window)->buffer; if (BUFFERP (buffer)) - Fset_window_buffer (sf->minibuffer_window, buffer, Qnil); + /* Use set_window_buffer instead of Fset_window_buffer (see + discussion of bug#11984, bug#12025, bug#12026). */ + set_window_buffer (sf->minibuffer_window, buffer, 0, 0); minibuf_window = sf->minibuffer_window; } @@ -247,7 +249,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial, val = Qnil; size = 100; len = 0; - line = (char *) xmalloc (size); + line = xmalloc (size); while ((c = getchar ()) != '\n') { @@ -263,7 +265,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial, if (STRING_BYTES_BOUND / 2 < size) memory_full (SIZE_MAX); size *= 2; - line = (char *) xrealloc (line, size); + line = xrealloc (line, size); } line[len++] = c; } @@ -405,6 +407,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, Lisp_Object dummy, frame; specbind (Qminibuffer_default, defalt); + specbind (intern ("inhibit-read-only"), Qnil); /* If Vminibuffer_completing_file_name is `lambda' on entry, it was t in previous recursive minibuffer, but was not set explicitly @@ -423,8 +426,8 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, { if (CONSP (initial)) { - Lisp_Object backup_n = Fcdr (initial); - initial = Fcar (initial); + Lisp_Object backup_n = XCDR (initial); + initial = XCAR (initial); CHECK_STRING (initial); if (!NILP (backup_n)) { @@ -561,11 +564,11 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, /* Defeat (setq-default truncate-lines t), since truncated lines do not work correctly in minibuffers. (Bug#5715, etc) */ - BVAR (current_buffer, truncate_lines) = Qnil; + bset_truncate_lines (current_buffer, Qnil); /* If appropriate, copy enable-multibyte-characters into the minibuffer. */ if (inherit_input_method) - BVAR (current_buffer, enable_multibyte_characters) = enable_multibyte; + bset_enable_multibyte_characters (current_buffer, 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 @@ -576,7 +579,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, you think of something better to do? Find another buffer with a better directory, and use that one instead. */ if (STRINGP (ambient_dir)) - BVAR (current_buffer, directory) = ambient_dir; + bset_directory (current_buffer, ambient_dir); else { Lisp_Object buf_list; @@ -590,7 +593,8 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, other_buf = XCDR (XCAR (buf_list)); if (STRINGP (BVAR (XBUFFER (other_buf), directory))) { - BVAR (current_buffer, directory) = BVAR (XBUFFER (other_buf), directory); + bset_directory (current_buffer, + BVAR (XBUFFER (other_buf), directory)); break; } } @@ -615,13 +619,17 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, if (! NILP (mini_window) && ! EQ (mini_window, minibuf_window) && !NILP (Fwindow_minibuffer_p (mini_window))) - Fset_window_buffer (mini_window, empty_minibuf, Qnil); + /* Use set_window_buffer instead of Fset_window_buffer (see + discussion of bug#11984, bug#12025, bug#12026). */ + set_window_buffer (mini_window, empty_minibuf, 0, 0); } /* Display this minibuffer in the proper window. */ - Fset_window_buffer (minibuf_window, Fcurrent_buffer (), Qnil); + /* Use set_window_buffer instead of Fset_window_buffer (see + discussion of bug#11984, bug#12025, bug#12026). */ + set_window_buffer (minibuf_window, Fcurrent_buffer (), 0, 0); Fselect_window (minibuf_window, Qnil); - XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0); + XWINDOW (minibuf_window)->hscroll = 0; Fmake_local_variable (Qprint_escape_newlines); print_escape_newlines = 1; @@ -663,7 +671,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, } clear_message (1, 1); - BVAR (current_buffer, keymap) = map; + bset_keymap (current_buffer, map); /* Turn on an input method stored in INPUT_METHOD if any. */ if (STRINGP (input_method) && !NILP (Ffboundp (Qactivate_input_method))) @@ -672,7 +680,7 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt, Frun_hooks (1, &Qminibuffer_setup_hook); /* Don't allow the user to undo past this point. */ - BVAR (current_buffer, undo_list) = Qnil; + bset_undo_list (current_buffer, Qnil); recursive_edit_1 (); @@ -789,10 +797,10 @@ get_minibuffer (EMACS_INT depth) Vminibuffer_list = nconc2 (Vminibuffer_list, tail); } buf = Fcar (tail); - if (NILP (buf) || NILP (BVAR (XBUFFER (buf), name))) + if (NILP (buf) || !BUFFER_LIVE_P (XBUFFER (buf))) { - sprintf (name, " *Minibuf-%"pI"d*", depth); - buf = Fget_buffer_create (build_string (name)); + buf = Fget_buffer_create + (make_formatted_string (name, " *Minibuf-%"pI"d*", depth)); /* Although the buffer's name starts with a space, undo should be enabled in it. */ @@ -803,13 +811,12 @@ get_minibuffer (EMACS_INT depth) else { ptrdiff_t count = SPECPDL_INDEX (); - /* `reset_buffer' blindly sets the list of overlays to NULL, so we - have to empty the list, otherwise we end up with overlays that - think they belong to this buffer while the buffer doesn't know about - them any more. */ + /* We have to empty both overlay lists. Otherwise we end + up with overlays that think they belong to this buffer + while the buffer doesn't know about them any more. */ delete_all_overlays (XBUFFER (buf)); reset_buffer (XBUFFER (buf)); - record_unwind_protect (Fset_buffer, Fcurrent_buffer ()); + record_unwind_current_buffer (); Fset_buffer (buf); if (!NILP (Ffboundp (intern ("minibuffer-inactive-mode")))) call0 (intern ("minibuffer-inactive-mode")); @@ -887,8 +894,8 @@ read_minibuf_unwind (Lisp_Object data) /* Make sure minibuffer window is erased, not ignored. */ windows_or_buffers_changed++; - XSETFASTINT (XWINDOW (window)->last_modified, 0); - XSETFASTINT (XWINDOW (window)->last_overlay_modified, 0); + XWINDOW (window)->last_modified = 0; + XWINDOW (window)->last_overlay_modified = 0; /* In case the previous minibuffer displayed in this miniwindow is dead, we may keep displaying this buffer (tho it's inactive), so reset it, @@ -1034,12 +1041,20 @@ Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits (Lisp_Object prompt, Lisp_Object initial_input, Lisp_Object history, Lisp_Object default_value, Lisp_Object inherit_input_method) { Lisp_Object val; + ptrdiff_t count = SPECPDL_INDEX (); + + /* Just in case we're in a recursive minibuffer, make it clear that the + previous minibuffer's completion table does not apply to the new + minibuffer. + FIXME: `minibuffer-completion-table' should be buffer-local instead. */ + specbind (Qminibuffer_completion_table, Qnil); + val = Fread_from_minibuffer (prompt, initial_input, Qnil, Qnil, history, default_value, inherit_input_method); if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value)) val = CONSP (default_value) ? XCAR (default_value) : default_value; - return val; + return unbind_to (count, val); } DEFUN ("read-no-blanks-input", Fread_no_blanks_input, Sread_no_blanks_input, 1, 3, 0, @@ -1265,7 +1280,7 @@ is used to further constrain the set of candidates. */) { collection = check_obarray (collection); obsize = ASIZE (collection); - bucket = XVECTOR (collection)->contents[idx]; + bucket = AREF (collection, idx); } while (1) @@ -1300,7 +1315,7 @@ is used to further constrain the set of candidates. */) break; else { - bucket = XVECTOR (collection)->contents[idx]; + bucket = AREF (collection, idx); continue; } } @@ -1528,7 +1543,7 @@ with a space are ignored unless STRING itself starts with a space. */) { collection = check_obarray (collection); obsize = ASIZE (collection); - bucket = XVECTOR (collection)->contents[idx]; + bucket = AREF (collection, idx); } while (1) @@ -1563,7 +1578,7 @@ with a space are ignored unless STRING itself starts with a space. */) break; else { - bucket = XVECTOR (collection)->contents[idx]; + bucket = AREF (collection, idx); continue; } } @@ -1726,8 +1741,6 @@ See also `completing-read-function'. */) return Ffuncall (9, args); } -Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold); - /* Test whether TXT is an exact completion. */ DEFUN ("test-completion", Ftest_completion, Stest_completion, 2, 3, 0, doc: /* Return non-nil if STRING is a valid completion. @@ -1773,7 +1786,7 @@ the values STRING, PREDICATE and `lambda'. */) { for (i = ASIZE (collection) - 1; i >= 0; i--) { - tail = XVECTOR (collection)->contents[i]; + tail = AREF (collection, i); if (SYMBOLP (tail)) while (1) { @@ -1846,15 +1859,14 @@ the values STRING, PREDICATE and `lambda'. */) } static Lisp_Object Qmetadata; -extern Lisp_Object Qbuffer; 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'. +STRING and PREDICATE have the same meanings as in `try-completion', +`all-completions', and `test-completion'. -The arguments STRING and PREDICATE are as in `try-completion', -`all-completions', and `test-completion'. */) +If FLAG is nil, invoke `try-completion'; if it is t, invoke +`all-completions'; otherwise invoke `test-completion'. */) (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag) { if (NILP (flag))