/* Minibuffer input and completion.
- Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998
+ Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
+#include <stdio.h>
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "charset.h"
#include "dispextern.h"
+#include "keyboard.h"
#include "frame.h"
#include "window.h"
#include "syntax.h"
-#include "keyboard.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
/* Nonzero means display completion help for invalid input. */
-int auto_help;
+Lisp_Object Vcompletion_auto_help;
/* The maximum length of a minibuffer history. */
extern Lisp_Object Qmouse_face;
+extern Lisp_Object Qfield;
\f
/* Put minibuf on currently selected frame's minibuffer.
We do this whenever the user starts a new minibuffer
void
choose_minibuf_frame ()
{
- if (selected_frame != 0
- && !EQ (minibuf_window, selected_frame->minibuffer_window))
+ if (FRAMEP (selected_frame)
+ && FRAME_LIVE_P (XFRAME (selected_frame))
+ && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
{
+ struct frame *sf = XFRAME (selected_frame);
+ Lisp_Object buffer;
+
/* I don't think that any frames may validly have a null minibuffer
window anymore. */
- if (NILP (selected_frame->minibuffer_window))
+ if (NILP (sf->minibuffer_window))
abort ();
- Fset_window_buffer (selected_frame->minibuffer_window,
- XWINDOW (minibuf_window)->buffer);
- minibuf_window = selected_frame->minibuffer_window;
+ /* 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);
+ minibuf_window = sf->minibuffer_window;
}
/* Make sure no other frame has a minibuffer as its selected window,
FOR_EACH_FRAME (tail, frame)
if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
- && !(XFRAME (frame) == selected_frame
+ && !(EQ (frame, selected_frame)
&& minibuf_level > 0))
Fset_frame_selected_window (frame, Fframe_first_window (frame));
}
return window;
}
-#include <stdio.h>
-
\f
/* Actual minibuffer invocation. */
int, Lisp_Object,
Lisp_Object, Lisp_Object,
int, int));
+static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, int));
+static Lisp_Object string_to_object P_ ((Lisp_Object, Lisp_Object));
+
+
+/* Read a Lisp object from VAL and return it. If VAL is an empty
+ string, and DEFALT is a string, read from DEFALT instead of VAL. */
+
+static Lisp_Object
+string_to_object (val, defalt)
+ Lisp_Object val, defalt;
+{
+ struct gcpro gcpro1, gcpro2;
+ Lisp_Object expr_and_pos;
+ int pos;
+
+ GCPRO2 (val, defalt);
+
+ if (STRINGP (val) && XSTRING (val)->size == 0
+ && STRINGP (defalt))
+ val = defalt;
+
+ expr_and_pos = Fread_from_string (val, Qnil, Qnil);
+ pos = XINT (Fcdr (expr_and_pos));
+ if (pos != XSTRING (val)->size)
+ {
+ /* Ignore trailing whitespace; any other trailing junk
+ is an error. */
+ int i;
+ pos = string_char_to_byte (val, pos);
+ for (i = pos; i < STRING_BYTES (XSTRING (val)); i++)
+ {
+ int c = XSTRING (val)->data[i];
+ if (c != ' ' && c != '\t' && c != '\n')
+ error ("Trailing garbage following expression");
+ }
+ }
+
+ val = Fcar (expr_and_pos);
+ RETURN_UNGCPRO (val);
+}
+
+
+/* Like read_minibuf but reading from stdin. This function is called
+ from read_minibuf to do the job if noninteractive. */
+
+static Lisp_Object
+read_minibuf_noninteractive (map, initial, prompt, backup_n, expflag,
+ histvar, histpos, defalt, allow_props,
+ inherit_input_method)
+ Lisp_Object map;
+ Lisp_Object initial;
+ Lisp_Object prompt;
+ Lisp_Object backup_n;
+ int expflag;
+ Lisp_Object histvar;
+ Lisp_Object histpos;
+ Lisp_Object defalt;
+ int allow_props;
+ int inherit_input_method;
+{
+ int size, len;
+ char *line, *s;
+ Lisp_Object val;
+
+ fprintf (stdout, "%s", XSTRING (prompt)->data);
+ fflush (stdout);
+
+ val = Qnil;
+ size = 100;
+ len = 0;
+ line = (char *) xmalloc (size * sizeof *line);
+ while ((s = fgets (line + len, size - len, stdin)) != NULL
+ && (len = strlen (line),
+ len == size - 1 && line[len - 1] != '\n'))
+ {
+ size *= 2;
+ line = (char *) xrealloc (line, size);
+ }
+
+ if (s)
+ {
+ len = strlen (line);
+
+ if (len > 0 && line[len - 1] == '\n')
+ line[--len] = '\0';
+
+ val = build_string (line);
+ xfree (line);
+ }
+ else
+ {
+ xfree (line);
+ error ("Error reading from stdin");
+ }
+
+ /* If Lisp form desired instead of string, parse it. */
+ if (expflag)
+ val = string_to_object (val, defalt);
+
+ return val;
+}
+
/* Read from the minibuffer using keymap MAP, initial contents INITIAL
(a string), putting point minus BACKUP_N bytes from the end of INITIAL,
Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
Lisp_Object enable_multibyte;
- extern Lisp_Object Qinvisible, Qintangible, Qread_only, Qfront_sticky;
+ extern Lisp_Object Qread_only, Qfront_sticky;
extern Lisp_Object Qrear_nonsticky;
specbind (Qminibuffer_default, defalt);
single_kboard_state ();
+#ifdef HAVE_X_WINDOWS
+ if (display_busy_cursor_p)
+ cancel_busy_cursor ();
+#endif
val = Qnil;
ambient_dir = current_buffer->directory;
build_string ("Command attempted to use minibuffer while in minibuffer"));
}
+ if (noninteractive)
+ return read_minibuf_noninteractive (map, initial, prompt, backup_n,
+ expflag, histvar, histpos, defalt,
+ allow_props, inherit_input_method);
+
/* Choose the minibuffer window and frame, and take action on them. */
choose_minibuf_frame ();
/* If the minibuffer window is on a different frame, save that
frame's configuration too. */
mini_frame = WINDOW_FRAME (XWINDOW (minibuf_window));
- if (XFRAME (mini_frame) != selected_frame)
+ if (!EQ (mini_frame, selected_frame))
record_unwind_protect (Fset_window_configuration,
Fcurrent_window_configuration (mini_frame));
Fcons (Vminibuffer_history_position,
Fcons (Vminibuffer_history_variable,
minibuf_save_list))))));
- minibuf_save_list
- = Fcons (current_buffer->prompt_end_charpos,
- minibuf_save_list);
record_unwind_protect (read_minibuf_unwind, Qnil);
minibuf_level++;
for (buf_list = Vbuffer_alist;
CONSP (buf_list);
- buf_list = XCONS (buf_list)->cdr)
+ buf_list = XCDR (buf_list))
{
Lisp_Object other_buf;
- other_buf = XCONS (XCONS (buf_list)->car)->cdr;
+ other_buf = XCDR (XCAR (buf_list));
if (STRINGP (XBUFFER (other_buf)->directory))
{
current_buffer->directory = XBUFFER (other_buf)->directory;
}
}
- if (XFRAME (mini_frame) != selected_frame)
- Fredirect_frame_focus (Fselected_frame (), mini_frame);
+ if (!EQ (mini_frame, selected_frame))
+ Fredirect_frame_focus (selected_frame, mini_frame);
Vminibuf_scroll_window = selected_window;
Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
Fmake_local_variable (Qprint_escape_newlines);
print_escape_newlines = 1;
- XSETFASTINT (current_buffer->prompt_end_charpos, 0);
/* Erase the buffer. */
{
/* Insert the prompt, record where it ends. */
Finsert (1, &minibuf_prompt);
- XSETFASTINT (current_buffer->prompt_end_charpos, PT);
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);
Fput_text_property (make_number (BEG), make_number (PT),
Qread_only, Qt, Qnil);
}
&& !NILP (Vrun_hooks))
call1 (Vrun_hooks, Qminibuffer_setup_hook);
+ /* Don't allow the user to undo past this point. */
+ current_buffer->undo_list = Qnil;
+
recursive_edit_1 ();
/* If cursor is on the minibuffer line,
XWINDOW (minibuf_window)->cursor.hpos = 0;
XWINDOW (minibuf_window)->cursor.x = 0;
XWINDOW (minibuf_window)->must_be_updated_p = 1;
- update_frame (selected_frame, 1, 1);
+ update_frame (XFRAME (selected_frame), 1, 1);
if (rif && rif->flush_display)
rif->flush_display (XFRAME (XWINDOW (minibuf_window)->frame));
}
/* Make minibuffer contents into a string. */
Fset_buffer (minibuffer);
- val = make_buffer_string (current_buffer->prompt_end_charpos,
- Z, allow_props);
+ if (allow_props)
+ val = Ffield_string (make_number (ZV));
+ else
+ val = Ffield_string_no_properties (make_number (ZV));
/* VAL is the string of minibuffer text. */
/* If Lisp form desired instead of string, parse it. */
if (expflag)
- {
- Lisp_Object expr_and_pos;
- unsigned char *p;
- int pos;
-
- if (STRINGP (val) && XSTRING (val)->size == 0
- && STRINGP (defalt))
- val = defalt;
-
- expr_and_pos = Fread_from_string (val, Qnil, Qnil);
- pos = XINT (Fcdr (expr_and_pos));
- if (pos != XSTRING (val)->size)
- {
- /* Ignore trailing whitespace; any other trailing junk is an error. */
- int i;
- pos = string_char_to_byte (val, pos);
- for (i = pos; i < STRING_BYTES (XSTRING (val)); i++)
- {
- int c = XSTRING (val)->data[i];
- if (c != ' ' && c != '\t' && c != '\n')
- error ("Trailing garbage following expression");
- }
- }
- val = Fcar (expr_and_pos);
- }
+ val = string_to_object (val, defalt);
/* The appropriate frame will get selected
in set-window-configuration. */
enabled in it. */
Fbuffer_enable_undo (buf);
- XCONS (tail)->car = buf;
+ XCAR (tail) = buf;
}
else
{
Fset_buffer (XWINDOW (window)->buffer);
/* Restore prompt, etc, from outer minibuffer level. */
- current_buffer->prompt_end_charpos = Fcar (minibuf_save_list);
- minibuf_save_list = Fcdr (minibuf_save_list);
-
minibuf_prompt = Fcar (minibuf_save_list);
minibuf_save_list = Fcdr (minibuf_save_list);
minibuf_prompt_width = XFASTINT (Fcar (minibuf_save_list));
if (NILP (keymap))
keymap = Vminibuffer_local_map;
else
- keymap = get_keymap (keymap);
+ keymap = get_keymap (keymap, 1, 0);
if (SYMBOLP (hist))
{
(prompt, def, require_match)
Lisp_Object prompt, def, require_match;
{
- Lisp_Object tem;
Lisp_Object args[4];
if (BUFFERP (def))
All that match are compared together; the longest initial sequence\n\
common to all matches is returned as a string.\n\
If there is no match at all, nil is returned.\n\
-For an exact match, t is returned.\n\
+For a unique match which is exact, t is returned.\n\
\n\
ALIST can be an obarray instead of an alist.\n\
Then the print names of all symbols in the obarray are the possible matches.\n\
it is used to test each possible match.\n\
The match is a candidate only if PREDICATE returns non-nil.\n\
The argument given to PREDICATE is the alist element\n\
-or the symbol from the obarray.")
+or the symbol from the obarray.\n\
+Additionally to this predicate, `completion-regexp-list'\n\
+is used to further constrain the set of candidates.")
(string, alist, predicate)
Lisp_Object string, alist, predicate;
{
Lisp_Object bestmatch, tail, elt, eltstring;
/* Size in bytes of BESTMATCH. */
- int bestmatchsize;
+ int bestmatchsize = 0;
/* These are in bytes, too. */
int compare, matchsize;
int list = CONSP (alist) || NILP (alist);
- int index, obsize;
+ int index = 0, obsize = 0;
int matchcount = 0;
Lisp_Object bucket, zero, end, tem;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
if (!list && !VECTORP (alist))
return call3 (alist, string, predicate, Qnil);
- bestmatch = Qnil;
+ bestmatch = bucket = Qnil;
/* If ALIST is not a list, set TAIL just for gc pro. */
tail = alist;
/* Ignore this element if it fails to match all the regexps. */
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
- regexps = XCONS (regexps)->cdr)
+ regexps = XCDR (regexps))
{
- tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
+ tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
int len;
{
register int l = len;
- register unsigned char *start = s1;
if (completion_ignore_case)
{
\n\
ALIST can also be a function to do the completion itself.\n\
It receives three arguments: the values STRING, PREDICATE and t.\n\
-Whatever it returns becomes the value of `all-completion'.\n\
+Whatever it returns becomes the value of `all-completions'.\n\
\n\
If optional third argument PREDICATE is non-nil,\n\
it is used to test each possible match.\n\
The match is a candidate only if PREDICATE returns non-nil.\n\
The argument given to PREDICATE is the alist element\n\
or the symbol from the obarray.\n\
+Additionally to this predicate, `completion-regexp-list'\n\
+is used to further constrain the set of candidates.\n\
\n\
If the optional fourth argument HIDE-SPACES is non-nil,\n\
strings in ALIST that start with a space\n\
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
int list = CONSP (alist) || NILP (alist);
- int index, obsize;
+ int index = 0, obsize = 0;
Lisp_Object bucket, tem;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
{
return call3 (alist, string, predicate, Qt);
}
- allmatches = Qnil;
+ allmatches = bucket = Qnil;
/* If ALIST is not a list, set TAIL just for gc pro. */
tail = alist;
/* Ignore this element if it fails to match all the regexps. */
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
- regexps = XCONS (regexps)->cdr)
+ regexps = XCDR (regexps))
{
- tem = Fstring_match (XCONS (regexps)->car, eltstring, zero);
+ tem = Fstring_match (XCAR (regexps), eltstring, zero);
if (NILP (tem))
break;
}
"Read a string in the minibuffer, with completion.\n\
PROMPT is a string to prompt with; normally it ends in a colon and a space.\n\
TABLE is an alist whose elements' cars are strings, or an obarray.\n\
+TABLE can also be a function to do the completion itself.\n\
PREDICATE limits completion to a subset of TABLE.\n\
See `try-completion' and `all-completions' for more details\n\
on completion, TABLE, and PREDICATE.\n\
*/
DEFUN ("completing-read", Fcompleting_read, Scompleting_read, 2, 8, 0,
0 /* See immediately above */)
- (prompt, table, predicate, require_match, init, hist, def, inherit_input_method)
- Lisp_Object prompt, table, predicate, require_match, init, hist, def;
- Lisp_Object inherit_input_method;
+ (prompt, table, predicate, require_match, initial_input, hist, def, inherit_input_method)
+ Lisp_Object prompt, table, predicate, require_match, initial_input;
+ Lisp_Object hist, def, inherit_input_method;
{
Lisp_Object val, histvar, histpos, position;
+ Lisp_Object init;
int pos = 0;
int count = specpdl_ptr - specpdl;
struct gcpro gcpro1;
- int disable_multibyte = ! NILP (Vminibuffer_completing_file_name);
+ init = initial_input;
GCPRO1 (def);
specbind (Qminibuffer_completion_table, table);
int
do_completion ()
{
- Lisp_Object completion, tem;
+ Lisp_Object completion, string, tem;
int completedp;
Lisp_Object last;
struct gcpro gcpro1, gcpro2;
- completion = Ftry_completion (Fbuffer_string (), Vminibuffer_completion_table,
+ completion = Ftry_completion (Ffield_string (make_number (ZV)),
+ Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
last = last_exact_completion;
last_exact_completion = Qnil;
return 1;
}
- /* compiler bug */
- tem = Fstring_equal (completion, Fbuffer_string());
- if (completedp = NILP (tem))
+ string = Ffield_string (make_number (ZV));
+
+ /* COMPLETEDP should be true if some completion was done, which
+ doesn't include simply changing the case of the entered string.
+ However, for appearance, the string is rewritten if the case
+ changes. */
+ tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qt);
+ completedp = !EQ (tem, Qt);
+
+ tem = Fcompare_strings (completion, Qnil, Qnil, string, Qnil, Qnil, Qnil);
+ if (!EQ (tem, Qt))
+ /* Rewrite the user's input. */
{
- Ferase_buffer (); /* Some completion happened */
+ Fdelete_field (make_number (ZV)); /* Some completion happened */
Finsert (1, &completion);
+
+ if (! completedp)
+ /* The case of the string changed, but that's all. We're not
+ sure whether this is a unique completion or not, so try again
+ using the real case (this shouldn't recurse again, because
+ the next time try-completion will return either `t' or the
+ exact string). */
+ {
+ UNGCPRO;
+ return do_completion ();
+ }
}
/* It did find a match. Do we match some possibility exactly now? */
- tem = test_completion (Fbuffer_string ());
+ tem = test_completion (Ffield_string (make_number (ZV)));
if (NILP (tem))
{
/* not an exact match */
UNGCPRO;
if (completedp)
return 5;
- else if (auto_help)
+ else if (!NILP (Vcompletion_auto_help))
Fminibuffer_completion_help ();
else
temp_echo_area_glyphs (" [Next char not unique]");
last_exact_completion = completion;
if (!NILP (last))
{
- tem = Fbuffer_string ();
+ tem = Ffield_string (make_number (ZV));
if (!NILP (Fequal (tem, last)))
Fminibuffer_completion_help ();
}
struct buffer *obuf = current_buffer;
Fset_buffer (XWINDOW (window)->buffer);
- tem = Fpos_visible_in_window_p (make_number (ZV), window);
+ tem = Fpos_visible_in_window_p (make_number (ZV), window, Qnil);
if (! NILP (tem))
/* If end is in view, scroll up to the beginning. */
Fset_window_start (window, make_number (BEGV), Qnil);
return Qnil;
case 1:
+ if (PT != ZV)
+ Fgoto_char (make_number (ZV));
temp_echo_area_glyphs (" [Sole completion]");
break;
case 3:
+ if (PT != ZV)
+ Fgoto_char (make_number (ZV));
temp_echo_area_glyphs (" [Complete, but not unique]");
break;
}
Lisp_Object val;
/* Allow user to specify null string */
- if (XFASTINT (current_buffer->prompt_end_charpos) == ZV)
+ if (XINT (Ffield_beginning (make_number (ZV), Qnil)) == ZV)
goto exit;
- if (!NILP (test_completion (Fbuffer_string ())))
+ if (!NILP (test_completion (Ffield_string (make_number (ZV)))))
goto exit;
/* Call do_completion, but ignore errors. */
return Qnil;
}
exit:
- Fthrow (Qexit, Qnil);
+ return Fthrow (Qexit, Qnil);
/* NOTREACHED */
}
register int i, i_byte;
register unsigned char *completion_string;
struct gcpro gcpro1, gcpro2;
+ int prompt_end_charpos;
/* 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 (Fbuffer_string (),
+ completion = Ftry_completion (Ffield_string (make_number (ZV)),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
if (NILP (completion))
return Qnil;
#if 0 /* How the below code used to look, for reference. */
- tem = Fbuffer_string ();
+ tem = Ffield_string (make_number (ZV));
b = XSTRING (tem)->data;
i = ZV - 1 - XSTRING (completion)->size;
p = XSTRING (completion)->data;
int buffer_nchars, completion_nchars;
CHECK_STRING (completion, 0);
- tem = Fbuffer_string ();
+ tem = Ffield_string (make_number (ZV));
GCPRO2 (completion, tem);
/* If reading a file name,
expand any $ENVVAR refs in the buffer and in TEM. */
if (! EQ (substituted, tem))
{
tem = substituted;
- Ferase_buffer ();
+ Fdelete_field (make_number (ZV));
insert_from_string (tem, 0, 0, XSTRING (tem)->size,
STRING_BYTES (XSTRING (tem)), 0);
}
}
#endif /* Rewritten code */
+ prompt_end_charpos = XINT (Ffield_beginning (make_number (ZV), Qnil));
+
{
- int prompt_end_charpos, prompt_end_bytepos;
- prompt_end_charpos = XFASTINT (current_buffer->prompt_end_charpos);
+ int prompt_end_bytepos;
prompt_end_bytepos = CHAR_TO_BYTE (prompt_end_charpos);
i = ZV - prompt_end_charpos;
i_byte = ZV_BYTE - prompt_end_bytepos;
if (i == XSTRING (completion)->size)
{
GCPRO1 (completion);
- tem = Ftry_completion (concat2 (Fbuffer_string (), build_string (" ")),
+ tem = Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string (" ")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
{
GCPRO1 (completion);
tem =
- Ftry_completion (concat2 (Fbuffer_string (), build_string ("-")),
+ Ftry_completion (concat2 (Ffield_string (make_number (ZV)), build_string ("-")),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate);
UNGCPRO;
i gets index in string of where to stop completing. */
{
int len, c;
-
+ int bytes = STRING_BYTES (XSTRING (completion));
completion_string = XSTRING (completion)->data;
for (; i_byte < STRING_BYTES (XSTRING (completion)); i_byte += len, i++)
{
c = STRING_CHAR_AND_LENGTH (completion_string + i_byte,
- XSTRING (completion)->size - i_byte,
+ bytes - i_byte,
len);
if (SYNTAX (c) != Sword)
{
/* If got no characters, print help for user. */
- if (i == ZV - XFASTINT (current_buffer->prompt_end_charpos))
+ if (i == ZV - prompt_end_charpos)
{
- if (auto_help)
+ if (!NILP (Vcompletion_auto_help))
Fminibuffer_completion_help ();
return Qnil;
}
/* Otherwise insert in minibuffer the chars we got */
- Ferase_buffer ();
+ Fdelete_field (make_number (ZV));
insert_from_string (completion, 0, 0, i, i_byte, 1);
return Qt;
}
int length;
Lisp_Object startpos, endpos;
+ startpos = Qnil;
+
elt = Fcar (tail);
/* Compute the length of this element. */
if (CONSP (elt))
don't put another on the same line. */
if (column > 33 || first
/* If this is really wide, don't put it second on a line. */
- || column > 0 && length > 45)
+ || (column > 0 && length > 45))
{
Fterpri (Qnil);
column = 0;
Lisp_Object completions;
message ("Making completion list...");
- completions = Fall_completions (Fbuffer_string (),
+ completions = Fall_completions (Ffield_string (make_number (ZV)),
Vminibuffer_completion_table,
Vminibuffer_completion_predicate,
Qt);
else
bitch_at_user ();
- Fthrow (Qexit, Qnil);
+ return Fthrow (Qexit, Qnil);
}
DEFUN ("exit-minibuffer", Fexit_minibuffer, Sexit_minibuffer, 0, 0, "",
"Terminate this minibuffer argument.")
()
{
- Fthrow (Qexit, Qnil);
+ return Fthrow (Qexit, Qnil);
}
DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
return Fcopy_sequence (minibuf_prompt);
}
-DEFUN ("minibuffer-prompt-width", Fminibuffer_prompt_width,
- Sminibuffer_prompt_width, 0, 0, 0,
- "Return the display width of the minibuffer prompt.")
- ()
-{
- return make_number (minibuf_prompt_width);
-}
-
-
-DEFUN ("minibuffer-prompt-end", Fminibuffer_prompt_end,
- Sminibuffer_prompt_end, 0, 0, 0,
- "Return the end buffer position of the mini-buffer prompt.\n\
-Value is 0 if current buffer is not a mini-buffer.")
- ()
-{
- return (NILP (current_buffer->prompt_end_charpos)
- ? make_number (0)
- : make_number (current_buffer->prompt_end_charpos));
-}
-
-
\f
/* Temporarily display the string M at the end of the current
minibuffer contents. This is used to display things like
property of a history variable overrides this default.");
XSETFASTINT (Vhistory_length, 30);
- DEFVAR_BOOL ("completion-auto-help", &auto_help,
+ DEFVAR_LISP ("completion-auto-help", &Vcompletion_auto_help,
"*Non-nil means automatically provide help for invalid completion input.");
- auto_help = 1;
+ Vcompletion_auto_help = Qt;
DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
"Non-nil means don't consider case significant in completion.");
defsubr (&Sread_no_blanks_input);
defsubr (&Sminibuffer_depth);
defsubr (&Sminibuffer_prompt);
- defsubr (&Sminibuffer_prompt_width);
- defsubr (&Sminibuffer_prompt_end);
defsubr (&Stry_completion);
defsubr (&Sall_completions);
HCoop / bpt / emacs.git / blobdiff