#include "lisp.h"
#include "commands.h"
+#include "character.h"
#include "buffer.h"
#include "dispextern.h"
#include "keyboard.h"
static Lisp_Object Qminibuffer_completion_table;
static Lisp_Object Qminibuffer_completion_predicate;
static Lisp_Object Qminibuffer_completion_confirm;
-static Lisp_Object Quser_variable_p;
+static Lisp_Object Qcustom_variable_p;
static Lisp_Object Qminibuffer_default;
/* Width of current mini-buffer prompt. Only set after display_line
of the line that contains the prompt. */
-static EMACS_INT minibuf_prompt_width;
+static ptrdiff_t minibuf_prompt_width;
\f
/* Put minibuf on currently selected frame's minibuffer.
{
if (FRAMEP (selected_frame)
&& FRAME_LIVE_P (XFRAME (selected_frame))
- && !EQ (minibuf_window, XFRAME (selected_frame)->minibuffer_window))
+ && !EQ (minibuf_window, FVAR (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 (sf->minibuffer_window))
+ if (NILP (FVAR (sf, minibuffer_window)))
abort ();
/* Under X, we come here with minibuf_window being the
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);
- minibuf_window = sf->minibuffer_window;
+ Fset_window_buffer (FVAR (sf, minibuffer_window), buffer, Qnil);
+ minibuf_window = FVAR (sf, minibuffer_window);
}
/* Make sure no other frame has a minibuffer as its selected window,
static Lisp_Object read_minibuf_unwind (Lisp_Object);
static Lisp_Object run_exit_minibuf_hook (Lisp_Object);
static Lisp_Object read_minibuf (Lisp_Object, Lisp_Object,
- Lisp_Object, Lisp_Object,
+ Lisp_Object,
int, Lisp_Object,
Lisp_Object, Lisp_Object,
int, int);
{
struct gcpro gcpro1, gcpro2;
Lisp_Object expr_and_pos;
- EMACS_INT pos;
+ ptrdiff_t pos;
GCPRO2 (val, defalt);
{
/* Ignore trailing whitespace; any other trailing junk
is an error. */
- EMACS_INT i;
+ ptrdiff_t i;
pos = string_char_to_byte (val, pos);
for (i = pos; i < SBYTES (val); i++)
{
val = Qnil;
size = 100;
len = 0;
- line = (char *) xmalloc (size);
+ line = xmalloc (size);
while ((c = getchar ()) != '\n')
{
If the current buffer is not a minibuffer, return its entire contents. */)
(void)
{
- EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
+ ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 1);
}
If the current buffer is not a minibuffer, return its entire contents. */)
(void)
{
- EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
+ ptrdiff_t prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 0);
}
If the current buffer is not a minibuffer, return its entire contents. */)
(void)
{
- EMACS_INT prompt_end = XINT (Fminibuffer_prompt_end ());
+ ptrdiff_t 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);
static Lisp_Object
read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
- Lisp_Object backup_n, int expflag,
+ int expflag,
Lisp_Object histvar, Lisp_Object histpos, Lisp_Object defalt,
int allow_props, int inherit_input_method)
{
Lisp_Object val;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
Lisp_Object mini_frame, ambient_dir, minibuffer, input_method;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
Lisp_Object enable_multibyte;
- int pos = INTEGERP (backup_n) ? XINT (backup_n) : 0;
+ EMACS_INT pos = 0;
/* String to add to the history. */
Lisp_Object histstring;
{
if (CONSP (initial))
{
- backup_n = Fcdr (initial);
- initial = Fcar (initial);
+ Lisp_Object backup_n = XCDR (initial);
+ initial = XCAR (initial);
CHECK_STRING (initial);
if (!NILP (backup_n))
{
/* 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);
+ XWINDOW (minibuf_window)->hscroll = 0;
Fmake_local_variable (Qprint_escape_newlines);
print_escape_newlines = 1;
/* Erase the buffer. */
{
- int count1 = SPECPDL_INDEX ();
+ ptrdiff_t count1 = SPECPDL_INDEX ();
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
Ferase_buffer ();
buf = Fcar (tail);
if (NILP (buf) || NILP (BVAR (XBUFFER (buf), name)))
{
- 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. */
}
else
{
- int 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. */
+ ptrdiff_t count = SPECPDL_INDEX ();
+ /* 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 ());
/* Erase the minibuffer we were using at this level. */
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
/* Prevent error in erase-buffer. */
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
/* 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,
GCPRO1 (default_value);
val = read_minibuf (keymap, initial_contents, prompt,
- Qnil, !NILP (read),
+ !NILP (read),
histvar, histpos, default_value,
minibuffer_allow_text_properties,
!NILP (inherit_input_method));
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_map, initial_contents,
- prompt, Qnil, 1, Qminibuffer_history,
+ prompt, 1, Qminibuffer_history,
make_number (0), Qnil, 0, 0);
}
(Lisp_Object prompt, Lisp_Object initial_contents)
{
return Feval (read_minibuf (Vread_expression_map, initial_contents,
- prompt, Qnil, 1, Qread_expression_history,
+ prompt, 1, Qread_expression_history,
make_number (0), Qnil, 0, 0),
Qnil);
}
(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,
(Lisp_Object prompt, Lisp_Object initial, Lisp_Object inherit_input_method)
{
CHECK_STRING (prompt);
- return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
+ return read_minibuf (Vminibuffer_local_ns_map, initial, prompt,
0, Qminibuffer_history, make_number (0), Qnil, 0,
!NILP (inherit_input_method));
}
#endif /* NOTDEF */
DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
- doc: /* Read the name of a user variable and return it as a symbol.
+ doc: /* Read the name of a user option and return it as a symbol.
Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
if it is a list.
-A user variable is one for which `user-variable-p' returns non-nil. */)
+A user option, or customizable variable, is one for which
+`custom-variable-p' returns non-nil. */)
(Lisp_Object prompt, Lisp_Object default_value)
{
Lisp_Object name, default_string;
default_string = default_value;
name = Fcompleting_read (prompt, Vobarray,
- Quser_variable_p, Qt,
+ Qcustom_variable_p, Qt,
Qnil, Qnil, default_string, Qnil);
if (NILP (name))
return name;
Lisp_Object args[4], result;
char *s;
ptrdiff_t len;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
if (BUFFERP (def))
def = BVAR (XBUFFER (def), name);
{
Lisp_Object bestmatch, tail, elt, eltstring;
/* Size in bytes of BESTMATCH. */
- int bestmatchsize = 0;
+ ptrdiff_t bestmatchsize = 0;
/* These are in bytes, too. */
- int compare, matchsize;
+ ptrdiff_t compare, matchsize;
enum { function_table, list_table, obarray_table, hash_table}
type = (HASH_TABLE_P (collection) ? hash_table
: VECTORP (collection) ? obarray_table
&& (!SYMBOLP (XCAR (collection))
|| NILP (XCAR (collection)))))
? list_table : function_table));
- EMACS_INT idx = 0, obsize = 0;
+ ptrdiff_t idx = 0, obsize = 0;
int matchcount = 0;
- int bindcount = -1;
+ ptrdiff_t bindcount = -1;
Lisp_Object bucket, zero, end, tem;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
{
collection = check_obarray (collection);
obsize = ASIZE (collection);
- bucket = XVECTOR (collection)->contents[idx];
+ bucket = AREF (collection, idx);
}
while (1)
break;
else
{
- bucket = XVECTOR (collection)->contents[idx];
+ bucket = AREF (collection, idx);
continue;
}
}
: NILP (collection) || (CONSP (collection)
&& (!SYMBOLP (XCAR (collection))
|| NILP (XCAR (collection))));
- EMACS_INT idx = 0, obsize = 0;
- int bindcount = -1;
+ ptrdiff_t idx = 0, obsize = 0;
+ ptrdiff_t bindcount = -1;
Lisp_Object bucket, tem, zero;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
{
collection = check_obarray (collection);
obsize = ASIZE (collection);
- bucket = XVECTOR (collection)->contents[idx];
+ bucket = AREF (collection, idx);
}
while (1)
break;
else
{
- bucket = XVECTOR (collection)->contents[idx];
+ bucket = AREF (collection, idx);
continue;
}
}
return Ffuncall (9, args);
}
\f
-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.
{
for (i = ASIZE (collection) - 1; i >= 0; i--)
{
- tail = XVECTOR (collection)->contents[i];
+ tail = AREF (collection, i);
if (SYMBOLP (tail))
while (1)
{
/* Reject this element if it fails to match all the regexps. */
if (CONSP (Vcompletion_regexp_list))
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qcase_fold_search, completion_ignore_case ? Qt : Qnil);
for (regexps = Vcompletion_regexp_list; CONSP (regexps);
regexps = XCDR (regexps))
staticpro (&last_minibuf_string);
last_minibuf_string = Qnil;
- DEFSYM (Quser_variable_p, "user-variable-p");
DEFSYM (Qminibuffer_history, "minibuffer-history");
DEFSYM (Qbuffer_name_history, "buffer-name-history");
Fset (Qbuffer_name_history, Qnil);
+ DEFSYM (Qcustom_variable_p, "custom-variable-p");
DEFSYM (Qminibuffer_setup_hook, "minibuffer-setup-hook");
DEFSYM (Qminibuffer_exit_hook, "minibuffer-exit-hook");
DEFSYM (Qhistory_length, "history-length");