static Lisp_Object last_exact_completion;
-/* Non-nil means it is the window for C-M-v to scroll
- when the minibuffer is selected. */
-
-extern Lisp_Object Vminibuf_scroll_window;
-
extern Lisp_Object Voverriding_local_map;
Lisp_Object Quser_variable_p;
{
/* This function is written to be most efficient when there's a prompt. */
Lisp_Object beg = make_number (BEGV);
- Lisp_Object end = Ffield_end (beg, Qnil);
+ Lisp_Object end = Ffield_end (beg, Qnil, Qnil);
if (XINT (end) == ZV && NILP (Fget_char_property (beg, Qfield, Qnil)))
return beg;
DEFUN ("minibuffer-contents", Fminibuffer_contents,
Sminibuffer_contents, 0, 0, 0,
- doc: /* Return the user input in a minbuffer as a string.
+ doc: /* Return the user input in a minibuffer as a string.
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 minbuffer as a string, without text-properties.
+ doc: /* Return the user input in a minibuffer as a string, without text-properties.
The current buffer must be a minibuffer. */)
()
{
GCPRO5 (map, initial, val, ambient_dir, input_method);
if (!STRINGP (prompt))
- prompt = build_string ("");
+ prompt = empty_string;
if (!enable_recursive_minibuffers
&& minibuf_level > 0)
if (inherit_input_method)
{
- /* `current-input-method' is buffer local. So, remeber it in
+ /* `current-input-method' is buffer local. So, remember it in
INPUT_METHOD before changing the current buffer. */
input_method = Fsymbol_value (Qcurrent_input_method);
enable_multibyte = current_buffer->enable_multibyte_characters;
Fredirect_frame_focus (selected_frame, mini_frame);
Vminibuf_scroll_window = selected_window;
+ if (minibuf_level == 1 || !EQ (minibuf_window, selected_window))
+ minibuf_selected_window = selected_window;
Fset_window_buffer (minibuf_window, Fcurrent_buffer ());
Fselect_window (minibuf_window);
XSETFASTINT (XWINDOW (minibuf_window)->hscroll, 0);
/* Run our hook, but not if it is empty.
(run-hooks would do nothing if it is empty,
- but it's important to save time here in the usual case). */
+ but it's important to save time here in the usual case.) */
if (!NILP (Vminibuffer_setup_hook) && !EQ (Vminibuffer_setup_hook, Qunbound)
&& !NILP (Vrun_hooks))
call1 (Vrun_hooks, Qminibuffer_setup_hook);
is STRING, but point is placed at position POSITION in the minibuffer.
Third arg KEYMAP is a keymap to use whilst reading;
if omitted or nil, the default is `minibuffer-local-map'.
-If fourth arg READ is non-nil, then interpret the result as a lisp object
+If fourth arg READ is non-nil, then interpret the result as a Lisp object
and return that object:
in other words, do `(car (read-from-string INPUT-STRING))'
Fifth arg HIST, if non-nil, specifies a history list
for history commands; but `read-from-minibuffer' does NOT return DEFAULT-VALUE
if the user enters empty input! It returns 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 current input method and the setting of `enable-multibyte-characters'.
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. */)
for history commands, and as the value to return if the user enters
the empty string.
Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
- the current input method and the setting of enable-multibyte-characters. */)
+ the current input method and the setting of `enable-multibyte-characters'. */)
(prompt, initial_input, history, default_value, inherit_input_method)
Lisp_Object prompt, initial_input, history, default_value;
Lisp_Object inherit_input_method;
doc: /* Read a string from the terminal, not allowing blanks.
Prompt with PROMPT, and provide INITIAL as an initial value of the input string.
Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
-the current input method and the setting of enable-multibyte-characters. */)
+the current input method and the setting of `enable-multibyte-characters'. */)
(prompt, initial, inherit_input_method)
Lisp_Object prompt, initial, inherit_input_method;
{
DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
doc: /* Read the name of a command and return as a symbol.
-Prompts with PROMPT. By default, return DEFAULT-VALUE. */)
+Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
(prompt, default_value)
Lisp_Object prompt, default_value;
{
#ifdef NOTDEF
DEFUN ("read-function", Fread_function, Sread_function, 1, 1, 0,
doc: /* One arg PROMPT, a string. Read the name of a function and return as a symbol.
-Prompts with PROMPT. */)
+Prompt with PROMPT. */)
(prompt)
Lisp_Object prompt;
{
DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
doc: /* Read the name of a user variable and return it as a symbol.
-Prompts with PROMPT. By default, return DEFAULT-VALUE.
+Prompt with PROMPT. By default, return DEFAULT-VALUE.
A user variable is one whose documentation starts with a `*' character. */)
(prompt, default_value)
Lisp_Object prompt, default_value;
}
DEFUN ("read-buffer", Fread_buffer, Sread_buffer, 1, 3, 0,
- doc: /* One arg PROMPT, a string. Read the name of a buffer and return as a string.
-Prompts with PROMPT.
+ doc: /* Read the name of a buffer and return as a string.
+Prompt with PROMPT.
Optional second arg DEF is value to return if user enters an empty line.
-If optional third arg REQUIRE-MATCH is non-nil, only existing buffer names are allowed. */)
+If optional third arg REQUIRE-MATCH is non-nil,
+ only existing buffer names are allowed. */)
(prompt, def, require_match)
Lisp_Object prompt, def, require_match;
{
int bestmatchsize = 0;
/* These are in bytes, too. */
int compare, matchsize;
- int list = CONSP (alist) || NILP (alist);
+ int list = NILP (alist) || (CONSP (alist)
+ && (!SYMBOLP (XCAR (alist))
+ || NILP (XCAR (alist))));
int index = 0, obsize = 0;
int matchcount = 0;
Lisp_Object bucket, zero, end, tem;
if (list)
{
- if (NILP (tail))
+ if (!CONSP (tail))
break;
- elt = Fcar (tail);
- eltstring = Fcar (elt);
- tail = Fcdr (tail);
+ elt = XCAR (tail);
+ eltstring = CONSP (elt) ? XCAR (elt) : elt;
+ tail = XCDR (tail);
}
else
{
if (!NILP (predicate))
{
if (EQ (predicate, Qcommandp))
- tem = Fcommandp (elt);
+ tem = Fcommandp (elt, Qnil);
else
{
GCPRO4 (tail, string, eltstring, bestmatch);
matchsize = XINT (tem) - 1;
if (matchsize < 0)
+ /* When can this happen ? -stef */
matchsize = compare;
if (completion_ignore_case)
{
bestmatch = eltstring;
}
bestmatchsize = matchsize;
+ if (matchsize <= XSTRING (string)->size
+ && matchcount > 1)
+ /* No need to look any further. */
+ break;
}
}
}
XSETFASTINT (end, bestmatchsize); /* all completions agree */
return Fsubstring (bestmatch, zero, end);
}
-
-/* Compare exactly LEN chars of strings at S1 and S2,
- ignoring case if appropriate.
- Return -1 if strings match,
- else number of chars that match at the beginning. */
-
-int
-scmp (s1, s2, len)
- register unsigned char *s1, *s2;
- int len;
-{
- register int l = len;
-
- if (completion_ignore_case)
- {
- while (l && DOWNCASE (*s1++) == DOWNCASE (*s2++))
- l--;
- }
- else
- {
- while (l && *s1++ == *s2++)
- l--;
- }
- if (l == 0)
- return -1;
- else
- {
- int match = len - l;
-
- /* Now *--S1 is the unmatching byte. If it is in the middle of
- multi-byte form, we must say that the multi-byte character
- there doesn't match. */
- while (match && *--s1 >= 0xA0) match--;
- return match;
- }
-}
\f
DEFUN ("all-completions", Fall_completions, Sall_completions, 2, 4, 0,
doc: /* Search for partial matches to STRING in ALIST.
{
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
- int list = CONSP (alist) || NILP (alist);
+ int list = NILP (alist) || (CONSP (alist)
+ && (!SYMBOLP (XCAR (alist))
+ || NILP (XCAR (alist))));
int index = 0, obsize = 0;
Lisp_Object bucket, tem;
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
if (list)
{
- if (NILP (tail))
+ if (!CONSP (tail))
break;
- elt = Fcar (tail);
- eltstring = Fcar (elt);
- tail = Fcdr (tail);
+ elt = XCAR (tail);
+ eltstring = CONSP (elt) ? XCAR (elt) : elt;
+ tail = XCDR (tail);
}
else
{
if (!NILP (predicate))
{
if (EQ (predicate, Qcommandp))
- tem = Fcommandp (elt);
+ tem = Fcommandp (elt, Qnil);
else
{
GCPRO4 (tail, eltstring, allmatches, string);
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.
- If it is also not t, Return does not exit if it does non-null completion.
+ 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 an empty string,
regardless of the value of REQUIRE-MATCH.
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially.
If it is (STRING . POSITION), the initial input
is STRING, but point is placed POSITION characters into the string.
- This feature is deprecated--it is best to pass nil for INITIAL.
+ This feature is deprecated--it is best to pass nil for INITIAL-INPUT
+ and supply the default value DEF instead. The user can yank the
+ default value into the minibuffer easily using \\[next-history-element].
+
HIST, if non-nil, specifies a history list
and optionally the initial position in the list.
It can be a symbol, which is the history list variable to use,
DEF, if non-nil, is the default value.
If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
- the current input method and the setting of enable-multibyte-characters.
+ the current input method and the setting of `enable-multibyte-characters'.
Completion ignores case if the ambient value of
`completion-ignore-case' is non-nil. */)
specbind (Qminibuffer_completion_table, table);
specbind (Qminibuffer_completion_predicate, predicate);
specbind (Qminibuffer_completion_confirm,
- EQ (require_match, Qt) ? Qnil : Qt);
+ EQ (require_match, Qt) ? Qnil : require_match);
last_exact_completion = Qnil;
position = Qnil;
}
\f
Lisp_Object Fminibuffer_completion_help ();
-Lisp_Object assoc_for_completion ();
+Lisp_Object Fassoc_string ();
/* Test whether TXT is an exact completion. */
-Lisp_Object
-test_completion (txt)
- Lisp_Object txt;
+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:
+the values STRING, PREDICATE and `lambda'. */)
+ (string, alist, predicate)
+ Lisp_Object string, alist, predicate;
{
- Lisp_Object tem;
+ Lisp_Object regexps, tem = Qnil;
+
+ CHECK_STRING (string);
- if (CONSP (Vminibuffer_completion_table)
- || NILP (Vminibuffer_completion_table))
- return assoc_for_completion (txt, Vminibuffer_completion_table);
- else if (VECTORP (Vminibuffer_completion_table))
+ if ((CONSP (alist) && (!SYMBOLP (XCAR (alist)) || NILP (XCAR (alist))))
+ || NILP (alist))
{
- /* Bypass intern-soft as that loses for nil */
- tem = oblookup (Vminibuffer_completion_table,
- XSTRING (txt)->data,
- XSTRING (txt)->size,
- STRING_BYTES (XSTRING (txt)));
+ tem = Fassoc_string (string, alist, completion_ignore_case ? Qt : Qnil);
+ if (CONSP (tem))
+ tem = XCAR (tem);
+ else
+ return Qnil;
+ }
+ else if (VECTORP (alist))
+ {
+ /* Bypass intern-soft as that loses for nil. */
+ tem = oblookup (alist,
+ XSTRING (string)->data,
+ XSTRING (string)->size,
+ STRING_BYTES (XSTRING (string)));
if (!SYMBOLP (tem))
{
- if (STRING_MULTIBYTE (txt))
- txt = Fstring_make_unibyte (txt);
+ if (STRING_MULTIBYTE (string))
+ string = Fstring_make_unibyte (string);
else
- txt = Fstring_make_multibyte (txt);
+ string = Fstring_make_multibyte (string);
tem = oblookup (Vminibuffer_completion_table,
- XSTRING (txt)->data,
- XSTRING (txt)->size,
- STRING_BYTES (XSTRING (txt)));
+ XSTRING (string)->data,
+ XSTRING (string)->size,
+ STRING_BYTES (XSTRING (string)));
if (!SYMBOLP (tem))
return Qnil;
}
- if (!NILP (Vminibuffer_completion_predicate))
- return call1 (Vminibuffer_completion_predicate, tem);
- else
- return Qt;
}
else
- return call3 (Vminibuffer_completion_table, txt,
- Vminibuffer_completion_predicate, Qlambda);
+ return call3 (alist, string, predicate, Qlambda);
+
+ /* Reject this element if it fails to match all the regexps. */
+ for (regexps = Vcompletion_regexp_list; CONSP (regexps);
+ regexps = XCDR (regexps))
+ {
+ if (NILP (Fstring_match (XCAR (regexps),
+ SYMBOLP (tem) ? string : tem,
+ Qnil)))
+ return Qnil;
+ }
+
+ /* Finally, check the predicate. */
+ if (!NILP (predicate))
+ return call1 (predicate, tem);
+ else
+ return Qt;
}
/* returns:
}
/* It did find a match. Do we match some possibility exactly now? */
- tem = test_completion (Fminibuffer_contents ());
+ tem = Ftest_completion (Fminibuffer_contents (),
+ Vminibuffer_completion_table,
+ Vminibuffer_completion_predicate);
if (NILP (tem))
{
/* not an exact match */
/* Like assoc but assumes KEY is a string, and ignores case if appropriate. */
-Lisp_Object
-assoc_for_completion (key, list)
+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.
+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)
register Lisp_Object key;
- Lisp_Object list;
+ Lisp_Object list, case_fold;
{
register Lisp_Object tail;
{
register Lisp_Object elt, tem, thiscar;
elt = Fcar (tail);
- if (!CONSP (elt)) continue;
- thiscar = Fcar (elt);
+ thiscar = CONSP (elt) ? XCAR (elt) : elt;
if (!STRINGP (thiscar))
continue;
tem = Fcompare_strings (thiscar, make_number (0), Qnil,
key, make_number (0), Qnil,
- completion_ignore_case ? Qt : Qnil);
+ case_fold);
if (EQ (tem, Qt))
return elt;
QUIT;
if (XINT (Fminibuffer_prompt_end ()) == ZV)
goto exit;
- if (!NILP (test_completion (Fminibuffer_contents ())))
+ if (!NILP (Ftest_completion (Fminibuffer_contents (),
+ Vminibuffer_completion_table,
+ Vminibuffer_completion_predicate)))
goto exit;
/* Call do_completion, but ignore errors. */
Vminibuffer_completion_predicate = Qnil;
DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
- doc: /* Non-nil => demand confirmation of completion before exiting minibuffer. */);
+ doc: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
Vminibuffer_completion_confirm = Qnil;
DEFVAR_LISP ("minibuffer-completing-file-name",
defsubr (&Stry_completion);
defsubr (&Sall_completions);
+ defsubr (&Stest_completion);
+ defsubr (&Sassoc_string);
defsubr (&Scompleting_read);
defsubr (&Sminibuffer_complete);
defsubr (&Sminibuffer_complete_word);