(store_in_keymap): Add `static' to declaration.

[bpt/emacs.git] / src / keymap.c

diff --git a/src/keymap.c b/src/keymap.c
index 2cecfcd..410d38e 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,5 @@
 /* Manipulation of keymaps
 /* Manipulation of keymaps

-   Copyright (C) 1985, 86, 87, 88, 93, 94, 95 Free Software Foundation, Inc.
+   Copyright (C) 1985, 86,87,88,93,94,95,98,99 Free Software Foundation, Inc.

 
 This file is part of GNU Emacs.
 
 
 This file is part of GNU Emacs.
 


@@ -30,8 +30,10 @@ Boston, MA 02111-1307, USA.  */
 #include "termhooks.h"
 #include "blockinput.h"
 #include "puresize.h"
 #include "termhooks.h"
 #include "blockinput.h"
 #include "puresize.h"

+#include "intervals.h"

 
 #define min(a, b) ((a) < (b) ? (a) : (b))
 
 #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)
 
 /* The number of elements in keymap vectors.  */
 #define DENSE_TABLE_SIZE (0200)


@@ -71,6 +73,10 @@ Lisp_Object Vminibuffer_local_must_match_map;
 /* Alist of minor mode variables and keymaps.  */
 Lisp_Object Vminor_mode_map_alist;
 
 /* Alist of minor mode variables and keymaps.  */
 Lisp_Object Vminor_mode_map_alist;
 

+/* Alist of major-mode-specific overrides for
+   minor mode variables and keymaps.  */
+Lisp_Object Vminor_mode_overriding_map_alist;
+

 /* Keymap mapping ASCII function key sequences onto their preferred forms.
    Initialized by the terminal-specific lisp files.  See DEFVAR for more
    documentation.  */
 /* Keymap mapping ASCII function key sequences onto their preferred forms.
    Initialized by the terminal-specific lisp files.  See DEFVAR for more
    documentation.  */


@@ -85,7 +91,7 @@ Lisp_Object Vkey_translation_map;
    when Emacs starts up.   t means don't record anything here.  */
 Lisp_Object Vdefine_key_rebound_commands;
 
    when Emacs starts up.   t means don't record anything here.  */
 Lisp_Object Vdefine_key_rebound_commands;
 

-Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii;
+Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii, Qmenu_item;

 
 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
    in a string key sequence is equivalent to prefixing with this
 
 /* A char with the CHAR_META bit set in a vector or the 0200 bit set
    in a string key sequence is equivalent to prefixing with this


@@ -94,16 +100,22 @@ extern Lisp_Object meta_prefix_char;
 
 extern Lisp_Object Voverriding_local_map;
 
 
 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.                        */
 
 DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,
 \f
 /* Keymap object support - constructors and predicates.                        */
 
 DEFUN ("make-keymap", Fmake_keymap, Smake_keymap, 0, 1, 0,

-  "Construct and return a new keymap, of the form (keymap VECTOR . ALIST).\n\
-VECTOR is a vector which holds the bindings for the ASCII\n\
+  "Construct and return a new keymap, of the form (keymap CHARTABLE . ALIST).\n\
+CHARTABLE is a char-table that holds the bindings for the ASCII\n\

 characters.  ALIST is an assoc-list which holds bindings for function keys,\n\
 mouse events, and any other things that appear in the input stream.\n\
 All entries in it are initially nil, meaning \"command undefined\".\n\n\
 characters.  ALIST is an assoc-list which holds bindings for function keys,\n\
 mouse events, and any other things that appear in the input stream.\n\
 All entries in it are initially nil, meaning \"command undefined\".\n\n\


@@ -118,8 +130,7 @@ in case you use it as a menu with `x-popup-menu'.")
   else
     tail = Qnil;
   return Fcons (Qkeymap,
   else
     tail = Qnil;
   return Fcons (Qkeymap,

-               Fcons (Fmake_vector (make_number (DENSE_TABLE_SIZE), Qnil),
-                      tail));
+               Fcons (Fmake_char_table (Qkeymap, Qnil), tail));

 }
 
 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,
 }
 
 DEFUN ("make-sparse-keymap", Fmake_sparse_keymap, Smake_sparse_keymap, 0, 1, 0,


@@ -191,6 +202,7 @@ is also allowed as an element.")
   (object)
      Lisp_Object object;
 {
   (object)
      Lisp_Object object;
 {

+  /* FIXME: Maybe this should return t for autoloaded keymaps?   -sm  */

   return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
 }
 
   return (NILP (get_keymap_1 (object, 0, 0)) ? Qnil : Qt);
 }
 


@@ -208,7 +220,10 @@ is also allowed as an element.")
    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
    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
 get_keymap_1 (object, error, autoload)


@@ -218,16 +233,23 @@ get_keymap_1 (object, error, autoload)
   Lisp_Object tem;
 
  autoload_retry:
   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)
 
   /* 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;
 
     {
       Lisp_Object tail;
 


@@ -244,6 +266,7 @@ get_keymap_1 (object, error, autoload)
        }
     }
 
        }
     }
 

+ end:

   if (error)
     wrong_type_argument (Qkeymapp, object);
   else
   if (error)
     wrong_type_argument (Qkeymapp, object);
   else


@@ -273,11 +296,11 @@ DEFUN ("keymap-parent", Fkeymap_parent, Skeymap_parent, 1, 1, 0,
   keymap = get_keymap_1 (keymap, 1, 1);
 
   /* Skip past the initial element `keymap'.  */
   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'.  */
     {
       /* See if there is another `keymap'.  */

-      if (EQ (Qkeymap, XCONS (list)->car))
+      if (KEYMAPP (list))

        return list;
     }
 
        return list;
     }
 


@@ -293,9 +316,12 @@ PARENT should be nil or another keymap.")
      Lisp_Object keymap, parent;
 {
   Lisp_Object list, prev;
      Lisp_Object keymap, parent;
 {
   Lisp_Object list, prev;

+  struct gcpro gcpro1;

   int i;
 
   keymap = get_keymap_1 (keymap, 1, 1);
   int i;
 
   keymap = get_keymap_1 (keymap, 1, 1);

+  GCPRO1 (keymap);
+  

   if (!NILP (parent))
     parent = get_keymap_1 (parent, 1, 1);
 
   if (!NILP (parent))
     parent = get_keymap_1 (parent, 1, 1);
 


@@ -303,17 +329,17 @@ PARENT should be nil or another keymap.")
   prev = keymap;
   while (1)
     {
   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 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 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;
          break;
        }
       prev = list;


@@ -321,32 +347,41 @@ PARENT should be nil or another keymap.")
 
   /* Scan through for submaps, and set their parents too.  */
 
 
   /* 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.  */
     {
       /* 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.  */
        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),
            fix_submap_inheritance (keymap, make_number (i),

-                                   XVECTOR (XCONS (list)->car)->contents[i]);
+                                   XVECTOR (XCAR (list))->contents[i]);
+
+      if (CHAR_TABLE_P (XCAR (list)))
+       {
+         Lisp_Object indices[3];
+
+         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.  */
 
 }
 
 /* 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.  */
 

+static void

 fix_submap_inheritance (map, event, submap)
      Lisp_Object map, event, submap;
 {
 fix_submap_inheritance (map, event, submap)
      Lisp_Object map, event, submap;
 {


@@ -355,28 +390,40 @@ fix_submap_inheritance (map, event, submap)
   /* SUBMAP is a cons that we found as a key binding.
      Discard the other things found in a menu key binding.  */
 
   /* SUBMAP is a cons that we found as a key binding.
      Discard the other things found in a menu key binding.  */
 

-  if (CONSP (submap)
-      && STRINGP (XCONS (submap)->car))
+  if (CONSP (submap))

     {
     {

-      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))
+      /* May be an old format menu item */
+      if (STRINGP (XCAR (submap)))

        {
        {

-         Lisp_Object carcar;
-         carcar = XCONS (XCONS (submap)->car)->car;
-         if (NILP (carcar) || VECTORP (carcar))
-           submap = XCONS (submap)->cdr;
+         submap = XCDR (submap);
+         /* Also remove a menu help string, if any,
+            following the menu item name.  */
+         if (CONSP (submap) && STRINGP (XCAR (submap)))
+           submap = XCDR (submap);
+         /* Also remove the sublist that caches key equivalences, if any.  */
+         if (CONSP (submap)
+             && CONSP (XCAR (submap)))
+           {
+             Lisp_Object carcar;
+             carcar = XCAR (XCAR (submap));
+             if (NILP (carcar) || VECTORP (carcar))
+               submap = XCDR (submap);
+           }
+       }
+
+      /* Or a new format menu item */
+      else if (EQ (XCAR (submap), Qmenu_item)
+              && CONSP (XCDR (submap)))
+       {
+         submap = XCDR (XCDR (submap));
+         if (CONSP (submap))
+           submap = XCAR (submap);

        }
     }
 
   /* If it isn't a keymap now, there's no work to do.  */
   if (! CONSP (submap)
        }
     }
 
   /* If it isn't a keymap now, there's no work to do.  */
   if (! CONSP (submap)

-      || ! EQ (XCONS (submap)->car, Qkeymap))
+      || ! EQ (XCAR (submap), Qkeymap))

     return;
 
   map_parent = Fkeymap_parent (map);
     return;
 
   map_parent = Fkeymap_parent (map);


@@ -387,11 +434,27 @@ fix_submap_inheritance (map, event, submap)
 
   /* If MAP's parent has something other than a keymap,
      our own submap shadows it completely, so use nil as SUBMAP's parent.  */
 
   /* 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)))
+  if (! (CONSP (parent_entry) && EQ (XCAR (parent_entry), Qkeymap)))

     parent_entry = Qnil;
 
   if (! EQ (parent_entry, submap))
     parent_entry = Qnil;
 
   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 (EQ (tem, parent_entry))
+           return;
+          if (CONSP (tem)
+             && EQ (XCAR (tem), Qkeymap))
+           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.
 }
 \f
 /* Look up IDX in MAP.  IDX may be any sort of event.


@@ -435,11 +498,11 @@ access_keymap (map, idx, t_ok, noinherit)
     Lisp_Object t_binding;
 
     t_binding = Qnil;
     Lisp_Object t_binding;
 
     t_binding = Qnil;

-    for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+    for (tail = map; CONSP (tail); tail = XCDR (tail))

       {
        Lisp_Object binding;
 
       {
        Lisp_Object binding;
 

-       binding = XCONS (tail)->car;
+       binding = XCAR (tail);

        if (SYMBOLP (binding))
          {
            /* If NOINHERIT, stop finding prefix definitions
        if (SYMBOLP (binding))
          {
            /* If NOINHERIT, stop finding prefix definitions


@@ -449,24 +512,42 @@ access_keymap (map, idx, t_ok, noinherit)
          }
        else if (CONSP (binding))
          {
          }
        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 && CONSP (val) && EQ (XCAR (val), Qkeymap))

                  return Qnil;
                if (CONSP (val))
                  fix_submap_inheritance (map, idx, val);
                return val;
              }
                  return Qnil;
                if (CONSP (val))
                  fix_submap_inheritance (map, idx, val);
                return val;
              }

-           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)];
          }
        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 && CONSP (val) && EQ (XCAR (val), Qkeymap))
+                 return Qnil;
+               if (CONSP (val))
+                 fix_submap_inheritance (map, idx, val);
+               return val;
+             }
+         }
+       else if (CHAR_TABLE_P (binding))
+         {
+           /* Character codes with modifiers
+              are not included in a char-table.
+              All character codes without modifiers are included.  */
+           if (NATNUMP (idx)
+               && ! (XFASTINT (idx)
+                     & (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
+                        | CHAR_SHIFT | CHAR_CTL | CHAR_META)))
+             {
+               val = Faref (binding, idx);
+               if (noprefix && CONSP (val) && EQ (XCAR (val), Qkeymap))

                  return Qnil;
                if (CONSP (val))
                  fix_submap_inheritance (map, idx, val);
                  return Qnil;
                if (CONSP (val))
                  fix_submap_inheritance (map, idx, val);


@@ -500,55 +581,112 @@ get_keyelt (object, autoload)
 {
   while (1)
     {
 {
   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))
-       object = access_keymap (map, Fcdr (object), 0, 0);
-      
-      /* If the keymap contents looks like (STRING . DEFN),
-        use DEFN.
+      /* 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))
+       {
+         if (CONSP (XCDR (object)))
+           {
+             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
+           /* Invalid keymap */
+           return object;
+       }
+
+      /* If the keymap contents looks like (STRING . DEFN), use DEFN.

         Keymap alist elements like (CHAR MENUSTRING . DEFN)
         will be used by HierarKey menus.  */
         Keymap alist elements like (CHAR MENUSTRING . DEFN)
         will be used by HierarKey menus.  */

-      else if (CONSP (object)
-              && 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.  */
          /* 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.  */
          /* 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;
            {
              Lisp_Object carcar;

-             carcar = XCONS (XCONS (object)->car)->car;
+             carcar = XCAR (XCAR (object));

              if (NILP (carcar) || VECTORP (carcar))
              if (NILP (carcar) || VECTORP (carcar))

-               object = XCONS (object)->cdr;
+               object = XCDR (object);

            }
        }
 
            }
        }
 

+      /* If the contents are (KEYMAP . ELEMENT), go indirect.  */

       else
       else

-       /* Anything else is really the value.  */
-       return object;
+       {
+         Lisp_Object map;
+         
+         map = get_keymap_1 (Fcar_safe (object), 0, autoload);
+         if (NILP (map))
+           /* Invalid keymap */
+           return object;
+         else
+           {
+             Lisp_Object key;
+             key = Fcdr (object);
+             if (INTEGERP (key) && (XUINT (key) & meta_modifier))
+               {
+                 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);
+               }
+             else
+               object = access_keymap (map, key, 0, 0);
+           }
+       }

     }
 }
 
     }
 }
 

-Lisp_Object
+static Lisp_Object

 store_in_keymap (keymap, idx, def)
      Lisp_Object keymap;
      register Lisp_Object idx;
      register Lisp_Object def;
 {
   /* If we are preparing to dump, and DEF is a menu element
 store_in_keymap (keymap, idx, def)
      Lisp_Object keymap;
      register Lisp_Object idx;
      register Lisp_Object def;
 {
   /* If we are preparing to dump, and DEF is a menu element

-     with a menu item string, copy it to ensure it is not pure.  */
-  if (CONSP (def) && PURE_P (def) && STRINGP (XCONS (def)->car))
-    def = Fcons (XCONS (def)->car, XCONS (def)->cdr);
+     with a menu item indicator, copy it to ensure it is not pure.  */
+  if (CONSP (def) && PURE_P (def)
+      && (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?),
     error ("attempt to define a key in a non-keymap");
 
   /* If idx is a list (some sort of mouse click, perhaps?),


@@ -578,11 +716,11 @@ store_in_keymap (keymap, idx, def)
     Lisp_Object insertion_point;
 
     insertion_point = keymap;
     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;
 
       {
        Lisp_Object elt;
 

-       elt = XCONS (tail)->car;
+       elt = XCAR (tail);

        if (VECTORP (elt))
          {
            if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)
        if (VECTORP (elt))
          {
            if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)


@@ -592,11 +730,26 @@ store_in_keymap (keymap, idx, def)
              }
            insertion_point = tail;
          }
              }
            insertion_point = tail;
          }

+       else if (CHAR_TABLE_P (elt))
+         {
+           /* Character codes with modifiers
+              are not included in a char-table.
+              All character codes without modifiers are included.  */
+           if (NATNUMP (idx)
+               && ! (XFASTINT (idx)
+                     & (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
+                        | CHAR_SHIFT | CHAR_CTL | CHAR_META)))
+             {
+               Faset (elt, idx, def);
+               return def;
+             }
+           insertion_point = tail;
+         }

        else if (CONSP (elt))
          {
        else if (CONSP (elt))
          {

-           if (EQ (idx, XCONS (elt)->car))
+           if (EQ (idx, XCAR (elt)))

              {
              {

-               XCONS (elt)->cdr = def;
+               XCDR (elt) = def;

                return def;
              }
          }
                return def;
              }
          }


@@ -616,13 +769,20 @@ store_in_keymap (keymap, idx, def)
   keymap_end:
     /* We have scanned the entire keymap, and not found a binding for
        IDX.  Let's add one.  */
   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;
 }
 
   }
          
   return def;
 }
 

+void
+copy_keymap_1 (chartable, idx, elt)
+     Lisp_Object chartable, idx, elt;
+{
+  if (!SYMBOLP (elt) && ! NILP (Fkeymapp (elt)))
+    Faset (chartable, idx, Fcopy_keymap (elt));
+}

 
 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
   "Return a copy of the keymap KEYMAP.\n\
 
 DEFUN ("copy-keymap", Fcopy_keymap, Scopy_keymap, 1, 1, 0,
   "Return a copy of the keymap KEYMAP.\n\


@@ -638,60 +798,107 @@ is not copied.")
 
   copy = Fcopy_alist (get_keymap (keymap));
 
 
   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;
 
     {
       Lisp_Object elt;
 

-      elt = XCONS (tail)->car;
-      if (VECTORP (elt))
+      elt = XCAR (tail);
+      if (CHAR_TABLE_P (elt))
+       {
+         Lisp_Object indices[3];
+
+         elt = Fcopy_sequence (elt);
+         XCAR (tail) = elt;
+
+         map_char_table (copy_keymap_1, Qnil, elt, elt, 0, indices);
+       }
+      else if (VECTORP (elt))

        {
          int i;
 
          elt = Fcopy_sequence (elt);
        {
          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])
                && ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
 
          for (i = 0; i < XVECTOR (elt)->size; i++)
            if (!SYMBOLP (XVECTOR (elt)->contents[i])
                && ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))

-             XVECTOR (elt)->contents[i] =
-               Fcopy_keymap (XVECTOR (elt)->contents[i]);
+             XVECTOR (elt)->contents[i]
+               = Fcopy_keymap (XVECTOR (elt)->contents[i]);

        }
        }

-      else if (CONSP (elt))
+      else if (CONSP (elt) && CONSP (XCDR (elt)))

        {
        {

-         /* Skip the optional menu string.  */
-         if (CONSP (XCONS (elt)->cdr)
-             && STRINGP (XCONS (XCONS (elt)->cdr)->car))
-           {
-             Lisp_Object tem;
-
-             /* Copy the cell, since copy-alist didn't go this deep.  */
-             XCONS (elt)->cdr = Fcons (XCONS (XCONS (elt)->cdr)->car,
-                                       XCONS (XCONS (elt)->cdr)->cdr);
-             elt = XCONS (elt)->cdr;
+         Lisp_Object tem;
+         tem = XCDR (elt);

 
 

-             /* Also skip the optional menu help string.  */
-             if (CONSP (XCONS (elt)->cdr)
-                 && STRINGP (XCONS (XCONS (elt)->cdr)->car))
+         /* Is this a new format menu item.  */
+         if (EQ (XCAR (tem),Qmenu_item))
+           {
+             /* Copy cell with menu-item marker.  */
+             XCDR (elt)
+               = Fcons (XCAR (tem), XCDR (tem));
+             elt = XCDR (elt);
+             tem = XCDR (elt);
+             if (CONSP (tem))
+               {
+                 /* Copy cell with menu-item name.  */
+                 XCDR (elt)
+                   = Fcons (XCAR (tem), XCDR (tem));
+                 elt = XCDR (elt);
+                 tem = XCDR (elt);
+               };
+             if (CONSP (tem))

                {
                {

-                 XCONS (elt)->cdr = Fcons (XCONS (XCONS (elt)->cdr)->car,
-                                           XCONS (XCONS (elt)->cdr)->cdr);
-                 elt = XCONS (elt)->cdr;
+                 /* Copy cell with binding and if the binding is a keymap,
+                    copy that.  */
+                 XCDR (elt)
+                   = Fcons (XCAR (tem), XCDR (tem));
+                 elt = XCDR (elt);
+                 tem = XCAR (elt);
+                 if (!(SYMBOLP (tem) || NILP (Fkeymapp (tem))))
+                   XCAR (elt) = Fcopy_keymap (tem);
+                 tem = XCDR (elt);
+                 if (CONSP (tem) && CONSP (XCAR (tem)))
+                   /* Delete cache for key equivalences.  */
+                   XCDR (elt) = XCDR (tem);

                }
                }

-             /* There may also be a list that caches key equivalences.
-                Just delete it for the new keymap.  */
-             if (CONSP (XCONS (elt)->cdr)
-                 && CONSP (XCONS (XCONS (elt)->cdr)->car)
-                 && (NILP (tem = XCONS (XCONS (XCONS (elt)->cdr)->car)->car)
-                     || VECTORP (tem)))
-               XCONS (elt)->cdr = XCONS (XCONS (elt)->cdr)->cdr;

            }
            }

-         if (CONSP (elt)
-             && ! SYMBOLP (XCONS (elt)->cdr)
-             && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
-           XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
+         else
+           {
+             /* It may be an old fomat menu item.
+                Skip the optional menu string.
+             */
+             if (STRINGP (XCAR (tem)))
+               {
+                 /* Copy the cell, since copy-alist didn't go this deep.  */
+                 XCDR (elt)
+                   = Fcons (XCAR (tem), XCDR (tem));
+                 elt = XCDR (elt);
+                 tem = XCDR (elt);
+                 /* Also skip the optional menu help string.  */
+                 if (CONSP (tem) && STRINGP (XCAR (tem)))
+                   {
+                     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 (XCAR (tem))
+                     && (NILP (XCAR (XCAR (tem)))
+                         || VECTORP (XCAR (XCAR (tem)))))
+                   XCDR (elt) = XCDR (tem);
+               }
+             if (CONSP (elt)
+                 && ! SYMBOLP (XCDR (elt))
+                 && ! NILP (Fkeymapp (XCDR (elt))))
+               XCDR (elt) = Fcopy_keymap (XCDR (elt));
+           }
+

        }
     }
        }
     }

-
+             

   return copy;
 }
 \f
   return copy;
 }
 \f


@@ -726,7 +933,6 @@ the front of KEYMAP.")
 {
   register int idx;
   register Lisp_Object c;
 {
   register int idx;
   register Lisp_Object c;

-  register Lisp_Object tem;

   register Lisp_Object cmd;
   int metized = 0;
   int meta_bit;
   register Lisp_Object cmd;
   int metized = 0;
   int meta_bit;


@@ -821,7 +1027,6 @@ recognize the default bindings, just as `read-key-sequence' does.")
      Lisp_Object accept_default;
 {
   register int idx;
      Lisp_Object accept_default;
 {
   register int idx;

-  register Lisp_Object tem;

   register Lisp_Object cmd;
   register Lisp_Object c;
   int metized = 0;
   register Lisp_Object cmd;
   register Lisp_Object c;
   int metized = 0;


@@ -918,8 +1123,8 @@ define_as_prefix (keymap, c)
         make it define this key.  */
       Lisp_Object tail;
 
         make it define this key.  */
       Lisp_Object tail;
 

-      for (tail = Fcdr (keymap); CONSP (tail); tail = XCONS (tail)->cdr)
-       if (EQ (XCONS (tail)->car, Qkeymap))
+      for (tail = Fcdr (keymap); CONSP (tail); tail = XCDR (tail))
+       if (EQ (XCAR (tail), Qkeymap))

          break;
 
       if (!NILP (tail))
          break;
 
       if (!NILP (tail))


@@ -984,65 +1189,81 @@ current_minor_maps (modeptr, mapptr)
      Lisp_Object **modeptr, **mapptr;
 {
   int i = 0;
      Lisp_Object **modeptr, **mapptr;
 {
   int i = 0;

+  int list_number = 0;

   Lisp_Object alist, assoc, var, val;
   Lisp_Object alist, assoc, var, val;

+  Lisp_Object lists[2];
+
+  lists[0] = Vminor_mode_overriding_map_alist;
+  lists[1] = Vminor_mode_map_alist;
+
+  for (list_number = 0; list_number < 2; list_number++)
+    for (alist = lists[list_number];
+        CONSP (alist);
+        alist = XCDR (alist))
+      if ((assoc = XCAR (alist), CONSP (assoc))
+         && (var = XCAR (assoc), SYMBOLP (var))
+         && (val = find_symbol_value (var), ! EQ (val, Qunbound))
+         && ! NILP (val))
+       {
+         Lisp_Object temp;

 
 

-  for (alist = Vminor_mode_map_alist;
-       CONSP (alist);
-       alist = XCONS (alist)->cdr)
-    if ((assoc = XCONS (alist)->car, CONSP (assoc))
-       && (var = XCONS (assoc)->car, SYMBOLP (var))
-       && (val = find_symbol_value (var), ! EQ (val, Qunbound))
-       && ! NILP (val))
-      {
-       Lisp_Object temp;
+         /* If a variable has an entry in Vminor_mode_overriding_map_alist,
+            and also an entry in Vminor_mode_map_alist,
+            ignore the latter.  */
+         if (list_number == 1)
+           {
+             val = assq_no_quit (var, lists[0]);
+             if (!NILP (val))
+               break;
+           }

 
 

-       if (i >= cmm_size)
-         {
-           Lisp_Object *newmodes, *newmaps;
+         if (i >= cmm_size)
+           {
+             Lisp_Object *newmodes, *newmaps;

 
 

-           if (cmm_maps)
-             {
-               BLOCK_INPUT;
-               cmm_size *= 2;
-               newmodes
-                 = (Lisp_Object *) realloc (cmm_modes,
-                                            cmm_size * sizeof (Lisp_Object));
-               newmaps
-                 = (Lisp_Object *) realloc (cmm_maps,
-                                            cmm_size * sizeof (Lisp_Object));
-               UNBLOCK_INPUT;
-             }
-           else
-             {
-               BLOCK_INPUT;
-               cmm_size = 30;
-               newmodes
-                 = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
-               newmaps
-                 = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
-               UNBLOCK_INPUT;
-             }
+             if (cmm_maps)
+               {
+                 BLOCK_INPUT;
+                 cmm_size *= 2;
+                 newmodes
+                   = (Lisp_Object *) realloc (cmm_modes,
+                                              cmm_size * sizeof (Lisp_Object));
+                 newmaps
+                   = (Lisp_Object *) realloc (cmm_maps,
+                                              cmm_size * sizeof (Lisp_Object));
+                 UNBLOCK_INPUT;
+               }
+             else
+               {
+                 BLOCK_INPUT;
+                 cmm_size = 30;
+                 newmodes
+                   = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
+                 newmaps
+                   = (Lisp_Object *) xmalloc (cmm_size * sizeof (Lisp_Object));
+                 UNBLOCK_INPUT;
+               }

 
 

-           if (newmaps && newmodes)
-             {
-               cmm_modes = newmodes;
-               cmm_maps = newmaps;
-             }
-           else
-             break;
-         }
+             if (newmaps && newmodes)
+               {
+                 cmm_modes = newmodes;
+                 cmm_maps = newmaps;
+               }
+             else
+               break;
+           }

 
 

-       /* Get the keymap definition--or nil if it is not defined.  */
-       temp = internal_condition_case_1 (Findirect_function,
-                                         XCONS (assoc)->cdr,
-                                         Qerror, current_minor_maps_error);
-       if (!NILP (temp))
-         {
-           cmm_modes[i] = var;
-           cmm_maps [i] = temp;
-           i++;
-         }
-      }
+         /* Get the keymap definition--or nil if it is not defined.  */
+         temp = internal_condition_case_1 (Findirect_function,
+                                           XCDR (assoc),
+                                           Qerror, current_minor_maps_error);
+         if (!NILP (temp))
+           {
+             cmm_modes[i] = var;
+             cmm_maps [i] = temp;
+             i++;
+           }
+       }

 
   if (modeptr) *modeptr = cmm_modes;
   if (mapptr)  *mapptr  = cmm_maps;
 
   if (modeptr) *modeptr = cmm_modes;
   if (mapptr)  *mapptr  = cmm_maps;


@@ -1099,7 +1320,15 @@ recognize the default bindings, just as `read-key-sequence' does.")
              RETURN_UNGCPRO (value);
          }
 
              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))
        {
 
       if (! NILP (local))
        {


@@ -1198,17 +1427,19 @@ bindings; see the description of `lookup-key' for more details about this.")
   return Flist (j, maps);
 }
 
   return Flist (j, maps);
 }
 

-DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 2, 0,
+DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 3, 0,

   "Define COMMAND as a prefix command.  COMMAND should be a symbol.\n\
 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
 If a second optional argument MAPVAR is given, the map is stored as\n\
 its value instead of as COMMAND's value; but COMMAND is still defined\n\
   "Define COMMAND as a prefix command.  COMMAND should be a symbol.\n\
 A new sparse keymap is stored as COMMAND's function definition and its value.\n\
 If a second optional argument MAPVAR is given, the map is stored as\n\
 its value instead of as COMMAND's value; but COMMAND is still defined\n\

-as a function.")
-  (command, mapvar)
-     Lisp_Object command, mapvar;
+as a function.\n\
+The third optional argument NAME, if given, supplies a menu name\n\
+string for the map.  This is required to use the keymap as a menu.")
+  (command, mapvar, name)
+     Lisp_Object command, mapvar, name;

 {
   Lisp_Object map;
 {
   Lisp_Object map;

-  map = Fmake_sparse_keymap (Qnil);
+  map = Fmake_sparse_keymap (name);

   Ffset (command, map);
   if (!NILP (mapvar))
     Fset (mapvar, map);
   Ffset (command, map);
   if (!NILP (mapvar))
     Fset (mapvar, map);


@@ -1268,6 +1499,8 @@ DEFUN ("current-minor-mode-maps", Fcurrent_minor_mode_maps, Scurrent_minor_mode_
 \f
 /* Help functions for describing and documenting keymaps.              */
 
 \f
 /* Help functions for describing and documenting keymaps.              */
 

+static void accessible_keymaps_char_table ();
+

 /* This function cannot GC.  */
 
 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
 /* This function cannot GC.  */
 
 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,


@@ -1300,7 +1533,28 @@ then the value includes only maps for prefixes that start with PREFIX.")
         It might even give us a list that isn't a keymap.  */
       tem = get_keymap_1 (tem, 0, 0);
       if (!NILP (tem))
         It might even give us a list that isn't a keymap.  */
       tem = get_keymap_1 (tem, 0, 0);
       if (!NILP (tem))

-       maps = Fcons (Fcons (prefix, tem), Qnil);
+       {
+         /* Convert PREFIX to a vector now, so that later on
+            we don't have to deal with the possibility of a string.  */
+         if (STRINGP (prefix))
+           {
+             int i, i_byte, c;
+             Lisp_Object copy;
+
+             copy = Fmake_vector (make_number (XSTRING (prefix)->size), Qnil);
+             for (i = 0, i_byte = 0; i < XSTRING (prefix)->size;)
+               {
+                 int i_before = i;
+
+                 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;
+           }
+         maps = Fcons (Fcons (prefix, tem), Qnil);
+       }

       else
        return Qnil;
     }
       else
        return Qnil;
     }


@@ -1316,7 +1570,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
      This is a breadth-first traversal, where tail is the queue of
      nodes, and maps accumulates a list of all nodes visited.  */
 
      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;
     {
       register Lisp_Object thisseq, thismap;
       Lisp_Object last;


@@ -1327,17 +1581,27 @@ then the value includes only maps for prefixes that start with PREFIX.")
       thismap = Fcdr (Fcar (tail));
       last = make_number (XINT (Flength (thisseq)) - 1);
       is_metized = (XINT (last) >= 0
       thismap = Fcdr (Fcar (tail));
       last = make_number (XINT (Flength (thisseq)) - 1);
       is_metized = (XINT (last) >= 0

+                   /* Don't metize the last char of PREFIX.  */
+                   && XINT (last) >= prefixlen

                    && EQ (Faref (thisseq, last), meta_prefix_char));
 
                    && EQ (Faref (thisseq, last), meta_prefix_char));
 

-      for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
+      for (; CONSP (thismap); thismap = XCDR (thismap))

        {
          Lisp_Object elt;
 
        {
          Lisp_Object elt;
 

-         elt = XCONS (thismap)->car;
+         elt = XCAR (thismap);

 
          QUIT;
 
 
          QUIT;
 

-         if (VECTORP (elt))
+         if (CHAR_TABLE_P (elt))
+           {
+             Lisp_Object indices[3];
+
+             map_char_table (accessible_keymaps_char_table, Qnil,
+                             elt, Fcons (maps, Fcons (tail, thisseq)),
+                             0, indices);
+           }
+         else if (VECTORP (elt))

            {
              register int i;
 
            {
              register int i;
 


@@ -1372,8 +1636,8 @@ then the value includes only maps for prefixes that start with PREFIX.")
                              /* This new sequence is the same length as
                                 thisseq, so stick it in the list right
                                 after this one.  */
                              /* 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
                            {


@@ -1383,12 +1647,12 @@ then the value includes only maps for prefixes that start with PREFIX.")
                        }
                    }
                }
                        }
                    }
                }

-           }       
+           }

          else if (CONSP (elt))
            {
          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))
              /* Ignore definitions that aren't keymaps themselves.  */
              tem = Fkeymapp (cmd);
              if (!NILP (tem))


@@ -1399,22 +1663,25 @@ then the value includes only maps for prefixes that start with PREFIX.")
                  if (NILP (tem))
                    {
                      /* Let elt be the event defined by this map entry.  */
                  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,
                         turn it into a meta-ized keystroke.  */
                      if (is_metized && INTEGERP (elt))
                        {
 
                      /* If the last key in thisseq is meta-prefix-char, and
                         this entry is a binding for an ascii keystroke,
                         turn it into a meta-ized keystroke.  */
                      if (is_metized && INTEGERP (elt))
                        {

-                         tem = Fcopy_sequence (thisseq);
-                         Faset (tem, last,
-                                make_number (XINT (elt) | meta_modifier));
+                         Lisp_Object element;
+
+                         element = thisseq;
+                         tem = Fvconcat (1, &element);
+                         XSETFASTINT (XVECTOR (tem)->contents[XINT (last)],
+                                      XINT (elt) | meta_modifier);

 
                          /* This new sequence is the same length as
                             thisseq, so stick it in the list right
                             after this one.  */
 
                          /* 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,
                        }
                      else
                        nconc2 (tail,


@@ -1432,11 +1699,11 @@ then the value includes only maps for prefixes that start with PREFIX.")
   /* Now find just the maps whose access prefixes start with PREFIX.  */
 
   good_maps = Qnil;
   /* 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;
     {
       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)
       /* 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)


@@ -1457,6 +1724,34 @@ then the value includes only maps for prefixes that start with PREFIX.")
   return Fnreverse (good_maps);
 }
 
   return Fnreverse (good_maps);
 }
 

+static void
+accessible_keymaps_char_table (args, index, cmd)
+     Lisp_Object args, index, cmd;
+{
+  Lisp_Object tem;
+  Lisp_Object maps, tail, thisseq;
+
+  if (NILP (cmd))
+    return;
+
+  maps = XCAR (args);
+  tail = XCAR (XCDR (args));
+  thisseq = XCDR (XCDR (args));
+
+  tem = Fkeymapp (cmd);
+  if (!NILP (tem))
+    {
+      cmd = get_keymap (cmd);
+      /* Ignore keymaps that are already added to maps.  */
+      tem = Frassq (cmd, maps);
+      if (NILP (tem))
+       {
+         tem = append_key (thisseq, index);
+         nconc2 (tail, Fcons (Fcons (tem, cmd), Qnil));
+       }
+    }
+}
+\f

 Lisp_Object Qsingle_key_description, Qkey_description;
 
 /* This function cannot GC.  */
 Lisp_Object Qsingle_key_description, Qkey_description;
 
 /* This function cannot GC.  */


@@ -1469,7 +1764,7 @@ spaces are put between sequence elements, etc.")
      Lisp_Object keys;
 {
   int len;
      Lisp_Object keys;
 {
   int len;

-  int i;
+  int i, i_byte;

   Lisp_Object sep;
   Lisp_Object *args;
 
   Lisp_Object sep;
   Lisp_Object *args;
 


@@ -1477,34 +1772,57 @@ spaces are put between sequence elements, etc.")
     {
       Lisp_Object vector;
       vector = Fmake_vector (Flength (keys), Qnil);
     {
       Lisp_Object vector;
       vector = Fmake_vector (Flength (keys), Qnil);

-      for (i = 0; i < XSTRING (keys)->size; i++)
+      for (i = 0, i_byte = 0; i < XSTRING (keys)->size; )

        {
        {

-         if (XSTRING (keys)->data[i] & 0x80)
-           XSETFASTINT (XVECTOR (vector)->contents[i],
-                        meta_modifier | (XSTRING (keys)->data[i] & ~0x80));
-         else
-           XSETFASTINT (XVECTOR (vector)->contents[i],
-                        XSTRING (keys)->data[i]);
+         int c;
+         int i_before = i;
+
+         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;
     }
        }
       keys = vector;
     }

-  else if (!VECTORP (keys))
-    keys = wrong_type_argument (Qarrayp, keys);

 
 

-  /* In effect, this computes
-     (mapconcat 'single-key-description keys " ")
-     but we shouldn't use mapconcat because it can do GC.  */
+  if (VECTORP (keys))
+    {
+      /* In effect, this computes
+        (mapconcat 'single-key-description keys " ")
+        but we shouldn't use mapconcat because it can do GC.  */

 
 

-  len = XVECTOR (keys)->size;
-  sep = build_string (" ");
-  /* This has one extra element at the end that we don't pass to Fconcat.  */
-  args = (Lisp_Object *) alloca (len * 2 * sizeof (Lisp_Object));
+      len = XVECTOR (keys)->size;
+      sep = build_string (" ");
+      /* This has one extra element at the end that we don't pass to Fconcat.  */
+      args = (Lisp_Object *) alloca (len * 2 * sizeof (Lisp_Object));

 
 

-  for (i = 0; i < len; i++)
+      for (i = 0; i < len; i++)
+       {
+         args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i],
+                                                Qnil);
+         args[i * 2 + 1] = sep;
+       }
+    }
+  else if (CONSP (keys))

     {
     {

-      args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i]);
-      args[i * 2 + 1] = sep;
+      /* In effect, this computes
+        (mapconcat 'single-key-description keys " ")
+        but we shouldn't use mapconcat because it can do GC.  */
+
+      len = XFASTINT (Flength (keys));
+      sep = build_string (" ");
+      /* This has one extra element at the end that we don't pass to Fconcat.  */
+      args = (Lisp_Object *) alloca (len * 2 * sizeof (Lisp_Object));
+
+      for (i = 0; i < len; i++)
+       {
+         args[i * 2] = Fsingle_key_description (XCAR (keys), Qnil);
+         args[i * 2 + 1] = sep;
+         keys = XCDR (keys);
+       }

     }
     }

+  else
+    keys = wrong_type_argument (Qarrayp, keys);

 
   return Fconcat (len * 2 - 1, args);
 }
 
   return Fconcat (len * 2 - 1, args);
 }


@@ -1514,8 +1832,12 @@ push_key_description (c, p)
      register unsigned int c;
      register char *p;
 {
      register unsigned int c;
      register char *p;
 {

+  unsigned c2;
+  

   /* Clear all the meaningless bits above the meta bit.  */
   c &= meta_modifier | ~ - meta_modifier;
   /* 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)
     {
 
   if (c & alt_modifier)
     {


@@ -1523,11 +1845,12 @@ push_key_description (c, p)
       *p++ = '-';
       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++ = '-';
     {
       *p++ = 'C';
       *p++ = '-';

-      c -= ctrl_modifier;
+      c &= ~ctrl_modifier;

     }
   if (c & hyper_modifier)
     {
     }
   if (c & hyper_modifier)
     {


@@ -1575,8 +1898,7 @@ push_key_description (c, p)
        }
       else
        {
        }
       else
        {

-         *p++ = 'C';
-         *p++ = '-';
+         /* `C-' already added above.  */

          if (c > 0 && c <= Ctl ('Z'))
            *p++ = c + 0140;
          else
          if (c > 0 && c <= Ctl ('Z'))
            *p++ = c + 0140;
          else


@@ -1590,31 +1912,37 @@ push_key_description (c, p)
       *p++ = 'L';
     }
   else if (c == ' ')
       *p++ = 'L';
     }
   else if (c == ' ')

-    {
+   {

       *p++ = 'S';
       *p++ = 'P';
       *p++ = 'C';
     }
       *p++ = 'S';
       *p++ = 'P';
       *p++ = 'C';
     }

-  else if (c < 128)
-    *p++ = c;
-  else if (c < 256)
+  else if (c < 128
+          || (NILP (current_buffer->enable_multibyte_characters)
+              && SINGLE_BYTE_CHAR_P (c)))

     *p++ = c;
     *p++ = c;

-  else if (c < 512)
-    {
-      *p++ = '\\';
-      *p++ = (7 & (c >> 6)) + '0';
-      *p++ = (7 & (c >> 3)) + '0';
-      *p++ = (7 & (c >> 0)) + '0';
-    }

   else
     {
   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';
+      if (! NILP (current_buffer->enable_multibyte_characters))
+       c = unibyte_char_to_multibyte (c);
+
+      if (NILP (current_buffer->enable_multibyte_characters)
+         || SINGLE_BYTE_CHAR_P (c)
+         || ! char_valid_p (c, 0))
+       {
+         int bit_offset;
+         *p++ = '\\';
+         /* The biggest character code uses 19 bits.  */
+         for (bit_offset = 18; bit_offset >= 0; bit_offset -= 3)
+           {
+             if (c >= (1 << bit_offset))
+               *p++ = ((c & (7 << bit_offset)) >> bit_offset) + '0';
+           }
+       }
+      else
+       {
+         p += CHAR_STRING (c, p);
+       }

     }
 
   return p;  
     }
 
   return p;  


@@ -1622,23 +1950,61 @@ push_key_description (c, p)
 
 /* This function cannot GC.  */
 
 
 /* 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\
   "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;

 {
 {

-  char tem[20];
+  if (CONSP (key) && lucid_event_type_list_p (key))
+    key = Fevent_convert_list (key);

 
   key = EVENT_HEAD (key);
 
   if (INTEGERP (key))          /* Normal character */
     {
 
   key = EVENT_HEAD (key);
 
   if (INTEGERP (key))          /* Normal character */
     {

-      *push_key_description (XUINT (key), tem) = 0;
-      return build_string (tem);
+      unsigned int charset, c1, c2;
+      int without_bits = XINT (key) & ~((-1) << CHARACTERBITS);
+
+      if (SINGLE_BYTE_CHAR_P (without_bits))
+       charset = 0;
+      else
+       SPLIT_CHAR (without_bits, charset, c1, c2);
+
+      if (charset
+         && CHARSET_DEFINED_P (charset)
+         && ((c1 >= 0 && c1 < 32)
+             || (c2 >= 0 && c2 < 32)))
+       {
+         /* Handle a generic character.  */
+         Lisp_Object name;
+         name = CHARSET_TABLE_INFO (charset, CHARSET_LONG_NAME_IDX);
+         CHECK_STRING (name, 0);
+         return concat2 (build_string ("Character set "), name);
+       }
+      else
+       {
+         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 */
     }
   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
   else if (STRINGP (key))      /* Buffer names in the menubar.  */
     return Fcopy_sequence (key);
   else


@@ -1679,21 +2045,23 @@ Control characters turn into \"^char\", etc.")
   (character)
      Lisp_Object character;
 {
   (character)
      Lisp_Object character;
 {

-  char tem[6];
+  /* Currently MAX_MULTIBYTE_LENGTH is 4 (< 6).  */
+  unsigned char str[6];
+  int c;

 
   CHECK_NUMBER (character, 0);
 
 
   CHECK_NUMBER (character, 0);
 

-  if (!SINGLE_BYTE_CHAR_P (XFASTINT (character)))
+  c = XINT (character);
+  if (!SINGLE_BYTE_CHAR_P (c))

     {
     {

-      char *str;
-      int len = non_ascii_char_to_string (XFASTINT (character), tem, &str);
+      int len = CHAR_STRING (c, str);

 
 

-      return make_string (str, len);
+      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
 }
 
 /* Return non-zero if SEQ contains only ASCII characters, perhaps with


@@ -1723,6 +2091,9 @@ ascii_sequence_p (seq)
 \f
 /* where-is - finding a command in a set of keymaps.                   */
 
 \f
 /* where-is - finding a command in a set of keymaps.                   */
 

+static Lisp_Object where_is_internal_1 ();
+static void where_is_internal_2 ();
+

 /* This function can GC if Flookup_key autoloads any keymaps.  */
 
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,
 /* This function can GC if Flookup_key autoloads any keymaps.  */
 
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,


@@ -1740,32 +2111,43 @@ and entirely reject menu bindings.\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.")
 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 firstonly, noindirect;
 {
   Lisp_Object maps;

-  Lisp_Object found, sequence;
-  int keymap_specified = !NILP (keymap);
+  Lisp_Object found, sequences;
+  Lisp_Object keymap1;
+  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);
 
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   /* 1 means ignore all menu bindings entirely.  */
   int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);
 

+  /* Find keymaps accessible from `keymap' or the current
+     context.  But don't muck with the value of `keymap',
+     because `where_is_internal_1' uses it to check for
+     shadowed bindings. */
+  keymap1 = xkeymap;

   if (! keymap_specified)
   if (! keymap_specified)

-    {
-#ifdef USE_TEXT_PROPERTIES
-      keymap = get_local_map (PT, current_buffer);
-#else
-      keymap = current_buffer->keymap;
-#endif
-    }
-
-  if (!NILP (keymap))
-    maps = nconc2 (Faccessible_keymaps (get_keymap (keymap), Qnil),
+    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
                   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)
 
   /* Put the minor mode keymaps on the front.  */
   if (! keymap_specified)


@@ -1774,25 +2156,22 @@ indirect definition itself.")
       minors = Fnreverse (Fcurrent_minor_mode_maps ());
       while (!NILP (minors))
        {
       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);
                                              Qnil),
                         maps);

-         minors = XCONS (minors)->cdr;
+         minors = XCDR (minors);

        }
     }
 
        }
     }
 

-  GCPRO5 (definition, keymap, maps, found, sequence);
+  GCPRO5 (definition, xkeymap, maps, found, sequences);

   found = Qnil;
   found = Qnil;

-  sequence = Qnil;
+  sequences = Qnil;

 
   for (; !NILP (maps); maps = Fcdr (maps))
     {
       /* Key sequence to reach map, and the map that it reaches */
       register Lisp_Object this, map;
 
 
   for (; !NILP (maps); maps = Fcdr (maps))
     {
       /* Key sequence to reach map, and the map that it reaches */
       register Lisp_Object this, map;
 

-      /* If Fcar (map) is a VECTOR, the current element within that vector.  */
-      int i = 0;
-

       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
         [M-CHAR] sequences, check if last character of the sequence
         is the meta-prefix char.  */
       /* In order to fold [META-PREFIX-CHAR CHAR] sequences into
         [M-CHAR] sequences, check if last character of the sequence
         is the meta-prefix char.  */


@@ -1817,9 +2196,11 @@ indirect definition itself.")
             For this reason, if Fcar (map) is a vector, we don't
             advance map to the next element until i indicates that we
             have finished off the vector.  */
             For this reason, if Fcar (map) is a vector, we don't
             advance map to the next element until i indicates that we
             have finished off the vector.  */

-         

          Lisp_Object elt, key, binding;
          Lisp_Object elt, key, binding;

-         elt = XCONS (map)->car;
+         elt = XCAR (map);
+         map = XCDR (map);
+
+         sequences = Qnil;

 
          QUIT;
 
 
          QUIT;
 


@@ -1827,130 +2208,69 @@ indirect definition itself.")
             advance map and i to the next binding.  */
          if (VECTORP (elt))
            {
             advance map and i to the next binding.  */
          if (VECTORP (elt))
            {

+             Lisp_Object sequence;
+             int i;

              /* In a vector, look at each element.  */
              /* In a vector, look at each element.  */

-             binding = XVECTOR (elt)->contents[i];
-             XSETFASTINT (key, i);
-             i++;
-
-             /* If we've just finished scanning a vector, advance map
-                to the next element, and reset i in anticipation of the
-                next vector we may find.  */
-             if (i >= XVECTOR (elt)->size)
+             for (i = 0; i < XVECTOR (elt)->size; i++)

                {
                {

-                 map = XCONS (map)->cdr;
-                 i = 0;
+                 binding = XVECTOR (elt)->contents[i];
+                 XSETFASTINT (key, i);
+                 sequence = where_is_internal_1 (binding, key, definition,
+                                                 noindirect, xkeymap, this,
+                                                 last, nomenus, last_is_meta);
+                 if (!NILP (sequence))
+                   sequences = Fcons (sequence, sequences);

                }
            }
                }
            }

-         else if (CONSP (elt))
+         else if (CHAR_TABLE_P (elt))

            {
            {

-             key = Fcar (Fcar (map));
-             binding = Fcdr (Fcar (map));
-
-             map = XCONS (map)->cdr;
+             Lisp_Object indices[3];
+             Lisp_Object args;
+
+             args = Fcons (Fcons (Fcons (definition, noindirect),
+                                  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 = XCDR (XCDR (XCAR (args)));

            }
            }

-         else
-           /* We want to ignore keymap elements that are neither
-              vectors nor conses.  */
+         else if (CONSP (elt))

            {
            {

-             map = XCONS (map)->cdr;
-             continue;
-           }
+             Lisp_Object sequence;

 
 

-         /* 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 (STRING ...), reject.  */
-                 if (CONSP (definition)
-                     && STRINGP (XCONS (definition)->car))
-                   continue;
-               }
-             else
-               binding = get_keyelt (binding, 0);
-           }
+             key = XCAR (elt);
+             binding = XCDR (elt);

 
 

-         /* End this iteration if this element does not match
-            the target.  */
-
-         if (CONSP (definition))
-           {
-             Lisp_Object tem;
-             tem = Fequal (binding, definition);
-             if (NILP (tem))
-               continue;
-           }
-         else
-           if (!EQ (binding, definition))
-             continue;
-
-         /* We have found a match.
-            Construct the key sequence where we found it.  */
-         if (INTEGERP (key) && last_is_meta)
-           {
-             sequence = Fcopy_sequence (this);
-             Faset (sequence, last, make_number (XINT (key) | meta_modifier));
+             sequence = where_is_internal_1 (binding, key, definition,
+                                             noindirect, xkeymap, this,
+                                             last, nomenus, last_is_meta);
+             if (!NILP (sequence))
+               sequences = Fcons (sequence, sequences);

            }
            }

-         else
-           sequence = append_key (this, key);
-
-         /* Verify that this key binding is not shadowed by another
-            binding for the same key, before we say it exists.

 
 

-            Mechanism: look for local definition of this key and if
-            it is defined and does not match what we found then
-            ignore this key.

 
 

-            Either nil or number as value from Flookup_key
-            means undefined.  */
-         if (keymap_specified)
+         for (; ! NILP (sequences); sequences = XCDR (sequences))

            {
            {

-             binding = Flookup_key (keymap, sequence, Qnil);
-             if (!NILP (binding) && !INTEGERP (binding))
-               {
-                 if (CONSP (definition))
-                   {
-                     Lisp_Object tem;
-                     tem = Fequal (binding, definition);
-                     if (NILP (tem))
-                       continue;
-                   }
-                 else
-                   if (!EQ (binding, definition))
-                     continue;
-               }
+             Lisp_Object sequence;
+
+             sequence = XCAR (sequences);
+
+             /* It is a true unshadowed match.  Record it, unless it's already
+                been seen (as could happen when inheriting keymaps).  */
+             if (NILP (Fmember (sequence, found)))
+               found = Fcons (sequence, found);
+
+             /* If firstonly is Qnon_ascii, then we can return the first
+                binding we find.  If firstonly is not Qnon_ascii but not
+                nil, then we should return the first ascii-only binding
+                we find.  */
+             if (EQ (firstonly, Qnon_ascii))
+               RETURN_UNGCPRO (sequence);
+             else if (! NILP (firstonly) && ascii_sequence_p (sequence))
+               RETURN_UNGCPRO (sequence);

            }
            }

-         else
-           {
-             binding = Fkey_binding (sequence, Qnil);
-             if (!EQ (binding, definition))
-               continue;
-           }
-
-         /* It is a true unshadowed match.  Record it, unless it's already
-            been seen (as could happen when inheriting keymaps).  */
-         if (NILP (Fmember (sequence, found)))
-           found = Fcons (sequence, found);
-
-         /* If firstonly is Qnon_ascii, then we can return the first
-            binding we find.  If firstonly is not Qnon_ascii but not
-            nil, then we should return the first ascii-only binding
-            we find.  */
-         if (EQ (firstonly, Qnon_ascii))
-           RETURN_UNGCPRO (sequence);
-         else if (! NILP (firstonly) && ascii_sequence_p (sequence))
-           RETURN_UNGCPRO (sequence);

        }
     }
 
        }
     }
 


@@ -1966,43 +2286,191 @@ indirect definition itself.")
     
   return found;
 }
     
   return found;
 }

+
+/* This is the function that Fwhere_is_internal calls using map_char_table.
+   ARGS has the form
+   (((DEFINITION . NOINDIRECT) . (KEYMAP . RESULT))
+    .
+    ((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.
+
+   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 args, key, binding;
+{
+  Lisp_Object definition, noindirect, keymap, this, last;
+  Lisp_Object result, sequence;
+  int nomenus, last_is_meta;
+  struct gcpro gcpro1, gcpro2, gcpro3;
+
+  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))
+    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 binding, key, definition, noindirect, keymap, this, last;
+     int nomenus, last_is_meta;
+{
+  Lisp_Object sequence;
+  int keymap_specified = !NILP (keymap);
+  struct gcpro gcpro1, gcpro2;
+
+  /* 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 (XCAR (definition),Qmenu_item)
+                 || STRINGP (XCAR (definition))))
+           return Qnil;
+       }
+      else
+       binding = get_keyelt (binding, 0);
+    }
+
+  /* End this iteration if this element does not match
+     the target.  */
+
+  if (CONSP (definition))
+    {
+      Lisp_Object tem;
+      tem = Fequal (binding, definition);
+      if (NILP (tem))
+       return Qnil;
+    }
+  else
+    if (!EQ (binding, definition))
+      return Qnil;
+
+  /* We have found a match.
+     Construct the key sequence where we found it.  */
+  if (INTEGERP (key) && last_is_meta)
+    {
+      sequence = Fcopy_sequence (this);
+      Faset (sequence, last, make_number (XINT (key) | meta_modifier));
+    }
+  else
+    sequence = append_key (this, key);
+
+  /* Verify that this key binding is not shadowed by another
+     binding for the same key, before we say it exists.
+
+     Mechanism: look for local definition of this key and if
+     it is defined and does not match what we found then
+     ignore this key.
+
+     Either nil or number as value from Flookup_key
+     means undefined.  */
+  GCPRO2 (sequence, binding);
+  if (keymap_specified)
+    {
+      binding = Flookup_key (keymap, sequence, Qnil);
+      if (!NILP (binding) && !INTEGERP (binding))
+       {
+         if (CONSP (definition))
+           {
+             Lisp_Object tem;
+             tem = Fequal (binding, definition);
+             if (NILP (tem))
+               RETURN_UNGCPRO (Qnil);
+           }
+         else
+           if (!EQ (binding, definition))
+             RETURN_UNGCPRO (Qnil);
+       }
+    }
+  else
+    {
+      binding = Fkey_binding (sequence, Qnil);
+      if (!EQ (binding, definition))
+       RETURN_UNGCPRO (Qnil);
+    }
+
+  RETURN_UNGCPRO (sequence);
+}

 \f
 /* describe-bindings - summarizing all the bindings in a set of keymaps.  */
 
 \f
 /* describe-bindings - summarizing all the bindings in a set of keymaps.  */
 

-DEFUN ("describe-bindings", Fdescribe_bindings, Sdescribe_bindings, 0, 1, "",
+DEFUN ("describe-bindings-internal", Fdescribe_bindings_internal, Sdescribe_bindings_internal, 0, 2, "",

   "Show a list of all defined keys, and their definitions.\n\
   "Show a list of all defined keys, and their definitions.\n\

-The list is put in a buffer, which is displayed.\n\
-An optional argument PREFIX, if non-nil, should be a key sequence;\n\
+We put that list in a buffer, and display the buffer.\n\
+\n\
+The optional argument MENUS, if non-nil, says to mention menu bindings.\n\
+\(Ordinarily these are omitted from the output.)\n\
+The optional argument PREFIX, if non-nil, should be a key sequence;\n\

 then we display only bindings that start with that prefix.")
 then we display only bindings that start with that prefix.")

-  (prefix)
-     Lisp_Object prefix;
+  (menus, prefix)
+     Lisp_Object menus, prefix;

 {
   register Lisp_Object thisbuf;
   XSETBUFFER (thisbuf, current_buffer);
   internal_with_output_to_temp_buffer ("*Help*",
                                       describe_buffer_bindings,
 {
   register Lisp_Object thisbuf;
   XSETBUFFER (thisbuf, current_buffer);
   internal_with_output_to_temp_buffer ("*Help*",
                                       describe_buffer_bindings,

-                                      Fcons (thisbuf, prefix));
+                                      list3 (thisbuf, prefix, menus));

   return Qnil;
 }
 
   return Qnil;
 }
 

-/* ARG is (BUFFER . PREFIX).  */
+/* ARG is (BUFFER PREFIX MENU-FLAG).  */

 
 static Lisp_Object
 describe_buffer_bindings (arg)
      Lisp_Object arg;
 {
   Lisp_Object descbuf, prefix, shadow;
 
 static Lisp_Object
 describe_buffer_bindings (arg)
      Lisp_Object arg;
 {
   Lisp_Object descbuf, prefix, shadow;

+  int nomenu;

   register Lisp_Object start1;
   struct gcpro gcpro1;
 
   char *alternate_heading
     = "\
   register Lisp_Object start1;
   struct gcpro gcpro1;
 
   char *alternate_heading
     = "\

-Alternate Characters (use anywhere the nominal character is listed):\n\
-nominal         alternate\n\
--------         ---------\n";
+Keyboard translations:\n\n\
+You type        Translation\n\
+--------        -----------\n";
+
+  descbuf = XCAR (arg);
+  arg = XCDR (arg);
+  prefix = XCAR (arg);
+  arg = XCDR (arg);
+  nomenu = NILP (XCAR (arg));

 
 

-  descbuf = XCONS (arg)->car;
-  prefix = XCONS (arg)->cdr;

   shadow = Qnil;
   GCPRO1 (shadow);
 
   shadow = Qnil;
   GCPRO1 (shadow);
 


@@ -2018,7 +2486,7 @@ nominal         alternate\n\
       for (c = 0; c < translate_len; c++)
        if (translate[c] != c)
          {
       for (c = 0; c < translate_len; c++)
        if (translate[c] != c)
          {

-           char buf[20];
+           char buf[KEY_DESCRIPTION_SIZE];

            char *bufend;
 
            if (alternate_heading)
            char *bufend;
 
            if (alternate_heading)


@@ -2041,7 +2509,7 @@ nominal         alternate\n\
 
   if (!NILP (Vkey_translation_map))
     describe_map_tree (Vkey_translation_map, 0, Qnil, prefix,
 
   if (!NILP (Vkey_translation_map))
     describe_map_tree (Vkey_translation_map, 0, Qnil, prefix,

-                      "Key translations", 0, 1, 0);
+                      "Key translations", nomenu, 1, 0);

 
   {
     int i, nmaps;
 
   {
     int i, nmaps;


@@ -2070,7 +2538,9 @@ nominal         alternate\n\
        if (!SYMBOLP (modes[i]))
          abort();
 
        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);
        *p++ = '`';
        bcopy (XSYMBOL (modes[i])->name->data, p,
               XSYMBOL (modes[i])->name->size);


@@ -2080,7 +2550,7 @@ nominal         alternate\n\
        p += sizeof (" Minor Mode Bindings") - 1;
        *p = 0;
 
        p += sizeof (" Minor Mode Bindings") - 1;
        *p = 0;
 

-       describe_map_tree (maps[i], 1, shadow, prefix, title, 0, 0, 0);
+       describe_map_tree (maps[i], 1, shadow, prefix, title, nomenu, 0, 0);

        shadow = Fcons (maps[i], shadow);
       }
   }
        shadow = Fcons (maps[i], shadow);
       }
   }


@@ -2096,17 +2566,17 @@ nominal         alternate\n\
   if (!NILP (start1))
     {
       describe_map_tree (start1, 1, shadow, prefix,
   if (!NILP (start1))
     {
       describe_map_tree (start1, 1, shadow, prefix,

-                        "Major Mode Bindings", 0, 0, 0);
+                        "\f\nMajor Mode Bindings", nomenu, 0, 0);

       shadow = Fcons (start1, shadow);
     }
 
   describe_map_tree (current_global_map, 1, shadow, prefix,
       shadow = Fcons (start1, shadow);
     }
 
   describe_map_tree (current_global_map, 1, shadow, prefix,

-                    "Global Bindings", 0, 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,
 
   /* 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", 0, 1, 0);
+                      "\f\nFunction key map translations", nomenu, 1, 0);

 
   call0 (intern ("help-mode"));
   Fset_buffer (descbuf);
 
   call0 (intern ("help-mode"));
   Fset_buffer (descbuf);


@@ -2141,7 +2611,7 @@ describe_map_tree (startmap, partial, shadow, prefix, title, nomenu, transl,
      int transl;
      int always_title;
 {
      int transl;
      int always_title;
 {

-  Lisp_Object maps, seen, sub_shadows;
+  Lisp_Object maps, orig_maps, seen, sub_shadows;

   struct gcpro gcpro1, gcpro2, gcpro3;
   int something = 0;
   char *key_heading
   struct gcpro gcpro1, gcpro2, gcpro3;
   int something = 0;
   char *key_heading


@@ -2149,7 +2619,7 @@ describe_map_tree (startmap, partial, shadow, prefix, title, nomenu, transl,
 key             binding\n\
 ---             -------\n";
 
 key             binding\n\
 ---             -------\n";
 

-  maps = Faccessible_keymaps (startmap, prefix);
+  orig_maps = maps = Faccessible_keymaps (startmap, prefix);

   seen = Qnil;
   sub_shadows = Qnil;
   GCPRO3 (maps, seen, sub_shadows);
   seen = Qnil;
   sub_shadows = Qnil;
   GCPRO3 (maps, seen, sub_shadows);


@@ -2159,7 +2629,7 @@ key             binding\n\
       Lisp_Object list;
 
       /* Delete from MAPS each element that is for the menu bar.  */
       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;
 
        {
          Lisp_Object elt, prefix, tem;
 


@@ -2199,11 +2669,11 @@ key             binding\n\
 
       sub_shadows = Qnil;
 
 
       sub_shadows = Qnil;
 

-      for (tail = shadow; CONSP (tail); tail = XCONS (tail)->cdr)
+      for (tail = shadow; CONSP (tail); tail = XCDR (tail))

        {
          Lisp_Object shmap;
 
        {
          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.  */
 
          /* If the sequence by which we reach this keymap is zero-length,
             then the shadow map for this keymap is just SHADOW.  */


@@ -2230,7 +2700,16 @@ key             binding\n\
            sub_shadows = Fcons (shmap, sub_shadows);
        }
 
            sub_shadows = Fcons (shmap, sub_shadows);
        }
 

-      describe_map (Fcdr (elt), Fcar (elt),
+      /* Maps we have already listed in this loop shadow this map.  */
+      for (tail = orig_maps; ! EQ (tail, maps); tail = XCDR (tail))
+       {
+         Lisp_Object tem;
+         tem = Fequal (Fcar (XCAR (tail)), prefix);
+         if (! NILP (tem))
+           sub_shadows = Fcons (XCDR (XCAR (tail)), sub_shadows);
+       }
+
+      describe_map (Fcdr (elt), prefix,

                    transl ? describe_translation : describe_command,
                    partial, sub_shadows, &seen, nomenu);
 
                    transl ? describe_translation : describe_command,
                    partial, sub_shadows, &seen, nomenu);
 


@@ -2324,9 +2803,9 @@ shadow_lookup (shadow, key, flag)
 {
   Lisp_Object tail, value;
 
 {
   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;
     }
       if (!NILP (value))
        return value;
     }


@@ -2341,7 +2820,7 @@ static void
 describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
      register Lisp_Object map;
      Lisp_Object keys;
 describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
      register Lisp_Object map;
      Lisp_Object keys;

-     int (*elt_describer) ();
+     void (*elt_describer) P_ ((Lisp_Object));

      int partial;
      Lisp_Object shadow;
      Lisp_Object *seen;
      int partial;
      Lisp_Object shadow;
      Lisp_Object *seen;


@@ -2375,16 +2854,18 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
 
   GCPRO3 (elt_prefix, definition, kludge);
 
 
   GCPRO3 (elt_prefix, definition, kludge);
 

-  for (tail = map; CONSP (tail); tail = XCONS (tail)->cdr)
+  for (tail = map; CONSP (tail); tail = XCDR (tail))

     {
       QUIT;
 
     {
       QUIT;
 

-      if (VECTORP (XCONS (tail)->car))
-       describe_vector (XCONS (tail)->car,
-                        elt_prefix, elt_describer, partial, shadow, map);
-      else if (CONSP (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 (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.)  */
 
          /* Ignore bindings whose "keys" are not really valid events.
             (We get these in the frames and buffers menu.)  */


@@ -2394,7 +2875,7 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
          if (nomenu && EQ (event, Qmenu_bar))
            continue;
 
          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;
 
          /* Don't show undefined commands or suppressed commands.  */
          if (NILP (definition)) continue;


@@ -2429,20 +2910,20 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
            insert1 (elt_prefix);
 
          /* THIS gets the string to describe the character EVENT.  */
            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);
        }
 
          /* 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);
        {
          /* 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);
        }
            break;
          *seen = Fcons (Fcons (tail, keys), *seen);
        }


@@ -2451,7 +2932,7 @@ describe_map (map, keys, elt_describer, partial, shadow, seen, nomenu)
   UNGCPRO;
 }
 
   UNGCPRO;
 }
 

-static int
+static void

 describe_vector_princ (elt)
      Lisp_Object elt;
 {
 describe_vector_princ (elt)
      Lisp_Object elt;
 {


@@ -2470,7 +2951,8 @@ This is text showing the elements of vector matched against indices.")
 
   specbind (Qstandard_output, Fcurrent_buffer ());
   CHECK_VECTOR_OR_CHAR_TABLE (vector, 0);
 
   specbind (Qstandard_output, Fcurrent_buffer ());
   CHECK_VECTOR_OR_CHAR_TABLE (vector, 0);

-  describe_vector (vector, Qnil, describe_vector_princ, 0, Qnil, Qnil);
+  describe_vector (vector, Qnil, describe_vector_princ, 0,
+                  Qnil, Qnil, (int *)0, 0);

 
   return unbind_to (count, Qnil);
 }
 
   return unbind_to (count, Qnil);
 }


@@ -2480,7 +2962,8 @@ This is text showing the elements of vector matched against indices.")
    in VECTOR.
 
    ELT_PREFIX describes what "comes before" the keys or indices defined
    in VECTOR.
 
    ELT_PREFIX describes what "comes before" the keys or indices defined

-   by this vector.
+   by this vector.  This is a human-readable string whose size
+   is not necessarily related to the situation.

 
    If the vector is in a keymap, ELT_PREFIX is a prefix key which
    leads to this keymap.
 
    If the vector is in a keymap, ELT_PREFIX is a prefix key which
    leads to this keymap.


@@ -2498,38 +2981,42 @@ This is text showing the elements of vector matched against indices.")
 
    ENTIRE_MAP is the keymap in which this vector appears.
    If the definition in effect in the whole map does not match
 
    ENTIRE_MAP is the keymap in which this vector appears.
    If the definition in effect in the whole map does not match

-   the one in this vector, we ignore this one.  */
+   the one in this vector, we ignore this one.

 
 

+   When describing a sub-char-table, INDICES is a list of
+   indices at higher levels in this char-table,
+   and CHAR_TABLE_DEPTH says how many levels down we have gone.  */
+
+void

 describe_vector (vector, elt_prefix, elt_describer,
 describe_vector (vector, elt_prefix, elt_describer,

-                partial, shadow, entire_map)
+                partial, shadow, entire_map,
+                indices, char_table_depth)

      register Lisp_Object vector;
      Lisp_Object elt_prefix;
      register Lisp_Object vector;
      Lisp_Object elt_prefix;

-     int (*elt_describer) ();
+     void (*elt_describer) P_ ((Lisp_Object));

      int partial;
      Lisp_Object shadow;
      Lisp_Object entire_map;
      int partial;
      Lisp_Object shadow;
      Lisp_Object entire_map;

+     int *indices;
+     int char_table_depth;

 {
 {

-  Lisp_Object dummy;

   Lisp_Object definition;
   Lisp_Object tem2;
   register int i;
   Lisp_Object suppress;
   Lisp_Object kludge;
   Lisp_Object definition;
   Lisp_Object tem2;
   register int i;
   Lisp_Object suppress;
   Lisp_Object kludge;

-  Lisp_Object chartable_kludge;

   int first = 1;
   int first = 1;

-  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
+  struct gcpro gcpro1, gcpro2, gcpro3;

   /* Range of elements to be handled.  */
   int from, to;
   /* Range of elements to be handled.  */
   int from, to;

-  /* The current depth of VECTOR if it is char-table.  */
-  int this_level;
-  /* Flag to tell if we should handle multibyte characters.  */
-  int multibyte = !NILP (current_buffer->enable_multibyte_characters);
-  /* Array of indices to access each level of char-table.
-     The elements are charset, code1, and code2.  */
-  int idx[3];

   /* A flag to tell if a leaf in this level of char-table is not a
      generic character (i.e. a complete multibyte character).  */
   int complete_char;
   /* A flag to tell if a leaf in this level of char-table is not a
      generic character (i.e. a complete multibyte character).  */
   int complete_char;

+  int character;
+  int starting_i;
+
+  if (indices == 0)
+    indices = (int *) alloca (3 * sizeof (int));

 
   definition = Qnil;
 
 
   definition = Qnil;
 


@@ -2537,69 +3024,66 @@ describe_vector (vector, elt_prefix, elt_describer,
      that is done once per vector element, we don't want to cons up a
      fresh vector every time.  */
   kludge = Fmake_vector (make_number (1), Qnil);
      that is done once per vector element, we don't want to cons up a
      fresh vector every time.  */
   kludge = Fmake_vector (make_number (1), Qnil);

-  GCPRO4 (elt_prefix, definition, kludge, chartable_kludge);
+  GCPRO3 (elt_prefix, definition, kludge);

 
   if (partial)
     suppress = intern ("suppress-keymap");
 
   if (CHAR_TABLE_P (vector))
     {
 
   if (partial)
     suppress = intern ("suppress-keymap");
 
   if (CHAR_TABLE_P (vector))
     {

-      /* Prepare for handling a nested char-table.  */
-      if (NILP (elt_prefix))
+      if (char_table_depth == 0)

        {
        {

-         /* VECTOR is the top level of char-table.  */
-         this_level = 0;
-         complete_char = 0;
+         /* VECTOR is a top level char-table.  */
+         complete_char = 1;

          from = 0;
          to = CHAR_TABLE_ORDINARY_SLOTS;
        }
       else
        {
          from = 0;
          to = CHAR_TABLE_ORDINARY_SLOTS;
        }
       else
        {

-         /* VECTOR is the deeper level of char-table.  */
-         this_level = XVECTOR (elt_prefix)->size;
-         if (this_level >= 3)
-           /* A char-table is not that deep.  */
-           wrong_type_argument (Qchar_table_p, vector);
-
-         /* For multibyte characters, the top level index for
-             charsets starts from 256.  */
-         idx[0] = XINT (XVECTOR (elt_prefix)->contents[0]) - 128;
-         for (i = 1; i < this_level; i++)
-           idx[i] = XINT (XVECTOR (elt_prefix)->contents[i]);
+         /* VECTOR is a sub char-table.  */
+         if (char_table_depth >= 3)
+           /* A char-table is never that deep.  */
+           error ("Too deep char table");
+

          complete_char
          complete_char

-           = (CHARSET_VALID_P (idx[0])
-              && ((CHARSET_DIMENSION (idx[0]) == 1 && this_level == 1)
-                  || this_level == 2));
+           = (CHARSET_VALID_P (indices[0])
+              && ((CHARSET_DIMENSION (indices[0]) == 1
+                   && char_table_depth == 1)
+                  || char_table_depth == 2));

 
          /* Meaningful elements are from 32th to 127th.  */
          from = 32;
 
          /* Meaningful elements are from 32th to 127th.  */
          from = 32;

-         to = 128;
+         to = SUB_CHAR_TABLE_ORDINARY_SLOTS;

        }
        }

-      chartable_kludge = Fmake_vector (make_number (this_level + 1), Qnil);
-      if (this_level != 0)
-       bcopy (XVECTOR (elt_prefix)->contents,
-              XVECTOR (chartable_kludge)->contents,
-              this_level * sizeof (Lisp_Object));

     }
   else
     {
     }
   else
     {

-      this_level = 0;
-      from = 0;

       /* This does the right thing for ordinary vectors.  */
       /* This does the right thing for ordinary vectors.  */

-      to = XFASTINT (Flength (vector));
-      /* Now, can this be just `XVECTOR (vector)->size'? -- K.Handa  */
+
+      complete_char = 1;
+      from = 0;
+      to = XVECTOR (vector)->size;

     }
 
   for (i = from; i < to; i++)
     {
       QUIT;
 
     }
 
   for (i = from; i < to; i++)
     {
       QUIT;
 

-      if (this_level == 0
-         && i >= CHAR_TABLE_SINGLE_BYTE_SLOTS
-         && !CHARSET_DEFINED_P (i - 128))
-       continue;
+      if (CHAR_TABLE_P (vector))
+       {
+         if (char_table_depth == 0 && i >= CHAR_TABLE_SINGLE_BYTE_SLOTS)
+           complete_char = 0;
+
+         if (i >= CHAR_TABLE_SINGLE_BYTE_SLOTS
+             && !CHARSET_DEFINED_P (i - 128))
+           continue;
+
+         definition
+           = get_keyelt (XCHAR_TABLE (vector)->contents[i], 0);
+       }
+      else
+       definition = get_keyelt (XVECTOR (vector)->contents[i], 0);

 
 

-      definition = get_keyelt (XVECTOR (vector)->contents[i], 0);

       if (NILP (definition)) continue;      
 
       /* Don't mention suppressed commands.  */
       if (NILP (definition)) continue;      
 
       /* Don't mention suppressed commands.  */


@@ -2612,12 +3096,33 @@ describe_vector (vector, elt_prefix, elt_describer,
          if (!NILP (tem)) continue;
        }
 
          if (!NILP (tem)) continue;
        }
 

+      /* Set CHARACTER to the character this entry describes, if any.
+        Also update *INDICES.  */
+      if (CHAR_TABLE_P (vector))
+       {
+         indices[char_table_depth] = i;
+
+         if (char_table_depth == 0)
+           {
+             character = i;
+             indices[0] = i - 128;
+           }
+         else if (complete_char)
+           {
+             character = MAKE_CHAR (indices[0], indices[1], indices[2]);
+           }
+         else
+           character = 0;
+       }
+      else
+       character = i;
+

       /* If this binding is shadowed by some other map, ignore it.  */
       /* If this binding is shadowed by some other map, ignore it.  */

-      if (!NILP (shadow))
+      if (!NILP (shadow) && complete_char)

        {
          Lisp_Object tem;
          
        {
          Lisp_Object tem;
          

-         XVECTOR (kludge)->contents[0] = make_number (i);
+         XVECTOR (kludge)->contents[0] = make_number (character);

          tem = shadow_lookup (shadow, kludge, Qt);
 
          if (!NILP (tem)) continue;
          tem = shadow_lookup (shadow, kludge, Qt);
 
          if (!NILP (tem)) continue;


@@ -2625,11 +3130,11 @@ describe_vector (vector, elt_prefix, elt_describer,
 
       /* Ignore this definition if it is shadowed by an earlier
         one in the same keymap.  */
 
       /* Ignore this definition if it is shadowed by an earlier
         one in the same keymap.  */

-      if (!NILP (entire_map))
+      if (!NILP (entire_map) && complete_char)

        {
          Lisp_Object tem;
 
        {
          Lisp_Object tem;
 

-         XVECTOR (kludge)->contents[0] = make_number (i);
+         XVECTOR (kludge)->contents[0] = make_number (character);

          tem = Flookup_key (entire_map, kludge, Qt);
 
          if (! EQ (tem, definition))
          tem = Flookup_key (entire_map, kludge, Qt);
 
          if (! EQ (tem, definition))


@@ -2638,110 +3143,130 @@ describe_vector (vector, elt_prefix, elt_describer,
 
       if (first)
        {
 
       if (first)
        {

-         if (this_level == 0)
+         if (char_table_depth == 0)

            insert ("\n", 1);
          first = 0;
        }
 
            insert ("\n", 1);
          first = 0;
        }
 

-      /* If VECTOR is a deeper char-table, show the depth by indentation.
-        THIS_LEVEL can be greater than 0 only for char-table.  */
-      if (this_level > 0)
-       insert ("    ", this_level * 2); /* THIS_LEVEL is 1 or 2.  */
+      /* For a sub char-table, show the depth by indentation.
+        CHAR_TABLE_DEPTH can be greater than 0 only for a char-table.  */
+      if (char_table_depth > 0)
+       insert ("    ", char_table_depth * 2); /* depth is 1 or 2.  */

 
 

-      /* Get a Lisp object for the character I.  */
-      XSETFASTINT (dummy, i);
+      /* Output the prefix that applies to every entry in this map.  */
+      if (!NILP (elt_prefix))
+       insert1 (elt_prefix);

 
 

-      if (CHAR_TABLE_P (vector))
+      /* Insert or describe the character this slot is for,
+        or a description of what it is for.  */
+      if (SUB_CHAR_TABLE_P (vector))

        {
          if (complete_char)
        {
          if (complete_char)

+           insert_char (character);
+         else

            {
            {

-             /* Combine ELT_PREFIX with I to produce a character code,
-                then insert that character's description.  */
-             idx[this_level] = i;
-             insert_char (MAKE_NON_ASCII_CHAR (idx[0], idx[1], idx[2]));
+             /* We need an octal representation for this block of
+                 characters.  */
+             char work[16];
+             sprintf (work, "(row %d)", i);
+             insert (work, strlen (work));

            }
            }

-         else if (this_level > 0)
+       }
+      else if (CHAR_TABLE_P (vector))
+       {
+         if (complete_char)
+           insert1 (Fsingle_key_description (make_number (character), Qnil));
+         else

            {
            {

-             /* We need an octal representation.  */
-             char work[5];
-             sprintf (work, "\\%03o", i & 255);
-             insert (work, 4);
+             /* Print the information for this character set.  */
+             insert_string ("<");
+             tem2 = CHARSET_TABLE_INFO (i - 128, CHARSET_SHORT_NAME_IDX);
+             if (STRINGP (tem2))
+               insert_from_string (tem2, 0, 0, XSTRING (tem2)->size,
+                                   STRING_BYTES (XSTRING (tem2)), 0);
+             else
+               insert ("?", 1);
+             insert (">", 1);

            }
            }

-         else
-           insert1 (Fsingle_key_description (dummy));

        }
       else
        {
        }
       else
        {

-         /* Output the prefix that applies to every entry in this map.  */
-         if (!NILP (elt_prefix))
-           insert1 (elt_prefix);
-
-         /* Get the string to describe the character DUMMY, and print it.  */
-         insert1 (Fsingle_key_description (dummy));
+         insert1 (Fsingle_key_description (make_number (character), Qnil));

        }
 
        }
 

-      /* If we find a char-table within a char-table,
+      /* If we find a sub char-table within a char-table,

         scan it recursively; it defines the details for
         a character set or a portion of a character set.  */
         scan it recursively; it defines the details for
         a character set or a portion of a character set.  */

-      if (multibyte && CHAR_TABLE_P (vector) && CHAR_TABLE_P (definition))
+      if (CHAR_TABLE_P (vector) && SUB_CHAR_TABLE_P (definition))

        {
        {

-         if (this_level == 0
-             && CHARSET_VALID_P (i - 128))
-           {
-             /* Before scanning the deeper table, print the
-                information for this character set.  */
-             insert_string ("\t\t<charset:");
-             tem2 = CHARSET_TABLE_INFO (i - 128, CHARSET_SHORT_NAME_IDX);
-             insert_from_string (tem2, 0 , XSTRING (tem2)->size, 0);
-             insert (">", 1);
-           }
-

          insert ("\n", 1);
          insert ("\n", 1);

-         XVECTOR (chartable_kludge)->contents[this_level] = make_number (i);
-         describe_vector (definition, chartable_kludge, elt_describer,
-                          partial, shadow, entire_map);
+         describe_vector (definition, elt_prefix, elt_describer,
+                          partial, shadow, entire_map,
+                          indices, char_table_depth + 1);

          continue;
        }
 
          continue;
        }
 

-      /* Find all consecutive characters that have the same definition.  */
-      while (i + 1 < to
-            && (tem2 = get_keyelt (XVECTOR (vector)->contents[i+1], 0),
-                !NILP (tem2))
-            && !NILP (Fequal (tem2, definition)))
-       i++;
+      starting_i = i;
+
+      /* Find all consecutive characters or rows that have the same
+         definition.  But, for elements of a top level char table, if
+         they are for charsets, we had better describe one by one even
+         if they have the same definition.  */
+      if (CHAR_TABLE_P (vector))
+       {
+         int limit = to;
+
+         if (char_table_depth == 0)
+           limit = CHAR_TABLE_SINGLE_BYTE_SLOTS;
+
+         while (i + 1 < limit
+                && (tem2 = get_keyelt (XCHAR_TABLE (vector)->contents[i + 1], 0),
+                    !NILP (tem2))
+                && !NILP (Fequal (tem2, definition)))
+           i++;
+       }
+      else
+       while (i + 1 < to
+              && (tem2 = get_keyelt (XVECTOR (vector)->contents[i + 1], 0),
+                  !NILP (tem2))
+              && !NILP (Fequal (tem2, definition)))
+         i++;
+      

 
       /* If we have a range of more than one character,
         print where the range reaches to.  */
 
 
       /* If we have a range of more than one character,
         print where the range reaches to.  */
 

-      if (i != XINT (dummy))
+      if (i != starting_i)

        {
          insert (" .. ", 4);
        {
          insert (" .. ", 4);

+
+         if (!NILP (elt_prefix))
+           insert1 (elt_prefix);
+

          if (CHAR_TABLE_P (vector))
            {
          if (CHAR_TABLE_P (vector))
            {

-             if (complete_char)
+             if (char_table_depth == 0)

                {
                {

-                 idx[this_level] = i;
-                 insert_char (MAKE_NON_ASCII_CHAR (idx[0], idx[1], idx[2]));
+                 insert1 (Fsingle_key_description (make_number (i), Qnil));

                }
                }

-             else if (this_level > 0)
+             else if (complete_char)

                {
                {

-                 char work[5];
-                 sprintf (work, "\\%03o", i & 255);
-                 insert (work, 4);
+                 indices[char_table_depth] = i;
+                 character = MAKE_CHAR (indices[0], indices[1], indices[2]);
+                 insert_char (character);

                }
              else
                {
                }
              else
                {

-                 XSETFASTINT (dummy, i);
-                 insert1 (Fsingle_key_description (dummy));
+                 /* We need an octal representation for this block of
+                    characters.  */
+                 char work[16];
+                 sprintf (work, "(row %d)", i);
+                 insert (work, strlen (work));

                }
            }
          else
            {
                }
            }
          else
            {

-             if (!NILP (elt_prefix) && !CHAR_TABLE_P (vector))
-               insert1 (elt_prefix);
-
-             XSETFASTINT (dummy, i);
-             insert1 (Fsingle_key_description (dummy));
+             insert1 (Fsingle_key_description (make_number (i), Qnil));

            }
        }
 
            }
        }
 


@@ -2751,10 +3276,10 @@ describe_vector (vector, elt_prefix, elt_describer,
       (*elt_describer) (definition);
     }
 
       (*elt_describer) (definition);
     }
 

-  /* For char-table, print `defalt' slot at last.  */
+  /* For (sub) char-table, print `defalt' slot at last.  */

   if (CHAR_TABLE_P (vector) && !NILP (XCHAR_TABLE (vector)->defalt))
     {
   if (CHAR_TABLE_P (vector) && !NILP (XCHAR_TABLE (vector)->defalt))
     {

-      insert ("    ", this_level * 2);
+      insert ("    ", char_table_depth * 2);

       insert_string ("<<default>>");
       (*elt_describer) (XCHAR_TABLE (vector)->defalt);
     }
       insert_string ("<<default>>");
       (*elt_describer) (XCHAR_TABLE (vector)->defalt);
     }


@@ -2798,19 +3323,21 @@ Return list of symbols found.")
   return apropos_accumulate;
 }
 \f
   return apropos_accumulate;
 }
 \f

+void

 syms_of_keymap ()
 {
 syms_of_keymap ()
 {

-  Lisp_Object tem;
-

   Qkeymap = intern ("keymap");
   staticpro (&Qkeymap);
 
   Qkeymap = intern ("keymap");
   staticpro (&Qkeymap);
 

-/* Initialize the keymaps standardly used.
-   Each one is the value of a Lisp variable, and is also
-   pointed to by a C variable */
+  /* Now we are ready to set up this property, so we can
+     create char tables.  */
+  Fput (Qkeymap, Qchar_table_extra_slots, make_number (0));

 
 

-  global_map = Fcons (Qkeymap,
-                     Fcons (Fmake_vector (make_number (0400), Qnil), Qnil));
+  /* Initialize the keymaps standardly used.
+     Each one is the value of a Lisp variable, and is also
+     pointed to by a C variable */
+
+  global_map = Fmake_keymap (Qnil);

   Fset (intern ("global-map"), global_map);
 
   current_global_map = global_map;
   Fset (intern ("global-map"), global_map);
 
   current_global_map = global_map;


@@ -2855,6 +3382,13 @@ If two active keymaps bind the same key, the keymap appearing earlier\n\
 in the list takes precedence.");
   Vminor_mode_map_alist = Qnil;
 
 in the list takes precedence.");
   Vminor_mode_map_alist = Qnil;
 

+  DEFVAR_LISP ("minor-mode-overriding-map-alist", &Vminor_mode_overriding_map_alist,
+    "Alist of keymaps to use for minor modes, in current major mode.\n\
+This variable is a alist just like `minor-mode-map-alist', and it is\n\
+used the same way (and before `minor-mode-map-alist'); however,\n\
+it is provided for major modes to bind locally.");
+  Vminor_mode_overriding_map_alist = Qnil;
+

   DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
   "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
 This allows Emacs to recognize function keys sent from ASCII\n\
   DEFVAR_LISP ("function-key-map", &Vfunction_key_map,
   "Keymap mapping ASCII function key sequences onto their preferred forms.\n\
 This allows Emacs to recognize function keys sent from ASCII\n\


@@ -2894,6 +3428,9 @@ and applies even for keys that have ordinary bindings.");
   Qnon_ascii = intern ("non-ascii");
   staticpro (&Qnon_ascii);
 
   Qnon_ascii = intern ("non-ascii");
   staticpro (&Qnon_ascii);
 

+  Qmenu_item = intern ("menu-item");
+  staticpro (&Qmenu_item);
+

   defsubr (&Skeymapp);
   defsubr (&Skeymap_parent);
   defsubr (&Sset_keymap_parent);
   defsubr (&Skeymapp);
   defsubr (&Skeymap_parent);
   defsubr (&Sset_keymap_parent);


@@ -2918,14 +3455,13 @@ and applies even for keys that have ordinary bindings.");
   defsubr (&Ssingle_key_description);
   defsubr (&Stext_char_description);
   defsubr (&Swhere_is_internal);
   defsubr (&Ssingle_key_description);
   defsubr (&Stext_char_description);
   defsubr (&Swhere_is_internal);

-  defsubr (&Sdescribe_bindings);
+  defsubr (&Sdescribe_bindings_internal);

   defsubr (&Sapropos_internal);
 }
 
   defsubr (&Sapropos_internal);
 }
 

+void

 keys_of_keymap ()
 {
 keys_of_keymap ()
 {

-  Lisp_Object tem;
-

   initial_define_key (global_map, 033, "ESC-prefix");
   initial_define_key (global_map, Ctl('X'), "Control-X-prefix");
 }
   initial_define_key (global_map, 033, "ESC-prefix");
   initial_define_key (global_map, Ctl('X'), "Control-X-prefix");
 }