return first_binding;
}
+/* Structure used to keep track of partial application of key remapping
+ such as Vfunction_key_map and Vkey_translation_map. */
+typedef struct keyremap
+{
+ Lisp_Object map;
+ int start, end;
+} keyremap;
+
+
/* Read a sequence of keys that ends with a non prefix character,
storing it in KEYBUF, a buffer of size BUFSIZE.
Prompt with PROMPT.
defs[i] is non-nil. */
volatile int first_binding;
/* Index of the first key that has no binding.
- It is useless to try fkey_start larger than that. */
+ It is useless to try fkey.start larger than that. */
volatile int first_unbound;
/* If t < mock_input, then KEYBUF[t] should be read as the next
volatile int mock_input = 0;
/* If the sequence is unbound in submaps[], then
- keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
- and fkey_map is its binding.
+ keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
+ and fkey.map is its binding.
These might be > t, indicating that all function key scanning
should hold off until t reaches them. We do this when we've just
recognized a function key, to avoid searching for the function
key's again in Vfunction_key_map. */
- volatile int fkey_start = 0, fkey_end = 0;
- volatile Lisp_Object fkey_map;
+ volatile keyremap fkey;
/* Likewise, for key_translation_map. */
- volatile int keytran_start = 0, keytran_end = 0;
- volatile Lisp_Object keytran_map;
+ volatile keyremap keytran;
/* If we receive a ``switch-frame'' event in the middle of a key sequence,
we put it off for later. While we're reading, we keep the event here. */
last_nonmenu_event = Qnil;
delayed_switch_frame = Qnil;
- fkey_map = Vfunction_key_map;
- keytran_map = Vkey_translation_map;
-
- /* If there is no function-key-map, turn off function key scanning. */
- if (!KEYMAPP (Vfunction_key_map))
- fkey_start = fkey_end = bufsize + 1;
-
- /* If there is no key-translation-map, turn off scanning. */
- if (!KEYMAPP (Vkey_translation_map))
- keytran_start = keytran_end = bufsize + 1;
+ fkey.map = Vfunction_key_map;
+ keytran.map = Vkey_translation_map;
+ /* If there is no translation-map, turn off scanning. */
+ fkey.start = fkey.end = KEYMAPP (fkey.map) ? 0 : bufsize + 1;
+ keytran.start = keytran.end = KEYMAPP (keytran.map) ? 0 : bufsize + 1;
if (INTERACTIVE)
{
/* If the best binding for the current key sequence is a keymap, or
we may be looking at a function key's escape sequence, keep on
reading. */
- while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
- || (first_binding >= nmaps && fkey_start < t)
- || (first_binding >= nmaps && keytran_start < t)
+ while (first_binding < nmaps
+ /* Keep reading as long as there's a prefix binding. */
+ ? !NILP (submaps[first_binding])
/* Don't return in the middle of a possible function key sequence,
if the only bindings we found were via case conversion.
Thus, if ESC O a has a function-key-map translation
and ESC o has a binding, don't return after ESC O,
so that we can translate ESC O plus the next character. */
- )
+ : (fkey.start < t || keytran.start < t))
{
Lisp_Object key;
int used_mouse_menu = 0;
volatile int echo_local_start, keys_local_start, local_first_binding;
/* key-translation-map is applied *after* function-key-map. */
- eassert (keytran_end <= fkey_start);
+ eassert (keytran.end <= fkey.start);
- if (first_unbound < fkey_start && first_unbound < keytran_start)
+ if (first_unbound < fkey.start && first_unbound < keytran.start)
{ /* The prefix upto first_unbound has no binding and has
no translation left to do either, so we know it's unbound.
If we don't stop now, we risk staying here indefinitely
for (i = first_unbound + 1; i < t; i++)
keybuf[i - first_unbound - 1] = keybuf[i];
mock_input = t - first_unbound - 1;
- fkey_end = fkey_start -= first_unbound + 1;
- fkey_map = Vfunction_key_map;
- keytran_end = keytran_start -= first_unbound + 1;
- keytran_map = Vkey_translation_map;
+ fkey.end = fkey.start -= first_unbound + 1;
+ fkey.map = Vfunction_key_map;
+ keytran.end = keytran.start -= first_unbound + 1;
+ keytran.map = Vkey_translation_map;
goto replay_sequence;
}
/* This is needed for the following scenario:
event 0: a down-event that gets dropped by calling replay_key.
event 1: some normal prefix like C-h.
- After event 0, first_unbound is 0, after event 1 fkey_start
- and keytran_start are both 1, so when we see that C-h is bound,
+ After event 0, first_unbound is 0, after event 1 fkey.start
+ and keytran.start are both 1, so when we see that C-h is bound,
we need to update first_unbound. */
first_unbound = max (t + 1, first_unbound);
else
{
Lisp_Object head;
- /* Remember the position to put an upper bound on fkey_start. */
+ /* Remember the position to put an upper bound on fkey.start. */
first_unbound = min (t, first_unbound);
head = EVENT_HEAD (key);
to go over the sequence before we return (since we keep the
invariant that keytran.end <= fkey.start). */
{
- if (fkey_start < t)
- (fkey_start = fkey_end = t, fkey_map = Vfunction_key_map);
+ if (fkey.start < t)
+ (fkey.start = fkey.end = t, fkey.map = Vfunction_key_map);
}
else
/* If the sequence is unbound, see if we can hang a function key
off the end of it. */
{
- Lisp_Object fkey_next;
+ Lisp_Object next;
- /* Continue scan from fkey_end until we find a bound suffix.
- If we fail, increment fkey_start and start over from there. */
- while (fkey_end < t)
+ /* Continue scan from fkey.end until we find a bound suffix.
+ If we fail, increment fkey.start and start over from there. */
+ while (fkey.end < t)
{
Lisp_Object key;
- key = keybuf[fkey_end++];
- fkey_next = access_keymap (fkey_map, key, 1, 0, 1);
+ key = keybuf[fkey.end++];
+ next = access_keymap (fkey.map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
- if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
- && CONSP (XSYMBOL (fkey_next)->function)
- && EQ (XCAR (XSYMBOL (fkey_next)->function), Qautoload))
- do_autoload (XSYMBOL (fkey_next)->function,
- fkey_next);
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next))
+ && CONSP (XSYMBOL (next)->function)
+ && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
+ do_autoload (XSYMBOL (next)->function, next);
/* Handle a symbol whose function definition is a keymap
or an array. */
- if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
- && (!NILP (Farrayp (XSYMBOL (fkey_next)->function))
- || KEYMAPP (XSYMBOL (fkey_next)->function)))
- fkey_next = XSYMBOL (fkey_next)->function;
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next))
+ && (!NILP (Farrayp (XSYMBOL (next)->function))
+ || KEYMAPP (XSYMBOL (next)->function)))
+ next = XSYMBOL (next)->function;
#if 0 /* I didn't turn this on, because it might cause trouble
for the mapping of return into C-m and tab into C-i. */
/* Optionally don't map function keys into other things.
This enables the user to redefine kp- keys easily. */
if (SYMBOLP (key) && !NILP (Vinhibit_function_key_mapping))
- fkey_next = Qnil;
+ next = Qnil;
#endif
/* If the function key map gives a function, not an
array, then call the function with no args and use
its value instead. */
- if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next))
/* If there's a binding (i.e. first_binding >= nmaps)
we don't want to apply this function-key-mapping. */
- && fkey_end == t && first_binding >= nmaps)
+ && fkey.end == t && first_binding >= nmaps)
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
- tem = fkey_next;
+ tem = next;
- GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
- fkey_next = call1 (fkey_next, prompt);
+ GCPRO3 (fkey.map, keytran.map, delayed_switch_frame);
+ next = call1 (next, prompt);
UNGCPRO;
/* If the function returned something invalid,
barf--don't ignore it.
(To ignore it safely, we would need to gcpro a bunch of
other variables.) */
- if (! (VECTORP (fkey_next) || STRINGP (fkey_next)))
+ if (! (VECTORP (next) || STRINGP (next)))
error ("Function in key-translation-map returns invalid key sequence");
}
- /* If keybuf[fkey_start..fkey_end] is bound in the
+ /* If keybuf[fkey.start..fkey.end] is bound in the
function key map and it's a suffix of the current
- sequence (i.e. fkey_end == t), replace it with
- the binding and restart with fkey_start at the end. */
- if ((VECTORP (fkey_next) || STRINGP (fkey_next))
+ sequence (i.e. fkey.end == t), replace it with
+ the binding and restart with fkey.start at the end. */
+ if ((VECTORP (next) || STRINGP (next))
/* If there's a binding (i.e. first_binding >= nmaps)
we don't want to apply this function-key-mapping. */
- && fkey_end == t && first_binding >= nmaps)
+ && fkey.end == t && first_binding >= nmaps)
{
- int len = XFASTINT (Flength (fkey_next));
+ int len = XFASTINT (Flength (next));
- t = fkey_start + len;
+ t = fkey.start + len;
if (t >= bufsize)
error ("Key sequence too long");
- if (VECTORP (fkey_next))
- bcopy (XVECTOR (fkey_next)->contents,
- keybuf + fkey_start,
- (t - fkey_start) * sizeof (keybuf[0]));
- else if (STRINGP (fkey_next))
+ if (VECTORP (next))
+ bcopy (XVECTOR (next)->contents,
+ keybuf + fkey.start,
+ (t - fkey.start) * sizeof (keybuf[0]));
+ else if (STRINGP (next))
{
int i;
for (i = 0; i < len; i++)
- XSETFASTINT (keybuf[fkey_start + i],
- SREF (fkey_next, i));
+ XSETFASTINT (keybuf[fkey.start + i], SREF (next, i));
}
mock_input = t;
- fkey_start = fkey_end = t;
- fkey_map = Vfunction_key_map;
+ fkey.start = fkey.end = t;
+ fkey.map = Vfunction_key_map;
/* Do pass the results through key-translation-map.
But don't retranslate what key-translation-map
has already translated. */
- keytran_end = keytran_start;
- keytran_map = Vkey_translation_map;
+ keytran.end = keytran.start;
+ keytran.map = Vkey_translation_map;
goto replay_sequence;
}
- fkey_map = get_keymap (fkey_next, 0, 1);
+ fkey.map = get_keymap (next, 0, 1);
/* If we no longer have a bound suffix, try a new positions for
- fkey_start. */
- if (!CONSP (fkey_map))
+ fkey.start. */
+ if (!CONSP (fkey.map))
{
- fkey_end = ++fkey_start;
- fkey_map = Vfunction_key_map;
+ fkey.end = ++fkey.start;
+ fkey.map = Vfunction_key_map;
}
}
}
/* Look for this sequence in key-translation-map. */
{
- Lisp_Object keytran_next;
+ Lisp_Object next;
- /* Scan from keytran_end until we find a bound suffix. */
- while (keytran_end < fkey_start)
+ /* Scan from keytran.end until we find a bound suffix. */
+ while (keytran.end < fkey.start)
{
Lisp_Object key;
- key = keybuf[keytran_end++];
- keytran_next
- = access_keymap (keytran_map, key, 1, 0, 1);
+ key = keybuf[keytran.end++];
+ next = access_keymap (keytran.map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
- if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
- && CONSP (XSYMBOL (keytran_next)->function)
- && EQ (XCAR (XSYMBOL (keytran_next)->function), Qautoload))
- do_autoload (XSYMBOL (keytran_next)->function,
- keytran_next);
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next))
+ && CONSP (XSYMBOL (next)->function)
+ && EQ (XCAR (XSYMBOL (next)->function), Qautoload))
+ do_autoload (XSYMBOL (next)->function, next);
/* Handle a symbol whose function definition is a keymap
or an array. */
- if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
- && (!NILP (Farrayp (XSYMBOL (keytran_next)->function))
- || KEYMAPP (XSYMBOL (keytran_next)->function)))
- keytran_next = XSYMBOL (keytran_next)->function;
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next))
+ && (!NILP (Farrayp (XSYMBOL (next)->function))
+ || KEYMAPP (XSYMBOL (next)->function)))
+ next = XSYMBOL (next)->function;
/* If the key translation map gives a function, not an
array, then call the function with one arg and use
its value instead. */
- if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next)))
+ if (SYMBOLP (next) && ! NILP (Ffboundp (next)))
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
- tem = keytran_next;
+ tem = next;
- GCPRO3 (fkey_map, keytran_map, delayed_switch_frame);
- keytran_next = call1 (keytran_next, prompt);
+ GCPRO3 (fkey.map, keytran.map, delayed_switch_frame);
+ next = call1 (next, prompt);
UNGCPRO;
/* If the function returned something invalid,
barf--don't ignore it.
(To ignore it safely, we would need to gcpro a bunch of
other variables.) */
- if (! (VECTORP (keytran_next) || STRINGP (keytran_next)))
+ if (! (VECTORP (next) || STRINGP (next)))
error ("Function in key-translation-map returns invalid key sequence");
}
- /* If keybuf[keytran_start..keytran_end] is bound in the
+ /* If keybuf[keytran.start..keytran.end] is bound in the
key translation map and it's a suffix of the current
- sequence (i.e. keytran_end == t), replace it with
- the binding and restart with keytran_start at the end. */
- if ((VECTORP (keytran_next) || STRINGP (keytran_next)))
+ sequence (i.e. keytran.end == t), replace it with
+ the binding and restart with keytran.start at the end. */
+ if ((VECTORP (next) || STRINGP (next)))
{
- int len = XFASTINT (Flength (keytran_next));
- int i, diff = len - (keytran_end - keytran_start);
+ int len = XFASTINT (Flength (next));
+ int i, diff = len - (keytran.end - keytran.start);
mock_input = max (t, mock_input);
if (mock_input + diff >= bufsize)
error ("Key sequence too long");
- /* Shift the keys that are after keytran_end. */
+ /* Shift the keys that are after keytran.end. */
if (diff < 0)
- for (i = keytran_end; i < mock_input; i++)
+ for (i = keytran.end; i < mock_input; i++)
keybuf[i + diff] = keybuf[i];
else if (diff > 0)
- for (i = mock_input - 1; i >= keytran_end; i--)
+ for (i = mock_input - 1; i >= keytran.end; i--)
keybuf[i + diff] = keybuf[i];
- /* Replace the keys between keytran_start and keytran_end
- with those from keytran_next. */
+ /* Replace the keys between keytran.start and keytran.end
+ with those from next. */
for (i = 0; i < len; i++)
- keybuf[keytran_start + i]
- = Faref (keytran_next, make_number (i));
+ keybuf[keytran.start + i]
+ = Faref (next, make_number (i));
mock_input += diff;
- keytran_start = keytran_end += diff;
- keytran_map = Vkey_translation_map;
+ keytran.start = keytran.end += diff;
+ keytran.map = Vkey_translation_map;
/* Adjust the function-key-map counters. */
- fkey_start += diff;
- fkey_end += diff;
+ fkey.start += diff;
+ fkey.end += diff;
goto replay_sequence;
}
- keytran_map = get_keymap (keytran_next, 0, 1);
+ keytran.map = get_keymap (next, 0, 1);
/* If we no longer have a bound suffix, try a new positions for
- keytran_start. */
- if (!CONSP (keytran_map))
+ keytran.start. */
+ if (!CONSP (keytran.map))
{
- keytran_end = ++keytran_start;
- keytran_map = Vkey_translation_map;
+ keytran.end = ++keytran.start;
+ keytran.map = Vkey_translation_map;
}
}
}
and is an upper case letter
use the corresponding lower-case letter instead. */
if (first_binding >= nmaps
- && fkey_start >= t && keytran_start >= t
+ && fkey.start >= t && keytran.start >= t
&& INTEGERP (key)
&& ((((XINT (key) & 0x3ffff)
< XCHAR_TABLE (current_buffer->downcase_table)->size)
and is a shifted function key,
use the corresponding unshifted function key instead. */
if (first_binding >= nmaps
- && fkey_start >= t && keytran_start >= t
+ && fkey.start >= t && keytran.start >= t
&& SYMBOLP (key))
{
Lisp_Object breakdown;
HCoop / bpt / emacs.git / commitdiff