#include "commands.h"
#include "buffer.h"
#include "keyboard.h"
+#include "termhooks.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
return tem;
- /* Should we do an autoload? */
+ /* 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))
{
- struct gcpro gcpro1, gcpro2;
+ Lisp_Object tail;
- GCPRO2 (tem, object)
- do_autoload (tem, object);
- UNGCPRO;
+ 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;
+ goto autoload_retry;
+ }
}
if (error)
ought to be a symbol. */
idx = EVENT_HEAD (idx);
- if (XTYPE (idx) == Lisp_Int
- && (XINT (idx) < 0 || XINT (idx) >= DENSE_TABLE_SIZE))
- error ("only ASCII characters may be looked up in keymaps");
-
/* 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);
{
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;
}
ought to be a symbol. */
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");
-
/* 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);
case Lisp_Vector:
if (XVECTOR (elt)->size != DENSE_TABLE_SIZE)
break;
- if (XTYPE (idx) == Lisp_Int)
+ if (XTYPE (idx) == Lisp_Int
+ && XINT (idx) >= 0 && XINT (idx) < DENSE_TABLE_SIZE)
{
XVECTOR (elt)->contents[XFASTINT (idx)] = def;
return def;
register Lisp_Object tem;
register Lisp_Object cmd;
int metized = 0;
+ int meta_bit;
int length;
struct gcpro gcpro1, gcpro2, gcpro3;
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++;
keymap = get_keymap_1 (cmd, 0, 1);
if (NILP (keymap))
- error ("Key sequence %s uses invalid prefix characters",
- XSTRING (key)->data);
+ {
+ /* 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);
+
+ 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);
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, 0));
+ cmd = get_keyelt (access_keymap (keymap, c, t_ok));
if (idx == length)
return cmd;
}
}
-/* 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
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 (binding)))
{
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)
+ 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];
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) && XFASTINT (Flength (keys)) > 0)
- keysdesc = concat2 (Fkey_description (keys),
- build_string (" "));
+ {
+ 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;
}