#include "commands.h"
#include "buffer.h"
#include "keyboard.h"
+#include "termhooks.h"
+#include "blockinput.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
For example:
- initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark");
-
- I haven't extended these to allow the initializing code to bind
- function keys and mouse events; since they are called by many files,
- I'd have to fix lots of callers, and nobody right now would be using
- the new functionality, so it seems like a waste of time. But there's
- no technical reason not to. -JimB */
+ initial_define_key (control_x_map, Ctl('X'), "exchange-point-and-mark"); */
void
initial_define_key (keymap, key, defname)
store_in_keymap (keymap, make_number (key), intern (defname));
}
+void
+initial_define_lispy_key (keymap, keyname, defname)
+ Lisp_Object keymap;
+ char *keyname;
+ char *defname;
+{
+ store_in_keymap (keymap, intern (keyname), intern (defname));
+}
+
/* Define character fromchar in map frommap as an alias for character
tochar in map tomap. Subsequent redefinitions of the latter WILL
affect the former. */
DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
"Return t if ARG is a keymap.\n\
\n\
-A keymap is list (keymap . ALIST), a list (keymap VECTOR . ALIST),\n\
+A keymap is a list (keymap . ALIST), a list (keymap VECTOR . ALIST),\n\
or a symbol whose function definition is a keymap is itself a keymap.\n\
ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
VECTOR is a 128-element vector of bindings for ASCII characters.")
(object)
Lisp_Object object;
{
- return (NILP (get_keymap_1 (object, 0)) ? Qnil : Qt);
+ return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
}
/* Check that OBJECT is a keymap (after dereferencing through any
- symbols). If it is, return it; otherwise, return nil, or signal an
- error if ERROR != 0. */
+ symbols). If it is, return it.
+
+ If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
+ is an autoload form, do the autoload and try again.
+
+ ERROR controls how we respond if OBJECT isn't a keymap.
+ If ERROR is non-zero, signal an error; otherwise, just return Qnil.
+
+ Note that most of the time, we don't want to pursue autoloads.
+ Functions like Faccessible_keymaps which scan entire keymap trees
+ shouldn't load every autoloaded keymap. I'm not sure about this,
+ but it seems to me that only read_key_sequence, Flookup_key, and
+ Fdefine_key should cause keymaps to be autoloaded. */
+
Lisp_Object
-get_keymap_1 (object, error)
+get_keymap_1 (object, error, autoload)
Lisp_Object object;
- int error;
+ int error, autoload;
{
- register Lisp_Object tem;
+ Lisp_Object tem;
+ autoload_retry:
tem = indirect_function (object);
if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
return tem;
+ /* Should we do an autoload? Autoload forms for keymaps have
+ Qkeymap as their fifth element. */
+ if (autoload
+ && XTYPE (object) == Lisp_Symbol
+ && CONSP (tem)
+ && EQ (XCONS (tem)->car, Qautoload))
+ {
+ Lisp_Object tail;
+
+ tail = Fnth (make_number (4), tem);
+ if (EQ (tail, Qkeymap))
+ {
+ struct gcpro gcpro1, gcpro2;
+
+ GCPRO2 (tem, object)
+ do_autoload (tem, object);
+ UNGCPRO;
+
+ goto autoload_retry;
+ }
+ }
+
if (error)
wrong_type_argument (Qkeymapp, object);
else
return Qnil;
}
+
+/* Follow any symbol chaining, and return the keymap denoted by OBJECT.
+ If OBJECT doesn't denote a keymap at all, signal an error. */
Lisp_Object
get_keymap (object)
Lisp_Object object;
{
- return get_keymap_1 (object, 1);
+ return get_keymap_1 (object, 0, 0);
}
/* Look up IDX in MAP. IDX may be any sort of event.
Note that this does only one level of lookup; IDX must be a single
- event, not a sequence. */
+ event, not a sequence.
+
+ If T_OK is non-zero, bindings for Qt are treated as default
+ bindings; any key left unmentioned by other tables and bindings is
+ given the binding of Qt.
+
+ If T_OK is zero, bindings for Qt are not treated specially. */
Lisp_Object
-access_keymap (map, idx)
+access_keymap (map, idx, t_ok)
Lisp_Object map;
Lisp_Object idx;
+ int t_ok;
{
/* If idx is a list (some sort of mouse click, perhaps?),
the index we want to use is the car of the list, which
ought to be a symbol. */
- if (EVENT_HAS_PARAMETERS (idx))
- idx = EVENT_HEAD (idx);
-
- if (XTYPE (idx) == Lisp_Int
- && (XINT (idx) < 0 || XINT (idx) >= DENSE_TABLE_SIZE))
- error ("only ASCII characters may used as keymap indices");
+ idx = EVENT_HEAD (idx);
/* If idx is a symbol, it might have modifiers, which need to
be put in the canonical order. */
- else if (XTYPE (idx) == Lisp_Symbol)
+ if (XTYPE (idx) == Lisp_Symbol)
idx = reorder_modifiers (idx);
{
Lisp_Object tail;
+ Lisp_Object t_binding = Qnil;
for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
{
case Lisp_Cons:
if (EQ (XCONS (binding)->car, idx))
return XCONS (binding)->cdr;
+ if (t_ok && EQ (XCONS (binding)->car, Qt))
+ t_binding = XCONS (binding)->cdr;
break;
case Lisp_Vector:
if (XVECTOR (binding)->size == DENSE_TABLE_SIZE
- && XTYPE (idx) == Lisp_Int)
+ && XTYPE (idx) == Lisp_Int
+ && XINT (idx) >= 0
+ && XINT (idx) < DENSE_TABLE_SIZE)
return XVECTOR (binding)->contents[XINT (idx)];
break;
}
+
+ QUIT;
}
- }
- return Qnil;
+ return t_binding;
+ }
}
/* Given OBJECT which was found in a slot in a keymap,
register Lisp_Object map, tem;
/* If the contents are (KEYMAP . ELEMENT), go indirect. */
- map = get_keymap_1 (Fcar_safe (object), 0);
+ map = get_keymap_1 (Fcar_safe (object), 0, 0);
tem = Fkeymapp (map);
if (!NILP (tem))
- object = access_keymap (map, Fcdr (object));
+ object = access_keymap (map, Fcdr (object), 0);
/* If the keymap contents looks like (STRING . DEFN),
use DEFN.
/* If idx is a list (some sort of mouse click, perhaps?),
the index we want to use is the car of the list, which
ought to be a symbol. */
- if (EVENT_HAS_PARAMETERS (idx))
- idx = EVENT_HEAD (idx);
-
- if (XTYPE (idx) == Lisp_Int
- && (XINT (idx) < 0 || XINT (idx) >= DENSE_TABLE_SIZE))
- error ("only ASCII characters may be used as keymap indices");
+ idx = EVENT_HEAD (idx);
/* If idx is a symbol, it might have modifiers, which need to
be put in the canonical order. */
- else if (XTYPE (idx) == Lisp_Symbol)
+ if (XTYPE (idx) == Lisp_Symbol)
idx = reorder_modifiers (idx);
switch (XTYPE (elt))
{
case Lisp_Vector:
- if (XTYPE (idx) == Lisp_Int)
+ if (XVECTOR (elt)->size != DENSE_TABLE_SIZE)
+ break;
+ if (XTYPE (idx) == Lisp_Int
+ && XINT (idx) >= 0 && XINT (idx) < DENSE_TABLE_SIZE)
{
XVECTOR (elt)->contents[XFASTINT (idx)] = def;
return def;
goto keymap_end;
break;
}
+
+ QUIT;
}
keymap_end:
If KEYMAP is a sparse keymap, the pair binding KEY to DEF is added at\n\
the front of KEYMAP.")
(keymap, key, def)
- register Lisp_Object keymap;
+ Lisp_Object keymap;
Lisp_Object key;
Lisp_Object def;
{
register Lisp_Object tem;
register Lisp_Object cmd;
int metized = 0;
+ int meta_bit;
int length;
+ struct gcpro gcpro1, gcpro2, gcpro3;
keymap = get_keymap (keymap);
&& XTYPE (key) != Lisp_String)
key = wrong_type_argument (Qarrayp, key);
- length = Flength (key);
+ length = XFASTINT (Flength (key));
if (length == 0)
return Qnil;
+ GCPRO3 (keymap, key, def);
+
+ if (XTYPE (key) == Lisp_Vector)
+ meta_bit = meta_modifier;
+ else
+ meta_bit = 0x80;
+
idx = 0;
while (1)
{
c = Faref (key, make_number (idx));
if (XTYPE (c) == Lisp_Int
- && XINT (c) >= 0200
+ && (XINT (c) & meta_bit)
&& !metized)
{
c = meta_prefix_char;
else
{
if (XTYPE (c) == Lisp_Int)
- XSETINT (c, XINT (c) & 0177);
+ XSETINT (c, XINT (c) & ~meta_bit);
metized = 0;
idx++;
}
if (idx == length)
- return store_in_keymap (keymap, c, def);
+ RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
- cmd = get_keyelt (access_keymap (keymap, c));
+ cmd = get_keyelt (access_keymap (keymap, c, 0));
if (NILP (cmd))
{
store_in_keymap (keymap, c, cmd);
}
- tem = Fkeymapp (cmd);
- if (NILP (tem))
- error ("Key sequence %s uses invalid prefix characters",
- XSTRING (key)->data);
+ keymap = get_keymap_1 (cmd, 0, 1);
+ if (NILP (keymap))
+ {
+ /* We must use Fkey_description rather than just passing key to
+ error; key might be a vector, not a string. */
+ Lisp_Object description = Fkey_description (key);
- keymap = get_keymap (cmd);
+ error ("Key sequence %s uses invalid prefix characters",
+ XSTRING (description)->data);
+ }
}
}
/* Value is number if KEY is too long; NIL if valid but has no definition. */
-DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 2, 0,
+DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
"In keymap KEYMAP, look up key sequence KEY. Return the definition.\n\
nil means undefined. See doc of `define-key' for kinds of definitions.\n\
+\n\
A number as value means KEY is \"too long\";\n\
that is, characters or symbols in it except for the last one\n\
fail to be a valid sequence of prefix characters in KEYMAP.\n\
The number is how many characters at the front of KEY\n\
-it takes to reach a non-prefix command.")
- (keymap, key)
+it takes to reach a non-prefix command.\n\
+\n\
+Normally, `lookup-key' ignores bindings for t, which act as default\n\
+bindings, used when nothing else in the keymap applies; this makes it\n\
+useable as a general function for probing keymaps. However, if the\n\
+third optional argument ACCEPT-DEFAULT is non-nil, `lookup-key' will\n\
+recognize the default bindings, just as `read-key-sequence' does.")
+ (keymap, key, accept_default)
register Lisp_Object keymap;
Lisp_Object key;
+ Lisp_Object accept_default;
{
register int idx;
register Lisp_Object tem;
register Lisp_Object c;
int metized = 0;
int length;
+ int t_ok = ! NILP (accept_default);
+ int meta_bit;
keymap = get_keymap (keymap);
&& XTYPE (key) != Lisp_String)
key = wrong_type_argument (Qarrayp, key);
- length = Flength (key);
+ length = XFASTINT (Flength (key));
if (length == 0)
return keymap;
+ if (XTYPE (key) == Lisp_Vector)
+ meta_bit = meta_modifier;
+ else
+ meta_bit = 0x80;
+
idx = 0;
while (1)
{
c = Faref (key, make_number (idx));
if (XTYPE (c) == Lisp_Int
- && XINT (c) >= 0200
+ && (XINT (c) & meta_bit)
&& !metized)
{
c = meta_prefix_char;
else
{
if (XTYPE (c) == Lisp_Int)
- XSETINT (c, XINT (c) & 0177);
+ XSETINT (c, XINT (c) & ~meta_bit);
metized = 0;
idx++;
}
- cmd = get_keyelt (access_keymap (keymap, c));
+ cmd = get_keyelt (access_keymap (keymap, c, t_ok));
if (idx == length)
return cmd;
- tem = Fkeymapp (cmd);
- if (NILP (tem))
+ keymap = get_keymap_1 (cmd, 0, 0);
+ if (NILP (keymap))
return make_number (idx);
- keymap = get_keymap (cmd);
QUIT;
}
}
-/* Append a key to the end of a key sequence. If key_sequence is a
- string and key is a character, the result will be another string;
- otherwise, it will be a vector. */
+/* Append a key to the end of a key sequence. We always make a vector. */
+
Lisp_Object
append_key (key_sequence, key)
Lisp_Object key_sequence, key;
args[0] = key_sequence;
- if (XTYPE (key_sequence) == Lisp_String
- && XTYPE (key) == Lisp_Int)
- {
- args[1] = Fchar_to_string (key);
- return Fconcat (2, args);
- }
- else
- {
- args[1] = Fcons (key, Qnil);
- return Fvconcat (2, args);
- }
+ args[1] = Fcons (key, Qnil);
+ return Fvconcat (2, args);
}
\f
if (cmm_maps)
{
+ BLOCK_INPUT;
newmodes = (Lisp_Object *) realloc (cmm_modes, cmm_size *= 2);
newmaps = (Lisp_Object *) realloc (cmm_maps, cmm_size);
+ UNBLOCK_INPUT;
}
else
{
+ BLOCK_INPUT;
newmodes = (Lisp_Object *) malloc (cmm_size = 30);
newmaps = (Lisp_Object *) malloc (cmm_size);
+ UNBLOCK_INPUT;
}
if (newmaps && newmodes)
return i;
}
-DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 1, 0,
+DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
"Return the binding for command KEY in current keymaps.\n\
-KEY is a string, a sequence of keystrokes.\n\
-The binding is probably a symbol with a function definition.")
- (key)
+KEY is a string or vector, a sequence of keystrokes.\n\
+The binding is probably a symbol with a function definition.\n\
+\n\
+Normally, `key-binding' ignores bindings for t, which act as default\n\
+bindings, used when nothing else in the keymap applies; this makes it\n\
+useable as a general function for probing keymaps. However, if the\n\
+third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\
+recognize the default bindings, just as `read-key-sequence' does.")
+ (key, accept_default)
Lisp_Object key;
{
Lisp_Object *maps, value;
for (i = 0; i < nmaps; i++)
if (! NILP (maps[i]))
{
- value = Flookup_key (maps[i], key);
+ value = Flookup_key (maps[i], key, accept_default);
if (! NILP (value) && XTYPE (value) != Lisp_Int)
return value;
}
if (! NILP (current_buffer->keymap))
{
- value = Flookup_key (current_buffer->keymap, key);
+ value = Flookup_key (current_buffer->keymap, key, accept_default);
if (! NILP (value) && XTYPE (value) != Lisp_Int)
return value;
}
- value = Flookup_key (current_global_map, key);
+ value = Flookup_key (current_global_map, key, accept_default);
if (! NILP (value) && XTYPE (value) != Lisp_Int)
return value;
return Qnil;
}
-DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 1, 0,
+DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
"Return the binding for command KEYS in current local keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
-The binding is probably a symbol with a function definition.")
- (keys)
- Lisp_Object keys;
+The binding is probably a symbol with a function definition.\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (keys, accept_default)
+ Lisp_Object keys, accept_default;
{
register Lisp_Object map;
map = current_buffer->keymap;
if (NILP (map))
return Qnil;
- return Flookup_key (map, keys);
+ return Flookup_key (map, keys, accept_default);
}
-DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 1, 0,
+DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
"Return the binding for command KEYS in current global keymap only.\n\
KEYS is a string, a sequence of keystrokes.\n\
The binding is probably a symbol with a function definition.\n\
This function's return values are the same as those of lookup-key\n\
-(which see).")
- (keys)
- Lisp_Object keys;
+(which see).\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (keys, accept_default)
+ Lisp_Object keys, accept_default;
{
- return Flookup_key (current_global_map, keys);
+ return Flookup_key (current_global_map, keys, accept_default);
}
-DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 1, 0,
+DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
"Find the visible minor mode bindings of KEY.\n\
Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
the symbol which names the minor mode binding KEY, and BINDING is\n\
minor-mode bindings, return nil. If the first binding is a\n\
non-prefix, all subsequent bindings will be omitted, since they would\n\
be ignored. Similarly, the list doesn't include non-prefix bindings\n\
-that come after prefix bindings.")
- (key)
+that come after prefix bindings.\n\
+\n\
+If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
+bindings; see the description of `lookup-key' for more details about this.")
+ (key, accept_default)
+ Lisp_Object key, accept_default;
{
Lisp_Object *modes, *maps;
int nmaps;
for (i = j = 0; i < nmaps; i++)
if (! NILP (maps[i])
- && ! NILP (binding = Flookup_key (maps[i], key))
+ && ! NILP (binding = Flookup_key (maps[i], key, accept_default))
&& XTYPE (binding) != Lisp_Int)
{
- if (! NILP (get_keymap_1 (binding, 0)))
+ if (! NILP (get_keymap (binding)))
maps[j++] = Fcons (modes[i], binding);
else if (j == 0)
return Fcons (Fcons (modes[i], binding), Qnil);
{
Lisp_Object maps, tail;
- maps = Fcons (Fcons (build_string (""), get_keymap (startmap)), Qnil);
+ maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
+ get_keymap (startmap)),
+ Qnil);
/* For each map in the list maps,
look at any other maps it points to,
keymap table. */
if (is_metized)
{
+ int meta_bit = meta_modifier;
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (i | 0200));
+
+ Faset (tem, last, make_number (i | meta_bit));
/* This new sequence is the same length as
thisseq, so stick it in the list right
after this one. */
- XCONS (tail)->cdr =
- Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
+ XCONS (tail)->cdr
+ = Fcons (Fcons (tem, cmd), XCONS (tail)->cdr);
}
else
{
if (is_metized && XTYPE (elt) == Lisp_Int)
{
tem = Fcopy_sequence (thisseq);
- Faset (tem, last, make_number (XINT (elt) | 0200));
+ Faset (tem, last,
+ make_number (XINT (elt) | meta_modifier));
/* This new sequence is the same length as
thisseq, so stick it in the list right
(keys)
Lisp_Object keys;
{
+ if (XTYPE (keys) == Lisp_String)
+ {
+ Lisp_Object vector;
+ int i;
+ vector = Fmake_vector (Flength (keys), Qnil);
+ for (i = 0; i < XSTRING (keys)->size; i++)
+ {
+ if (XSTRING (keys)->data[i] & 0x80)
+ XFASTINT (XVECTOR (vector)->contents[i])
+ = meta_modifier | (XSTRING (keys)->data[i] & ~0x80);
+ else
+ XFASTINT (XVECTOR (vector)->contents[i])
+ = XSTRING (keys)->data[i];
+ }
+ keys = vector;
+ }
return Fmapconcat (Qsingle_key_description, keys, build_string (" "));
}
register unsigned int c;
register char *p;
{
- if (c >= 0200)
+ /* Clear all the meaningless bits above the meta bit. */
+ c &= meta_modifier | ~ - meta_modifier;
+
+ if (c & alt_modifier)
+ {
+ *p++ = 'A';
+ *p++ = '-';
+ c -= alt_modifier;
+ }
+ if (c & ctrl_modifier)
+ {
+ *p++ = 'C';
+ *p++ = '-';
+ c -= ctrl_modifier;
+ }
+ if (c & hyper_modifier)
+ {
+ *p++ = 'H';
+ *p++ = '-';
+ c -= hyper_modifier;
+ }
+ if (c & meta_modifier)
{
*p++ = 'M';
*p++ = '-';
- c -= 0200;
+ c -= meta_modifier;
+ }
+ if (c & shift_modifier)
+ {
+ *p++ = 'S';
+ *p++ = '-';
+ c -= shift_modifier;
+ }
+ if (c & super_modifier)
+ {
+ *p++ = 's';
+ *p++ = '-';
+ c -= super_modifier;
}
if (c < 040)
{
*p++ = 'S';
*p++ = 'C';
}
- else if (c == Ctl('I'))
+ else if (c == '\t')
{
*p++ = 'T';
*p++ = 'A';
*p++ = 'P';
*p++ = 'C';
}
- else
+ else if (c < 256)
*p++ = c;
+ else
+ {
+ *p++ = '\\';
+ *p++ = (7 & (c >> 15)) + '0';
+ *p++ = (7 & (c >> 12)) + '0';
+ *p++ = (7 & (c >> 9)) + '0';
+ *p++ = (7 & (c >> 6)) + '0';
+ *p++ = (7 & (c >> 3)) + '0';
+ *p++ = (7 & (c >> 0)) + '0';
+ }
return p;
}
(key)
Lisp_Object key;
{
- register unsigned char c;
- char tem[6];
+ char tem[20];
- if (EVENT_HAS_PARAMETERS (key))
- key = EVENT_HEAD (key);
+ key = EVENT_HEAD (key);
switch (XTYPE (key))
{
case Lisp_Int: /* Normal character */
- c = XINT (key) & 0377;
- *push_key_description (c, tem) = 0;
+ *push_key_description (XUINT (key), tem) = 0;
return build_string (tem);
case Lisp_Symbol: /* Function key or event-symbol */
if (XTYPE (key) == Lisp_Int && last_is_meta)
{
sequence = Fcopy_sequence (this);
- Faset (sequence, last, make_number (XINT (key) | 0200));
+ Faset (sequence, last, make_number (XINT (key) | meta_modifier));
}
else
sequence = append_key (this, key);
means undefined. */
if (!NILP (local_keymap))
{
- binding = Flookup_key (local_keymap, sequence);
+ binding = Flookup_key (local_keymap, sequence, Qnil);
if (!NILP (binding) && XTYPE (binding) != Lisp_Int)
{
if (XTYPE (definition) == Lisp_Cons)
what we should use. */
else
{
- sh = Flookup_key (shadow, Fcar (elt));
+ sh = Flookup_key (shadow, Fcar (elt), Qt);
if (XTYPE (sh) == Lisp_Int)
sh = Qnil;
}
{
register Lisp_Object keysdesc;
- if (!NILP (keys) && Flength (keys) > 0)
- keysdesc = concat2 (Fkey_description (keys),
- build_string (" "));
+ if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
+ {
+ Lisp_Object tem;
+ /* Call Fkey_description first, to avoid GC bug for the other string. */
+ tem = Fkey_description (keys);
+ keysdesc = concat2 (tem, build_string (" "));
+ }
else
keysdesc = Qnil;
Lisp_Object tem;
XVECTOR (kludge)->contents[0] = tem1;
- tem = Flookup_key (shadow, kludge);
+ tem = Flookup_key (shadow, kludge, Qt);
if (!NILP (tem)) continue;
}
Lisp_Object vector;
{
CHECK_VECTOR (vector, 0);
- describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil, Qnil);
+ describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil);
}
describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
Lisp_Object tem;
XVECTOR (kludge)->contents[0] = make_number (i);
- tem = Flookup_key (shadow, kludge);
+ tem = Flookup_key (shadow, kludge, Qt);
if (!NILP (tem)) continue;
}
HCoop / bpt / emacs.git / blobdiff