/* Minibuffer input and completion.
- Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+ 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ 2008, 2009, 2010 Free Software Foundation, Inc.
This file is part of GNU Emacs.
-GNU Emacs is free software; you can redistribute it and/or modify
+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 3, or (at your option)
-any later version.
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <stdio.h>
+#include <setjmp.h>
#include "lisp.h"
#include "commands.h"
int completion_ignore_case;
Lisp_Object Qcompletion_ignore_case;
+int read_buffer_completion_ignore_case;
/* List of regexps that should restrict possible completions. */
or when a minibuffer exits. */
void
-choose_minibuf_frame ()
+choose_minibuf_frame (void)
{
if (FRAMEP (selected_frame)
&& FRAME_LIVE_P (XFRAME (selected_frame))
if (MINI_WINDOW_P (XWINDOW (FRAME_SELECTED_WINDOW (XFRAME (frame))))
&& !(EQ (frame, selected_frame)
&& minibuf_level > 0))
- Fset_frame_selected_window (frame, Fframe_first_window (frame));
+ Fset_frame_selected_window (frame, Fframe_first_window (frame), Qnil);
}
}
Lisp_Object
-choose_minibuf_frame_1 (ignore)
- Lisp_Object ignore;
+choose_minibuf_frame_1 (Lisp_Object ignore)
{
choose_minibuf_frame ();
return Qnil;
doc: /* Specify which minibuffer window to use for the minibuffer.
This affects where the minibuffer is displayed if you put text in it
without invoking the usual minibuffer commands. */)
- (window)
- Lisp_Object window;
+ (Lisp_Object window)
{
CHECK_WINDOW (window);
if (! MINI_WINDOW_P (XWINDOW (window)))
\f
/* Actual minibuffer invocation. */
-static Lisp_Object read_minibuf_unwind P_ ((Lisp_Object));
-static Lisp_Object run_exit_minibuf_hook P_ ((Lisp_Object));
-static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
- Lisp_Object, Lisp_Object,
- 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));
+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,
+ int, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, int);
+static Lisp_Object read_minibuf_noninteractive (Lisp_Object, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, Lisp_Object,
+ Lisp_Object, Lisp_Object,
+ int, int);
+static Lisp_Object string_to_object (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;
+string_to_object (Lisp_Object val, Lisp_Object defalt)
{
struct gcpro gcpro1, gcpro2;
Lisp_Object expr_and_pos;
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;
+read_minibuf_noninteractive (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;
doc: /* Return t if BUFFER is a minibuffer.
No argument or nil as argument means use current buffer as BUFFER.
BUFFER can be a buffer or a buffer name. */)
- (buffer)
- Lisp_Object buffer;
+ (Lisp_Object buffer)
{
Lisp_Object tem;
Sminibuffer_prompt_end, 0, 0, 0,
doc: /* Return the buffer position of the end of the minibuffer prompt.
Return (point-min) if current buffer is not a minibuffer. */)
- ()
+ (void)
{
/* This function is written to be most efficient when there's a prompt. */
Lisp_Object beg, end, tem;
Sminibuffer_contents, 0, 0, 0,
doc: /* Return the user input in a minibuffer as a string.
If the current buffer is not a minibuffer, return its entire contents. */)
- ()
+ (void)
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 1);
Sminibuffer_contents_no_properties, 0, 0, 0,
doc: /* Return the user input in a minibuffer as a string, without text-properties.
If the current buffer is not a minibuffer, return its entire contents. */)
- ()
+ (void)
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
return make_buffer_string (prompt_end, ZV, 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. */)
- ()
+ (void)
{
int prompt_end = XINT (Fminibuffer_prompt_end ());
if (PT < prompt_end)
current input method. */
static Lisp_Object
-read_minibuf (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;
+read_minibuf (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)
{
Lisp_Object val;
int count = SPECPDL_INDEX ();
build_string ("Command attempted to use minibuffer while in minibuffer"));
}
- if (noninteractive && NILP (Vexecuting_kbd_macro))
+ if ((noninteractive
+ /* In case we are running as a daemon, only do this before
+ detaching from the terminal. */
+ || (IS_DAEMON && (daemon_pipe[1] >= 0)))
+ && NILP (Vexecuting_kbd_macro))
{
val = read_minibuf_noninteractive (map, initial, prompt,
make_number (pos),
Lisp_Object histval;
/* If variable is unbound, make it nil. */
- if (EQ (SYMBOL_VALUE (Vminibuffer_history_variable), Qunbound))
- Fset (Vminibuffer_history_variable, Qnil);
- histval = Fsymbol_value (Vminibuffer_history_variable);
+ histval = find_symbol_value (Vminibuffer_history_variable);
+ if (EQ (histval, Qunbound))
+ Fset (Vminibuffer_history_variable, Qnil);
/* The value of the history variable must be a cons or nil. Other
values are unacceptable. We silently ignore these values. */
used for nonrecursive minibuffer invocations */
Lisp_Object
-get_minibuffer (depth)
- int depth;
+get_minibuffer (int depth)
{
Lisp_Object tail, num, buf;
char name[24];
- extern Lisp_Object nconc2 ();
+ extern Lisp_Object nconc2 (Lisp_Object, Lisp_Object);
XSETFASTINT (num, depth);
tail = Fnthcdr (num, Vminibuffer_list);
}
static Lisp_Object
-run_exit_minibuf_hook (data)
- Lisp_Object data;
+run_exit_minibuf_hook (Lisp_Object data)
{
if (!NILP (Vminibuffer_exit_hook) && !EQ (Vminibuffer_exit_hook, Qunbound)
&& !NILP (Vrun_hooks))
not, and it restores the current window, buffer, etc. */
static Lisp_Object
-read_minibuf_unwind (data)
- Lisp_Object data;
+read_minibuf_unwind (Lisp_Object data)
{
Lisp_Object old_deactivate_mark;
Lisp_Object window;
history commands. For consistency, you should also specify that
element of the history as the value of INITIAL-CONTENTS. Positions
are counted starting from 1 at the beginning of the list.
-Sixth arg DEFAULT-VALUE is the default value. If non-nil, it is available
- for history commands; but, unless READ is non-nil, `read-from-minibuffer'
- does NOT return DEFAULT-VALUE if the user enters empty input! It returns
- the empty string.
+Sixth arg DEFAULT-VALUE is the default value or the list of default values.
+ If non-nil, it is available for history commands, and as the value
+ (or the first element of the list of default values) to return
+ if the user enters the empty string. But, unless READ is non-nil,
+ `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'.
If the variable `minibuffer-allow-text-properties' is non-nil,
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)
- Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
- Lisp_Object inherit_input_method;
+ (Lisp_Object prompt, Lisp_Object initial_contents, Lisp_Object keymap, Lisp_Object read, Lisp_Object hist, Lisp_Object default_value, Lisp_Object inherit_input_method)
{
Lisp_Object histvar, histpos, val;
struct gcpro gcpro1;
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'.) */)
- (prompt, initial_contents)
- Lisp_Object prompt, initial_contents;
+ (Lisp_Object prompt, Lisp_Object initial_contents)
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_map, 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'.) */)
- (prompt, initial_contents)
- Lisp_Object prompt, initial_contents;
+ (Lisp_Object prompt, Lisp_Object initial_contents)
{
return Feval (read_minibuf (Vread_expression_map, initial_contents,
prompt, Qnil, 1, Qread_expression_history,
The third arg HISTORY, if non-nil, specifies a history list
and optionally the initial position in the list.
See `read-from-minibuffer' for details of HISTORY argument.
-Fourth arg DEFAULT-VALUE is the default value. If non-nil, it is used
- for history commands, and as the value to return if the user enters
- the empty string.
+Fourth arg DEFAULT-VALUE is the default value or the list of default values.
+ If non-nil, it is used for history commands, and as the value (or the first
+ element of the list of default values) 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'. */)
- (prompt, initial_input, history, default_value, inherit_input_method)
- Lisp_Object prompt, initial_input, history, default_value;
- Lisp_Object inherit_input_method;
+ (Lisp_Object prompt, Lisp_Object initial_input, Lisp_Object history, Lisp_Object default_value, Lisp_Object inherit_input_method)
{
Lisp_Object val;
val = Fread_from_minibuffer (prompt, initial_input, Qnil,
not useful in this function.)
Third arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
the current input method and the setting of`enable-multibyte-characters'. */)
- (prompt, initial, inherit_input_method)
- Lisp_Object prompt, initial, inherit_input_method;
+ (Lisp_Object prompt, Lisp_Object initial, Lisp_Object inherit_input_method)
{
CHECK_STRING (prompt);
return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
doc: /* Read the name of a command and return as a symbol.
-Prompt with PROMPT. By default, return DEFAULT-VALUE. */)
- (prompt, default_value)
- Lisp_Object prompt, default_value;
+Prompt with PROMPT. By default, return DEFAULT-VALUE or its first element
+if it is a list. */)
+ (Lisp_Object prompt, Lisp_Object default_value)
{
Lisp_Object name, default_string;
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.
Prompt with PROMPT. */)
- (prompt)
- Lisp_Object prompt;
+ (Lisp_Object prompt)
{
return Fintern (Fcompleting_read (prompt, Vobarray, Qfboundp, Qt, Qnil, Qnil, Qnil, Qnil),
Qnil);
DEFUN ("read-variable", Fread_variable, Sread_variable, 1, 2, 0,
doc: /* Read the name of a user variable and return it as a symbol.
-Prompt with PROMPT. By default, return DEFAULT-VALUE.
+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. */)
- (prompt, default_value)
- Lisp_Object prompt, default_value;
+ (Lisp_Object prompt, Lisp_Object default_value)
{
Lisp_Object name, default_string;
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.
-The argument PROMPT should be a string ending with a colon and a space. */)
- (prompt, def, require_match)
- Lisp_Object prompt, def, require_match;
+ If DEF is a list of default values, return its first element.
+Optional third arg REQUIRE-MATCH determines whether non-existing
+ buffer names are allowed. It has the same meaning as the
+ REQUIRE-MATCH argument of `confirm-after-completion'.
+The argument PROMPT should be a string ending with a colon and a space.
+If `read-buffer-completion-ignore-case' is non-nil, completion ignores
+case while reading the buffer name.
+If `read-buffer-function' is non-nil, this works by calling it as a
+function, instead of the usual behavior. */)
+ (Lisp_Object prompt, Lisp_Object def, Lisp_Object require_match)
{
- Lisp_Object args[4];
+ Lisp_Object args[4], result;
unsigned char *s;
int len;
+ int count = SPECPDL_INDEX ();
if (BUFFERP (def))
def = XBUFFER (def)->name;
+ specbind (Qcompletion_ignore_case,
+ read_buffer_completion_ignore_case ? Qt : Qnil);
+
if (NILP (Vread_buffer_function))
{
if (!NILP (def))
prompt = Fformat (3, args);
}
- return Fcompleting_read (prompt, intern ("internal-complete-buffer"),
- Qnil, require_match, Qnil, Qbuffer_name_history,
- def, Qnil);
+ result = Fcompleting_read (prompt, intern ("internal-complete-buffer"),
+ Qnil, require_match, Qnil, Qbuffer_name_history,
+ def, Qnil);
}
else
{
args[1] = prompt;
args[2] = def;
args[3] = require_match;
- return Ffuncall(4, args);
+ result = Ffuncall(4, args);
}
+ return unbind_to (count, result);
}
\f
static Lisp_Object
-minibuf_conform_representation (string, basis)
- Lisp_Object string, basis;
+minibuf_conform_representation (Lisp_Object string, Lisp_Object basis)
{
if (STRING_MULTIBYTE (string) == STRING_MULTIBYTE (basis))
return string;
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, collection, predicate)
- Lisp_Object string, collection, predicate;
+ (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
{
Lisp_Object bestmatch, tail, elt, eltstring;
/* Size in bytes of BESTMATCH. */
else
matchsize = XINT (tem) - 1;
- if (matchsize < 0)
- /* When can this happen ? -stef */
- matchsize = compare;
if (completion_ignore_case)
{
/* If this is an exact match except for case,
/* Return t if the supplied string is an exact match (counting case);
it does not require any change to be made. */
- if (matchcount == 1 && bestmatchsize == SCHARS (string)
- && (tem = Fcompare_strings (bestmatch, make_number (0),
- make_number (bestmatchsize),
- string, make_number (0),
- make_number (bestmatchsize),
- Qnil),
- EQ (Qt, tem)))
+ if (matchcount == 1 && !NILP (Fequal (bestmatch, string)))
return Qt;
XSETFASTINT (zero, 0); /* Else extract the part in which */
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 COLLECTION that start with a space
-are ignored unless STRING itself starts with a space. */)
- (string, collection, predicate, hide_spaces)
- Lisp_Object string, collection, predicate, hide_spaces;
+An obsolete optional fourth argument HIDE-SPACES is still accepted for
+backward compatibility. If non-nil, strings in COLLECTION that start
+with a space are ignored unless STRING itself starts with a space. */)
+ (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate, Lisp_Object hide_spaces)
{
Lisp_Object tail, elt, eltstring;
Lisp_Object allmatches;
tail = collection;
if (type == 2)
{
+ collection = check_obarray (collection);
obsize = XVECTOR (collection)->size;
bucket = XVECTOR (collection)->contents[index];
}
{
if (!EQ (bucket, zero))
{
+ if (!SYMBOLP (bucket))
+ error ("Bad data in guts of obarray");
elt = bucket;
eltstring = elt;
if (XSYMBOL (bucket)->next)
&& SCHARS (string) <= SCHARS (eltstring)
/* If HIDE_SPACES, reject alternatives that start with space
unless the input starts with space. */
- && ((SBYTES (string) > 0
- && SREF (string, 0) == ' ')
- || SREF (eltstring, 0) != ' '
- || NILP (hide_spaces))
+ && (NILP (hide_spaces)
+ || (SBYTES (string) > 0
+ && SREF (string, 0) == ' ')
+ || SREF (eltstring, 0) != ' ')
&& (tem = Fcompare_strings (eltstring, zero,
make_number (SCHARS (string)),
string, zero,
- t means that the user is not allowed to exit unless
the input is (or completes to) an element of COLLECTION or is null.
- nil means that the user can exit with any input.
-- `confirm-only' means that the user can exit with any input, but she will
- need to confirm her choice if the input is not an element of COLLECTION.
+- `confirm' means that the user can exit with any input, but she needs
+ to confirm her choice if the input is not an element of COLLECTION.
+- `confirm-after-completion' means that the user can exit with any
+ input, but she needs to confirm her choice if she called
+ `minibuffer-complete' right before `minibuffer-complete-and-exit'
+ and the input is not an element of COLLECTION.
- anything else behaves like t except that 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 the input is null, `completing-read' returns DEF, or the first element
+of the list of default values, or an empty string if DEF is nil,
+regardless of the value of REQUIRE-MATCH.
If INITIAL-INPUT is non-nil, insert it in the minibuffer initially,
with point positioned at the end.
1 at the beginning of the list. The variable `history-length'
controls the maximum length of a history list.
-DEF, if non-nil, is the default value.
+DEF, if non-nil, is the default value or the list of default values.
If INHERIT-INPUT-METHOD is non-nil, the minibuffer inherits
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. */)
- (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 prompt, Lisp_Object collection, Lisp_Object predicate, Lisp_Object require_match, Lisp_Object initial_input, Lisp_Object hist, Lisp_Object def, Lisp_Object inherit_input_method)
{
Lisp_Object val, histvar, histpos, position;
Lisp_Object init;
: (NILP (Vminibuffer_completing_file_name)
|| EQ (Vminibuffer_completing_file_name, Qlambda)
? Vminibuffer_local_must_match_map
- : Vminibuffer_local_must_match_filename_map),
+ : Vminibuffer_local_filename_must_match_map),
init, prompt, make_number (pos), 0,
histvar, histpos, def, 0,
!NILP (inherit_input_method));
RETURN_UNGCPRO (unbind_to (count, val));
}
\f
-Lisp_Object Fassoc_string ();
+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,
Takes the same arguments as `all-completions' and `try-completion'.
If COLLECTION is a function, it is called with three arguments:
the values STRING, PREDICATE and `lambda'. */)
- (string, collection, predicate)
- Lisp_Object string, collection, predicate;
+ (Lisp_Object string, Lisp_Object collection, Lisp_Object predicate)
{
Lisp_Object regexps, tail, tem = Qnil;
int i = 0;
The arguments STRING and PREDICATE are as in `try-completion',
`all-completions', and `test-completion'. */)
- (string, predicate, flag)
- Lisp_Object string, predicate, flag;
+ (Lisp_Object string, Lisp_Object predicate, Lisp_Object flag)
{
if (NILP (flag))
return Ftry_completion (string, Vbuffer_alist, predicate);
else if (EQ (flag, Qt))
- return Fall_completions (string, Vbuffer_alist, predicate, Qt);
+ {
+ Lisp_Object res = Fall_completions (string, Vbuffer_alist, predicate, Qnil);
+ if (SCHARS (string) > 0)
+ return res;
+ else
+ { /* Strip out internal buffers. */
+ Lisp_Object bufs = res;
+ /* First, look for a non-internal buffer in `res'. */
+ while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
+ bufs = XCDR (bufs);
+ if (NILP (bufs))
+ /* All bufs in `res' are internal, so don't trip them out. */
+ return res;
+ res = bufs;
+ while (CONSP (XCDR (bufs)))
+ if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
+ XSETCDR (bufs, XCDR (XCDR (bufs)));
+ else
+ bufs = XCDR (bufs);
+ return res;
+ }
+ }
else /* assume `lambda' */
return Ftest_completion (string, Vbuffer_alist, predicate);
}
Unlike `assoc', KEY can also match an entry in LIST 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, case_fold;
+ (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold)
{
register Lisp_Object tail;
\f
DEFUN ("minibuffer-depth", Fminibuffer_depth, Sminibuffer_depth, 0, 0, 0,
doc: /* Return current depth of activations of minibuffer, a nonnegative integer. */)
- ()
+ (void)
{
return make_number (minibuf_level);
}
DEFUN ("minibuffer-prompt", Fminibuffer_prompt, Sminibuffer_prompt, 0, 0, 0,
doc: /* Return the prompt string of the currently-active minibuffer.
If no minibuffer is active, return nil. */)
- ()
+ (void)
{
return Fcopy_sequence (minibuf_prompt);
}
\f
void
-init_minibuf_once ()
+init_minibuf_once (void)
{
Vminibuffer_list = Qnil;
staticpro (&Vminibuffer_list);
}
void
-syms_of_minibuf ()
+syms_of_minibuf (void)
{
minibuf_level = 0;
minibuf_prompt = Qnil;
minibuf_save_list = Qnil;
staticpro (&minibuf_save_list);
- Qcompletion_ignore_case = intern ("completion-ignore-case");
+ Qcompletion_ignore_case = intern_c_string ("completion-ignore-case");
staticpro (&Qcompletion_ignore_case);
- Qread_file_name_internal = intern ("read-file-name-internal");
+ Qread_file_name_internal = intern_c_string ("read-file-name-internal");
staticpro (&Qread_file_name_internal);
- Qminibuffer_default = intern ("minibuffer-default");
+ Qminibuffer_default = intern_c_string ("minibuffer-default");
staticpro (&Qminibuffer_default);
Fset (Qminibuffer_default, Qnil);
- Qminibuffer_completion_table = intern ("minibuffer-completion-table");
+ Qminibuffer_completion_table = intern_c_string ("minibuffer-completion-table");
staticpro (&Qminibuffer_completion_table);
- Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
+ Qminibuffer_completion_confirm = intern_c_string ("minibuffer-completion-confirm");
staticpro (&Qminibuffer_completion_confirm);
- Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
+ Qminibuffer_completion_predicate = intern_c_string ("minibuffer-completion-predicate");
staticpro (&Qminibuffer_completion_predicate);
staticpro (&last_minibuf_string);
last_minibuf_string = Qnil;
- Quser_variable_p = intern ("user-variable-p");
+ Quser_variable_p = intern_c_string ("user-variable-p");
staticpro (&Quser_variable_p);
- Qminibuffer_history = intern ("minibuffer-history");
+ Qminibuffer_history = intern_c_string ("minibuffer-history");
staticpro (&Qminibuffer_history);
- Qbuffer_name_history = intern ("buffer-name-history");
+ Qbuffer_name_history = intern_c_string ("buffer-name-history");
staticpro (&Qbuffer_name_history);
Fset (Qbuffer_name_history, Qnil);
- Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
+ Qminibuffer_setup_hook = intern_c_string ("minibuffer-setup-hook");
staticpro (&Qminibuffer_setup_hook);
- Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
+ Qminibuffer_exit_hook = intern_c_string ("minibuffer-exit-hook");
staticpro (&Qminibuffer_exit_hook);
- Qhistory_length = intern ("history-length");
+ Qhistory_length = intern_c_string ("history-length");
staticpro (&Qhistory_length);
- Qcurrent_input_method = intern ("current-input-method");
+ Qcurrent_input_method = intern_c_string ("current-input-method");
staticpro (&Qcurrent_input_method);
- Qactivate_input_method = intern ("activate-input-method");
+ Qactivate_input_method = intern_c_string ("activate-input-method");
staticpro (&Qactivate_input_method);
- Qcase_fold_search = intern ("case-fold-search");
+ Qcase_fold_search = intern_c_string ("case-fold-search");
staticpro (&Qcase_fold_search);
- Qread_expression_history = intern ("read-expression-history");
+ Qread_expression_history = intern_c_string ("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_BOOL ("read-buffer-completion-ignore-case",
+ &read_buffer_completion_ignore_case,
+ doc: /* *Non-nil means completion ignores case when reading a buffer name. */);
+ read_buffer_completion_ignore_case = 0;
+
DEFVAR_LISP ("minibuffer-setup-hook", &Vminibuffer_setup_hook,
doc: /* Normal hook run just after entry to minibuffer. */);
Vminibuffer_setup_hook = Qnil;
DEFVAR_BOOL ("completion-ignore-case", &completion_ignore_case,
doc: /* Non-nil means don't consider case significant in completion.
-
-For file-name completion, the variable `read-file-name-completion-ignore-case'
+For file-name completion, `read-file-name-completion-ignore-case'
+controls the behavior, rather than this variable.
+For buffer name completion, `read-buffer-completion-ignore-case'
controls the behavior, rather than this variable. */);
completion_ignore_case = 0;
Vminibuffer_completion_predicate = Qnil;
DEFVAR_LISP ("minibuffer-completion-confirm", &Vminibuffer_completion_confirm,
- doc: /* Non-nil means to demand confirmation of completion before exiting minibuffer. */);
+ doc: /* Whether to demand confirmation of completion before exiting minibuffer.
+If nil, confirmation is not required.
+If the value is `confirm', the user may exit with an input that is not
+ a valid completion alternative, but Emacs asks for confirmation.
+If the value is `confirm-after-completion', the user may exit with an
+ input that is not a valid completion alternative, but Emacs asks for
+ confirmation if the user submitted the input right after any of the
+ completion commands listed in `minibuffer-confirm-exit-commands'. */);
Vminibuffer_completion_confirm = Qnil;
DEFVAR_LISP ("minibuffer-completing-file-name",
/* We use `intern' here instead of Qread_only to avoid
initialization-order problems. */
Vminibuffer_prompt_properties
- = Fcons (intern ("read-only"), Fcons (Qt, Qnil));
+ = Fcons (intern_c_string ("read-only"), Fcons (Qt, Qnil));
DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
doc: /* Minibuffer keymap used for reading Lisp expressions. */);
defsubr (&Scompleting_read);
}
-void
-keys_of_minibuf ()
-{
- initial_define_key (Vminibuffer_local_map, Ctl ('g'),
- "abort-recursive-edit");
- initial_define_key (Vminibuffer_local_map, Ctl ('m'),
- "exit-minibuffer");
- initial_define_key (Vminibuffer_local_map, Ctl ('j'),
- "exit-minibuffer");
-
- initial_define_key (Vminibuffer_local_ns_map, ' ',
- "exit-minibuffer");
- initial_define_key (Vminibuffer_local_ns_map, '\t',
- "exit-minibuffer");
- initial_define_key (Vminibuffer_local_ns_map, '?',
- "self-insert-and-exit");
-
- initial_define_key (Vminibuffer_local_completion_map, '\t',
- "minibuffer-complete");
- initial_define_key (Vminibuffer_local_completion_map, ' ',
- "minibuffer-complete-word");
- 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");
-
- Fdefine_key (Vminibuffer_local_must_match_filename_map,
- build_string (" "), Qnil);
-}
-
/* arch-tag: 8f69b601-fba3-484c-a6dd-ceaee54a7a73
(do not change this comment) */
HCoop / bpt / emacs.git / blobdiff