(Fnext_property_change): Fix previous change.

[gnu-emacs] / src / keymap.c

diff --git a/src/keymap.c b/src/keymap.c
index 5738edbfd13bd96101d5e588e3e38c042fdaeda5..e5890f59a2b9d1d4b8d5af0bfdc241d0fa107464 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,5 @@
 /* Manipulation of keymaps
 /* Manipulation of keymaps

-   Copyright (C) 1985, 1986, 1987, 1988, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1985, 86, 87, 88, 93, 94 Free Software Foundation, Inc.

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


@@ -18,7 +18,7 @@ along with GNU Emacs; see the file COPYING.  If not, write to
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 
 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 

-#include "config.h"
+#include <config.h>

 #include <stdio.h>
 #undef NULL
 #include "lisp.h"
 #include <stdio.h>
 #undef NULL
 #include "lisp.h"


@@ -80,12 +80,13 @@ Lisp_Object Qkeymapp, Qkeymap, Qnon_ascii;
    character.  */
 extern Lisp_Object meta_prefix_char;
 
    character.  */
 extern Lisp_Object meta_prefix_char;
 

+extern Lisp_Object Voverriding_local_map;
+

 void describe_map_tree ();
 static Lisp_Object define_as_prefix ();
 static Lisp_Object describe_buffer_bindings ();
 static void describe_command ();
 static void describe_map ();
 void describe_map_tree ();
 static Lisp_Object define_as_prefix ();
 static Lisp_Object describe_buffer_bindings ();
 static void describe_command ();
 static void describe_map ();

-static void describe_map_2 ();

 \f
 /* Keymap object support - constructors and predicates.                        */
 
 \f
 /* Keymap object support - constructors and predicates.                        */
 


@@ -162,8 +163,8 @@ synkey (frommap, fromchar, tomap, tochar)
      int fromchar, tochar;
 {
   Lisp_Object v, c;
      int fromchar, tochar;
 {
   Lisp_Object v, c;

-  XSET (v, Lisp_Vector, tomap);
-  XFASTINT (c) = tochar;
+  XSETVECTOR (v, tomap);
+  XSETFASTINT (c, tochar);

   frommap->contents[fromchar] = Fcons (v, c);
 }
 #endif /* 0 */
   frommap->contents[fromchar] = Fcons (v, c);
 }
 #endif /* 0 */


@@ -172,7 +173,7 @@ DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
   "Return t if ARG is a keymap.\n\
 \n\
 A keymap is a list (keymap . ALIST),\n\
   "Return t if ARG is a keymap.\n\
 \n\
 A keymap is a list (keymap . ALIST),\n\

-or a symbol whose function definition is a keymap is itself a keymap.\n\
+or a symbol whose function definition is itself a keymap.\n\

 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
 a vector of densely packed bindings for small character codes\n\
 is also allowed as an element.")
 ALIST elements look like (CHAR . DEFN) or (SYMBOL . DEFN);\n\
 a vector of densely packed bindings for small character codes\n\
 is also allowed as an element.")


@@ -187,6 +188,7 @@ is also allowed as an element.")
 
    If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
    is an autoload form, do the autoload and try again.
 
    If AUTOLOAD is non-zero and OBJECT is a symbol whose function value
    is an autoload form, do the autoload and try again.

+   If AUTOLOAD is nonzero, callers must assume GC is possible.

 
    ERROR controls how we respond if OBJECT isn't a keymap.
    If ERROR is non-zero, signal an error; otherwise, just return Qnil.
 
    ERROR controls how we respond if OBJECT isn't a keymap.
    If ERROR is non-zero, signal an error; otherwise, just return Qnil.


@@ -212,7 +214,7 @@ get_keymap_1 (object, error, autoload)
   /* Should we do an autoload?  Autoload forms for keymaps have
      Qkeymap as their fifth element.  */
   if (autoload
   /* Should we do an autoload?  Autoload forms for keymaps have
      Qkeymap as their fifth element.  */
   if (autoload

-      && XTYPE (object) == Lisp_Symbol
+      && SYMBOLP (object)

       && CONSP (tem)
       && EQ (XCONS (tem)->car, Qautoload))
     {
       && CONSP (tem)
       && EQ (XCONS (tem)->car, Qautoload))
     {


@@ -244,7 +246,7 @@ Lisp_Object
 get_keymap (object)
      Lisp_Object object;
 {
 get_keymap (object)
      Lisp_Object object;
 {

-  return get_keymap_1 (object, 0, 0);
+  return get_keymap_1 (object, 1, 0);

 }
 
 
 }
 
 


@@ -277,31 +279,32 @@ access_keymap (map, idx, t_ok, noinherit)
 
   /* If idx is a symbol, it might have modifiers, which need to
      be put in the canonical order.  */
 
   /* If idx is a symbol, it might have modifiers, which need to
      be put in the canonical order.  */

-  if (XTYPE (idx) == Lisp_Symbol)
+  if (SYMBOLP (idx))

     idx = reorder_modifiers (idx);
   else if (INTEGERP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */
     idx = reorder_modifiers (idx);
   else if (INTEGERP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */

-    XFASTINT (idx) = XINT (idx) & (CHAR_META | (CHAR_META - 1));
+    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));

 
   {
     Lisp_Object tail;
 
   {
     Lisp_Object tail;

-    Lisp_Object 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 = XCONS (tail)->cdr)
       {

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

 
 

-       switch (XTYPE (binding))
+       binding = XCONS (tail)->car;
+       if (SYMBOLP (binding))

          {
          {

-         case Lisp_Symbol:

            /* If NOINHERIT, stop finding prefix definitions
               after we pass a second occurrence of the `keymap' symbol.  */
            if (noinherit && EQ (binding, Qkeymap) && ! EQ (tail, map))
              noprefix = 1;
            /* If NOINHERIT, stop finding prefix definitions
               after we pass a second occurrence of the `keymap' symbol.  */
            if (noinherit && EQ (binding, Qkeymap) && ! EQ (tail, map))
              noprefix = 1;

-           break;
-
-         case Lisp_Cons:
+         }
+       else if (CONSP (binding))
+         {

            if (EQ (XCONS (binding)->car, idx))
              {
                val = XCONS (binding)->cdr;
            if (EQ (XCONS (binding)->car, idx))
              {
                val = XCONS (binding)->cdr;


@@ -311,19 +314,16 @@ access_keymap (map, idx, t_ok, noinherit)
              }
            if (t_ok && EQ (XCONS (binding)->car, Qt))
              t_binding = XCONS (binding)->cdr;
              }
            if (t_ok && EQ (XCONS (binding)->car, Qt))
              t_binding = XCONS (binding)->cdr;

-           break;
-
-         case Lisp_Vector:
-           if (XTYPE (idx) == Lisp_Int
-               && XINT (idx) >= 0
-               && XINT (idx) < XVECTOR (binding)->size)
+         }
+       else if (VECTORP (binding))
+         {
+           if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (binding)->size)

              {
              {

-               val = XVECTOR (binding)->contents[XINT (idx)];
+               val = XVECTOR (binding)->contents[XFASTINT (idx)];

                if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
                  return Qnil;
                return val;
              }
                if (noprefix && CONSP (val) && EQ (XCONS (val)->car, Qkeymap))
                  return Qnil;
                return val;
              }

-           break;

          }
 
        QUIT;
          }
 
        QUIT;


@@ -340,18 +340,22 @@ access_keymap (map, idx, t_ok, noinherit)
    and INDEX is the object to look up in KEYMAP to yield the definition.
 
    Also if OBJECT has a menu string as the first element,
    and INDEX is the object to look up in KEYMAP to yield the definition.
 
    Also if OBJECT has a menu string as the first element,

-   remove that.  Also remove a menu help string as second element.  */
+   remove that.  Also remove a menu help string as second element.
+
+   If AUTOLOAD is nonzero, load autoloadable keymaps
+   that are referred to with indirection.  */

 
 Lisp_Object
 
 Lisp_Object

-get_keyelt (object)
+get_keyelt (object, autoload)

      register Lisp_Object object;
      register Lisp_Object object;

+     int autoload;

 {
   while (1)
     {
       register Lisp_Object map, tem;
 
       /* If the contents are (KEYMAP . ELEMENT), go indirect.  */
 {
   while (1)
     {
       register Lisp_Object map, tem;
 
       /* If the contents are (KEYMAP . ELEMENT), go indirect.  */

-      map = get_keymap_1 (Fcar_safe (object), 0, 0);
+      map = get_keymap_1 (Fcar_safe (object), 0, autoload);

       tem = Fkeymapp (map);
       if (!NILP (tem))
        object = access_keymap (map, Fcdr (object), 0, 0);
       tem = Fkeymapp (map);
       if (!NILP (tem))
        object = access_keymap (map, Fcdr (object), 0, 0);


@@ -360,15 +364,23 @@ get_keyelt (object)
         use DEFN.
         Keymap alist elements like (CHAR MENUSTRING . DEFN)
         will be used by HierarKey menus.  */
         use DEFN.
         Keymap alist elements like (CHAR MENUSTRING . DEFN)
         will be used by HierarKey menus.  */

-      else if (XTYPE (object) == Lisp_Cons
-              && XTYPE (XCONS (object)->car) == Lisp_String)
+      else if (CONSP (object)
+              && STRINGP (XCONS (object)->car))

        {
          object = XCONS (object)->cdr;
          /* Also remove a menu help string, if any,
             following the menu item name.  */
        {
          object = XCONS (object)->cdr;
          /* Also remove a menu help string, if any,
             following the menu item name.  */

-         if (XTYPE (object) == Lisp_Cons
-             && XTYPE (XCONS (object)->car) == Lisp_String)
+         if (CONSP (object) && STRINGP (XCONS (object)->car))

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

+         /* Also remove the sublist that caches key equivalences, if any.  */
+         if (CONSP (object)
+             && CONSP (XCONS (object)->car))
+           {
+             Lisp_Object carcar;
+             carcar = XCONS (XCONS (object)->car)->car;
+             if (NILP (carcar) || VECTORP (carcar))
+               object = XCONS (object)->cdr;
+           }

        }
 
       else
        }
 
       else


@@ -383,8 +395,13 @@ store_in_keymap (keymap, idx, def)
      register Lisp_Object idx;
      register Lisp_Object def;
 {
      register Lisp_Object idx;
      register Lisp_Object def;
 {

-  if (XTYPE (keymap) != Lisp_Cons
-      || ! EQ (XCONS (keymap)->car, Qkeymap))
+  /* 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 (!NILP (Vpurify_flag) && CONSP (def)
+      && STRINGP (XCONS (def)->car))
+    def = Fcons (XCONS (def)->car, XCONS (def)->cdr);
+
+  if (!CONSP (keymap) || ! EQ (XCONS (keymap)->car, 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?),


@@ -394,12 +411,12 @@ store_in_keymap (keymap, idx, def)
 
   /* If idx is a symbol, it might have modifiers, which need to
      be put in the canonical order.  */
 
   /* If idx is a symbol, it might have modifiers, which need to
      be put in the canonical order.  */

-  if (XTYPE (idx) == Lisp_Symbol)
+  if (SYMBOLP (idx))

     idx = reorder_modifiers (idx);
   else if (INTEGERP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */
     idx = reorder_modifiers (idx);
   else if (INTEGERP (idx))
     /* Clobber the high bits that can be present on a machine
        with more than 24 bits of integer.  */

-    XFASTINT (idx) = XINT (idx) & (CHAR_META | (CHAR_META - 1));
+    XSETFASTINT (idx, XINT (idx) & (CHAR_META | (CHAR_META - 1)));

 
   /* Scan the keymap for a binding of idx.  */
   {
 
   /* Scan the keymap for a binding of idx.  */
   {


@@ -411,40 +428,39 @@ store_in_keymap (keymap, idx, def)
        towards the front of the alist and character lookups in dense
        keymaps will remain fast.  Otherwise, this just points at the
        front of the keymap.  */
        towards the front of the alist and character lookups in dense
        keymaps will remain fast.  Otherwise, this just points at the
        front of the keymap.  */

-    Lisp_Object insertion_point = keymap;
+    Lisp_Object insertion_point;

 
 

+    insertion_point = keymap;

     for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
       {
     for (tail = XCONS (keymap)->cdr; CONSP (tail); tail = XCONS (tail)->cdr)
       {

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

 
 

-       switch (XTYPE (elt))
+       elt = XCONS (tail)->car;
+       if (VECTORP (elt))

          {
          {

-         case Lisp_Vector:
-           if (XTYPE (idx) == Lisp_Int
-               && XINT (idx) >= 0 && XINT (idx) < XVECTOR (elt)->size)
+           if (NATNUMP (idx) && XFASTINT (idx) < XVECTOR (elt)->size)

              {
                XVECTOR (elt)->contents[XFASTINT (idx)] = def;
                return def;
              }
            insertion_point = tail;
              {
                XVECTOR (elt)->contents[XFASTINT (idx)] = def;
                return def;
              }
            insertion_point = tail;

-           break;
-
-         case Lisp_Cons:
+         }
+       else if (CONSP (elt))
+         {

            if (EQ (idx, XCONS (elt)->car))
              {
                XCONS (elt)->cdr = def;
                return def;
              }
            if (EQ (idx, XCONS (elt)->car))
              {
                XCONS (elt)->cdr = def;
                return def;
              }

-           break;
-
-         case Lisp_Symbol:
+         }
+       else if (SYMBOLP (elt))
+         {

            /* If we find a 'keymap' symbol in the spine of KEYMAP,
                then we must have found the start of a second keymap
                being used as the tail of KEYMAP, and a binding for IDX
                should be inserted before it.  */
            if (EQ (elt, Qkeymap))
              goto keymap_end;
            /* If we find a 'keymap' symbol in the spine of KEYMAP,
                then we must have found the start of a second keymap
                being used as the tail of KEYMAP, and a binding for IDX
                should be inserted before it.  */
            if (EQ (elt, Qkeymap))
              goto keymap_end;

-           break;

          }
 
        QUIT;
          }
 
        QUIT;


@@ -453,8 +469,8 @@ 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);
+    XCONS (insertion_point)->cdr
+      = Fcons (Fcons (idx, def), XCONS (insertion_point)->cdr);

   }
          
   return def;
   }
          
   return def;


@@ -477,9 +493,10 @@ is not copied.")
 
   for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
     {
 
   for (tail = copy; CONSP (tail); tail = XCONS (tail)->cdr)
     {

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

 
 

-      if (XTYPE (elt) == Lisp_Vector)
+      elt = XCONS (tail)->car;
+      if (VECTORP (elt))

        {
          int i;
 
        {
          int i;
 


@@ -487,15 +504,45 @@ is not copied.")
          XCONS (tail)->car = elt;
 
          for (i = 0; i < XVECTOR (elt)->size; i++)
          XCONS (tail)->car = elt;
 
          for (i = 0; i < XVECTOR (elt)->size; i++)

-           if (XTYPE (XVECTOR (elt)->contents[i]) != Lisp_Symbol
+           if (!SYMBOLP (XVECTOR (elt)->contents[i])

                && ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
              XVECTOR (elt)->contents[i] =
                Fcopy_keymap (XVECTOR (elt)->contents[i]);
        }
                && ! NILP (Fkeymapp (XVECTOR (elt)->contents[i])))
              XVECTOR (elt)->contents[i] =
                Fcopy_keymap (XVECTOR (elt)->contents[i]);
        }

-      else if (CONSP (elt)
-              && XTYPE (XCONS (elt)->cdr) != Lisp_Symbol
-              && ! NILP (Fkeymapp (XCONS (elt)->cdr)))
-       XCONS (elt)->cdr = Fcopy_keymap (XCONS (elt)->cdr);
+      else if (CONSP (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;
+
+             /* Also skip the optional menu help string.  */
+             if (CONSP (XCONS (elt)->cdr)
+                 && STRINGP (XCONS (XCONS (elt)->cdr)->car))
+               {
+                 XCONS (elt)->cdr = Fcons (XCONS (XCONS (elt)->cdr)->car,
+                                           XCONS (XCONS (elt)->cdr)->cdr);
+                 elt = XCONS (elt)->cdr;
+               }
+             /* 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);
+       }

     }
 
   return copy;
     }
 
   return copy;


@@ -503,10 +550,14 @@ is not copied.")
 \f
 /* Simple Keymap mutators and accessors.                               */
 
 \f
 /* Simple Keymap mutators and accessors.                               */
 

+/* GC is possible in this function if it autoloads a keymap.  */
+

 DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
   "Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.\n\
 KEYMAP is a keymap.  KEY is a string or a vector of symbols and characters\n\
 meaning a sequence of keystrokes and events.\n\
 DEFUN ("define-key", Fdefine_key, Sdefine_key, 3, 3, 0,
   "Args KEYMAP, KEY, DEF.  Define key sequence KEY, in KEYMAP, as DEF.\n\
 KEYMAP is a keymap.  KEY is a string or a vector of symbols and characters\n\
 meaning a sequence of keystrokes and events.\n\

+Non-ASCII characters with codes above 127 (such as ISO Latin-1)\n\
+can be included if you use a vector.\n\

 DEF is anything that can be a key's definition:\n\
  nil (means key is undefined in this keymap),\n\
  a command (a Lisp function suitable for interactive calling)\n\
 DEF is anything that can be a key's definition:\n\
  nil (means key is undefined in this keymap),\n\
  a command (a Lisp function suitable for interactive calling)\n\


@@ -535,10 +586,9 @@ the front of KEYMAP.")
   int length;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   int length;
   struct gcpro gcpro1, gcpro2, gcpro3;
 

-  keymap = get_keymap (keymap);
+  keymap = get_keymap_1 (keymap, 1, 1);

 
 

-  if (XTYPE (key) != Lisp_Vector
-      && XTYPE (key) != Lisp_String)
+  if (!VECTORP (key) && !STRINGP (key))

     key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));
     key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));


@@ -547,7 +597,7 @@ the front of KEYMAP.")
 
   GCPRO3 (keymap, key, def);
 
 
   GCPRO3 (keymap, key, def);
 

-  if (XTYPE (key) == Lisp_Vector)
+  if (VECTORP (key))

     meta_bit = meta_modifier;
   else
     meta_bit = 0x80;
     meta_bit = meta_modifier;
   else
     meta_bit = 0x80;


@@ -557,7 +607,10 @@ the front of KEYMAP.")
     {
       c = Faref (key, make_number (idx));
 
     {
       c = Faref (key, make_number (idx));
 

-      if (XTYPE (c) == Lisp_Int
+      if (CONSP (c) && lucid_event_type_list_p (c))
+       c = convert_event_type_list (c);
+
+      if (INTEGERP (c)

          && (XINT (c) & meta_bit)
          && !metized)
        {
          && (XINT (c) & meta_bit)
          && !metized)
        {


@@ -566,17 +619,20 @@ the front of KEYMAP.")
        }
       else
        {
        }
       else
        {

-         if (XTYPE (c) == Lisp_Int)
+         if (INTEGERP (c))

            XSETINT (c, XINT (c) & ~meta_bit);
 
          metized = 0;
          idx++;
        }
 
            XSETINT (c, XINT (c) & ~meta_bit);
 
          metized = 0;
          idx++;
        }
 

+      if (! INTEGERP (c) && ! SYMBOLP (c) && ! CONSP (c))
+       error ("Key sequence contains invalid events");
+

       if (idx == length)
        RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
 
       if (idx == length)
        RETURN_UNGCPRO (store_in_keymap (keymap, c, def));
 

-      cmd = get_keyelt (access_keymap (keymap, c, 0, 1));
+      cmd = get_keyelt (access_keymap (keymap, c, 0, 1), 1);

 
       /* If this key is undefined, make it a prefix.  */
       if (NILP (cmd))
 
       /* If this key is undefined, make it a prefix.  */
       if (NILP (cmd))


@@ -584,18 +640,15 @@ the front of KEYMAP.")
 
       keymap = get_keymap_1 (cmd, 0, 1);
       if (NILP (keymap))
 
       keymap = get_keymap_1 (cmd, 0, 1);
       if (NILP (keymap))

-       {
-         /* We must use Fkey_description rather than just passing key to
-            error; key might be a vector, not a string.  */
-         Lisp_Object description = Fkey_description (key);
-
-         error ("Key sequence %s uses invalid prefix characters",
-                XSTRING (description)->data);
-       }
+       /* We must use Fkey_description rather than just passing key to
+          error; key might be a vector, not a string.  */
+       error ("Key sequence %s uses invalid prefix characters",
+              XSTRING (Fkey_description (key))->data);

     }
 }
 
 /* Value is number if KEY is too long; NIL if valid but has no definition. */
     }
 }
 
 /* Value is number if KEY is too long; NIL if valid but has no definition. */

+/* GC is possible in this function if it autoloads a keymap.  */

 
 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
   "In keymap KEYMAP, look up key sequence KEY.  Return the definition.\n\
 
 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
   "In keymap KEYMAP, look up key sequence KEY.  Return the definition.\n\


@@ -625,28 +678,33 @@ recognize the default bindings, just as `read-key-sequence' does.")
   int length;
   int t_ok = ! NILP (accept_default);
   int meta_bit;
   int length;
   int t_ok = ! NILP (accept_default);
   int meta_bit;

+  struct gcpro gcpro1;

 
 

-  keymap = get_keymap (keymap);
+  keymap = get_keymap_1 (keymap, 1, 1);

 
 

-  if (XTYPE (key) != Lisp_Vector
-      && XTYPE (key) != Lisp_String)
+  if (!VECTORP (key) && !STRINGP (key))

     key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));
   if (length == 0)
     return keymap;
 
     key = wrong_type_argument (Qarrayp, key);
 
   length = XFASTINT (Flength (key));
   if (length == 0)
     return keymap;
 

-  if (XTYPE (key) == Lisp_Vector)
+  if (VECTORP (key))

     meta_bit = meta_modifier;
   else
     meta_bit = 0x80;
 
     meta_bit = meta_modifier;
   else
     meta_bit = 0x80;
 

+  GCPRO1 (key);
+

   idx = 0;
   while (1)
     {
       c = Faref (key, make_number (idx));
 
   idx = 0;
   while (1)
     {
       c = Faref (key, make_number (idx));
 

-      if (XTYPE (c) == Lisp_Int
+      if (CONSP (c) && lucid_event_type_list_p (c))
+       c = convert_event_type_list (c);
+
+      if (INTEGERP (c)

          && (XINT (c) & meta_bit)
          && !metized)
        {
          && (XINT (c) & meta_bit)
          && !metized)
        {


@@ -655,20 +713,20 @@ recognize the default bindings, just as `read-key-sequence' does.")
        }
       else
        {
        }
       else
        {

-         if (XTYPE (c) == Lisp_Int)
+         if (INTEGERP (c))

            XSETINT (c, XINT (c) & ~meta_bit);
 
          metized = 0;
          idx++;
        }
 
            XSETINT (c, XINT (c) & ~meta_bit);
 
          metized = 0;
          idx++;
        }
 

-      cmd = get_keyelt (access_keymap (keymap, c, t_ok, 0));
+      cmd = get_keyelt (access_keymap (keymap, c, t_ok, 0), 1);

       if (idx == length)
       if (idx == length)

-       return cmd;
+       RETURN_UNGCPRO (cmd);

 
 

-      keymap = get_keymap_1 (cmd, 0, 0);
+      keymap = get_keymap_1 (cmd, 0, 1);

       if (NILP (keymap))
       if (NILP (keymap))

-       return make_number (idx);
+       RETURN_UNGCPRO (make_number (idx));

 
       QUIT;
     }
 
       QUIT;
     }


@@ -759,9 +817,9 @@ current_minor_maps (modeptr, mapptr)
   for (alist = Vminor_mode_map_alist;
        CONSP (alist);
        alist = XCONS (alist)->cdr)
   for (alist = Vminor_mode_map_alist;
        CONSP (alist);
        alist = XCONS (alist)->cdr)

-    if (CONSP (assoc = XCONS (alist)->car)
-       && XTYPE (var = XCONS (assoc)->car) == Lisp_Symbol
-       && ! EQ ((val = find_symbol_value (var)), Qunbound)
+    if ((assoc = XCONS (alist)->car, CONSP (assoc))
+       && (var = XCONS (assoc)->car, SYMBOLP (var))
+       && (val = find_symbol_value (var), ! EQ (val, Qunbound))

        && ! NILP (val))
       {
        if (i >= cmm_size)
        && ! NILP (val))
       {
        if (i >= cmm_size)


@@ -771,15 +829,23 @@ current_minor_maps (modeptr, mapptr)
            if (cmm_maps)
              {
                BLOCK_INPUT;
            if (cmm_maps)
              {
                BLOCK_INPUT;

-               newmodes = (Lisp_Object *) realloc (cmm_modes, cmm_size *= 2);
-               newmaps  = (Lisp_Object *) realloc (cmm_maps,  cmm_size);
+               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;
                UNBLOCK_INPUT;
              }
            else
              {
                BLOCK_INPUT;

-               newmodes = (Lisp_Object *) malloc (cmm_size = 30);
-               newmaps  = (Lisp_Object *) malloc (cmm_size);
+               cmm_size = 30;
+               newmodes
+                 = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));
+               newmaps
+                 = (Lisp_Object *) malloc (cmm_size * sizeof (Lisp_Object));

                UNBLOCK_INPUT;
              }
 
                UNBLOCK_INPUT;
              }
 


@@ -801,6 +867,8 @@ current_minor_maps (modeptr, mapptr)
   return i;
 }
 
   return i;
 }
 

+/* GC is possible in this function if it autoloads a keymap.  */
+

 DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
   "Return the binding for command KEY in current keymaps.\n\
 KEY is a string or vector, a sequence of keystrokes.\n\
 DEFUN ("key-binding", Fkey_binding, Skey_binding, 1, 2, 0,
   "Return the binding for command KEY in current keymaps.\n\
 KEY is a string or vector, a sequence of keystrokes.\n\


@@ -808,38 +876,56 @@ The binding is probably a symbol with a function definition.\n\
 \n\
 Normally, `key-binding' ignores bindings for t, which act as default\n\
 bindings, used when nothing else in the keymap applies; this makes it\n\
 \n\
 Normally, `key-binding' ignores bindings for t, which act as default\n\
 bindings, used when nothing else in the keymap applies; this makes it\n\

-useable as a general function for probing keymaps.  However, if the\n\
-third optional argument ACCEPT-DEFAULT is non-nil, `key-binding' will\n\
+usable as a general function for probing keymaps.  However, if the\n\
+optional second argument ACCEPT-DEFAULT is non-nil, `key-binding' does\n\

 recognize the default bindings, just as `read-key-sequence' does.")
   (key, accept_default)
 recognize the default bindings, just as `read-key-sequence' does.")
   (key, accept_default)

-     Lisp_Object key;
+     Lisp_Object key, accept_default;

 {
   Lisp_Object *maps, value;
   int nmaps, i;
 {
   Lisp_Object *maps, value;
   int nmaps, i;

+  struct gcpro gcpro1;

 
 

-  nmaps = current_minor_maps (0, &maps);
-  for (i = 0; i < nmaps; i++)
-    if (! NILP (maps[i]))
-      {
-       value = Flookup_key (maps[i], key, accept_default);
-       if (! NILP (value) && XTYPE (value) != Lisp_Int)
-         return value;
-      }
+  GCPRO1 (key);

 
 

-  if (! NILP (current_buffer->keymap))
+  if (!NILP (Voverriding_local_map))

     {
     {

-      value = Flookup_key (current_buffer->keymap, key, accept_default);
-      if (! NILP (value) && XTYPE (value) != Lisp_Int)
-       return value;
+      value = Flookup_key (Voverriding_local_map, key, accept_default);
+      if (! NILP (value) && !INTEGERP (value))
+       RETURN_UNGCPRO (value);
+    }
+  else
+    { 
+      nmaps = current_minor_maps (0, &maps);
+      /* Note that all these maps are GCPRO'd
+        in the places where we found them.  */
+
+      for (i = 0; i < nmaps; i++)
+       if (! NILP (maps[i]))
+         {
+           value = Flookup_key (maps[i], key, accept_default);
+           if (! NILP (value) && !INTEGERP (value))
+             RETURN_UNGCPRO (value);
+         }
+
+      if (! NILP (current_buffer->keymap))
+       {
+         value = Flookup_key (current_buffer->keymap, key, accept_default);
+         if (! NILP (value) && !INTEGERP (value))
+           RETURN_UNGCPRO (value);
+       }

     }
 
   value = Flookup_key (current_global_map, key, accept_default);
     }
 
   value = Flookup_key (current_global_map, key, accept_default);

-  if (! NILP (value) && XTYPE (value) != Lisp_Int)
+  UNGCPRO;
+  if (! NILP (value) && !INTEGERP (value))

     return value;
   
   return Qnil;
 }
 
     return value;
   
   return Qnil;
 }
 

+/* GC is possible in this function if it autoloads a keymap.  */
+

 DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
   "Return the binding for command KEYS in current local keymap only.\n\
 KEYS is a string, a sequence of keystrokes.\n\
 DEFUN ("local-key-binding", Flocal_key_binding, Slocal_key_binding, 1, 2, 0,
   "Return the binding for command KEYS in current local keymap only.\n\
 KEYS is a string, a sequence of keystrokes.\n\


@@ -857,12 +943,14 @@ bindings; see the description of `lookup-key' for more details about this.")
   return Flookup_key (map, keys, accept_default);
 }
 
   return Flookup_key (map, keys, accept_default);
 }
 

+/* GC is possible in this function if it autoloads a keymap.  */
+

 DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
   "Return the binding for command KEYS in current global keymap only.\n\
 KEYS is a string, a sequence of keystrokes.\n\
 The binding is probably a symbol with a function definition.\n\
 This function's return values are the same as those of lookup-key\n\
 DEFUN ("global-key-binding", Fglobal_key_binding, Sglobal_key_binding, 1, 2, 0,
   "Return the binding for command KEYS in current global keymap only.\n\
 KEYS is a string, a sequence of keystrokes.\n\
 The binding is probably a symbol with a function definition.\n\
 This function's return values are the same as those of lookup-key\n\

-(which see).\n\
+\(which see).\n\

 \n\
 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
 bindings; see the description of `lookup-key' for more details about this.")
 \n\
 If optional argument ACCEPT-DEFAULT is non-nil, recognize default\n\
 bindings; see the description of `lookup-key' for more details about this.")


@@ -872,6 +960,8 @@ bindings; see the description of `lookup-key' for more details about this.")
   return Flookup_key (current_global_map, keys, accept_default);
 }
 
   return Flookup_key (current_global_map, keys, accept_default);
 }
 

+/* GC is possible in this function if it autoloads a keymap.  */
+

 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
   "Find the visible minor mode bindings of KEY.\n\
 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\
 DEFUN ("minor-mode-key-binding", Fminor_mode_key_binding, Sminor_mode_key_binding, 1, 2, 0,
   "Find the visible minor mode bindings of KEY.\n\
 Return an alist of pairs (MODENAME . BINDING), where MODENAME is the\n\


@@ -891,89 +981,30 @@ bindings; see the description of `lookup-key' for more details about this.")
   int nmaps;
   Lisp_Object binding;
   int i, j;
   int nmaps;
   Lisp_Object binding;
   int i, j;

+  struct gcpro gcpro1, gcpro2;

 
   nmaps = current_minor_maps (&modes, &maps);
 
   nmaps = current_minor_maps (&modes, &maps);

+  /* Note that all these maps are GCPRO'd
+     in the places where we found them.  */
+
+  binding = Qnil;
+  GCPRO2 (key, binding);

 
   for (i = j = 0; i < nmaps; i++)
     if (! NILP (maps[i])
        && ! NILP (binding = Flookup_key (maps[i], key, accept_default))
 
   for (i = j = 0; i < nmaps; i++)
     if (! NILP (maps[i])
        && ! NILP (binding = Flookup_key (maps[i], key, accept_default))

-       && XTYPE (binding) != Lisp_Int)
+       && !INTEGERP (binding))

       {
        if (! NILP (get_keymap (binding)))
          maps[j++] = Fcons (modes[i], binding);
        else if (j == 0)
       {
        if (! NILP (get_keymap (binding)))
          maps[j++] = Fcons (modes[i], binding);
        else if (j == 0)

-         return Fcons (Fcons (modes[i], binding), Qnil);
+         RETURN_UNGCPRO (Fcons (Fcons (modes[i], binding), Qnil));

       }
 
       }
 

+  UNGCPRO;

   return Flist (j, maps);
 }
 
   return Flist (j, maps);
 }
 

-DEFUN ("global-set-key", Fglobal_set_key, Sglobal_set_key, 2, 2,
-  "kSet key globally: \nCSet key %s to command: ",
-  "Give KEY a global binding as COMMAND.\n\
-COMMAND is a symbol naming an interactively-callable function.\n\
-KEY is a key sequence (a string or vector of characters or event types).\n\
-Note that if KEY has a local binding in the current buffer\n\
-that local binding will continue to shadow any global binding.")
-  (keys, function)
-     Lisp_Object keys, function;
-{
-  if (XTYPE (keys) != Lisp_Vector
-      && XTYPE (keys) != Lisp_String)
-    keys = wrong_type_argument (Qarrayp, keys);
-
-  Fdefine_key (current_global_map, keys, function);
-  return Qnil;
-}
-
-DEFUN ("local-set-key", Flocal_set_key, Slocal_set_key, 2, 2,
-  "kSet key locally: \nCSet key %s locally to command: ",
-  "Give KEY a local binding as COMMAND.\n\
-COMMAND is a symbol naming an interactively-callable function.\n\
-KEY is a key sequence (a string or vector of characters or event types).\n\
-The binding goes in the current buffer's local map,\n\
-which is shared with other buffers in the same major mode.")
-  (keys, function)
-     Lisp_Object keys, function;
-{
-  register Lisp_Object map;
-  map = current_buffer->keymap;
-  if (NILP (map))
-    {
-      map = Fmake_sparse_keymap (Qnil);
-      current_buffer->keymap = map;
-    }
-
-  if (XTYPE (keys) != Lisp_Vector
-      && XTYPE (keys) != Lisp_String)
-    keys = wrong_type_argument (Qarrayp, keys);
-
-  Fdefine_key (map, keys, function);
-  return Qnil;
-}
-
-DEFUN ("global-unset-key", Fglobal_unset_key, Sglobal_unset_key,
-  1, 1, "kUnset key globally: ",
-  "Remove global binding of KEY.\n\
-KEY is a string representing a sequence of keystrokes.")
-  (keys)
-     Lisp_Object keys;
-{
-  return Fglobal_set_key (keys, Qnil);
-}
-
-DEFUN ("local-unset-key", Flocal_unset_key, Slocal_unset_key, 1, 1,
-  "kUnset key locally: ",
-  "Remove local binding of KEY.\n\
-KEY is a string representing a sequence of keystrokes.")
-  (keys)
-     Lisp_Object keys;
-{
-  if (!NILP (current_buffer->keymap))
-    Flocal_set_key (keys, Qnil);
-  return Qnil;
-}
-

 DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 2, 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\
 DEFUN ("define-prefix-command", Fdefine_prefix_command, Sdefine_prefix_command, 1, 2, 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\


@@ -1000,6 +1031,8 @@ DEFUN ("use-global-map", Fuse_global_map, Suse_global_map, 1, 1, 0,
 {
   keymap = get_keymap (keymap);
   current_global_map = keymap;
 {
   keymap = get_keymap (keymap);
   current_global_map = keymap;

+  record_asynch_buffer_change ();
+

   return Qnil;
 }
 
   return Qnil;
 }
 


@@ -1013,6 +1046,7 @@ If KEYMAP is nil, that means no local keymap.")
     keymap = get_keymap (keymap);
 
   current_buffer->keymap = keymap;
     keymap = get_keymap (keymap);
 
   current_buffer->keymap = keymap;

+  record_asynch_buffer_change ();

 
   return Qnil;
 }
 
   return Qnil;
 }


@@ -1043,6 +1077,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.              */
 

+/* This function cannot GC.  */
+

 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
   1, 2, 0,
   "Find all keymaps accessible via prefix characters from KEYMAP.\n\
 DEFUN ("accessible-keymaps", Faccessible_keymaps, Saccessible_keymaps,
   1, 2, 0,
   "Find all keymaps accessible via prefix characters from KEYMAP.\n\


@@ -1057,12 +1093,30 @@ then the value includes only maps for prefixes that start with PREFIX.")
   Lisp_Object maps, good_maps, tail;
   int prefixlen = 0;
 
   Lisp_Object maps, good_maps, tail;
   int prefixlen = 0;
 

+  /* no need for gcpro because we don't autoload any keymaps.  */
+

   if (!NILP (prefix))
     prefixlen = XINT (Flength (prefix));
 
   if (!NILP (prefix))
     prefixlen = XINT (Flength (prefix));
 

-  maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
-                      get_keymap (startmap)),
-               Qnil);
+  if (!NILP (prefix))
+    {
+      /* If a prefix was specified, start with the keymap (if any) for
+        that prefix, so we don't waste time considering other prefixes.  */
+      Lisp_Object tem;
+      tem = Flookup_key (startmap, prefix, Qt);
+      /* Flookup_key may give us nil, or a number,
+        if the prefix is not defined in this particular map.
+        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);
+      else
+       return Qnil;
+    }
+  else
+    maps = Fcons (Fcons (Fmake_vector (make_number (0), Qnil),
+                        get_keymap (startmap)),
+                 Qnil);

 
   /* For each map in the list maps,
      look at any other maps it points to,
 
   /* For each map in the list maps,
      look at any other maps it points to,


@@ -1073,21 +1127,26 @@ then the value includes only maps for prefixes that start with PREFIX.")
 
   for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr)
     {
 
   for (tail = maps; CONSP (tail); tail = XCONS (tail)->cdr)
     {

-      register Lisp_Object thisseq = Fcar (Fcar (tail));
-      register Lisp_Object thismap = Fcdr (Fcar (tail));
-      Lisp_Object last = make_number (XINT (Flength (thisseq)) - 1);
-
+      register Lisp_Object thisseq, thismap;
+      Lisp_Object last;

       /* Does the current sequence end in the meta-prefix-char?  */
       /* Does the current sequence end in the meta-prefix-char?  */

-      int is_metized = (XINT (last) >= 0
-                       && EQ (Faref (thisseq, last), meta_prefix_char));
+      int is_metized;
+
+      thisseq = Fcar (Fcar (tail));
+      thismap = Fcdr (Fcar (tail));
+      last = make_number (XINT (Flength (thisseq)) - 1);
+      is_metized = (XINT (last) >= 0
+                   && EQ (Faref (thisseq, last), meta_prefix_char));

 
       for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
        {
 
       for (; CONSP (thismap); thismap = XCONS (thismap)->cdr)
        {

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

 
          QUIT;
 
 
          QUIT;
 

-         if (XTYPE (elt) == Lisp_Vector)
+         if (VECTORP (elt))

            {
              register int i;
 
            {
              register int i;
 


@@ -1097,7 +1156,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
                  register Lisp_Object tem;
                  register Lisp_Object cmd;
 
                  register Lisp_Object tem;
                  register Lisp_Object cmd;
 

-                 cmd = get_keyelt (XVECTOR (elt)->contents[i]);
+                 cmd = get_keyelt (XVECTOR (elt)->contents[i], 0);

                  if (NILP (cmd)) continue;
                  tem = Fkeymapp (cmd);
                  if (!NILP (tem))
                  if (NILP (cmd)) continue;
                  tem = Fkeymapp (cmd);
                  if (!NILP (tem))


@@ -1136,9 +1195,9 @@ then the value includes only maps for prefixes that start with PREFIX.")
            }       
          else if (CONSP (elt))
            {
            }       
          else if (CONSP (elt))
            {

-             register Lisp_Object cmd = get_keyelt (XCONS (elt)->cdr);
-             register Lisp_Object tem, filter;
+             register Lisp_Object cmd, tem, filter;

 
 

+             cmd = get_keyelt (XCONS (elt)->cdr, 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))


@@ -1154,7 +1213,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
                      /* 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 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 && XTYPE (elt) == Lisp_Int)
+                     if (is_metized && INTEGERP (elt))

                        {
                          tem = Fcopy_sequence (thisseq);
                          Faset (tem, last,
                        {
                          tem = Fcopy_sequence (thisseq);
                          Faset (tem, last,


@@ -1195,7 +1254,7 @@ then the value includes only maps for prefixes that start with PREFIX.")
          for (i = 0; i < prefixlen; i++)
            {
              Lisp_Object i1;
          for (i = 0; i < prefixlen; i++)
            {
              Lisp_Object i1;

-             XFASTINT (i1) = i;
+             XSETFASTINT (i1, i);

              if (!EQ (Faref (thisseq, i1), Faref (prefix, i1)))
                break;
            }
              if (!EQ (Faref (thisseq, i1), Faref (prefix, i1)))
                break;
            }


@@ -1209,6 +1268,8 @@ then the value includes only maps for prefixes that start with PREFIX.")
 
 Lisp_Object Qsingle_key_description, Qkey_description;
 
 
 Lisp_Object Qsingle_key_description, Qkey_description;
 

+/* This function cannot GC.  */
+

 DEFUN ("key-description", Fkey_description, Skey_description, 1, 1, 0,
   "Return a pretty description of key-sequence KEYS.\n\
 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\
 DEFUN ("key-description", Fkey_description, Skey_description, 1, 1, 0,
   "Return a pretty description of key-sequence KEYS.\n\
 Control characters turn into \"C-foo\" sequences, meta into \"M-foo\"\n\


@@ -1216,23 +1277,45 @@ spaces are put between sequence elements, etc.")
   (keys)
      Lisp_Object keys;
 {
   (keys)
      Lisp_Object keys;
 {

-  if (XTYPE (keys) == Lisp_String)
+  int len;
+  int i;
+  Lisp_Object sep;
+  Lisp_Object *args;
+
+  if (STRINGP (keys))

     {
       Lisp_Object vector;
     {
       Lisp_Object vector;

-      int i;

       vector = Fmake_vector (Flength (keys), Qnil);
       for (i = 0; i < XSTRING (keys)->size; i++)
        {
          if (XSTRING (keys)->data[i] & 0x80)
       vector = Fmake_vector (Flength (keys), Qnil);
       for (i = 0; i < XSTRING (keys)->size; i++)
        {
          if (XSTRING (keys)->data[i] & 0x80)

-           XFASTINT (XVECTOR (vector)->contents[i])
-             = meta_modifier | (XSTRING (keys)->data[i] & ~0x80);
+           XSETFASTINT (XVECTOR (vector)->contents[i],
+                        meta_modifier | (XSTRING (keys)->data[i] & ~0x80));

          else
          else

-           XFASTINT (XVECTOR (vector)->contents[i])
-             = XSTRING (keys)->data[i];
+           XSETFASTINT (XVECTOR (vector)->contents[i],
+                        XSTRING (keys)->data[i]);

        }
       keys = vector;
     }
        }
       keys = vector;
     }

-  return Fmapconcat (Qsingle_key_description, keys, build_string (" "));
+  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.  */
+
+  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++)
+    {
+      args[i * 2] = Fsingle_key_description (XVECTOR (keys)->contents[i]);
+      args[i * 2 + 1] = sep;
+    }
+
+  return Fconcat (len * 2 - 1, args);

 }
 
 char *
 }
 
 char *


@@ -1343,6 +1426,8 @@ push_key_description (c, p)
   return p;  
 }
 
   return p;  
 }
 

+/* This function cannot GC.  */
+

 DEFUN ("single-key-description", Fsingle_key_description, Ssingle_key_description, 1, 1, 0,
   "Return a pretty description of command character KEY.\n\
 Control characters turn into C-whatever, etc.")
 DEFUN ("single-key-description", Fsingle_key_description, Ssingle_key_description, 1, 1, 0,
   "Return a pretty description of command character KEY.\n\
 Control characters turn into C-whatever, etc.")


@@ -1353,18 +1438,17 @@ Control characters turn into C-whatever, etc.")
 
   key = EVENT_HEAD (key);
 
 
   key = EVENT_HEAD (key);
 

-  switch (XTYPE (key))
+  if (INTEGERP (key))          /* Normal character */

     {
     {

-    case Lisp_Int:             /* Normal character */

       *push_key_description (XUINT (key), tem) = 0;
       return build_string (tem);
       *push_key_description (XUINT (key), tem) = 0;
       return build_string (tem);

-
-    case Lisp_Symbol:          /* Function key or event-symbol */
-      return Fsymbol_name (key);
-
-    default:
-      error ("KEY must be an integer, cons, or symbol.");

     }
     }

+  else if (SYMBOLP (key))      /* Function key or event-symbol */
+    return Fsymbol_name (key);
+  else if (STRINGP (key))      /* Buffer names in the menubar.  */
+    return Fcopy_sequence (key);
+  else
+    error ("KEY must be an integer, cons, symbol, or string");

 }
 
 char *
 }
 
 char *


@@ -1393,6 +1477,8 @@ push_text_char_description (c, p)
   return p;  
 }
 
   return p;  
 }
 

+/* This function cannot GC.  */
+

 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0,
   "Return a pretty description of file-character CHAR.\n\
 Control characters turn into \"^char\", etc.")
 DEFUN ("text-char-description", Ftext_char_description, Stext_char_description, 1, 1, 0,
   "Return a pretty description of file-character CHAR.\n\
 Control characters turn into \"^char\", etc.")


@@ -1414,14 +1500,17 @@ static int
 ascii_sequence_p (seq)
      Lisp_Object seq;
 {
 ascii_sequence_p (seq)
      Lisp_Object seq;
 {

-  Lisp_Object i;
+  int i;

   int len = XINT (Flength (seq));
   int len = XINT (Flength (seq));

-  
-  for (XFASTINT (i) = 0; XFASTINT (i) < len; XFASTINT (i)++)
+
+  for (i = 0; i < len; i++)

     {
     {

-      Lisp_Object elt = Faref (seq, i);
+      Lisp_Object ii, elt;
+
+      XSETFASTINT (ii, i);
+      elt = Faref (seq, ii);

 
 

-      if (XTYPE (elt) != Lisp_Int
+      if (!INTEGERP (elt)

          || (XUINT (elt) & ~CHAR_META) >= 0x80)
        return 0;
     }
          || (XUINT (elt) & ~CHAR_META) >= 0x80)
        return 0;
     }


@@ -1432,46 +1521,72 @@ 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.                   */
 

-DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
-  "Return list of keys that invoke DEFINITION in KEYMAP or KEYMAP1.\n\
-If KEYMAP is nil, search only KEYMAP1.\n\
-If KEYMAP1 is nil, use the current global map.\n\
+/* This function can GC if Flookup_key autoloads any keymaps.  */
+
+DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 4, 0,
+  "Return list of keys that invoke DEFINITION.\n\
+If KEYMAP is non-nil, search only KEYMAP and the global keymap.\n\
+If KEYMAP is nil, search all the currently active keymaps.\n\

 \n\
 \n\

-If optional 4th arg FIRSTONLY is non-nil, return a string representing\n\
-the first key sequence found, rather than a list of all possible key\n\
-sequences.  If FIRSTONLY is t, avoid key sequences which use non-ASCII\n\
-keys and therefore may not be usable on ASCII terminals.  If FIRSTONLY\n\
-is the symbol `non-ascii', return the first binding found, no matter\n\
-what its components.\n\
+If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,\n\
+rather than a list of all possible key sequences.\n\
+If FIRSTONLY is the symbol `non-ascii', return the first binding found,\n\
+no matter what it is.\n\
+If FIRSTONLY has another non-nil value, prefer sequences of ASCII characters,\n\
+and entirely reject menu bindings.\n\

 \n\
 \n\

-If optional 5th arg NOINDIRECT is non-nil, don't follow indirections\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.")
 to other keymaps or slots.  This makes it possible to search for an\n\
 indirect definition itself.")

-  (definition, local_keymap, global_keymap, firstonly, noindirect)
-     Lisp_Object definition, local_keymap, global_keymap;
+  (definition, keymap, firstonly, noindirect)
+     Lisp_Object definition, keymap;

      Lisp_Object firstonly, noindirect;
 {
      Lisp_Object firstonly, noindirect;
 {

-  register Lisp_Object maps;
-  Lisp_Object found;
+  Lisp_Object maps;
+  Lisp_Object found, sequence;
+  int keymap_specified = !NILP (keymap);
+  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+  /* 1 means ignore all menu bindings entirely.  */
+  int nomenus = !NILP (firstonly) && !EQ (firstonly, Qnon_ascii);

 
 

-  if (NILP (global_keymap))
-    global_keymap = current_global_map;
+  if (! keymap_specified)
+    {
+#ifdef USE_TEXT_PROPERTIES
+      keymap = get_local_map (PT, current_buffer);
+#else
+      keymap = current_buffer->keymap;
+#endif
+    }

 
 

-  if (!NILP (local_keymap))
-    maps = nconc2 (Faccessible_keymaps (get_keymap (local_keymap), Qnil),
-                  Faccessible_keymaps (get_keymap (global_keymap), Qnil));
+  if (!NILP (keymap))
+    maps = nconc2 (Faccessible_keymaps (get_keymap (keymap), Qnil),
+                  Faccessible_keymaps (get_keymap (current_global_map),
+                                       Qnil));

   else
   else

-    maps = Faccessible_keymaps (get_keymap (global_keymap), Qnil);
+    maps = Faccessible_keymaps (get_keymap (current_global_map), Qnil);
+
+  /* Put the minor mode keymaps on the front.  */
+  if (! keymap_specified)
+    {
+      Lisp_Object minors;
+      minors = Fnreverse (Fcurrent_minor_mode_maps ());
+      while (!NILP (minors))
+       {
+         maps = nconc2 (Faccessible_keymaps (get_keymap (XCONS (minors)->car),
+                                             Qnil),
+                        maps);
+         minors = XCONS (minors)->cdr;
+       }
+    }

 
 

+  GCPRO5 (definition, keymap, maps, found, sequence);

   found = Qnil;
   found = Qnil;

+  sequence = Qnil;

 
   for (; !NILP (maps); maps = Fcdr (maps))
     {
 
   for (; !NILP (maps); maps = Fcdr (maps))
     {

-      /* Key sequence to reach map */
-      register Lisp_Object this = Fcar (Fcar (maps));
-
-      /* The map that it reaches */
-      register Lisp_Object map  = Fcdr (Fcar (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;
 
       /* If Fcar (map) is a VECTOR, the current element within that vector.  */
       int i = 0;


@@ -1479,9 +1594,14 @@ indirect definition itself.")
       /* 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.  */

-      Lisp_Object last = make_number (XINT (Flength (this)) - 1);
-      int last_is_meta = (XINT (last) >= 0
-                         && EQ (Faref (this, last), meta_prefix_char));
+      Lisp_Object last;
+      int last_is_meta;
+
+      this = Fcar (Fcar (maps));
+      map  = Fcdr (Fcar (maps));
+      last = make_number (XINT (Flength (this)) - 1);
+      last_is_meta = (XINT (last) >= 0
+                     && EQ (Faref (this, last), meta_prefix_char));

 
       QUIT;
 
 
       QUIT;
 


@@ -1496,18 +1616,18 @@ indirect definition itself.")
             advance map to the next element until i indicates that we
             have finished off the vector.  */
          
             advance map to the next element until i indicates that we
             have finished off the vector.  */
          

-         Lisp_Object elt = XCONS (map)->car;
-         Lisp_Object key, binding, sequence;
+         Lisp_Object elt, key, binding;
+         elt = XCONS (map)->car;

 
          QUIT;
 
          /* Set key and binding to the current key and binding, and
             advance map and i to the next binding.  */
 
          QUIT;
 
          /* Set key and binding to the current key and binding, and
             advance map and i to the next binding.  */

-         if (XTYPE (elt) == Lisp_Vector)
+         if (VECTORP (elt))

            {
              /* In a vector, look at each element.  */
              binding = XVECTOR (elt)->contents[i];
            {
              /* In a vector, look at each element.  */
              binding = XVECTOR (elt)->contents[i];

-             XFASTINT (key) = i;
+             XSETFASTINT (key, i);

              i++;
 
              /* If we've just finished scanning a vector, advance map
              i++;
 
              /* If we've just finished scanning a vector, advance map


@@ -1536,12 +1656,33 @@ indirect definition itself.")
 
          /* Search through indirections unless that's not wanted.  */
          if (NILP (noindirect))
 
          /* Search through indirections unless that's not wanted.  */
          if (NILP (noindirect))

-           binding = get_keyelt (binding);
+           {
+             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);
+           }

 
          /* End this iteration if this element does not match
             the target.  */
 
 
          /* End this iteration if this element does not match
             the target.  */
 

-         if (XTYPE (definition) == Lisp_Cons)
+         if (CONSP (definition))

            {
              Lisp_Object tem;
              tem = Fequal (binding, definition);
            {
              Lisp_Object tem;
              tem = Fequal (binding, definition);


@@ -1554,7 +1695,7 @@ indirect definition itself.")
 
          /* We have found a match.
             Construct the key sequence where we found it.  */
 
          /* We have found a match.
             Construct the key sequence where we found it.  */

-         if (XTYPE (key) == Lisp_Int && last_is_meta)
+         if (INTEGERP (key) && last_is_meta)

            {
              sequence = Fcopy_sequence (this);
              Faset (sequence, last, make_number (XINT (key) | meta_modifier));
            {
              sequence = Fcopy_sequence (this);
              Faset (sequence, last, make_number (XINT (key) | meta_modifier));


@@ -1571,12 +1712,12 @@ indirect definition itself.")
 
             Either nil or number as value from Flookup_key
             means undefined.  */
 
             Either nil or number as value from Flookup_key
             means undefined.  */

-         if (!NILP (local_keymap))
+         if (keymap_specified)

            {
            {

-             binding = Flookup_key (local_keymap, sequence, Qnil);
-             if (!NILP (binding) && XTYPE (binding) != Lisp_Int)
+             binding = Flookup_key (keymap, sequence, Qnil);
+             if (!NILP (binding) && !INTEGERP (binding))

                {
                {

-                 if (XTYPE (definition) == Lisp_Cons)
+                 if (CONSP (definition))

                    {
                      Lisp_Object tem;
                      tem = Fequal (binding, definition);
                    {
                      Lisp_Object tem;
                      tem = Fequal (binding, definition);


@@ -1588,21 +1729,31 @@ indirect definition itself.")
                      continue;
                }
            }
                      continue;
                }
            }

+         else
+           {
+             binding = Fkey_binding (sequence, Qnil);
+             if (!EQ (binding, definition))
+               continue;
+           }

 
 

-         /* It is a true unshadowed match.  Record it.  */
-         found = Fcons (sequence, found);
+         /* 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))
 
          /* 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 sequence;
+           RETURN_UNGCPRO (sequence);

          else if (! NILP (firstonly) && ascii_sequence_p (sequence))
          else if (! NILP (firstonly) && ascii_sequence_p (sequence))

-           return sequence;
+           RETURN_UNGCPRO (sequence);

        }
     }
 
        }
     }
 

+  UNGCPRO;
+

   found = Fnreverse (found);
 
   /* firstonly may have been t, but we may have gone all the way through
   found = Fnreverse (found);
 
   /* firstonly may have been t, but we may have gone all the way through


@@ -1613,40 +1764,6 @@ indirect definition itself.")
     
   return found;
 }
     
   return found;
 }

-
-/* Return a string listing the keys and buttons that run DEFINITION.  */
-
-static Lisp_Object
-where_is_string (definition)
-     Lisp_Object definition;
-{
-  register Lisp_Object keys, keys1;
-
-  keys = Fwhere_is_internal (definition,
-                            current_buffer->keymap, Qnil, Qnil, Qnil);
-  keys1 = Fmapconcat (Qkey_description, keys, build_string (", "));
-
-  return keys1;
-}
-
-DEFUN ("where-is", Fwhere_is, Swhere_is, 1, 1, "CWhere is command: ",
-  "Print message listing key sequences that invoke specified command.\n\
-Argument is a command definition, usually a symbol with a function definition.")
-  (definition)
-     Lisp_Object definition;
-{
-  register Lisp_Object string;
-
-  CHECK_SYMBOL (definition, 0);
-  string = where_is_string (definition);
- 
-  if (XSTRING (string)->size)
-    message ("%s is on %s", XSYMBOL (definition)->name->data,
-            XSTRING (string)->data);
-  else
-    message ("%s is not on any key", XSYMBOL (definition)->name->data);
-  return Qnil;
-}

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


@@ -1659,7 +1776,7 @@ then we display only bindings that start with that prefix.")
      Lisp_Object prefix;
 {
   register Lisp_Object thisbuf;
      Lisp_Object prefix;
 {
   register Lisp_Object thisbuf;

-  XSET (thisbuf, Lisp_Buffer, current_buffer);
+  XSETBUFFER (thisbuf, current_buffer);

   internal_with_output_to_temp_buffer ("*Help*",
                                       describe_buffer_bindings,
                                       Fcons (thisbuf, prefix));
   internal_with_output_to_temp_buffer ("*Help*",
                                       describe_buffer_bindings,
                                       Fcons (thisbuf, prefix));


@@ -1673,7 +1790,8 @@ describe_buffer_bindings (arg)
      Lisp_Object arg;
 {
   Lisp_Object descbuf, prefix, shadow;
      Lisp_Object arg;
 {
   Lisp_Object descbuf, prefix, shadow;

-  register Lisp_Object start1, start2;
+  register Lisp_Object start1;
+  struct gcpro gcpro1;

 
   char *alternate_heading
     = "\
 
   char *alternate_heading
     = "\


@@ -1684,11 +1802,12 @@ nominal         alternate\n\
   descbuf = XCONS (arg)->car;
   prefix = XCONS (arg)->cdr;
   shadow = Qnil;
   descbuf = XCONS (arg)->car;
   prefix = XCONS (arg)->cdr;
   shadow = Qnil;

+  GCPRO1 (shadow);

 
   Fset_buffer (Vstandard_output);
 
   /* Report on alternates for keys.  */
 
   Fset_buffer (Vstandard_output);
 
   /* Report on alternates for keys.  */

-  if (XTYPE (Vkeyboard_translate_table) == Lisp_String)
+  if (STRINGP (Vkeyboard_translate_table))

     {
       int c;
       unsigned char *translate = XSTRING (Vkeyboard_translate_table)->data;
     {
       int c;
       unsigned char *translate = XSTRING (Vkeyboard_translate_table)->data;


@@ -1725,54 +1844,58 @@ nominal         alternate\n\
     /* Temporarily switch to descbuf, so that we can get that buffer's
        minor modes correctly.  */
     Fset_buffer (descbuf);
     /* Temporarily switch to descbuf, so that we can get that buffer's
        minor modes correctly.  */
     Fset_buffer (descbuf);

-    nmaps = current_minor_maps (&modes, &maps);
+    if (!NILP (Voverriding_local_map))
+      nmaps = 0;
+    else
+      nmaps = current_minor_maps (&modes, &maps);

     Fset_buffer (Vstandard_output);
 
     /* Print the minor mode maps.  */
     for (i = 0; i < nmaps; i++)
       {
     Fset_buffer (Vstandard_output);
 
     /* Print the minor mode maps.  */
     for (i = 0; i < nmaps; i++)
       {

-       /* Tht title for a minor mode keymap
+       /* The title for a minor mode keymap

           is constructed at run time.
           We let describe_map_tree do the actual insertion
           because it takes care of other features when doing so.  */
           is constructed at run time.
           We let describe_map_tree do the actual insertion
           because it takes care of other features when doing so.  */

-       char *title = (char *) alloca (40 + XSYMBOL (modes[i])->name->size);
-       char *p = title;
-
-       if (XTYPE (modes[i]) == Lisp_Symbol)
-         {
-           *p++ = '`';
-           bcopy (XSYMBOL (modes[i])->name->data, p,
-                  XSYMBOL (modes[i])->name->size);
-           p += XSYMBOL (modes[i])->name->size;
-           *p++ = '\'';
-         }
-       else
-         {
-           bcopy ("Strangely Named", p, sizeof ("Strangely Named"));
-           p += sizeof ("Strangely Named");
-         }
-       bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings"));
-       p += sizeof (" Minor Mode Bindings");
+       char *title, *p;
+
+       if (!SYMBOLP (modes[i]))
+         abort();
+
+       p = title = (char *) alloca (40 + XSYMBOL (modes[i])->name->size);
+       *p++ = '`';
+       bcopy (XSYMBOL (modes[i])->name->data, p,
+              XSYMBOL (modes[i])->name->size);
+       p += XSYMBOL (modes[i])->name->size;
+       *p++ = '\'';
+       bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings") - 1);
+       p += sizeof (" Minor Mode Bindings") - 1;

        *p = 0;
 
        *p = 0;
 

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

        shadow = Fcons (maps[i], shadow);
       }
   }
 
   /* Print the (major mode) local map.  */
        shadow = Fcons (maps[i], shadow);
       }
   }
 
   /* Print the (major mode) local map.  */

-  start1 = XBUFFER (descbuf)->keymap;
+  if (!NILP (Voverriding_local_map))
+    start1 = Voverriding_local_map;
+  else
+    start1 = XBUFFER (descbuf)->keymap;
+

   if (!NILP (start1))
     {
       describe_map_tree (start1, 0, shadow, prefix,
   if (!NILP (start1))
     {
       describe_map_tree (start1, 0, shadow, prefix,

-                        "Major Mode Bindings");
+                        "Major Mode Bindings", 0);

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

-                    "Global Bindings");
+                    "Global Bindings", 0);

 
 

+  call0 (intern ("help-mode"));

   Fset_buffer (descbuf);
   Fset_buffer (descbuf);

+  UNGCPRO;

   return Qnil;
 }
 
   return Qnil;
 }
 


@@ -1784,16 +1907,18 @@ nominal         alternate\n\
     don't mention keys which would be shadowed by any of them.
    PREFIX, if non-nil, says mention only keys that start with PREFIX.
    TITLE, if not 0, is a string to insert at the beginning.
     don't mention keys which would be shadowed by any of them.
    PREFIX, if non-nil, says mention only keys that start with PREFIX.
    TITLE, if not 0, is a string to insert at the beginning.

-   TITLE should not end with a colon or a newline; we supply that.  */
+   TITLE should not end with a colon or a newline; we supply that.
+   If NOMENU is not 0, then omit menu-bar commands.  */

 
 void
 
 void

-describe_map_tree (startmap, partial, shadow, prefix, title)
+describe_map_tree (startmap, partial, shadow, prefix, title, nomenu)

      Lisp_Object startmap, shadow, prefix;
      int partial;
      char *title;
      Lisp_Object startmap, shadow, prefix;
      int partial;
      char *title;

+     int nomenu;

 {
 {

-  Lisp_Object maps;
-  struct gcpro gcpro1;
+  Lisp_Object maps, seen, sub_shadows;
+  struct gcpro gcpro1, gcpro2, gcpro3;

   int something = 0;
   char *key_heading
     = "\
   int something = 0;
   char *key_heading
     = "\


@@ -1801,7 +1926,29 @@ key             binding\n\
 ---             -------\n";
 
   maps = Faccessible_keymaps (startmap, prefix);
 ---             -------\n";
 
   maps = Faccessible_keymaps (startmap, prefix);

-  GCPRO1 (maps);
+  seen = Qnil;
+  sub_shadows = Qnil;
+  GCPRO3 (maps, seen, sub_shadows);
+
+  if (nomenu)
+    {
+      Lisp_Object list;
+
+      /* Delete from MAPS each element that is for the menu bar.  */
+      for (list = maps; !NILP (list); list = XCONS (list)->cdr)
+       {
+         Lisp_Object elt, prefix, tem;
+
+         elt = Fcar (list);
+         prefix = Fcar (elt);
+         if (XVECTOR (prefix)->size >= 1)
+           {
+             tem = Faref (prefix, make_number (0));
+             if (EQ (tem, Qmenu_bar))
+               maps = Fdelq (elt, maps);
+           }
+       }
+    }

 
   if (!NILP (maps))
     {
 
   if (!NILP (maps))
     {


@@ -1821,7 +1968,7 @@ key             binding\n\
 
   for (; !NILP (maps); maps = Fcdr (maps))
     {
 
   for (; !NILP (maps); maps = Fcdr (maps))
     {

-      register Lisp_Object elt, prefix, sub_shadows, tail;
+      register Lisp_Object elt, prefix, tail;

 
       elt = Fcar (maps);
       prefix = Fcar (elt);
 
       elt = Fcar (maps);
       prefix = Fcar (elt);


@@ -1836,18 +1983,16 @@ key             binding\n\
 
          /* 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.  */

-         if ((XTYPE (prefix) == Lisp_String
-              && XSTRING (prefix)->size == 0)
-             || (XTYPE (prefix) == Lisp_Vector
-                 && XVECTOR (prefix)->size == 0))
+         if ((STRINGP (prefix) && XSTRING (prefix)->size == 0)
+             || (VECTORP (prefix) && XVECTOR (prefix)->size == 0))

            ;
          /* If the sequence by which we reach this keymap actually has
             some elements, then the sequence's definition in SHADOW is
             what we should use.  */
          else
            {
            ;
          /* If the sequence by which we reach this keymap actually has
             some elements, then the sequence's definition in SHADOW is
             what we should use.  */
          else
            {

-             shmap = Flookup_key (shadow, Fcar (elt), Qt);
-             if (XTYPE (shmap) == Lisp_Int)
+             shmap = Flookup_key (shmap, Fcar (elt), Qt);
+             if (INTEGERP (shmap))

                shmap = Qnil;
            }
 
                shmap = Qnil;
            }
 


@@ -1861,7 +2006,8 @@ key             binding\n\
            sub_shadows = Fcons (shmap, sub_shadows);
        }
 
            sub_shadows = Fcons (shmap, sub_shadows);
        }
 

-      describe_map (Fcdr (elt), Fcar (elt), partial, sub_shadows);
+      describe_map (Fcdr (elt), Fcar (elt), describe_command,
+                   partial, sub_shadows, &seen);

 
     skip: ;
     }
 
     skip: ;
     }


@@ -1880,12 +2026,14 @@ describe_command (definition)
 
   Findent_to (make_number (16), make_number (1));
 
 
   Findent_to (make_number (16), make_number (1));
 

-  if (XTYPE (definition) == Lisp_Symbol)
+  if (SYMBOLP (definition))

     {
     {

-      XSET (tem1, Lisp_String, XSYMBOL (definition)->name);
+      XSETSTRING (tem1, XSYMBOL (definition)->name);

       insert1 (tem1);
       insert_string ("\n");
     }
       insert1 (tem1);
       insert_string ("\n");
     }

+  else if (STRINGP (definition))
+    insert_string ("Keyboard Macro\n");

   else
     {
       tem1 = Fkeymapp (definition);
   else
     {
       tem1 = Fkeymapp (definition);


@@ -1896,31 +2044,6 @@ describe_command (definition)
     }
 }
 
     }
 }
 

-/* Describe the contents of map MAP, assuming that this map itself is
-   reached by the sequence of prefix keys KEYS (a string or vector).
-   PARTIAL, SHADOW is as in `describe_map_tree' above.  */
-
-static void
-describe_map (map, keys, partial, shadow)
-     Lisp_Object map, keys;
-     int partial;
-     Lisp_Object shadow;
-{
-  register Lisp_Object keysdesc;
-
-  if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
-    {
-      Lisp_Object tem;
-      /* Call Fkey_description first, to avoid GC bug for the other string.  */
-      tem = Fkey_description (keys);
-      keysdesc = concat2 (tem, build_string (" "));
-    }
-  else
-    keysdesc = Qnil;
-
-  describe_map_2 (map, keysdesc, describe_command, partial, shadow);
-}
-

 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
    Returns the first non-nil binding found in any of those maps.  */
 
 /* Like Flookup_key, but uses a list of keymaps SHADOW instead of a single map.
    Returns the first non-nil binding found in any of those maps.  */
 


@@ -1939,16 +2062,20 @@ shadow_lookup (shadow, key, flag)
   return Qnil;
 }
 
   return Qnil;
 }
 

-/* Insert a description of KEYMAP into the current buffer.  */
+/* Describe the contents of map MAP, assuming that this map itself is
+   reached by the sequence of prefix keys KEYS (a string or vector).
+   PARTIAL, SHADOW are as in `describe_map_tree' above.  */

 
 static void
 
 static void

-describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
-     register Lisp_Object keymap;
-     Lisp_Object elt_prefix;
+describe_map (map, keys, elt_describer, partial, shadow, seen)
+     register Lisp_Object map;
+     Lisp_Object keys;

      int (*elt_describer) ();
      int partial;
      Lisp_Object shadow;
      int (*elt_describer) ();
      int partial;
      Lisp_Object shadow;

+     Lisp_Object *seen;

 {
 {

+  Lisp_Object elt_prefix;

   Lisp_Object tail, definition, event;
   Lisp_Object tem;
   Lisp_Object suppress;
   Lisp_Object tail, definition, event;
   Lisp_Object tem;
   Lisp_Object suppress;


@@ -1956,6 +2083,15 @@ describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
   int first = 1;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   int first = 1;
   struct gcpro gcpro1, gcpro2, gcpro3;
 

+  if (!NILP (keys) && XFASTINT (Flength (keys)) > 0)
+    {
+      /* Call Fkey_description first, to avoid GC bug for the other string.  */
+      tem = Fkey_description (keys);
+      elt_prefix = concat2 (tem, build_string (" "));
+    }
+  else
+    elt_prefix = Qnil;
+

   if (partial)
     suppress = intern ("suppress-keymap");
 
   if (partial)
     suppress = intern ("suppress-keymap");
 


@@ -1967,21 +2103,27 @@ describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
 
   GCPRO3 (elt_prefix, definition, kludge);
 
 
   GCPRO3 (elt_prefix, definition, kludge);
 

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

     {
       QUIT;
 
     {
       QUIT;
 

-      if (XTYPE (XCONS (tail)->car) == Lisp_Vector)
+      if (VECTORP (XCONS (tail)->car))

        describe_vector (XCONS (tail)->car,
                         elt_prefix, elt_describer, partial, shadow);
        describe_vector (XCONS (tail)->car,
                         elt_prefix, elt_describer, partial, shadow);

-      else
+      else if (CONSP (XCONS (tail)->car))

        {
        {

-         event = Fcar_safe (Fcar (tail));
-         definition = get_keyelt (Fcdr_safe (Fcar (tail)));
+         event = XCONS (XCONS (tail)->car)->car;
+
+         /* Ignore bindings whose "keys" are not really valid events.
+            (We get these in the frames and buffers menu.)  */
+         if (! (SYMBOLP (event) || INTEGERP (event)))
+           continue;
+
+         definition = get_keyelt (XCONS (XCONS (tail)->car)->cdr, 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;

-         if (XTYPE (definition) == Lisp_Symbol && partial)
+         if (SYMBOLP (definition) && partial)

            {
              tem = Fget (definition, suppress);
              if (!NILP (tem))
            {
              tem = Fget (definition, suppress);
              if (!NILP (tem))


@@ -1998,7 +2140,7 @@ describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
              if (!NILP (tem)) continue;
            }
 
              if (!NILP (tem)) continue;
            }
 

-         tem = Flookup_key (keymap, kludge, Qt);
+         tem = Flookup_key (map, kludge, Qt);

          if (! EQ (tem, definition)) continue;
 
          if (first)
          if (! EQ (tem, definition)) continue;
 
          if (first)


@@ -2018,6 +2160,16 @@ describe_map_2 (keymap, elt_prefix, elt_describer, partial, shadow)
             for alignment purposes.  */
          (*elt_describer) (definition);
        }
             for alignment purposes.  */
          (*elt_describer) (definition);
        }

+      else if (EQ (XCONS (tail)->car, Qkeymap))
+       {
+         /* The same keymap might be in the structure twice, if we're
+            using an inherited keymap.  So skip anything we've already
+            encountered.  */
+         tem = Fassq (tail, *seen);
+         if (CONSP (tem) && !NILP (Fequal (XCONS (tem)->car, keys)))
+           break;
+         *seen = Fcons (Fcons (tail, keys), *seen);
+       }

     }
 
   UNGCPRO;
     }
 
   UNGCPRO;


@@ -2077,12 +2229,12 @@ describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
   for (i = 0; i < XVECTOR (vector)->size; i++)
     {
       QUIT;
   for (i = 0; i < XVECTOR (vector)->size; i++)
     {
       QUIT;

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

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

-      if (XTYPE (tem1) == Lisp_Symbol && partial)
+      if (SYMBOLP (tem1) && partial)

        {
          this = Fget (tem1, suppress);
          if (!NILP (this))
        {
          this = Fget (tem1, suppress);
          if (!NILP (this))


@@ -2112,7 +2264,7 @@ describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
        insert1 (elt_prefix);
 
       /* Get the string to describe the character I, and print it.  */
        insert1 (elt_prefix);
 
       /* Get the string to describe the character I, and print it.  */

-      XFASTINT (dummy) = i;
+      XSETFASTINT (dummy, i);

 
       /* THIS gets the string to describe the character DUMMY.  */
       this = Fsingle_key_description (dummy);
 
       /* THIS gets the string to describe the character DUMMY.  */
       this = Fsingle_key_description (dummy);


@@ -2120,7 +2272,7 @@ describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
 
       /* Find all consecutive characters that have the same definition.  */
       while (i + 1 < XVECTOR (vector)->size
 
       /* Find all consecutive characters that have the same definition.  */
       while (i + 1 < XVECTOR (vector)->size

-            && (tem2 = get_keyelt (XVECTOR (vector)->contents[i+1]),
+            && (tem2 = get_keyelt (XVECTOR (vector)->contents[i+1], 0),

                 EQ (tem2, tem1)))
        i++;
 
                 EQ (tem2, tem1)))
        i++;
 


@@ -2133,7 +2285,7 @@ describe_vector (vector, elt_prefix, elt_describer, partial, shadow)
          if (!NILP (elt_prefix))
            insert1 (elt_prefix);
 
          if (!NILP (elt_prefix))
            insert1 (elt_prefix);
 

-         XFASTINT (dummy) = i;
+         XSETFASTINT (dummy, i);

          insert1 (Fsingle_key_description (dummy));
        }
 
          insert1 (Fsingle_key_description (dummy));
        }
 


@@ -2236,15 +2388,18 @@ in the list takes precedence.");
 This allows Emacs to recognize function keys sent from ASCII\n\
 terminals at any point in a key sequence.\n\
 \n\
 This allows Emacs to recognize function keys sent from ASCII\n\
 terminals at any point in a key sequence.\n\
 \n\

-The read-key-sequence function replaces subsequences bound by\n\
-function-key-map with their bindings.  When the current local and global\n\
+The `read-key-sequence' function replaces any subsequence bound by\n\
+`function-key-map' with its binding.  More precisely, when the active\n\

 keymaps have no binding for the current key sequence but\n\
 keymaps have no binding for the current key sequence but\n\

-function-key-map binds a suffix of the sequence to a vector or string,\n\
-read-key-sequence replaces the matching suffix with its binding, and\n\
+`function-key-map' binds a suffix of the sequence to a vector or string,\n\
+`read-key-sequence' replaces the matching suffix with its binding, and\n\

 continues with the new sequence.\n\
 \n\
 continues with the new sequence.\n\
 \n\

-For example, suppose function-key-map binds `ESC O P' to [f1].\n\
-Typing `ESC O P' to read-key-sequence would return [f1].  Typing\n\
+The events that come from bindings in `function-key-map' are not\n\
+themselves looked up in `function-key-map'.\n\
+\n\
+For example, suppose `function-key-map' binds `ESC O P' to [f1].\n\
+Typing `ESC O P' to `read-key-sequence' would return [f1].  Typing\n\

 `C-x ESC O P' would return [?\\C-x f1].  If [f1] were a prefix\n\
 key, typing `ESC O P x' would return [f1 x].");
   Vfunction_key_map = Fmake_sparse_keymap (Qnil);
 `C-x ESC O P' would return [?\\C-x f1].  If [f1] were a prefix\n\
 key, typing `ESC O P x' would return [f1 x].");
   Vfunction_key_map = Fmake_sparse_keymap (Qnil);


@@ -2269,12 +2424,8 @@ key, typing `ESC O P x' would return [f1 x].");
   defsubr (&Slocal_key_binding);
   defsubr (&Sglobal_key_binding);
   defsubr (&Sminor_mode_key_binding);
   defsubr (&Slocal_key_binding);
   defsubr (&Sglobal_key_binding);
   defsubr (&Sminor_mode_key_binding);

-  defsubr (&Sglobal_set_key);
-  defsubr (&Slocal_set_key);

   defsubr (&Sdefine_key);
   defsubr (&Slookup_key);
   defsubr (&Sdefine_key);
   defsubr (&Slookup_key);

-  defsubr (&Sglobal_unset_key);
-  defsubr (&Slocal_unset_key);

   defsubr (&Sdefine_prefix_command);
   defsubr (&Suse_global_map);
   defsubr (&Suse_local_map);
   defsubr (&Sdefine_prefix_command);
   defsubr (&Suse_global_map);
   defsubr (&Suse_local_map);


@@ -2287,7 +2438,6 @@ key, typing `ESC O P x' would return [f1 x].");
   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 (&Swhere_is);

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