/* Manipulation of keymaps
- Copyright (C) 1985, 86,87,88,93,94,95,98 Free Software Foundation, Inc.
+ Copyright (C) 1985, 86,87,88,93,94,95,98,99, 2000
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#endif
-#undef NULL
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "termhooks.h"
#include "blockinput.h"
#include "puresize.h"
+#include "intervals.h"
#define min(a, b) ((a) < (b) ? (a) : (b))
+#define KEYMAPP(m) (!NILP (Fkeymapp (m)))
/* The number of elements in keymap vectors. */
#define DENSE_TABLE_SIZE (0200)
extern Lisp_Object Voverriding_local_map;
-static Lisp_Object define_as_prefix ();
-static Lisp_Object describe_buffer_bindings ();
-static void describe_command (), describe_translation ();
-static void describe_map ();
+static Lisp_Object store_in_keymap P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+static void fix_submap_inheritance P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
+
+static Lisp_Object define_as_prefix P_ ((Lisp_Object, Lisp_Object));
+static Lisp_Object describe_buffer_bindings P_ ((Lisp_Object));
+static void describe_command P_ ((Lisp_Object));
+static void describe_translation P_ ((Lisp_Object));
+static void describe_map P_ ((Lisp_Object, Lisp_Object,
+ void (*) P_ ((Lisp_Object)),
+ int, Lisp_Object, Lisp_Object*, int));
\f
/* Keymap object support - constructors and predicates. */
(object)
Lisp_Object object;
{
+ /* FIXME: Maybe this should return t for autoloaded keymaps? -sm */
return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
}
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. */
+ Fdefine_key should cause keymaps to be autoloaded.
+
+ This function can GC when AUTOLOAD is non-zero, because it calls
+ do_autoload which can GC. */
Lisp_Object
get_keymap_1 (object, error, autoload)
Lisp_Object tem;
autoload_retry:
- tem = indirect_function (object);
- if (CONSP (tem) && EQ (XCONS (tem)->car, Qkeymap))
- return tem;
+ if (NILP (object))
+ goto end;
+ if (CONSP (object) && EQ (XCAR (object), Qkeymap))
+ return object;
+ else
+ {
+ tem = indirect_function (object);
+ if (CONSP (tem) && EQ (XCAR (tem), Qkeymap))
+ return tem;
+ }
/* Should we do an autoload? Autoload forms for keymaps have
Qkeymap as their fifth element. */
if (autoload
&& SYMBOLP (object)
&& CONSP (tem)
- && EQ (XCONS (tem)->car, Qautoload))
+ && EQ (XCAR (tem), Qautoload))
{
Lisp_Object tail;
}
}
+ end:
if (error)
wrong_type_argument (Qkeymapp, object);
- else
- return Qnil;
+ return Qnil;
}
keymap = get_keymap_1 (keymap, 1, 1);
/* Skip past the initial element `keymap'. */
- list = XCONS (keymap)->cdr;
- for (; CONSP (list); list = XCONS (list)->cdr)
+ list = XCDR (keymap);
+ for (; CONSP (list); list = XCDR (list))
{
/* See if there is another `keymap'. */
- if (EQ (Qkeymap, XCONS (list)->car))
+ if (KEYMAPP (list))
return list;
}
- return Qnil;
+ return get_keymap_1(list, 0, 1);
+}
+
+
+/* Check whether MAP is one of MAPS parents. */
+int
+keymap_memberp (map, maps)
+ Lisp_Object map, maps;
+{
+ if (NILP (map)) return 0;
+ while (KEYMAPP (maps) && !EQ (map, maps))
+ maps = Fkeymap_parent (maps);
+ return (EQ (map, maps));
}
/* Set the parent keymap of MAP to PARENT. */
Lisp_Object keymap, parent;
{
Lisp_Object list, prev;
+ struct gcpro gcpro1;
int i;
keymap = get_keymap_1 (keymap, 1, 1);
+ GCPRO1 (keymap);
+
if (!NILP (parent))
- parent = get_keymap_1 (parent, 1, 1);
+ {
+ parent = get_keymap_1 (parent, 1, 1);
+
+ /* Check for cycles. */
+ if (keymap_memberp (keymap, parent))
+ error ("Cyclic keymap inheritance");
+ }
/* Skip past the initial element `keymap'. */
prev = keymap;
while (1)
{
- list = XCONS (prev)->cdr;
+ list = XCDR (prev);
/* If there is a parent keymap here, replace it.
If we came to the end, add the parent in PREV. */
- if (! CONSP (list) || EQ (Qkeymap, XCONS (list)->car))
+ if (! CONSP (list) || KEYMAPP (list))
{
/* If we already have the right parent, return now
so that we avoid the loops below. */
- if (EQ (XCONS (prev)->cdr, parent))
- return parent;
+ if (EQ (XCDR (prev), parent))
+ RETURN_UNGCPRO (parent);
- XCONS (prev)->cdr = parent;
+ XCDR (prev) = parent;
break;
}
prev = list;
/* Scan through for submaps, and set their parents too. */
- for (list = XCONS (keymap)->cdr; CONSP (list); list = XCONS (list)->cdr)
+ for (list = XCDR (keymap); CONSP (list); list = XCDR (list))
{
/* Stop the scan when we come to the parent. */
- if (EQ (XCONS (list)->car, Qkeymap))
+ if (EQ (XCAR (list), Qkeymap))
break;
/* If this element holds a prefix map, deal with it. */
- if (CONSP (XCONS (list)->car)
- && CONSP (XCONS (XCONS (list)->car)->cdr))
- fix_submap_inheritance (keymap, XCONS (XCONS (list)->car)->car,
- XCONS (XCONS (list)->car)->cdr);
-
- if (VECTORP (XCONS (list)->car))
- for (i = 0; i < XVECTOR (XCONS (list)->car)->size; i++)
- if (CONSP (XVECTOR (XCONS (list)->car)->contents[i]))
+ if (CONSP (XCAR (list))
+ && CONSP (XCDR (XCAR (list))))
+ fix_submap_inheritance (keymap, XCAR (XCAR (list)),
+ XCDR (XCAR (list)));
+
+ if (VECTORP (XCAR (list)))
+ for (i = 0; i < XVECTOR (XCAR (list))->size; i++)
+ if (CONSP (XVECTOR (XCAR (list))->contents[i]))
fix_submap_inheritance (keymap, make_number (i),
- XVECTOR (XCONS (list)->car)->contents[i]);
+ XVECTOR (XCAR (list))->contents[i]);
- if (CHAR_TABLE_P (XCONS (list)->car))
+ if (CHAR_TABLE_P (XCAR (list)))
{
Lisp_Object indices[3];
- map_char_table (fix_submap_inheritance, Qnil, XCONS (list)->car,
+ map_char_table (fix_submap_inheritance, Qnil, XCAR (list),
keymap, 0, indices);
}
}
- return parent;
+ RETURN_UNGCPRO (parent);
}
/* EVENT is defined in MAP as a prefix, and SUBMAP is its definition.
if EVENT is also a prefix in MAP's parent,
make sure that SUBMAP inherits that definition as its own parent. */
-void
+static void
fix_submap_inheritance (map, event, submap)
Lisp_Object map, event, submap;
{
/* SUBMAP is a cons that we found as a key binding.
Discard the other things found in a menu key binding. */
- if (CONSP (submap))
- {
- /* May be an old format menu item */
- if (STRINGP (XCONS (submap)->car))
- {
- submap = XCONS (submap)->cdr;
- /* Also remove a menu help string, if any,
- following the menu item name. */
- if (CONSP (submap) && STRINGP (XCONS (submap)->car))
- submap = XCONS (submap)->cdr;
- /* Also remove the sublist that caches key equivalences, if any. */
- if (CONSP (submap)
- && CONSP (XCONS (submap)->car))
- {
- Lisp_Object carcar;
- carcar = XCONS (XCONS (submap)->car)->car;
- if (NILP (carcar) || VECTORP (carcar))
- submap = XCONS (submap)->cdr;
- }
- }
-
- /* Or a new format menu item */
- else if (EQ (XCONS (submap)->car, Qmenu_item)
- && CONSP (XCONS (submap)->cdr))
- {
- submap = XCONS (XCONS (submap)->cdr)->cdr;
- if (CONSP (submap))
- submap = XCONS (submap)->car;
- }
- }
+ submap = get_keymap_1 (get_keyelt (submap, 0), 0, 0);
/* If it isn't a keymap now, there's no work to do. */
- if (! CONSP (submap)
- || ! EQ (XCONS (submap)->car, Qkeymap))
+ if (NILP (submap))
return;
map_parent = Fkeymap_parent (map);
if (! NILP (map_parent))
- parent_entry = access_keymap (map_parent, event, 0, 0);
+ parent_entry =
+ get_keymap_1 (access_keymap (map_parent, event, 0, 0, 0), 0, 0);
else
parent_entry = Qnil;
/* If MAP's parent has something other than a keymap,
- our own submap shadows it completely, so use nil as SUBMAP's parent. */
- if (! (CONSP (parent_entry) && EQ (XCONS (parent_entry)->car, Qkeymap)))
- parent_entry = Qnil;
+ our own submap shadows it completely. */
+ if (NILP (parent_entry))
+ return;
if (! EQ (parent_entry, submap))
- Fset_keymap_parent (submap, parent_entry);
+ {
+ Lisp_Object submap_parent;
+ submap_parent = submap;
+ while (1)
+ {
+ Lisp_Object tem;
+
+ tem = Fkeymap_parent (submap_parent);
+
+ if (KEYMAPP (tem))
+ {
+ if (keymap_memberp (tem, parent_entry))
+ /* Fset_keymap_parent could create a cycle. */
+ return;
+ submap_parent = tem;
+ }
+ else
+ break;
+ }
+ Fset_keymap_parent (submap_parent, parent_entry);
+ }
}
\f
/* Look up IDX in MAP. IDX may be any sort of event.
If NOINHERIT, don't accept a subkeymap found in an inherited keymap. */
Lisp_Object
-access_keymap (map, idx, t_ok, noinherit)
+access_keymap (map, idx, t_ok, noinherit, autoload)
Lisp_Object map;
Lisp_Object idx;
int t_ok;
int noinherit;
+ int autoload;
{
int noprefix = 0;
Lisp_Object val;
with more than 24 bits of integer. */
XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));
+ /* Handle the special meta -> esc mapping. */
+ if (INTEGERP (idx) && XUINT (idx) & meta_modifier)
+ {
+ /* See if there is a meta-map. If there's none, there is
+ no binding for IDX, unless a default binding exists in MAP. */
+ Lisp_Object meta_map =
+ get_keymap_1 (access_keymap (map, meta_prefix_char,
+ t_ok, noinherit, autoload),
+ 0, autoload);
+ if (!NILP (meta_map))
+ {
+ map = meta_map;
+ idx = make_number (XUINT (idx) & ~meta_modifier);
+ }
+ else if (t_ok)
+ /* Set IDX to t, so that we only find a default binding. */
+ idx = Qt;
+ else
+ /* We know there is no binding. */
+ return Qnil;
+ }
+
{
Lisp_Object tail;
Lisp_Object t_binding;
t_binding = Qnil;
- for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = XCDR (map);
+ (CONSP (tail)
+ || (tail = get_keymap_1 (tail, 0, autoload),
+ CONSP (tail)));
+ tail = XCDR (tail))
{
Lisp_Object binding;
- binding = XCONS (tail)->car;
+ binding = XCAR (tail);
if (SYMBOLP (binding))
{
/* If NOINHERIT, stop finding prefix definitions
after we pass a second occurrence of the `keymap' symbol. */
- if (noinherit && EQ (binding, Qkeymap) && ! EQ (tail, map))
+ if (noinherit && EQ (binding, Qkeymap))
noprefix = 1;
}
else if (CONSP (binding))
{
- if (EQ (XCONS (binding)->car, idx))
+ if (EQ (XCAR (binding), idx))
{
- val = XCONS (binding)->cdr;
- if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+ val = XCDR (binding);
+ if (noprefix && KEYMAPP (val))
return Qnil;
if (CONSP (val))
fix_submap_inheritance (map, idx, val);
- return val;
+ return get_keyelt (val, autoload);
}
- if (t_ok && EQ (XCONS (binding)->car, Qt))
- t_binding = XCONS (binding)->cdr;
+ if (t_ok && EQ (XCAR (binding), Qt))
+ t_binding = XCDR (binding);
}
else if (VECTORP (binding))
{
if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (binding)->size)
{
val = XVECTOR (binding)->contents[XFASTINT (idx)];
- if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+ if (noprefix && KEYMAPP (val))
return Qnil;
if (CONSP (val))
fix_submap_inheritance (map, idx, val);
- return val;
+ return get_keyelt (val, autoload);
}
}
else if (CHAR_TABLE_P (binding))
| CHAR_SHIFT | CHAR_CTL | CHAR_META)))
{
val = Faref (binding, idx);
- if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
+ if (noprefix && KEYMAPP (val))
return Qnil;
if (CONSP (val))
fix_submap_inheritance (map, idx, val);
- return val;
+ return get_keyelt (val, autoload);
}
}
QUIT;
}
- return t_binding;
+ return get_keyelt (t_binding, autoload);
}
}
{
while (1)
{
- register Lisp_Object map, tem;
+ if (!(CONSP (object)))
+ /* This is really the value. */
+ return object;
- /* If the contents are (KEYMAP . ELEMENT), go indirect. */
- map = get_keymap_1 (Fcar_safe (object), 0, autoload);
- tem = Fkeymapp (map);
- if (!NILP (tem))
+ /* If the keymap contents looks like (keymap ...) or (lambda ...)
+ then use itself. */
+ else if (EQ (XCAR (object), Qkeymap) || EQ (XCAR (object), Qlambda))
+ return object;
+
+ /* If the keymap contents looks like (menu-item name . DEFN)
+ or (menu-item name DEFN ...) then use DEFN.
+ This is a new format menu item. */
+ else if (EQ (XCAR (object), Qmenu_item))
{
- Lisp_Object key;
- key = Fcdr (object);
- if (INTEGERP (key) && (XINT (key) & meta_modifier))
+ if (CONSP (XCDR (object)))
{
- object = access_keymap (map, meta_prefix_char, 0, 0);
- map = get_keymap_1 (object, 0, autoload);
- object = access_keymap (map,
- make_number (XINT (key) & ~meta_modifier),
- 0, 0);
+ Lisp_Object tem;
+
+ object = XCDR (XCDR (object));
+ tem = object;
+ if (CONSP (object))
+ object = XCAR (object);
+
+ /* If there's a `:filter FILTER', apply FILTER to the
+ menu-item's definition to get the real definition to
+ use. Temporarily inhibit GC while evaluating FILTER,
+ because not functions calling get_keyelt are prepared
+ for a GC. */
+ for (; CONSP (tem) && CONSP (XCDR (tem)); tem = XCDR (tem))
+ if (EQ (XCAR (tem), QCfilter))
+ {
+ int count = inhibit_garbage_collection ();
+ Lisp_Object filter;
+ filter = XCAR (XCDR (tem));
+ filter = list2 (filter, list2 (Qquote, object));
+ object = menu_item_eval_property (filter);
+ unbind_to (count, Qnil);
+ break;
+ }
}
else
- object = access_keymap (map, key, 0, 0);
+ /* Invalid keymap */
+ return object;
}
- else if (!(CONSP (object)))
- /* This is really the value. */
- return object;
-
- /* If the keymap contents looks like (STRING . DEFN),
- use DEFN.
+ /* If the keymap contents looks like (STRING . DEFN), use DEFN.
Keymap alist elements like (CHAR MENUSTRING . DEFN)
will be used by HierarKey menus. */
- else if (STRINGP (XCONS (object)->car))
+ else if (STRINGP (XCAR (object)))
{
- object = XCONS (object)->cdr;
+ object = XCDR (object);
/* Also remove a menu help string, if any,
following the menu item name. */
- if (CONSP (object) && STRINGP (XCONS (object)->car))
- object = XCONS (object)->cdr;
+ if (CONSP (object) && STRINGP (XCAR (object)))
+ object = XCDR (object);
/* Also remove the sublist that caches key equivalences, if any. */
- if (CONSP (object)
- && CONSP (XCONS (object)->car))
+ if (CONSP (object) && CONSP (XCAR (object)))
{
Lisp_Object carcar;
- carcar = XCONS (XCONS (object)->car)->car;
+ carcar = XCAR (XCAR (object));
if (NILP (carcar) || VECTORP (carcar))
- object = XCONS (object)->cdr;
+ object = XCDR (object);
}
}
- /* If the keymap contents looks like (menu-item name . DEFN)
- or (menu-item name DEFN ...) then use DEFN.
- This is a new format menu item.
- */
- else if (EQ (XCONS (object)->car, Qmenu_item)
- && CONSP (XCONS (object)->cdr))
+ /* If the contents are (KEYMAP . ELEMENT), go indirect. */
+ else
{
- object = XCONS (XCONS (object)->cdr)->cdr;
- if (CONSP (object))
- object = XCONS (object)->car;
+ Lisp_Object map;
+ map = get_keymap_1 (Fcar_safe (object), 0, autoload);
+ return (NILP (map) ? object /* Invalid keymap */
+ : access_keymap (map, Fcdr (object), 0, 0, autoload));
}
-
- else
- /* Anything else is really the value. */
- return object;
}
}
-Lisp_Object
+static Lisp_Object
store_in_keymap (keymap, idx, def)
Lisp_Object keymap;
register Lisp_Object idx;
/* If we are preparing to dump, and DEF is a menu element
with a menu item indicator, copy it to ensure it is not pure. */
if (CONSP (def) && PURE_P (def)
- && (EQ (XCONS (def)->car, Qmenu_item) || STRINGP (XCONS (def)->car)))
- def = Fcons (XCONS (def)->car, XCONS (def)->cdr);
+ && (EQ (XCAR (def), Qmenu_item) || STRINGP (XCAR (def))))
+ def = Fcons (XCAR (def), XCDR (def));
- if (!CONSP (keymap) || ! EQ (XCONS (keymap)->car, Qkeymap))
+ if (!CONSP (keymap) || ! EQ (XCAR (keymap), Qkeymap))
error ("attempt to define a key in a non-keymap");
/* If idx is a list (some sort of mouse click, perhaps?),
Lisp_Object insertion_point;
insertion_point = keymap;
- for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = XCDR (keymap); CONSP (tail); tail = XCDR (tail))
{
Lisp_Object elt;
- elt = XCONS (tail)->car;
+ elt = XCAR (tail);
if (VECTORP (elt))
{
if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)
}
else if (CONSP (elt))
{
- if (EQ (idx, XCONS (elt)->car))
+ if (EQ (idx, XCAR (elt)))
{
- XCONS (elt)->cdr = def;
+ XCDR (elt) = def;
return def;
}
}
keymap_end:
/* We have scanned the entire keymap, and not found a binding for
IDX. Let's add one. */
- XCONS (insertion_point)->cdr
- = Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr);
+ XCDR (insertion_point)
+ = Fcons (Fcons (idx, def), XCDR (insertion_point));
}
-
+
return def;
}
copy = Fcopy_alist (get_keymap (keymap));
- for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = copy; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object elt;
- elt = XCONS (tail)->car;
+ elt = XCAR (tail);
if (CHAR_TABLE_P (elt))
{
Lisp_Object indices[3];
elt = Fcopy_sequence (elt);
- XCONS (tail)->car = elt;
+ XCAR (tail) = elt;
map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
}
int i;
elt = Fcopy_sequence (elt);
- XCONS (tail)->car = elt;
+ XCAR (tail) = elt;
for (i = 0; i < XVECTOR (elt)->size; i++)
if (!SYMBOLP (XVECTOR (elt)->contents[i])
XVECTOR (elt)->contents[i]
= Fcopy_keymap (XVECTOR (elt)->contents[i]);
}
- else if (CONSP (elt) && CONSP (XCONS (elt)->cdr))
+ else if (CONSP (elt) && CONSP (XCDR (elt)))
{
Lisp_Object tem;
- tem = XCONS (elt)->cdr;
+ tem = XCDR (elt);
/* Is this a new format menu item. */
- if (EQ (XCONS (tem)->car,Qmenu_item))
+ if (EQ (XCAR (tem),Qmenu_item))
{
/* Copy cell with menu-item marker. */
- XCONS (elt)->cdr
- = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
- elt = XCONS (elt)->cdr;
- tem = XCONS (elt)->cdr;
+ XCDR (elt)
+ = Fcons (XCAR (tem), XCDR (tem));
+ elt = XCDR (elt);
+ tem = XCDR (elt);
if (CONSP (tem))
{
/* Copy cell with menu-item name. */
- XCONS (elt)->cdr
- = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
- elt = XCONS (elt)->cdr;
- tem = XCONS (elt)->cdr;
+ XCDR (elt)
+ = Fcons (XCAR (tem), XCDR (tem));
+ elt = XCDR (elt);
+ tem = XCDR (elt);
};
if (CONSP (tem))
{
/* Copy cell with binding and if the binding is a keymap,
copy that. */
- XCONS (elt)->cdr
- = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
- elt = XCONS (elt)->cdr;
- tem = XCONS (elt)->car;
+ XCDR (elt)
+ = Fcons (XCAR (tem), XCDR (tem));
+ elt = XCDR (elt);
+ tem = XCAR (elt);
if (!(SYMBOLP (tem) || NILP (Fkeymapp (tem))))
- XCONS (elt)->car = Fcopy_keymap (tem);
- tem = XCONS (elt)->cdr;
- if (CONSP (tem) && CONSP (XCONS (tem)->car))
+ XCAR (elt) = Fcopy_keymap (tem);
+ tem = XCDR (elt);
+ if (CONSP (tem) && CONSP (XCAR (tem)))
/* Delete cache for key equivalences. */
- XCONS (elt)->cdr = XCONS (tem)->cdr;
+ XCDR (elt) = XCDR (tem);
}
}
else
/* It may be an old fomat menu item.
Skip the optional menu string.
*/
- if (STRINGP (XCONS (tem)->car))
+ if (STRINGP (XCAR (tem)))
{
/* Copy the cell, since copy-alist didn't go this deep. */
- XCONS (elt)->cdr
- = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
- elt = XCONS (elt)->cdr;
- tem = XCONS (elt)->cdr;
+ XCDR (elt)
+ = Fcons (XCAR (tem), XCDR (tem));
+ elt = XCDR (elt);
+ tem = XCDR (elt);
/* Also skip the optional menu help string. */
- if (CONSP (tem) && STRINGP (XCONS (tem)->car))
+ if (CONSP (tem) && STRINGP (XCAR (tem)))
{
- XCONS (elt)->cdr
- = Fcons (XCONS (tem)->car, XCONS (tem)->cdr);
- elt = XCONS (elt)->cdr;
- tem = XCONS (elt)->cdr;
+ XCDR (elt)
+ = Fcons (XCAR (tem), XCDR (tem));
+ elt = XCDR (elt);
+ tem = XCDR (elt);
}
/* There may also be a list that caches key equivalences.
Just delete it for the new keymap. */
if (CONSP (tem)
- && CONSP (XCONS (tem)->car)
- && (NILP (XCONS (XCONS (tem)->car)->car)
- || VECTORP (XCONS (XCONS (tem)->car)->car)))
- XCONS (elt)->cdr = XCONS (tem)->cdr;
+ && CONSP (XCAR (tem))
+ && (NILP (XCAR (XCAR (tem)))
+ || VECTORP (XCAR (XCAR (tem)))))
+ XCDR (elt) = XCDR (tem);
}
if (CONSP (elt)
- && ! SYMBOLP (XCONS (elt)->cdr)
- && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
- XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
+ && ! SYMBOLP (XCDR (elt))
+ && ! NILP (Fkeymapp (XCDR (elt))))
+ XCDR (elt) = Fcopy_keymap (XCDR (elt));
}
}
{
register int idx;
register Lisp_Object c;
- register Lisp_Object tem;
register Lisp_Object cmd;
int metized = 0;
int meta_bit;
if (idx == length)
RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
- cmd = get_keyelt (access_keymap (keymap, c, 0, 1), 1);
+ cmd = access_keymap (keymap, c, 0, 1, 1);
/* If this key is undefined, make it a prefix. */
if (NILP (cmd))
Lisp_Object accept_default;
{
register int idx;
- register Lisp_Object tem;
register Lisp_Object cmd;
register Lisp_Object c;
- int metized = 0;
int length;
int t_ok = ! NILP (accept_default);
- int meta_bit;
struct gcpro gcpro1;
keymap = get_keymap_1 (keymap, 1, 1);
if (length == 0)
return keymap;
- if (VECTORP (key))
- meta_bit = meta_modifier;
- else
- meta_bit = 0x80;
-
GCPRO1 (key);
idx = 0;
while (1)
{
- c = Faref (key, make_number (idx));
+ c = Faref (key, make_number (idx++));
if (CONSP (c) && lucid_event_type_list_p (c))
c = Fevent_convert_list (c);
- if (INTEGERP (c)
- && (XINT (c) & meta_bit)
- && !metized)
- {
- c = meta_prefix_char;
- metized = 1;
- }
- else
- {
- if (INTEGERP (c))
- XSETINT (c, XINT (c) & ~meta_bit);
-
- metized = 0;
- idx++;
- }
+ /* Turn the 8th bit of string chars into a meta modifier. */
+ if (XINT (c) & 0x80 && STRINGP (key))
+ XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
- cmd = get_keyelt (access_keymap (keymap, c, t_ok, 0), 1);
+ cmd = access_keymap (keymap, c, t_ok, 0, 1);
if (idx == length)
RETURN_UNGCPRO (cmd);
define_as_prefix (keymap, c)
Lisp_Object keymap, c;
{
- Lisp_Object inherit, cmd;
+ Lisp_Object cmd;
cmd = Fmake_sparse_keymap (Qnil);
/* If this key is defined as a prefix in an inherited keymap,
make it a prefix in this map, and make its definition
inherit the other prefix definition. */
- inherit = access_keymap (keymap, c, 0, 0);
-#if 0
- /* This code is needed to do the right thing in the following case:
- keymap A inherits from B,
- you define KEY as a prefix in A,
- then later you define KEY as a prefix in B.
- We want the old prefix definition in A to inherit from that in B.
- It is hard to do that retroactively, so this code
- creates the prefix in B right away.
-
- But it turns out that this code causes problems immediately
- when the prefix in A is defined: it causes B to define KEY
- as a prefix with no subcommands.
-
- So I took out this code. */
- if (NILP (inherit))
- {
- /* If there's an inherited keymap
- and it doesn't define this key,
- make it define this key. */
- Lisp_Object tail;
-
- for (tail = Fcdr (keymap); CONSP (tail); tail = XCONS (tail)->cdr)
- if (EQ (XCONS (tail)->car, Qkeymap))
- break;
-
- if (!NILP (tail))
- inherit = define_as_prefix (tail, c);
- }
-#endif
-
- cmd = nconc2 (cmd, inherit);
+ cmd = nconc2 (cmd, access_keymap (keymap, c, 0, 0, 0));
store_in_keymap (keymap, c, cmd);
return cmd;
for (list_number = 0; list_number < 2; list_number++)
for (alist = lists[list_number];
CONSP (alist);
- alist = XCONS (alist)->cdr)
- if ((assoc = XCONS (alist)->car, CONSP (assoc))
- && (var = XCONS (assoc)->car, SYMBOLP (var))
+ alist = XCDR (alist))
+ if ((assoc = XCAR (alist), CONSP (assoc))
+ && (var = XCAR (assoc), SYMBOLP (var))
&& (val = find_symbol_value (var), ! EQ (val, Qunbound))
&& ! NILP (val))
{
BLOCK_INPUT;
cmm_size = 30;
newmodes
- = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
+ = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
newmaps
- = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
+ = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
UNBLOCK_INPUT;
}
/* Get the keymap definition--or nil if it is not defined. */
temp = internal_condition_case_1 (Findirect_function,
- XCONS (assoc)->cdr,
+ XCDR (assoc),
Qerror, current_minor_maps_error);
if (!NILP (temp))
{
RETURN_UNGCPRO (value);
}
- local = get_local_map (PT, current_buffer);
+ local = get_local_map (PT, current_buffer, keymap);
+ if (! NILP (local))
+ {
+ value = Flookup_key (local, key, accept_default);
+ if (! NILP (value) && !INTEGERP (value))
+ RETURN_UNGCPRO (value);
+ }
+
+ local = get_local_map (PT, current_buffer, local_map);
if (! NILP (local))
{
for (i = 0, i_byte = 0; i < XSTRING (prefix)->size;)
{
int i_before = i;
- if (STRING_MULTIBYTE (prefix))
- FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
- else
- {
- c = XSTRING (prefix)->data[i++];
- if (c & 0200)
- c ^= 0200 | meta_modifier;
- }
+
+ FETCH_STRING_CHAR_ADVANCE (c, prefix, i, i_byte);
+ if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
+ c ^= 0200 | meta_modifier;
XVECTOR (copy)->contents[i_before] = make_number (c);
}
prefix = copy;
This is a breadth-first traversal, where tail is the queue of
nodes, and maps accumulates a list of all nodes visited. */
- for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = maps; CONSP (tail); tail = XCDR (tail))
{
register Lisp_Object thisseq, thismap;
Lisp_Object last;
&& XINT (last) >= prefixlen
&& EQ (Faref (thisseq, last), meta_prefix_char));
- for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
+ for (; CONSP (thismap); thismap = XCDR (thismap))
{
Lisp_Object elt;
- elt = XCONS (thismap)->car;
+ elt = XCAR (thismap);
QUIT;
/* 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);
+ XCDR (tail)
+ = Fcons (Fcons (tem, cmd), XCDR (tail));
}
else
{
}
else if (CONSP (elt))
{
- register Lisp_Object cmd, tem, filter;
+ register Lisp_Object cmd, tem;
- cmd = get_keyelt (XCONS (elt)->cdr, 0);
+ cmd = get_keyelt (XCDR (elt), 0);
/* Ignore definitions that aren't keymaps themselves. */
tem = Fkeymapp (cmd);
if (!NILP (tem))
if (NILP (tem))
{
/* Let elt be the event defined by this map entry. */
- elt = XCONS (elt)->car;
+ elt = XCAR (elt);
/* If the last key in thisseq is meta-prefix-char, and
this entry is a binding for an ascii keystroke,
/* 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);
+ XCDR (tail)
+ = Fcons (Fcons (tem, cmd), XCDR (tail));
}
else
nconc2 (tail,
/* Now find just the maps whose access prefixes start with PREFIX. */
good_maps = Qnil;
- for (; CONSP (maps); maps = XCONS (maps)->cdr)
+ for (; CONSP (maps); maps = XCDR (maps))
{
Lisp_Object elt, thisseq;
- elt = XCONS (maps)->car;
- thisseq = XCONS (elt)->car;
+ elt = XCAR (maps);
+ thisseq = XCAR (elt);
/* The access prefix must be at least as long as PREFIX,
and the first elements must match those of PREFIX. */
if (XINT (Flength (thisseq)) >= prefixlen)
if (NILP (cmd))
return;
- maps = XCONS (args)->car;
- tail = XCONS (XCONS (args)->cdr)->car;
- thisseq = XCONS (XCONS (args)->cdr)->cdr;
+ maps = XCAR (args);
+ tail = XCAR (XCDR (args));
+ thisseq = XCDR (XCDR (args));
tem = Fkeymapp (cmd);
if (!NILP (tem))
(keys)
Lisp_Object keys;
{
- int len;
+ int len = 0;
int i, i_byte;
Lisp_Object sep;
- Lisp_Object *args;
+ Lisp_Object *args = NULL;
if (STRINGP (keys))
{
int c;
int i_before = i;
- if (STRING_MULTIBYTE (keys))
- FETCH_STRING_CHAR_ADVANCE (c, keys, i, i_byte);
- else
- {
- c = XSTRING (keys)->data[i++];
- if (c & 0200)
- c ^= 0200 | meta_modifier;
- }
-
+ FETCH_STRING_CHAR_ADVANCE (c, keys, i, i_byte);
+ if (SINGLE_BYTE_CHAR_P (c) && (c & 0200))
+ c ^= 0200 | meta_modifier;
XSETFASTINT (XVECTOR (vector)->contents[i_before], c);
}
keys = vector;
for (i = 0; i < len; i++)
{
- args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i]);
+ args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i],
+ Qnil);
args[i * 2 + 1] = sep;
}
}
for (i = 0; i < len; i++)
{
- args[i * 2] = Fsingle_key_description (XCONS (keys)->car);
+ args[i * 2] = Fsingle_key_description (XCAR (keys), Qnil);
args[i * 2 + 1] = sep;
- keys = XCONS (keys)->cdr;
+ keys = XCDR (keys);
}
}
else
register unsigned int c;
register char *p;
{
+ unsigned c2;
+
/* Clear all the meaningless bits above the meta bit. */
c &= meta_modifier | ~ - meta_modifier;
+ c2 = c & ~(alt_modifier | ctrl_modifier | hyper_modifier
+ | meta_modifier | shift_modifier | super_modifier);
if (c & alt_modifier)
{
*p++ = '-';
c -= alt_modifier;
}
- if (c & ctrl_modifier)
+ if ((c & ctrl_modifier) != 0
+ || (c2 < ' ' && c2 != 27 && c2 != '\t' && c2 != Ctl ('M')))
{
*p++ = 'C';
*p++ = '-';
- c -= ctrl_modifier;
+ c &= ~ctrl_modifier;
}
if (c & hyper_modifier)
{
}
else
{
- *p++ = 'C';
- *p++ = '-';
+ /* `C-' already added above. */
if (c > 0 && c <= Ctl ('Z'))
*p++ = c + 0140;
else
}
else
{
- unsigned char work[4], *str;
- int i = CHAR_STRING (c, work, str);
- bcopy (str, p, i);
- p += i;
+ p += CHAR_STRING (c, p);
}
}
/* This function cannot GC. */
-DEFUN ("single-key-description", Fsingle_key_description, Ssingle_key_description, 1, 1, 0,
+DEFUN ("single-key-description", Fsingle_key_description,
+ Ssingle_key_description, 1, 2, 0,
"Return a pretty description of command character KEY.\n\
-Control characters turn into C-whatever, etc.")
- (key)
- Lisp_Object key;
+Control characters turn into C-whatever, etc.\n\
+Optional argument NO-ANGLES non-nil means don't put angle brackets\n\
+around function keys and event symbols.")
+ (key, no_angles)
+ Lisp_Object key, no_angles;
{
if (CONSP (key) && lucid_event_type_list_p (key))
key = Fevent_convert_list (key);
if (SINGLE_BYTE_CHAR_P (without_bits))
charset = 0;
else
- SPLIT_NON_ASCII_CHAR (without_bits, charset, c1, c2);
+ SPLIT_CHAR (without_bits, charset, c1, c2);
if (charset
&& CHARSET_DEFINED_P (charset)
}
else
{
- char tem[20];
+ char tem[KEY_DESCRIPTION_SIZE];
*push_key_description (XUINT (key), tem) = 0;
return build_string (tem);
}
}
else if (SYMBOLP (key)) /* Function key or event-symbol */
- return Fsymbol_name (key);
+ {
+ if (NILP (no_angles))
+ {
+ char *buffer
+ = (char *) alloca (STRING_BYTES (XSYMBOL (key)->name) + 5);
+ sprintf (buffer, "<%s>", XSYMBOL (key)->name->data);
+ return build_string (buffer);
+ }
+ else
+ return Fsymbol_name (key);
+ }
else if (STRINGP (key)) /* Buffer names in the menubar. */
return Fcopy_sequence (key);
else
error ("KEY must be an integer, cons, symbol, or string");
+ return Qnil;
}
char *
(character)
Lisp_Object character;
{
- char tem[6];
+ /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6). */
+ unsigned char str[6];
+ int c;
CHECK_NUMBER (character, 0);
- if (!SINGLE_BYTE_CHAR_P (XFASTINT (character)))
+ c = XINT (character);
+ if (!SINGLE_BYTE_CHAR_P (c))
{
- unsigned char *str;
- int len = non_ascii_char_to_string (XFASTINT (character), tem, &str);
+ int len = CHAR_STRING (c, str);
return make_multibyte_string (str, 1, len);
}
- *push_text_char_description (XINT (character) & 0377, tem) = 0;
+ *push_text_char_description (c & 0377, str) = 0;
- return build_string (tem);
+ return build_string (str);
}
/* Return non-zero if SEQ contains only ASCII characters, perhaps with
/* This function can GC if Flookup_key autoloads any keymaps. */
+static INLINE int
+menu_item_p (item)
+ Lisp_Object item;
+{
+ return (CONSP (item)
+ && (EQ (XCAR (item),Qmenu_item)
+ || STRINGP (XCAR (item))));
+}
+
DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,
"Return list of keys that invoke DEFINITION.\n\
If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
If optional 4th arg NOINDIRECT is non-nil, don't follow indirections\n\
to other keymaps or slots. This makes it possible to search for an\n\
indirect definition itself.")
- (definition, keymap, firstonly, noindirect)
- Lisp_Object definition, keymap;
+ (definition, xkeymap, firstonly, noindirect)
+ Lisp_Object definition, xkeymap;
Lisp_Object firstonly, noindirect;
{
Lisp_Object maps;
Lisp_Object found, sequences;
Lisp_Object keymap1;
- int keymap_specified = !NILP (keymap);
+ int keymap_specified = !NILP (xkeymap);
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
/* 1 means ignore all menu bindings entirely. */
int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
context. But don't muck with the value of `keymap',
because `where_is_internal_1' uses it to check for
shadowed bindings. */
- keymap1 = keymap;
+ keymap1 = xkeymap;
if (! keymap_specified)
- {
-#ifdef USE_TEXT_PROPERTIES
- keymap1 = get_local_map (PT, current_buffer);
-#else
- keymap1 = current_buffer->keymap;
-#endif
- }
+ keymap1 = get_local_map (PT, current_buffer, keymap);
if (!NILP (keymap1))
maps = nconc2 (Faccessible_keymaps (get_keymap (keymap1), Qnil),
Faccessible_keymaps (get_keymap (current_global_map),
Qnil));
else
- maps = Faccessible_keymaps (get_keymap (current_global_map), Qnil);
+ {
+ keymap1 = xkeymap;
+ if (! keymap_specified)
+ keymap1 = get_local_map (PT, current_buffer, local_map);
+
+ if (!NILP (keymap1))
+ maps = nconc2 (Faccessible_keymaps (get_keymap (keymap1), Qnil),
+ Faccessible_keymaps (get_keymap (current_global_map),
+ Qnil));
+ else
+ maps = Faccessible_keymaps (get_keymap (current_global_map), Qnil);
+ }
/* Put the minor mode keymaps on the front. */
if (! keymap_specified)
minors = Fnreverse (Fcurrent_minor_mode_maps ());
while (!NILP (minors))
{
- maps = nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors)->car),
+ maps = nconc2 (Faccessible_keymaps (get_keymap (XCAR (minors)),
Qnil),
maps);
- minors = XCONS (minors)->cdr;
+ minors = XCDR (minors);
}
}
- GCPRO5 (definition, keymap, maps, found, sequences);
+ GCPRO5 (definition, xkeymap, maps, found, sequences);
found = Qnil;
sequences = Qnil;
last_is_meta = (XINT (last) >= 0
&& EQ (Faref (this, last), meta_prefix_char));
+ if (nomenus && XINT (last) >= 0)
+ { /* If no menu entries should be returned, skip over the
+ keymaps bound to `menu-bar' and `tool-bar'. */
+ Lisp_Object tem = Faref (this, 0);
+ if (EQ (tem, Qmenu_bar) || EQ (tem, Qtool_bar))
+ continue;
+ }
+
QUIT;
while (CONSP (map))
advance map to the next element until i indicates that we
have finished off the vector. */
Lisp_Object elt, key, binding;
- elt = XCONS (map)->car;
- map = XCONS (map)->cdr;
+ elt = XCAR (map);
+ map = XCDR (map);
sequences = Qnil;
binding = XVECTOR (elt)->contents[i];
XSETFASTINT (key, i);
sequence = where_is_internal_1 (binding, key, definition,
- noindirect, keymap, this,
+ noindirect, xkeymap, this,
last, nomenus, last_is_meta);
if (!NILP (sequence))
sequences = Fcons (sequence, sequences);
Lisp_Object args;
args = Fcons (Fcons (Fcons (definition, noindirect),
- Fcons (keymap, Qnil)),
+ Fcons (xkeymap, Qnil)),
Fcons (Fcons (this, last),
Fcons (make_number (nomenus),
make_number (last_is_meta))));
-
map_char_table (where_is_internal_2, Qnil, elt, args,
0, indices);
- sequences = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
+ sequences = XCDR (XCDR (XCAR (args)));
}
else if (CONSP (elt))
{
Lisp_Object sequence;
- key = XCONS (elt)->car;
- binding = XCONS (elt)->cdr;
+ key = XCAR (elt);
+ binding = XCDR (elt);
sequence = where_is_internal_1 (binding, key, definition,
- noindirect, keymap, this,
+ noindirect, xkeymap, this,
last, nomenus, last_is_meta);
if (!NILP (sequence))
sequences = Fcons (sequence, sequences);
}
- for (; ! NILP (sequences); sequences = XCONS (sequences)->cdr)
+ for (; ! NILP (sequences); sequences = XCDR (sequences))
{
Lisp_Object sequence;
- sequence = XCONS (sequences)->car;
+ sequence = XCAR (sequences);
/* It is a true unshadowed match. Record it, unless it's already
been seen (as could happen when inheriting keymaps). */
.
((THIS . LAST) . (NOMENUS . LAST_IS_META)))
Since map_char_table doesn't really use the return value from this function,
- we the result append to RESULT, the slot in ARGS. */
+ we the result append to RESULT, the slot in ARGS.
+
+ This function can GC because it calls where_is_internal_1 which can
+ GC. */
static void
where_is_internal_2 (args, key, binding)
Lisp_Object definition, noindirect, keymap, this, last;
Lisp_Object result, sequence;
int nomenus, last_is_meta;
+ struct gcpro gcpro1, gcpro2, gcpro3;
- result = XCONS (XCONS (XCONS (args)->car)->cdr)->cdr;
- definition = XCONS (XCONS (XCONS (args)->car)->car)->car;
- noindirect = XCONS (XCONS (XCONS (args)->car)->car)->cdr;
- keymap = XCONS (XCONS (XCONS (args)->car)->cdr)->car;
- this = XCONS (XCONS (XCONS (args)->cdr)->car)->car;
- last = XCONS (XCONS (XCONS (args)->cdr)->car)->cdr;
- nomenus = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->car);
- last_is_meta = XFASTINT (XCONS (XCONS (XCONS (args)->cdr)->cdr)->cdr);
+ GCPRO3 (args, key, binding);
+ result = XCDR (XCDR (XCAR (args)));
+ definition = XCAR (XCAR (XCAR (args)));
+ noindirect = XCDR (XCAR (XCAR (args)));
+ keymap = XCAR (XCDR (XCAR (args)));
+ this = XCAR (XCAR (XCDR (args)));
+ last = XCDR (XCAR (XCDR (args)));
+ nomenus = XFASTINT (XCAR (XCDR (XCDR (args))));
+ last_is_meta = XFASTINT (XCDR (XCDR (XCDR (args))));
sequence = where_is_internal_1 (binding, key, definition, noindirect, keymap,
this, last, nomenus, last_is_meta);
if (!NILP (sequence))
- XCONS (XCONS (XCONS (args)->car)->cdr)->cdr
- = Fcons (sequence, result);
+ XCDR (XCDR (XCAR (args))) = Fcons (sequence, result);
+
+ UNGCPRO;
}
+
+/* This function can GC.because Flookup_key calls get_keymap_1 with
+ non-zero argument AUTOLOAD. */
+
static Lisp_Object
where_is_internal_1 (binding, key, definition, noindirect, keymap, this, last,
nomenus, last_is_meta)
{
Lisp_Object sequence;
int keymap_specified = !NILP (keymap);
+ struct gcpro gcpro1, gcpro2;
+ /* Skip left-over menu-items.
+ These can appear in a keymap bound to a mouse click, for example. */
+ if (nomenus && menu_item_p (binding))
+ return Qnil;
/* Search through indirections unless that's not wanted. */
if (NILP (noindirect))
- {
- if (nomenus)
- {
- while (1)
- {
- Lisp_Object map, tem;
- /* If the contents are (KEYMAP . ELEMENT), go indirect. */
- map = get_keymap_1 (Fcar_safe (definition), 0, 0);
- tem = Fkeymapp (map);
- if (!NILP (tem))
- definition = access_keymap (map, Fcdr (definition), 0, 0);
- else
- break;
- }
- /* If the contents are (menu-item ...) or (STRING ...), reject. */
- if (CONSP (definition)
- && (EQ (XCONS (definition)->car,Qmenu_item)
- || STRINGP (XCONS (definition)->car)))
- return Qnil;
- }
- else
- binding = get_keyelt (binding, 0);
- }
+ binding = get_keyelt (binding, 0);
/* End this iteration if this element does not match
the target. */
Either nil or number as value from Flookup_key
means undefined. */
+ GCPRO2 (sequence, binding);
if (keymap_specified)
{
binding = Flookup_key (keymap, sequence, Qnil);
Lisp_Object tem;
tem = Fequal (binding, definition);
if (NILP (tem))
- return Qnil;
+ RETURN_UNGCPRO (Qnil);
}
else
if (!EQ (binding, definition))
- return Qnil;
+ RETURN_UNGCPRO (Qnil);
}
}
else
{
binding = Fkey_binding (sequence, Qnil);
if (!EQ (binding, definition))
- return Qnil;
+ RETURN_UNGCPRO (Qnil);
}
- return sequence;
+ RETURN_UNGCPRO (sequence);
}
\f
/* describe-bindings - summarizing all the bindings in a set of keymaps. */
You type Translation\n\
-------- -----------\n";
- descbuf = XCONS (arg)->car;
- arg = XCONS (arg)->cdr;
- prefix = XCONS (arg)->car;
- arg = XCONS (arg)->cdr;
- nomenu = NILP (XCONS (arg)->car);
+ descbuf = XCAR (arg);
+ arg = XCDR (arg);
+ prefix = XCAR (arg);
+ arg = XCDR (arg);
+ nomenu = NILP (XCAR (arg));
shadow = Qnil;
GCPRO1 (shadow);
for (c = 0; c < translate_len; c++)
if (translate[c] != c)
{
- char buf[20];
+ char buf[KEY_DESCRIPTION_SIZE];
char *bufend;
if (alternate_heading)
if (!SYMBOLP (modes[i]))
abort();
- p = title = (char *) alloca (40 + XSYMBOL (modes[i])->name->size);
+ p = title = (char *) alloca (42 + XSYMBOL (modes[i])->name->size);
+ *p++ = '\f';
+ *p++ = '\n';
*p++ = '`';
bcopy (XSYMBOL (modes[i])->name->data, p,
XSYMBOL (modes[i])->name->size);
if (!NILP (start1))
{
describe_map_tree (start1, 1, shadow, prefix,
- "Major Mode Bindings", nomenu, 0, 0);
+ "\f\nMajor Mode Bindings", nomenu, 0, 0);
shadow = Fcons (start1, shadow);
}
describe_map_tree (current_global_map, 1, shadow, prefix,
- "Global Bindings", nomenu, 0, 1);
+ "\f\nGlobal Bindings", nomenu, 0, 1);
/* Print the function-key-map translations under this prefix. */
if (!NILP (Vfunction_key_map))
describe_map_tree (Vfunction_key_map, 0, Qnil, prefix,
- "Function key map translations", nomenu, 1, 0);
+ "\f\nFunction key map translations", nomenu, 1, 0);
call0 (intern ("help-mode"));
Fset_buffer (descbuf);
Lisp_Object list;
/* Delete from MAPS each element that is for the menu bar. */
- for (list = maps; !NILP (list); list = XCONS (list)->cdr)
+ for (list = maps; !NILP (list); list = XCDR (list))
{
Lisp_Object elt, prefix, tem;
sub_shadows = Qnil;
- for (tail = shadow; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = shadow; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object shmap;
- shmap = XCONS (tail)->car;
+ shmap = XCAR (tail);
/* If the sequence by which we reach this keymap is zero-length,
then the shadow map for this keymap is just SHADOW. */
{
Lisp_Object tail, value;
- for (tail = shadow; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = shadow; CONSP (tail); tail = XCDR (tail))
{
- value = Flookup_key (XCONS (tail)->car, key, flag);
+ value = Flookup_key (XCAR (tail), key, flag);
if (!NILP (value))
return value;
}
int first = 1;
struct gcpro gcpro1, gcpro2, gcpro3;
+ suppress = Qnil;
+
if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
{
/* Call Fkey_description first, to avoid GC bug for the other string. */
GCPRO3 (elt_prefix, definition, kludge);
- for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (tail = map; CONSP (tail); tail = XCDR (tail))
{
QUIT;
- if (VECTORP (XCONS (tail)->car)
- || CHAR_TABLE_P (XCONS (tail)->car))
- describe_vector (XCONS (tail)->car,
+ if (VECTORP (XCAR (tail))
+ || CHAR_TABLE_P (XCAR (tail)))
+ describe_vector (XCAR (tail),
elt_prefix, elt_describer, partial, shadow, map,
(int *)0, 0);
- else if (CONSP (XCONS (tail)->car))
+ else if (CONSP (XCAR (tail)))
{
- event = XCONS (XCONS (tail)->car)->car;
+ event = XCAR (XCAR (tail));
/* Ignore bindings whose "keys" are not really valid events.
(We get these in the frames and buffers menu.) */
if (nomenu && EQ (event, Qmenu_bar))
continue;
- definition = get_keyelt (XCONS (XCONS (tail)->car)->cdr, 0);
+ definition = get_keyelt (XCDR (XCAR (tail)), 0);
/* Don't show undefined commands or suppressed commands. */
if (NILP (definition)) continue;
insert1 (elt_prefix);
/* THIS gets the string to describe the character EVENT. */
- insert1 (Fsingle_key_description (event));
+ insert1 (Fsingle_key_description (event, Qnil));
/* Print a description of the definition of this character.
elt_describer will take care of spacing out far enough
for alignment purposes. */
(*elt_describer) (definition);
}
- else if (EQ (XCONS (tail)->car, Qkeymap))
+ else if (EQ (XCAR (tail), Qkeymap))
{
/* The same keymap might be in the structure twice, if we're
using an inherited keymap. So skip anything we've already
encountered. */
tem = Fassq (tail, *seen);
- if (CONSP (tem) && !NILP (Fequal (XCONS (tem)->car, keys)))
+ if (CONSP (tem) && !NILP (Fequal (XCAR (tem), keys)))
break;
*seen = Fcons (Fcons (tail, keys), *seen);
}
Lisp_Object suppress;
Lisp_Object kludge;
int first = 1;
- struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+ struct gcpro gcpro1, gcpro2, gcpro3;
/* Range of elements to be handled. */
int from, to;
/* A flag to tell if a leaf in this level of char-table is not a
int character;
int starting_i;
+ suppress = Qnil;
+
if (indices == 0)
indices = (int *) alloca (3 * sizeof (int));
}
else if (complete_char)
{
- character
- = MAKE_NON_ASCII_CHAR (indices[0], indices[1], indices[2]);
+ character = MAKE_CHAR (indices[0], indices[1], indices[2]);
}
else
character = 0;
else if (CHAR_TABLE_P (vector))
{
if (complete_char)
- insert1 (Fsingle_key_description (make_number (character)));
+ insert1 (Fsingle_key_description (make_number (character), Qnil));
else
{
/* Print the information for this character set. */
}
else
{
- insert1 (Fsingle_key_description (make_number (character)));
+ insert1 (Fsingle_key_description (make_number (character), Qnil));
}
/* If we find a sub char-table within a char-table,
{
if (char_table_depth == 0)
{
- insert1 (Fsingle_key_description (make_number (i)));
+ insert1 (Fsingle_key_description (make_number (i), Qnil));
}
else if (complete_char)
{
indices[char_table_depth] = i;
- character
- = MAKE_NON_ASCII_CHAR (indices[0], indices[1], indices[2]);
+ character = MAKE_CHAR (indices[0], indices[1], indices[2]);
insert_char (character);
}
else
}
else
{
- insert1 (Fsingle_key_description (make_number (i)));
+ insert1 (Fsingle_key_description (make_number (i), Qnil));
}
}
void
syms_of_keymap ()
{
- Lisp_Object tem;
-
Qkeymap = intern ("keymap");
staticpro (&Qkeymap);
void
keys_of_keymap ()
{
- Lisp_Object tem;
-
initial_define_key (global_map, 033, "ESC-prefix");
initial_define_key (global_map, Ctl('X'), "Control-X-prefix");
}
HCoop / bpt / emacs.git / blobdiff