XEmacs 21.2.36 "Notos"

[chise/xemacs-chise.git.1] / src / keymap.c

diff --git a/src/keymap.c b/src/keymap.c
index efab47d..9cae3ab 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -30,7 +30,6 @@ Boston, MA 02111-1307, USA.  */
 
 #include "buffer.h"
 #include "bytecode.h"
 
 #include "buffer.h"
 #include "bytecode.h"

-#include "commands.h"

 #include "console.h"
 #include "elhash.h"
 #include "events.h"
 #include "console.h"
 #include "elhash.h"
 #include "events.h"

@@ -38,17 +37,6 @@ Boston, MA 02111-1307, USA.  */
 #include "insdel.h"
 #include "keymap.h"
 #include "window.h"
 #include "insdel.h"
 #include "keymap.h"
 #include "window.h"

-
-#ifdef WINDOWSNT
-/* Hmm, under unix we want X modifiers, under NT we want X modifiers if
-   we are running X and Windows modifiers otherwise.
-   gak. This is a kludge until we support multiple native GUIs!
-*/
-#undef MOD_ALT
-#undef MOD_CONTROL
-#undef MOD_SHIFT
-#endif
-

 #include "events-mod.h"
 
 \f
 #include "events-mod.h"
 
 \f

@@ -100,25 +88,25 @@ Boston, MA 02111-1307, USA.  */
 
    If the key `C-a' was bound to some command, the hierarchy would look like
 
 
    If the key `C-a' was bound to some command, the hierarchy would look like
 

-      keymap-1: associates the integer MOD_CONTROL with keymap-2
+      keymap-1: associates the integer XEMACS_MOD_CONTROL with keymap-2

       keymap-2: associates "a" with the command
 
    Similarly, if the key `C-H-a' was bound to some command, the hierarchy
    would look like
 
       keymap-2: associates "a" with the command
 
    Similarly, if the key `C-H-a' was bound to some command, the hierarchy
    would look like
 

-      keymap-1: associates the integer (MOD_CONTROL | MOD_HYPER)
+      keymap-1: associates the integer (XEMACS_MOD_CONTROL | XEMACS_MOD_HYPER)

                 with keymap-2
       keymap-2: associates "a" with the command
 
    Note that a special exception is made for the meta modifier, in order
    to deal with ESC/meta lossage.  Any key combination containing the
    meta modifier is first indexed off of the main map into the meta
                 with keymap-2
       keymap-2: associates "a" with the command
 
    Note that a special exception is made for the meta modifier, in order
    to deal with ESC/meta lossage.  Any key combination containing the
    meta modifier is first indexed off of the main map into the meta

-   submap (with hash key MOD_META) and then indexed off of the
+   submap (with hash key XEMACS_MOD_META) and then indexed off of the

    meta submap with the meta modifier removed from the key combination.
    For example, when associating a command with C-M-H-a, we'd have
 
    meta submap with the meta modifier removed from the key combination.
    For example, when associating a command with C-M-H-a, we'd have
 

-      keymap-1: associates the integer MOD_META with keymap-2
-      keymap-2: associates the integer (MOD_CONTROL | MOD_HYPER)
+      keymap-1: associates the integer XEMACS_MOD_META with keymap-2
+      keymap-2: associates the integer (XEMACS_MOD_CONTROL | XEMACS_MOD_HYPER)

                 with keymap-3
       keymap-3: associates "a" with the command
 
                 with keymap-3
       keymap-3: associates "a" with the command
 

@@ -132,7 +120,7 @@ Boston, MA 02111-1307, USA.  */
    Note that this new model of keymaps takes much of the magic away from
    the Escape key: the value of the variable `esc-map' is no longer indexed
    in the `global-map' under the ESC key.  It's indexed under the integer
    Note that this new model of keymaps takes much of the magic away from
    the Escape key: the value of the variable `esc-map' is no longer indexed
    in the `global-map' under the ESC key.  It's indexed under the integer

-   MOD_META.  This is not user-visible, however; none of the "bucky"
+   XEMACS_MOD_META.  This is not user-visible, however; none of the "bucky"

    maps are.
 
    There is a hack in Flookup_key() that makes (lookup-key global-map "\^[")
    maps are.
 
    There is a hack in Flookup_key() that makes (lookup-key global-map "\^[")

@@ -142,7 +130,7 @@ Boston, MA 02111-1307, USA.  */
    Since keymaps are opaque, the only way to extract information from them
    is with the functions lookup-key, key-binding, local-key-binding, and
    global-key-binding, which work just as before, and the new function
    Since keymaps are opaque, the only way to extract information from them
    is with the functions lookup-key, key-binding, local-key-binding, and
    global-key-binding, which work just as before, and the new function

-   map-keymap, which is roughly analagous to maphash.
+   map-keymap, which is roughly analogous to maphash.

 
    Note that map-keymap perpetuates the illusion that the "bucky" submaps
    don't exist: if you map over a keymap with bucky submaps, it will also
 
    Note that map-keymap perpetuates the illusion that the "bucky" submaps
    don't exist: if you map over a keymap with bucky submaps, it will also

@@ -157,39 +145,26 @@ Boston, MA 02111-1307, USA.  */
 
  */
 
 
  */
 

-struct keymap
+struct Lisp_Keymap

 {
   struct lcrecord_header header;
 {
   struct lcrecord_header header;

-  Lisp_Object parents;         /* Keymaps to be searched after this one
-                                *  An ordered list */
+  Lisp_Object parents;         /* Keymaps to be searched after this one.
+                                  An ordered list */

   Lisp_Object prompt;           /* Qnil or a string to print in the minibuffer
   Lisp_Object prompt;           /* Qnil or a string to print in the minibuffer

-                                 *  when reading from this keymap */
-
+                                   when reading from this keymap */

   Lisp_Object table;           /* The contents of this keymap */
   Lisp_Object inverse_table;   /* The inverse mapping of the above */
   Lisp_Object table;           /* The contents of this keymap */
   Lisp_Object inverse_table;   /* The inverse mapping of the above */

-

   Lisp_Object default_binding;  /* Use this if no other binding is found
   Lisp_Object default_binding;  /* Use this if no other binding is found

-                                 *  (this overrides parent maps and the
-                                 *   normal global-map lookup). */
-
-
+                                   (this overrides parent maps and the
+                                   normal global-map lookup). */

   Lisp_Object sub_maps_cache;  /* Cache of directly inferior keymaps;
                                   This holds an alist, of the key and the
                                   maps, or the modifier bit and the map.
                                   If this is the symbol t, then the cache
   Lisp_Object sub_maps_cache;  /* Cache of directly inferior keymaps;
                                   This holds an alist, of the key and the
                                   maps, or the modifier bit and the map.
                                   If this is the symbol t, then the cache

-                                  needs to be recomputed.
-                                */
-  int fullness;                        /* How many entries there are in this table.
-                                  This should be the same as the fullness
-                                  of the `table', but hash.c is broken. */
+                                  needs to be recomputed. */

   Lisp_Object name;             /* Just for debugging convenience */
 };
 
   Lisp_Object name;             /* Just for debugging convenience */
 };
 

-#define XKEYMAP(x) XRECORD (x, keymap, struct keymap)
-#define XSETKEYMAP(x, p) XSETRECORD (x, p, keymap)
-#define KEYMAPP(x) RECORDP (x, keymap)
-#define CHECK_KEYMAP(x) CHECK_RECORD (x, keymap)
-

 #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier)
 #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0)
 
 #define MAKE_MODIFIER_HASH_KEY(modifier) make_int (modifier)
 #define MODIFIER_HASH_KEY_BITS(x) (INTP (x) ? XINT (x) : 0)
 

@@ -197,7 +172,7 @@ struct keymap
 
 /* Actually allocate storage for these variables */
 
 
 /* Actually allocate storage for these variables */
 

-static Lisp_Object Vcurrent_global_map; /* Always a keymap */
+Lisp_Object Vcurrent_global_map; /* Always a keymap */

 
 static Lisp_Object Vmouse_grabbed_buffer;
 
 
 static Lisp_Object Vmouse_grabbed_buffer;
 

@@ -236,6 +211,7 @@ static void describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
                          Lisp_Object shadow,
                          int mice_only_p,
                          Lisp_Object buffer);
                          Lisp_Object shadow,
                          int mice_only_p,
                          Lisp_Object buffer);

+static Lisp_Object keymap_submaps (Lisp_Object keymap);

 
 Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift;
 Lisp_Object Qbutton0, Qbutton1, Qbutton2, Qbutton3;
 
 Lisp_Object Qcontrol, Qctrl, Qmeta, Qsuper, Qhyper, Qalt, Qshift;
 Lisp_Object Qbutton0, Qbutton1, Qbutton2, Qbutton3;

@@ -258,15 +234,15 @@ Lisp_Object QLFD, QTAB, QRET, QESC, QDEL, QSPC, QBS;
 /************************************************************************/
 
 static Lisp_Object
 /************************************************************************/
 
 static Lisp_Object

-mark_keymap (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_keymap (Lisp_Object obj)

 {
 {

-  struct keymap *keymap = XKEYMAP (obj);
-  ((markobj) (keymap->parents));
-  ((markobj) (keymap->prompt));
-  ((markobj) (keymap->inverse_table));
-  ((markobj) (keymap->sub_maps_cache));
-  ((markobj) (keymap->default_binding));
-  ((markobj) (keymap->name));
+  Lisp_Keymap *keymap = XKEYMAP (obj);
+  mark_object (keymap->parents);
+  mark_object (keymap->prompt);
+  mark_object (keymap->inverse_table);
+  mark_object (keymap->sub_maps_cache);
+  mark_object (keymap->default_binding);
+  mark_object (keymap->name);

   return keymap->table;
 }
 
   return keymap->table;
 }
 

@@ -274,27 +250,37 @@ static void
 print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
   /* This function can GC */
 print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
   /* This function can GC */

-  struct keymap *keymap = XKEYMAP (obj);
+  Lisp_Keymap *keymap = XKEYMAP (obj);

   char buf[200];
   char buf[200];

-  int size = XINT (Fkeymap_fullness (obj));

   if (print_readably)
     error ("printing unreadable object #<keymap 0x%x>", keymap->header.uid);
   write_c_string ("#<keymap ", printcharfun);
   if (!NILP (keymap->name))
   if (print_readably)
     error ("printing unreadable object #<keymap 0x%x>", keymap->header.uid);
   write_c_string ("#<keymap ", printcharfun);
   if (!NILP (keymap->name))

-    print_internal (keymap->name, printcharfun, 1);
-  /* #### Yuck!  This is no way to form plural!  --hniksic */
-  sprintf (buf, "%s%d entr%s 0x%x>",
-           ((NILP (keymap->name)) ? "" : " "),
-           size,
-           ((size == 1) ? "y" : "ies"),
-           keymap->header.uid);
+    {
+      print_internal (keymap->name, printcharfun, 1);
+      write_c_string (" ", printcharfun);
+    }
+  sprintf (buf, "size %ld 0x%x>",
+          (long) XINT (Fkeymap_fullness (obj)), keymap->header.uid);

   write_c_string (buf, printcharfun);
 }
 
   write_c_string (buf, printcharfun);
 }
 

+static const struct lrecord_description keymap_description[] = {
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, parents) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, prompt) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, table) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, inverse_table) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, default_binding) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, sub_maps_cache) },
+  { XD_LISP_OBJECT, offsetof (Lisp_Keymap, name) },
+  { XD_END }
+};
+

 /* No need for keymap_equal #### Why not? */
 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap,
                                mark_keymap, print_keymap, 0, 0, 0,
 /* No need for keymap_equal #### Why not? */
 DEFINE_LRECORD_IMPLEMENTATION ("keymap", keymap,
                                mark_keymap, print_keymap, 0, 0, 0,

-                              struct keymap);
+                              keymap_description,
+                              Lisp_Keymap);

 \f
 /************************************************************************/
 /*                Traversing keymaps and their parents                  */
 \f
 /************************************************************************/
 /*                Traversing keymaps and their parents                  */

@@ -318,19 +304,19 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents,
   start_keymap = get_keymap (start_keymap, 1, 1);
   keymap = start_keymap;
   /* Hack special-case parents at top-level */
   start_keymap = get_keymap (start_keymap, 1, 1);
   keymap = start_keymap;
   /* Hack special-case parents at top-level */

-  tail = ((!NILP (tail)) ? tail : XKEYMAP (keymap)->parents);
+  tail = !NILP (tail) ? tail : XKEYMAP (keymap)->parents;

 
   for (;;)
     {
       Lisp_Object result;
 
       QUIT;
 
   for (;;)
     {
       Lisp_Object result;
 
       QUIT;

-      result = ((mapper) (keymap, mapper_arg));
+      result = mapper (keymap, mapper_arg);

       if (!NILP (result))
        {
          while (CONSP (malloc_bites))
            {
       if (!NILP (result))
        {
          while (CONSP (malloc_bites))
            {

-             struct Lisp_Cons *victim = XCONS (malloc_bites);
+             Lisp_Cons *victim = XCONS (malloc_bites);

              malloc_bites = victim->cdr;
              free_cons (victim);
            }
              malloc_bites = victim->cdr;
              free_cons (victim);
            }

@@ -347,7 +333,7 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents,
          stack_depth--;
          if (CONSP (malloc_bites))
            {
          stack_depth--;
          if (CONSP (malloc_bites))
            {

-             struct Lisp_Cons *victim = XCONS (malloc_bites);
+             Lisp_Cons *victim = XCONS (malloc_bites);

              tail = victim->car;
              malloc_bites = victim->cdr;
              free_cons (victim);
              tail = victim->car;
              malloc_bites = victim->cdr;
              free_cons (victim);

@@ -409,40 +395,40 @@ traverse_keymaps (Lisp_Object start_keymap, Lisp_Object start_parents,
 /*                     Some low-level functions                         */
 /************************************************************************/
 
 /*                     Some low-level functions                         */
 /************************************************************************/
 

-static unsigned int
+static int

 bucky_sym_to_bucky_bit (Lisp_Object sym)
 {
 bucky_sym_to_bucky_bit (Lisp_Object sym)
 {

-  if (EQ (sym, Qcontrol)) return MOD_CONTROL;
-  if (EQ (sym, Qmeta))    return MOD_META;
-  if (EQ (sym, Qsuper))   return MOD_SUPER;
-  if (EQ (sym, Qhyper))   return MOD_HYPER;
-  if (EQ (sym, Qalt))     return MOD_ALT;
-  if (EQ (sym, Qsymbol))  return MOD_ALT; /* #### - reverse compat */
-  if (EQ (sym, Qshift))   return MOD_SHIFT;
+  if (EQ (sym, Qcontrol)) return XEMACS_MOD_CONTROL;
+  if (EQ (sym, Qmeta))    return XEMACS_MOD_META;
+  if (EQ (sym, Qsuper))   return XEMACS_MOD_SUPER;
+  if (EQ (sym, Qhyper))   return XEMACS_MOD_HYPER;
+  if (EQ (sym, Qalt))     return XEMACS_MOD_ALT;
+  if (EQ (sym, Qsymbol))  return XEMACS_MOD_ALT; /* #### - reverse compat */
+  if (EQ (sym, Qshift))   return XEMACS_MOD_SHIFT;

 
   return 0;
 }
 
 static Lisp_Object
 
   return 0;
 }
 
 static Lisp_Object

-control_meta_superify (Lisp_Object frob, unsigned int modifiers)
+control_meta_superify (Lisp_Object frob, int modifiers)

 {
   if (modifiers == 0)
     return frob;
   frob = Fcons (frob, Qnil);
 {
   if (modifiers == 0)
     return frob;
   frob = Fcons (frob, Qnil);

-  if (modifiers & MOD_SHIFT)   frob = Fcons (Qshift,   frob);
-  if (modifiers & MOD_ALT)     frob = Fcons (Qalt,     frob);
-  if (modifiers & MOD_HYPER)   frob = Fcons (Qhyper,   frob);
-  if (modifiers & MOD_SUPER)   frob = Fcons (Qsuper,   frob);
-  if (modifiers & MOD_CONTROL) frob = Fcons (Qcontrol, frob);
-  if (modifiers & MOD_META)    frob = Fcons (Qmeta,    frob);
+  if (modifiers & XEMACS_MOD_SHIFT)   frob = Fcons (Qshift,   frob);
+  if (modifiers & XEMACS_MOD_ALT)     frob = Fcons (Qalt,     frob);
+  if (modifiers & XEMACS_MOD_HYPER)   frob = Fcons (Qhyper,   frob);
+  if (modifiers & XEMACS_MOD_SUPER)   frob = Fcons (Qsuper,   frob);
+  if (modifiers & XEMACS_MOD_CONTROL) frob = Fcons (Qcontrol, frob);
+  if (modifiers & XEMACS_MOD_META)    frob = Fcons (Qmeta,    frob);

   return frob;
 }
 
 static Lisp_Object
   return frob;
 }
 
 static Lisp_Object

-make_key_description (CONST struct key_data *key, int prettify)
+make_key_description (const struct key_data *key, int prettify)

 {
   Lisp_Object keysym = key->keysym;
 {
   Lisp_Object keysym = key->keysym;

-  unsigned int modifiers = key->modifiers;
+  int modifiers = key->modifiers;

 
   if (prettify && CHARP (keysym))
     {
 
   if (prettify && CHARP (keysym))
     {

@@ -467,18 +453,21 @@ make_key_description (CONST struct key_data *key, int prettify)
 
 static Lisp_Object
 raw_lookup_key (Lisp_Object keymap,
 
 static Lisp_Object
 raw_lookup_key (Lisp_Object keymap,

-                CONST struct key_data *raw_keys, int raw_keys_count,
+                const struct key_data *raw_keys, int raw_keys_count,

                 int keys_so_far, int accept_default);
 
 /* Relies on caller to gc-protect args */
 static Lisp_Object
 keymap_lookup_directly (Lisp_Object keymap,
                 int keys_so_far, int accept_default);
 
 /* Relies on caller to gc-protect args */
 static Lisp_Object
 keymap_lookup_directly (Lisp_Object keymap,

-                        Lisp_Object keysym, unsigned int modifiers)
+                        Lisp_Object keysym, int modifiers)

 {
 {

-  struct keymap *k;
+  Lisp_Keymap *k;

 
 

-  if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
-                     | MOD_ALT | MOD_SHIFT)) != 0)
+  modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3
+                | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5);
+  if ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER
+                    | XEMACS_MOD_HYPER | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT))
+      != 0)

     abort ();
 
   k = XKEYMAP (keymap);
     abort ();
 
   k = XKEYMAP (keymap);

@@ -491,14 +480,14 @@ keymap_lookup_directly (Lisp_Object keymap,
       keysym = i_fart_on_gcc;
     }
 
       keysym = i_fart_on_gcc;
     }
 

-  if (modifiers & MOD_META)     /* Utterly hateful ESC lossage */
+  if (modifiers & XEMACS_MOD_META)     /* Utterly hateful ESC lossage */

     {
     {

-      Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
+      Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META),

                                      k->table, Qnil);
       if (NILP (submap))
         return Qnil;
       k = XKEYMAP (submap);
                                      k->table, Qnil);
       if (NILP (submap))
         return Qnil;
       k = XKEYMAP (submap);

-      modifiers &= ~MOD_META;
+      modifiers &= ~XEMACS_MOD_META;

     }
 
   if (modifiers != 0)
     }
 
   if (modifiers != 0)

@@ -534,7 +523,7 @@ keymap_store_inverse_internal (Lisp_Object inverse_table,
     }
   else
     {
     }
   else
     {

-      while (CONSP (Fcdr (keys)))
+      while (CONSP (XCDR (keys)))

        keys = XCDR (keys);
       XCDR (keys) = Fcons (XCDR (keys), keysym);
       /* No need to call puthash because we've destructively
        keys = XCDR (keys);
       XCDR (keys) = Fcons (XCDR (keys), keysym);
       /* No need to call puthash because we've destructively

@@ -582,38 +571,57 @@ keymap_delete_inverse_internal (Lisp_Object inverse_table,
    */
 }
 
    */
 }
 

+/* Prevent luser from shooting herself in the foot using something like
+   (define-key ctl-x-4-map "p" global-map) */
+static void
+check_keymap_definition_loop (Lisp_Object def, Lisp_Keymap *to_keymap)
+{
+  def = get_keymap (def, 0, 0);
+
+  if (KEYMAPP (def))
+    {
+      Lisp_Object maps;
+
+      if (XKEYMAP (def) == to_keymap)
+       signal_simple_error ("Cyclic keymap definition", def);
+
+      for (maps = keymap_submaps (def);
+          CONSP (maps);
+          maps = XCDR (maps))
+       check_keymap_definition_loop (XCDR (XCAR (maps)), to_keymap);
+    }
+}

 
 static void
 
 static void

-keymap_store_internal (Lisp_Object keysym, struct keymap *keymap,
-                      Lisp_Object value)
+keymap_store_internal (Lisp_Object keysym, Lisp_Keymap *keymap,
+                      Lisp_Object def)

 {
 {

-  Lisp_Object prev_value = Fgethash (keysym, keymap->table, Qnil);
+  Lisp_Object prev_def = Fgethash (keysym, keymap->table, Qnil);

 
 

-  if (EQ (prev_value, value))
+  if (EQ (prev_def, def))

       return;
       return;

-  if (!NILP (prev_value))
+
+  check_keymap_definition_loop (def, keymap);
+
+  if (!NILP (prev_def))

     keymap_delete_inverse_internal (keymap->inverse_table,
     keymap_delete_inverse_internal (keymap->inverse_table,

-                                    keysym, prev_value);
-  if (NILP (value))
+                                    keysym, prev_def);
+  if (NILP (def))

     {
     {

-      keymap->fullness--;
-      if (keymap->fullness < 0) abort ();

       Fremhash (keysym, keymap->table);
     }
   else
     {
       Fremhash (keysym, keymap->table);
     }
   else
     {

-      if (NILP (prev_value))
-       keymap->fullness++;
-      Fputhash (keysym, value, keymap->table);
+      Fputhash (keysym, def, keymap->table);

       keymap_store_inverse_internal (keymap->inverse_table,
       keymap_store_inverse_internal (keymap->inverse_table,

-                                     keysym, value);
+                                     keysym, def);

     }
   keymap_tick++;
 }
 
 
 static Lisp_Object
     }
   keymap_tick++;
 }
 
 
 static Lisp_Object

-create_bucky_submap (struct keymap *k, unsigned int modifiers,
+create_bucky_submap (Lisp_Keymap *k, int modifiers,

                      Lisp_Object parent_for_debugging_info)
 {
   Lisp_Object submap = Fmake_sparse_keymap (Qnil);
                      Lisp_Object parent_for_debugging_info)
 {
   Lisp_Object submap = Fmake_sparse_keymap (Qnil);

@@ -629,35 +637,31 @@ create_bucky_submap (struct keymap *k, unsigned int modifiers,
 
 /* Relies on caller to gc-protect keymap, keysym, value */
 static void
 
 /* Relies on caller to gc-protect keymap, keysym, value */
 static void

-keymap_store (Lisp_Object keymap, CONST struct key_data *key,
+keymap_store (Lisp_Object keymap, const struct key_data *key,

               Lisp_Object value)
 {
   Lisp_Object keysym = key->keysym;
               Lisp_Object value)
 {
   Lisp_Object keysym = key->keysym;

-  unsigned int modifiers = key->modifiers;
-  struct keymap *k;
-
-  if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
-                     | MOD_ALT | MOD_SHIFT)) != 0)
-    abort ();
+  int modifiers = key->modifiers;
+  Lisp_Keymap *k = XKEYMAP (keymap);

 
 

-  k = XKEYMAP (keymap);
+  modifiers &= ~(XEMACS_MOD_BUTTON1 | XEMACS_MOD_BUTTON2 | XEMACS_MOD_BUTTON3
+                | XEMACS_MOD_BUTTON4 | XEMACS_MOD_BUTTON5);
+  assert ((modifiers & ~(XEMACS_MOD_CONTROL | XEMACS_MOD_META
+                        | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER
+                        | XEMACS_MOD_ALT | XEMACS_MOD_SHIFT)) == 0);

 
   /* If the keysym is a one-character symbol, use the char code instead. */
   if (SYMBOLP (keysym) && string_char_length (XSYMBOL (keysym)->name) == 1)
 
   /* If the keysym is a one-character symbol, use the char code instead. */
   if (SYMBOLP (keysym) && string_char_length (XSYMBOL (keysym)->name) == 1)

-    {
-      Lisp_Object run_the_gcc_developers_over_with_a_steamroller =
-       make_char (string_char (XSYMBOL (keysym)->name, 0));
-      keysym = run_the_gcc_developers_over_with_a_steamroller;
-    }
+    keysym = make_char (string_char (XSYMBOL (keysym)->name, 0));

 
 

-  if (modifiers & MOD_META)     /* Utterly hateful ESC lossage */
+  if (modifiers & XEMACS_MOD_META)     /* Utterly hateful ESC lossage */

     {
     {

-      Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
+      Lisp_Object submap = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META),

                                     k->table, Qnil);
       if (NILP (submap))
                                     k->table, Qnil);
       if (NILP (submap))

-       submap = create_bucky_submap (k, MOD_META, keymap);
+       submap = create_bucky_submap (k, XEMACS_MOD_META, keymap);

       k = XKEYMAP (submap);
       k = XKEYMAP (submap);

-      modifiers &= ~MOD_META;
+      modifiers &= ~XEMACS_MOD_META;

     }
 
   if (modifiers != 0)
     }
 
   if (modifiers != 0)

@@ -683,32 +687,27 @@ struct keymap_submaps_closure
 };
 
 static int
 };
 
 static int

-keymap_submaps_mapper_0 (CONST void *hash_key, void *hash_contents,
+keymap_submaps_mapper_0 (Lisp_Object key, Lisp_Object value,

                          void *keymap_submaps_closure)
 {
   /* This function can GC */
                          void *keymap_submaps_closure)
 {
   /* This function can GC */

-  Lisp_Object contents;
-  VOID_TO_LISP (contents, hash_contents);

   /* Perform any autoloads, etc */
   /* Perform any autoloads, etc */

-  Fkeymapp (contents);
+  Fkeymapp (value);

   return 0;
 }
 
 static int
   return 0;
 }
 
 static int

-keymap_submaps_mapper (CONST void *hash_key, void *hash_contents,
+keymap_submaps_mapper (Lisp_Object key, Lisp_Object value,

                        void *keymap_submaps_closure)
 {
   /* This function can GC */
                        void *keymap_submaps_closure)
 {
   /* This function can GC */

-  Lisp_Object key, contents;

   Lisp_Object *result_locative;
   struct keymap_submaps_closure *cl =
     (struct keymap_submaps_closure *) keymap_submaps_closure;
   Lisp_Object *result_locative;
   struct keymap_submaps_closure *cl =
     (struct keymap_submaps_closure *) keymap_submaps_closure;

-  CVOID_TO_LISP (key, hash_key);
-  VOID_TO_LISP (contents, hash_contents);

   result_locative = cl->result_locative;
 
   result_locative = cl->result_locative;
 

-  if (!NILP (Fkeymapp (contents)))
-    *result_locative = Fcons (Fcons (key, contents), *result_locative);
+  if (!NILP (Fkeymapp (value)))
+    *result_locative = Fcons (Fcons (key, value), *result_locative);

   return 0;
 }
 
   return 0;
 }
 

@@ -719,7 +718,7 @@ static Lisp_Object
 keymap_submaps (Lisp_Object keymap)
 {
   /* This function can GC */
 keymap_submaps (Lisp_Object keymap)
 {
   /* This function can GC */

-  struct keymap *k = XKEYMAP (keymap);
+  Lisp_Keymap *k = XKEYMAP (keymap);

 
   if (EQ (k->sub_maps_cache, Qt)) /* Unknown */
     {
 
   if (EQ (k->sub_maps_cache, Qt)) /* Unknown */
     {

@@ -750,28 +749,30 @@ keymap_submaps (Lisp_Object keymap)
 /************************************************************************/
 
 static Lisp_Object
 /************************************************************************/
 
 static Lisp_Object

-make_keymap (int size)
+make_keymap (size_t size)

 {
   Lisp_Object result;
 {
   Lisp_Object result;

-  struct keymap *keymap = alloc_lcrecord_type (struct keymap, lrecord_keymap);
+  Lisp_Keymap *keymap = alloc_lcrecord_type (Lisp_Keymap, &lrecord_keymap);

 
   XSETKEYMAP (result, keymap);
 
 
   XSETKEYMAP (result, keymap);
 

-  keymap->parents = Qnil;
-  keymap->table = Qnil;
-  keymap->prompt = Qnil;
+  keymap->parents         = Qnil;
+  keymap->prompt          = Qnil;
+  keymap->table           = Qnil;
+  keymap->inverse_table   = Qnil;

   keymap->default_binding = Qnil;
   keymap->default_binding = Qnil;

-  keymap->inverse_table = Qnil;
-  keymap->sub_maps_cache = Qnil; /* No possible submaps */
-  keymap->fullness = 0;
+  keymap->sub_maps_cache  = Qnil; /* No possible submaps */
+  keymap->name            = Qnil;
+

   if (size != 0) /* hack for copy-keymap */
     {
   if (size != 0) /* hack for copy-keymap */
     {

-      keymap->table = Fmake_hashtable (make_int (size), Qnil);
+      keymap->table =
+       make_lisp_hash_table (size, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);

       /* Inverse table is often less dense because of duplicate key-bindings.
          If not, it will grow anyway. */
       /* Inverse table is often less dense because of duplicate key-bindings.
          If not, it will grow anyway. */

-      keymap->inverse_table = Fmake_hashtable (make_int (size * 3 / 4), Qnil);
+      keymap->inverse_table =
+       make_lisp_hash_table (size * 3 / 4, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ);

     }
     }

-  keymap->name = Qnil;

   return result;
 }
 
   return result;
 }
 

@@ -1052,7 +1053,7 @@ get_keyelt (Lisp_Object object, int accept_default)
       struct key_data indirection;
       if (CHARP (idx))
        {
       struct key_data indirection;
       if (CHARP (idx))
        {

-         struct Lisp_Event event;
+         Lisp_Event event;

          event.event_type = empty_event;
          character_to_event (XCHAR (idx), &event,
                              XCONSOLE (Vselected_console), 0, 0);
          event.event_type = empty_event;
          character_to_event (XCHAR (idx), &event,
                              XCONSOLE (Vselected_console), 0, 0);

@@ -1063,7 +1064,7 @@ get_keyelt (Lisp_Object object, int accept_default)
          if (!INTP (XCDR (idx)))
            return Qnil;
          indirection.keysym = XCAR (idx);
          if (!INTP (XCDR (idx)))
            return Qnil;
          indirection.keysym = XCAR (idx);

-         indirection.modifiers = XINT (XCDR (idx));
+         indirection.modifiers = (unsigned char) XINT (XCDR (idx));

        }
       else if (SYMBOLP (idx))
        {
        }
       else if (SYMBOLP (idx))
        {

@@ -1094,7 +1095,7 @@ get_keyelt (Lisp_Object object, int accept_default)
 }
 
 static Lisp_Object
 }
 
 static Lisp_Object

-keymap_lookup_1 (Lisp_Object keymap, CONST struct key_data *key,
+keymap_lookup_1 (Lisp_Object keymap, const struct key_data *key,

                  int accept_default)
 {
   /* This function can GC */
                  int accept_default)
 {
   /* This function can GC */

@@ -1114,38 +1115,34 @@ struct copy_keymap_inverse_closure
 };
 
 static int
 };
 
 static int

-copy_keymap_inverse_mapper (CONST void *hash_key, void *hash_contents,
+copy_keymap_inverse_mapper (Lisp_Object key, Lisp_Object value,

                             void *copy_keymap_inverse_closure)
 {
                             void *copy_keymap_inverse_closure)
 {

-  Lisp_Object key, inverse_table, inverse_contents;

   struct copy_keymap_inverse_closure *closure =
     (struct copy_keymap_inverse_closure *) copy_keymap_inverse_closure;
 
   struct copy_keymap_inverse_closure *closure =
     (struct copy_keymap_inverse_closure *) copy_keymap_inverse_closure;
 

-  VOID_TO_LISP (inverse_table, closure);
-  VOID_TO_LISP (inverse_contents, hash_contents);
-  CVOID_TO_LISP (key, hash_key);

   /* copy-sequence deals with dotted lists. */
   /* copy-sequence deals with dotted lists. */

-  if (CONSP (inverse_contents))
-    inverse_contents = Fcopy_sequence (inverse_contents);
-  Fputhash (key, inverse_contents, closure->inverse_table);
+  if (CONSP (value))
+    value = Fcopy_list (value);
+  Fputhash (key, value, closure->inverse_table);

 
   return 0;
 }
 
 
 static Lisp_Object
 
   return 0;
 }
 
 
 static Lisp_Object

-copy_keymap_internal (struct keymap *keymap)
+copy_keymap_internal (Lisp_Keymap *keymap)

 {
   Lisp_Object nkm = make_keymap (0);
 {
   Lisp_Object nkm = make_keymap (0);

-  struct keymap *new_keymap = XKEYMAP (nkm);
+  Lisp_Keymap *new_keymap = XKEYMAP (nkm);

   struct copy_keymap_inverse_closure copy_keymap_inverse_closure;
   copy_keymap_inverse_closure.inverse_table = keymap->inverse_table;
 
   struct copy_keymap_inverse_closure copy_keymap_inverse_closure;
   copy_keymap_inverse_closure.inverse_table = keymap->inverse_table;
 

-  new_keymap->parents = Fcopy_sequence (keymap->parents);
-  new_keymap->fullness = keymap->fullness;
+  new_keymap->parents        = Fcopy_sequence (keymap->parents);

   new_keymap->sub_maps_cache = Qnil; /* No submaps */
   new_keymap->sub_maps_cache = Qnil; /* No submaps */

-  new_keymap->table = Fcopy_hashtable (keymap->table);
-  new_keymap->inverse_table = Fcopy_hashtable (keymap->inverse_table);
+  new_keymap->table          = Fcopy_hash_table (keymap->table);
+  new_keymap->inverse_table  = Fcopy_hash_table (keymap->inverse_table);
+  new_keymap->default_binding = keymap->default_binding;

   /* After copying the inverse map, we need to copy the conses which
      are its values, lest they be shared by the copy, and mangled.
    */
   /* After copying the inverse map, we need to copy the conses which
      are its values, lest they be shared by the copy, and mangled.
    */

@@ -1159,30 +1156,26 @@ static Lisp_Object copy_keymap (Lisp_Object keymap);
 
 struct copy_keymap_closure
 {
 
 struct copy_keymap_closure
 {

-  struct keymap *self;
+  Lisp_Keymap *self;

 };
 
 static int
 };
 
 static int

-copy_keymap_mapper (CONST void *hash_key, void *hash_contents,
+copy_keymap_mapper (Lisp_Object key, Lisp_Object value,

                     void *copy_keymap_closure)
 {
   /* This function can GC */
                     void *copy_keymap_closure)
 {
   /* This function can GC */

-  Lisp_Object key, contents;

   struct copy_keymap_closure *closure =
     (struct copy_keymap_closure *) copy_keymap_closure;
 
   struct copy_keymap_closure *closure =
     (struct copy_keymap_closure *) copy_keymap_closure;
 

-  CVOID_TO_LISP (key, hash_key);
-  VOID_TO_LISP (contents, hash_contents);

   /* When we encounter a keymap which is indirected through a
      symbol, we need to copy the sub-map.  In v18, the form
        (lookup-key (copy-keymap global-map) "\C-x")
      returned a new keymap, not the symbol 'Control-X-prefix.
    */
   /* When we encounter a keymap which is indirected through a
      symbol, we need to copy the sub-map.  In v18, the form
        (lookup-key (copy-keymap global-map) "\C-x")
      returned a new keymap, not the symbol 'Control-X-prefix.
    */

-  contents = get_keymap (contents,
-                        0, 1); /* #### autoload GC-safe here? */
-  if (KEYMAPP (contents))
+  value = get_keymap (value, 0, 1); /* #### autoload GC-safe here? */
+  if (KEYMAPP (value))

     keymap_store_internal (key, closure->self,
     keymap_store_internal (key, closure->self,

-                          copy_keymap (contents));
+                          copy_keymap (value));

   return 0;
 }
 
   return 0;
 }
 

@@ -1223,16 +1216,17 @@ keymap_fullness (Lisp_Object keymap)
   struct gcpro gcpro1, gcpro2;
 
   keymap = get_keymap (keymap, 1, 1);
   struct gcpro gcpro1, gcpro2;
 
   keymap = get_keymap (keymap, 1, 1);

-  fullness = XKEYMAP (keymap)->fullness;
-  sub_maps = keymap_submaps (keymap);
+  fullness = XINT (Fhash_table_count (XKEYMAP (keymap)->table));

   GCPRO2 (keymap, sub_maps);
   GCPRO2 (keymap, sub_maps);

-  for (; !NILP (sub_maps); sub_maps = XCDR (sub_maps))
+  for (sub_maps = keymap_submaps (keymap);
+       !NILP (sub_maps);
+       sub_maps = XCDR (sub_maps))

     {
       if (MODIFIER_HASH_KEY_BITS (XCAR (XCAR (sub_maps))) != 0)
        {
     {
       if (MODIFIER_HASH_KEY_BITS (XCAR (XCAR (sub_maps))) != 0)
        {

-         Lisp_Object sub_map = XCDR (XCAR (sub_maps));
-         fullness--; /* don't count bucky maps */
-         fullness += keymap_fullness (sub_map);
+         Lisp_Object bucky_map = XCDR (XCAR (sub_maps));
+         fullness--; /* don't count bucky maps themselves. */
+         fullness += keymap_fullness (bucky_map);

        }
     }
   UNGCPRO;
        }
     }
   UNGCPRO;

@@ -1259,7 +1253,7 @@ Return the number of bindings in the keymap.
 static void
 define_key_check_and_coerce_keysym (Lisp_Object spec,
                                    Lisp_Object *keysym,
 static void
 define_key_check_and_coerce_keysym (Lisp_Object spec,
                                    Lisp_Object *keysym,

-                                   unsigned int modifiers)
+                                   int modifiers)

 {
   /* Now, check and massage the trailing keysym specifier. */
   if (SYMBOLP (*keysym))
 {
   /* Now, check and massage the trailing keysym specifier. */
   if (SYMBOLP (*keysym))

@@ -1282,21 +1276,19 @@ define_key_check_and_coerce_keysym (Lisp_Object spec,
           problems ... */
        signal_simple_error ("keysym char must be printable", *keysym);
       /* #### This bites!  I want to be able to write (control shift a) */
           problems ... */
        signal_simple_error ("keysym char must be printable", *keysym);
       /* #### This bites!  I want to be able to write (control shift a) */

-      if (modifiers & MOD_SHIFT)
+      if (modifiers & XEMACS_MOD_SHIFT)

        signal_simple_error
        signal_simple_error

-         ("the `shift' modifier may not be applied to ASCII keysyms",
+         ("The `shift' modifier may not be applied to ASCII keysyms",

           spec);
     }
   else
     {
           spec);
     }
   else
     {

-      signal_simple_error ("unknown keysym specifier",
-                          *keysym);
+      signal_simple_error ("Unknown keysym specifier", *keysym);

     }
 
   if (SYMBOLP (*keysym))
     {
     }
 
   if (SYMBOLP (*keysym))
     {

-      char *name = (char *)
-       string_data (XSYMBOL (*keysym)->name);
+      char *name = (char *) string_data (XSYMBOL (*keysym)->name);

 
       /* FSFmacs uses symbols with the printed representation of keysyms in
         their names, like 'M-x, and we use the syntax '(meta x).  So, to avoid
 
       /* FSFmacs uses symbols with the printed representation of keysyms in
         their names, like 'M-x, and we use the syntax '(meta x).  So, to avoid

@@ -1359,6 +1351,8 @@ define_key_check_and_coerce_keysym (Lisp_Object spec,
        *keysym = QKescape;
       else if (EQ (*keysym, QDEL))
        *keysym = QKdelete;
        *keysym = QKescape;
       else if (EQ (*keysym, QDEL))
        *keysym = QKdelete;

+      else if (EQ (*keysym, QSPC))
+       *keysym = QKspace;

       else if (EQ (*keysym, QBS))
        *keysym = QKbackspace;
       /* Emacs compatibility */
       else if (EQ (*keysym, QBS))
        *keysym = QKbackspace;
       /* Emacs compatibility */

@@ -1398,7 +1392,7 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value)
 {
   if (CHAR_OR_CHAR_INTP (spec))
     {
 {
   if (CHAR_OR_CHAR_INTP (spec))
     {

-      struct Lisp_Event event;
+      Lisp_Event event;

       event.event_type = empty_event;
       character_to_event (XCHAR_OR_CHAR_INT (spec), &event,
                          XCONSOLE (Vselected_console), 0, 0);
       event.event_type = empty_event;
       character_to_event (XCHAR_OR_CHAR_INT (spec), &event,
                          XCONSOLE (Vselected_console), 0, 0);

@@ -1459,14 +1453,14 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value)
     }
   else if (CONSP (spec))
     {
     }
   else if (CONSP (spec))
     {

-      unsigned int modifiers = 0;
+      int modifiers = 0;

       Lisp_Object keysym = Qnil;
       Lisp_Object rest = spec;
 
       /* First, parse out the leading modifier symbols. */
       while (CONSP (rest))
        {
       Lisp_Object keysym = Qnil;
       Lisp_Object rest = spec;
 
       /* First, parse out the leading modifier symbols. */
       while (CONSP (rest))
        {

-         unsigned int modifier;
+         int modifier;

 
          keysym = XCAR (rest);
          modifier = bucky_sym_to_bucky_bit (keysym);
 
          keysym = XCAR (rest);
          modifier = bucky_sym_to_bucky_bit (keysym);

@@ -1474,19 +1468,19 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value)
          if (!NILP (XCDR (rest)))
            {
              if (! modifier)
          if (!NILP (XCDR (rest)))
            {
              if (! modifier)

-               signal_simple_error ("unknown modifier", keysym);
+               signal_simple_error ("Unknown modifier", keysym);

            }
          else
            {
              if (modifier)
            }
          else
            {
              if (modifier)

-               signal_simple_error ("nothing but modifiers here",
+               signal_simple_error ("Nothing but modifiers here",

                                     spec);
            }
          rest = XCDR (rest);
          QUIT;
        }
       if (!NILP (rest))
                                     spec);
            }
          rest = XCDR (rest);
          QUIT;
        }
       if (!NILP (rest))

-        signal_simple_error ("dotted list", spec);
+        signal_simple_error ("List must be nil-terminated", spec);

 
       define_key_check_and_coerce_keysym (spec, &keysym, modifiers);
       returned_value->keysym = keysym;
 
       define_key_check_and_coerce_keysym (spec, &keysym, modifiers);
       returned_value->keysym = keysym;

@@ -1494,7 +1488,7 @@ define_key_parser (Lisp_Object spec, struct key_data *returned_value)
     }
   else
     {
     }
   else
     {

-      signal_simple_error ("unknown key-sequence specifier",
+      signal_simple_error ("Unknown key-sequence specifier",

                           spec);
     }
 }
                           spec);
     }
 }

@@ -1513,7 +1507,7 @@ key_desc_list_to_event (Lisp_Object list, Lisp_Object event,
     {
       Lisp_Object fn, arg;
       if (! NILP (Fcdr (Fcdr (list))))
     {
       Lisp_Object fn, arg;
       if (! NILP (Fcdr (Fcdr (list))))

-       signal_simple_error ("invalid menu event desc", list);
+       signal_simple_error ("Invalid menu event desc", list);

       arg = Fcar (Fcdr (list));
       if (SYMBOLP (arg))
        fn = Qcall_interactively;
       arg = Fcar (Fcdr (list));
       if (SYMBOLP (arg))
        fn = Qcall_interactively;

@@ -1546,8 +1540,7 @@ key_desc_list_to_event (Lisp_Object list, Lisp_Object event,
 
 
 int
 
 
 int

-event_matches_key_specifier_p (struct Lisp_Event *event,
-                              Lisp_Object key_specifier)
+event_matches_key_specifier_p (Lisp_Event *event, Lisp_Object key_specifier)

 {
   Lisp_Object event2;
   int retval;
 {
   Lisp_Object event2;
   int retval;

@@ -1598,9 +1591,9 @@ event_matches_key_specifier_p (struct Lisp_Event *event,
 }
 
 static int
 }
 
 static int

-meta_prefix_char_p (CONST struct key_data *key)
+meta_prefix_char_p (const struct key_data *key)

 {
 {

-  struct Lisp_Event event;
+  Lisp_Event event;

 
   event.event_type = key_press_event;
   event.channel = Vselected_console;
 
   event.event_type = key_press_event;
   event.channel = Vselected_console;

@@ -1621,6 +1614,12 @@ This can be useful, e.g., to determine if the user pressed `help-char' or
          ? Qt : Qnil);
 }
 
          ? Qt : Qnil);
 }
 

+#define MACROLET(k,m) do {             \
+  returned_value->keysym = (k);                \
+  returned_value->modifiers = (m);     \
+  RETURN_SANS_WARNINGS;                        \
+} while (0)
+

 /* ASCII grunge.
    Given a keysym, return another keysym/modifier pair which could be
    considered the same key in an ASCII world.  Backspace returns ^H, for
 /* ASCII grunge.
    Given a keysym, return another keysym/modifier pair which could be
    considered the same key in an ASCII world.  Backspace returns ^H, for

@@ -1631,15 +1630,12 @@ define_key_alternate_name (struct key_data *key,
                            struct key_data *returned_value)
 {
   Lisp_Object keysym = key->keysym;
                            struct key_data *returned_value)
 {
   Lisp_Object keysym = key->keysym;

-  unsigned int modifiers = key->modifiers;
-  unsigned int modifiers_sans_control = (modifiers & (~MOD_CONTROL));
-  unsigned int modifiers_sans_meta = (modifiers & (~MOD_META));
+  int modifiers = key->modifiers;
+  int modifiers_sans_control = (modifiers & (~XEMACS_MOD_CONTROL));
+  int modifiers_sans_meta = (modifiers & (~XEMACS_MOD_META));

   returned_value->keysym = Qnil; /* By default, no "alternate" key */
   returned_value->modifiers = 0;
   returned_value->keysym = Qnil; /* By default, no "alternate" key */
   returned_value->modifiers = 0;

-#define MACROLET(k,m) do { returned_value->keysym = (k); \
-                          returned_value->modifiers = (m); \
-                           RETURN__; } while (0)
-  if (modifiers_sans_meta == MOD_CONTROL)
+  if (modifiers_sans_meta == XEMACS_MOD_CONTROL)

     {
       if EQ (keysym, QKspace)
         MACROLET (make_char ('@'), modifiers);
     {
       if EQ (keysym, QKspace)
         MACROLET (make_char ('@'), modifiers);

@@ -1666,15 +1662,15 @@ define_key_alternate_name (struct key_data *key,
   else if (modifiers_sans_meta != 0)
     return;
   else if (EQ (keysym, QKbackspace)) /* backspace => c-h */
   else if (modifiers_sans_meta != 0)
     return;
   else if (EQ (keysym, QKbackspace)) /* backspace => c-h */

-    MACROLET (make_char ('h'), (modifiers | MOD_CONTROL));
+    MACROLET (make_char ('h'), (modifiers | XEMACS_MOD_CONTROL));

   else if (EQ (keysym, QKtab))       /* tab => c-i */
   else if (EQ (keysym, QKtab))       /* tab => c-i */

-    MACROLET (make_char ('i'), (modifiers | MOD_CONTROL));
+    MACROLET (make_char ('i'), (modifiers | XEMACS_MOD_CONTROL));

   else if (EQ (keysym, QKlinefeed))  /* linefeed => c-j */
   else if (EQ (keysym, QKlinefeed))  /* linefeed => c-j */

-    MACROLET (make_char ('j'), (modifiers | MOD_CONTROL));
+    MACROLET (make_char ('j'), (modifiers | XEMACS_MOD_CONTROL));

   else if (EQ (keysym, QKreturn))    /* return => c-m */
   else if (EQ (keysym, QKreturn))    /* return => c-m */

-    MACROLET (make_char ('m'), (modifiers | MOD_CONTROL));
+    MACROLET (make_char ('m'), (modifiers | XEMACS_MOD_CONTROL));

   else if (EQ (keysym, QKescape))    /* escape => c-[ */
   else if (EQ (keysym, QKescape))    /* escape => c-[ */

-    MACROLET (make_char ('['), (modifiers | MOD_CONTROL));
+    MACROLET (make_char ('['), (modifiers | XEMACS_MOD_CONTROL));

   else
     return;
 #undef MACROLET
   else
     return;
 #undef MACROLET

@@ -1711,7 +1707,10 @@ ensure_meta_prefix_char_keymapp (Lisp_Object keys, int indx,
        XVECTOR_DATA (new_keys) [i] = XVECTOR_DATA (keys) [i];
     }
   else
        XVECTOR_DATA (new_keys) [i] = XVECTOR_DATA (keys) [i];
     }
   else

-    abort ();
+    {
+      new_keys = Qnil;
+      abort ();
+    }

 
   if (EQ (keys, new_keys))
     error_with_frob (mpc_binding,
 
   if (EQ (keys, new_keys))
     error_with_frob (mpc_binding,

@@ -1903,20 +1902,17 @@ these features.
                 (defvar my-escape-map (lookup-key my-map "\e"))
                 if the luser really wants the map in a variable.
                 */
                 (defvar my-escape-map (lookup-key my-map "\e"))
                 if the luser really wants the map in a variable.
                 */

-             Lisp_Object mmap;
+             Lisp_Object meta_map;

               struct gcpro ngcpro1;
 
               NGCPRO1 (c);
               struct gcpro ngcpro1;
 
               NGCPRO1 (c);

-              mmap = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
-                               XKEYMAP (keymap)->table, Qnil);
-             if (!NILP (mmap)
-                 && keymap_fullness (mmap) != 0)
-               {
-                  Lisp_Object desc
-                    = Fsingle_key_description (Vmeta_prefix_char);
-                 signal_simple_error_2
-                   ("Map contains meta-bindings, can't bind", desc, keymap);
-               }
+              meta_map = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META),
+                                  XKEYMAP (keymap)->table, Qnil);
+             if (!NILP (meta_map)
+                 && keymap_fullness (meta_map) != 0)
+               signal_simple_error_2
+                 ("Map contains meta-bindings, can't bind",
+                  Fsingle_key_description (Vmeta_prefix_char), keymap);

               NUNGCPRO;
            }
          else
               NUNGCPRO;
            }
          else

@@ -1937,14 +1933,14 @@ these features.
 
       if (metized)
        {
 
       if (metized)
        {

-         raw_key1.modifiers  |= MOD_META;
-         raw_key2.modifiers |= MOD_META;
+         raw_key1.modifiers |= XEMACS_MOD_META;
+         raw_key2.modifiers |= XEMACS_MOD_META;

          metized = 0;
        }
 
       /* This crap is to make sure that someone doesn't bind something like
         "C-x M-a" while "C-x ESC" has a non-keymap binding. */
          metized = 0;
        }
 
       /* This crap is to make sure that someone doesn't bind something like
         "C-x M-a" while "C-x ESC" has a non-keymap binding. */

-      if (raw_key1.modifiers & MOD_META)
+      if (raw_key1.modifiers & XEMACS_MOD_META)

        ensure_meta_prefix_char_keymapp (keys, idx, keymap);
 
       if (++idx == len)
        ensure_meta_prefix_char_keymapp (keys, idx, keymap);
 
       if (++idx == len)

@@ -1970,7 +1966,7 @@ these features.
            keymap_store (keymap, &raw_key1, cmd);
          }
        if (NILP (Fkeymapp (cmd)))
            keymap_store (keymap, &raw_key1, cmd);
          }
        if (NILP (Fkeymapp (cmd)))

-          signal_simple_error_2 ("invalid prefix keys in sequence",
+          signal_simple_error_2 ("Invalid prefix keys in sequence",

                                 c, keys);
 
        if (ascii_hack && !NILP (raw_key2.keysym) &&
                                 c, keys);
 
        if (ascii_hack && !NILP (raw_key2.keysym) &&

@@ -1994,7 +1990,7 @@ these features.
 struct raw_lookup_key_mapper_closure
 {
   int remaining;
 struct raw_lookup_key_mapper_closure
 {
   int remaining;

-  CONST struct key_data *raw_keys;
+  const struct key_data *raw_keys;

   int raw_keys_count;
   int keys_so_far;
   int accept_default;
   int raw_keys_count;
   int keys_so_far;
   int accept_default;

@@ -2005,7 +2001,7 @@ static Lisp_Object raw_lookup_key_mapper (Lisp_Object k, void *);
 /* Caller should gc-protect args (keymaps may autoload) */
 static Lisp_Object
 raw_lookup_key (Lisp_Object keymap,
 /* Caller should gc-protect args (keymaps may autoload) */
 static Lisp_Object
 raw_lookup_key (Lisp_Object keymap,

-                CONST struct key_data *raw_keys, int raw_keys_count,
+                const struct key_data *raw_keys, int raw_keys_count,

                 int keys_so_far, int accept_default)
 {
   /* This function can GC */
                 int keys_so_far, int accept_default)
 {
   /* This function can GC */

@@ -2028,7 +2024,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg)
   int accept_default = c->accept_default;
   int remaining = c->remaining;
   int keys_so_far = c->keys_so_far;
   int accept_default = c->accept_default;
   int remaining = c->remaining;
   int keys_so_far = c->keys_so_far;

-  CONST struct key_data *raw_keys = c->raw_keys;
+  const struct key_data *raw_keys = c->raw_keys;

   Lisp_Object cmd;
 
   if (! meta_prefix_char_p (&(raw_keys[0])))
   Lisp_Object cmd;
 
   if (! meta_prefix_char_p (&(raw_keys[0])))

@@ -2057,7 +2053,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg)
        * element is the meta-prefix-char will return the keymap that
        * the "meta" keys are stored in, if there is no binding for
        * the meta-prefix-char (and if this map has a "meta" submap).
        * element is the meta-prefix-char will return the keymap that
        * the "meta" keys are stored in, if there is no binding for
        * the meta-prefix-char (and if this map has a "meta" submap).

-       * If this map doesnt have a "meta" submap, then the
+       * If this map doesn't have a "meta" submap, then the

        * meta-prefix-char is looked up just like any other key.
        */
       if (remaining == 0)
        * meta-prefix-char is looked up just like any other key.
        */
       if (remaining == 0)

@@ -2067,7 +2063,7 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg)
          if (NILP (cmd))
            {
              /* Do kludgy return of the meta-map */
          if (NILP (cmd))
            {
              /* Do kludgy return of the meta-map */

-             cmd = Fgethash (MAKE_MODIFIER_HASH_KEY (MOD_META),
+             cmd = Fgethash (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META),

                              XKEYMAP (k)->table, Qnil);
            }
        }
                              XKEYMAP (k)->table, Qnil);
            }
        }

@@ -2079,11 +2075,12 @@ raw_lookup_key_mapper (Lisp_Object k, void *arg)
          if (!NILP (cmd))
            cmd = raw_lookup_key (cmd, raw_keys + 1, remaining,
                                  keys_so_far + 1, accept_default);
          if (!NILP (cmd))
            cmd = raw_lookup_key (cmd, raw_keys + 1, remaining,
                                  keys_so_far + 1, accept_default);

-         else if ((raw_keys[1].modifiers & MOD_META) == 0)
+         else if ((raw_keys[1].modifiers & XEMACS_MOD_META) == 0)

            {
              struct key_data metified;
              metified.keysym = raw_keys[1].keysym;
            {
              struct key_data metified;
              metified.keysym = raw_keys[1].keysym;

-             metified.modifiers = raw_keys[1].modifiers | MOD_META;
+             metified.modifiers = raw_keys[1].modifiers |
+               (unsigned char) XEMACS_MOD_META;

 
              /* Search for meta-next-char sequence directly */
              cmd = keymap_lookup_1 (k, &metified, accept_default);
 
              /* Search for meta-next-char sequence directly */
              cmd = keymap_lookup_1 (k, &metified, accept_default);

@@ -2119,7 +2116,7 @@ lookup_keys (Lisp_Object keymap, int nkeys, Lisp_Object *keys,
   if (nkeys == 0)
     return Qnil;
 
   if (nkeys == 0)
     return Qnil;
 

-  if (nkeys < (countof (kkk)))
+  if (nkeys < countof (kkk))

     raw_keys = kkk;
   else
     raw_keys = alloca_array (struct key_data, nkeys);
     raw_keys = kkk;
   else
     raw_keys = alloca_array (struct key_data, nkeys);

@@ -2149,7 +2146,7 @@ lookup_events (Lisp_Object event_head, int nmaps, Lisp_Object keymaps[],
 
   nkeys = event_chain_count (event_head);
 
 
   nkeys = event_chain_count (event_head);
 

-  if (nkeys < (countof (kkk)))
+  if (nkeys < countof (kkk))

     raw_keys = kkk;
   else
     raw_keys = alloca_array (struct key_data, nkeys);
     raw_keys = kkk;
   else
     raw_keys = alloca_array (struct key_data, nkeys);

@@ -2226,7 +2223,7 @@ it takes to reach a non-prefix command.
    map of the buffer in which the mouse was clicked in event0 is a click.
 
    It would be kind of nice if this were in Lisp so that this semi-hairy
    map of the buffer in which the mouse was clicked in event0 is a click.
 
    It would be kind of nice if this were in Lisp so that this semi-hairy

-   semi-heuristic command-lookup behaviour could be readily understood and
+   semi-heuristic command-lookup behavior could be readily understood and

    customised.  However, this needs to be pretty fast, or performance of
    keyboard macros goes to shit; putting this in lisp slows macros down
    2-3x.  And they're already slower than v18 by 5-6x.
    customised.  However, this needs to be pretty fast, or performance of
    keyboard macros goes to shit; putting this in lisp slows macros down
    2-3x.  And they're already slower than v18 by 5-6x.

@@ -2375,8 +2372,7 @@ get_relevant_keymaps (Lisp_Object keys,
                  get_relevant_extent_keymaps
                    (Fevent_modeline_position (terminal),
                     XBUFFER (buffer)->generated_modeline_string,
                  get_relevant_extent_keymaps
                    (Fevent_modeline_position (terminal),
                     XBUFFER (buffer)->generated_modeline_string,

-                    /* #### third arg should maybe be a glyph. */
-                    Qnil, &closure);
+                    Fevent_glyph_extent (terminal), &closure);

 
                  if (!UNBOUNDP (map) && !NILP (map))
                    relevant_map_push (get_keymap (map, 1, 1), &closure);
 
                  if (!UNBOUNDP (map) && !NILP (map))
                    relevant_map_push (get_keymap (map, 1, 1), &closure);

@@ -2410,7 +2406,7 @@ get_relevant_keymaps (Lisp_Object keys,
 
   {
     int nmaps = closure.nmaps;
 
   {
     int nmaps = closure.nmaps;

-    /* Silently truncate at 100 keymaps to prevent infinite losssage */
+    /* Silently truncate at 100 keymaps to prevent infinite lossage */

     if (nmaps >= max_maps && max_maps > 0)
       maps[max_maps - 1] = Vcurrent_global_map;
     else
     if (nmaps >= max_maps && max_maps > 0)
       maps[max_maps - 1] = Vcurrent_global_map;
     else

@@ -2426,7 +2422,7 @@ get_relevant_keymaps (Lisp_Object keys,
    first element in the list returned.  This is so we can correctly
    search the keymaps associated with glyphs which may be physically
    disjoint from their extents: for example, if a glyph is out in the
    first element in the list returned.  This is so we can correctly
    search the keymaps associated with glyphs which may be physically
    disjoint from their extents: for example, if a glyph is out in the

-   margin, we should still consult the kemyap of that glyph's extent,
+   margin, we should still consult the keymap of that glyph's extent,

    which may not itself be under the mouse.
  */
 
    which may not itself be under the mouse.
  */
 

@@ -2744,33 +2740,29 @@ Return the current global keymap.
 
 struct map_keymap_unsorted_closure
 {
 
 struct map_keymap_unsorted_closure
 {

-  void (*fn) (CONST struct key_data *, Lisp_Object binding, void *arg);
+  void (*fn) (const struct key_data *, Lisp_Object binding, void *arg);

   void *arg;
   void *arg;

-  unsigned int modifiers;
+  int modifiers;

 };
 
 /* used by map_keymap() */
 static int
 };
 
 /* used by map_keymap() */
 static int

-map_keymap_unsorted_mapper (CONST void *hash_key, void *hash_contents,
+map_keymap_unsorted_mapper (Lisp_Object keysym, Lisp_Object value,

                             void *map_keymap_unsorted_closure)
 {
   /* This function can GC */
                             void *map_keymap_unsorted_closure)
 {
   /* This function can GC */

-  Lisp_Object keysym;
-  Lisp_Object contents;

   struct map_keymap_unsorted_closure *closure =
     (struct map_keymap_unsorted_closure *) map_keymap_unsorted_closure;
   struct map_keymap_unsorted_closure *closure =
     (struct map_keymap_unsorted_closure *) map_keymap_unsorted_closure;

-  unsigned int modifiers = closure->modifiers;
-  unsigned int mod_bit;
-  CVOID_TO_LISP (keysym, hash_key);
-  VOID_TO_LISP (contents, hash_contents);
+  int modifiers = closure->modifiers;
+  int mod_bit;

   mod_bit = MODIFIER_HASH_KEY_BITS (keysym);
   if (mod_bit != 0)
     {
       int omod = modifiers;
       closure->modifiers = (modifiers | mod_bit);
   mod_bit = MODIFIER_HASH_KEY_BITS (keysym);
   if (mod_bit != 0)
     {
       int omod = modifiers;
       closure->modifiers = (modifiers | mod_bit);

-      contents = get_keymap (contents, 1, 0);
+      value = get_keymap (value, 1, 0);

       elisp_maphash (map_keymap_unsorted_mapper,
       elisp_maphash (map_keymap_unsorted_mapper,

-                    XKEYMAP (contents)->table,
+                    XKEYMAP (value)->table,

                     map_keymap_unsorted_closure);
       closure->modifiers = omod;
     }
                     map_keymap_unsorted_closure);
       closure->modifiers = omod;
     }

@@ -2779,7 +2771,7 @@ map_keymap_unsorted_mapper (CONST void *hash_key, void *hash_contents,
       struct key_data key;
       key.keysym = keysym;
       key.modifiers = modifiers;
       struct key_data key;
       key.keysym = keysym;
       key.modifiers = modifiers;

-      ((*closure->fn) (&key, contents, closure->arg));
+      ((*closure->fn) (&key, value, closure->arg));

     }
   return 0;
 }
     }
   return 0;
 }

@@ -2792,16 +2784,13 @@ struct map_keymap_sorted_closure
 
 /* used by map_keymap_sorted() */
 static int
 
 /* used by map_keymap_sorted() */
 static int

-map_keymap_sorted_mapper (CONST void *hash_key, void *hash_contents,
+map_keymap_sorted_mapper (Lisp_Object key, Lisp_Object value,

                           void *map_keymap_sorted_closure)
 {
   struct map_keymap_sorted_closure *cl =
     (struct map_keymap_sorted_closure *) map_keymap_sorted_closure;
                           void *map_keymap_sorted_closure)
 {
   struct map_keymap_sorted_closure *cl =
     (struct map_keymap_sorted_closure *) map_keymap_sorted_closure;

-  Lisp_Object key, contents;

   Lisp_Object *list = cl->result_locative;
   Lisp_Object *list = cl->result_locative;

-  CVOID_TO_LISP (key, hash_key);
-  VOID_TO_LISP (contents, hash_contents);
-  *list = Fcons (Fcons (key, contents), *list);
+  *list = Fcons (Fcons (key, value), *list);

   return 0;
 }
 
   return 0;
 }
 

@@ -2815,7 +2804,7 @@ map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
 {
   /* obj1 and obj2 are conses with keysyms in their cars.  Cdrs are ignored.
    */
 {
   /* obj1 and obj2 are conses with keysyms in their cars.  Cdrs are ignored.
    */

-  unsigned int bit1, bit2;
+  int bit1, bit2;

   int sym1_p = 0;
   int sym2_p = 0;
   obj1 = XCAR (obj1);
   int sym1_p = 0;
   int sym2_p = 0;
   obj1 = XCAR (obj1);

@@ -2889,8 +2878,8 @@ map_keymap_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
 /* used by map_keymap() */
 static void
 map_keymap_sorted (Lisp_Object keymap_table,
 /* used by map_keymap() */
 static void
 map_keymap_sorted (Lisp_Object keymap_table,

-                   unsigned int modifiers,
-                   void (*function) (CONST struct key_data *key,
+                   int modifiers,
+                   void (*function) (const struct key_data *key,

                                      Lisp_Object binding,
                                      void *map_keymap_sorted_closure),
                    void *map_keymap_sorted_closure)
                                      Lisp_Object binding,
                                      void *map_keymap_sorted_closure),
                    void *map_keymap_sorted_closure)

@@ -2899,7 +2888,7 @@ map_keymap_sorted (Lisp_Object keymap_table,
   struct gcpro gcpro1;
   Lisp_Object contents = Qnil;
 
   struct gcpro gcpro1;
   Lisp_Object contents = Qnil;
 

-  if (XINT (Fhashtable_fullness (keymap_table)) == 0)
+  if (XINT (Fhash_table_count (keymap_table)) == 0)

     return;
 
   GCPRO1 (contents);
     return;
 
   GCPRO1 (contents);

@@ -2914,7 +2903,7 @@ map_keymap_sorted (Lisp_Object keymap_table,
     {
       Lisp_Object keysym = XCAR (XCAR (contents));
       Lisp_Object binding = XCDR (XCAR (contents));
     {
       Lisp_Object keysym = XCAR (XCAR (contents));
       Lisp_Object binding = XCDR (XCAR (contents));

-      unsigned int sub_bits = MODIFIER_HASH_KEY_BITS (keysym);
+      int sub_bits = MODIFIER_HASH_KEY_BITS (keysym);

       if (sub_bits != 0)
        map_keymap_sorted (XKEYMAP (get_keymap (binding,
                                                1, 1))->table,
       if (sub_bits != 0)
        map_keymap_sorted (XKEYMAP (get_keymap (binding,
                                                1, 1))->table,

@@ -2935,7 +2924,7 @@ map_keymap_sorted (Lisp_Object keymap_table,
 
 /* used by Fmap_keymap() */
 static void
 
 /* used by Fmap_keymap() */
 static void

-map_keymap_mapper (CONST struct key_data *key,
+map_keymap_mapper (const struct key_data *key,

                    Lisp_Object binding,
                    void *function)
 {
                    Lisp_Object binding,
                    void *function)
 {

@@ -2948,7 +2937,7 @@ map_keymap_mapper (CONST struct key_data *key,
 
 static void
 map_keymap (Lisp_Object keymap_table, int sort_first,
 
 static void
 map_keymap (Lisp_Object keymap_table, int sort_first,

-            void (*function) (CONST struct key_data *key,
+            void (*function) (const struct key_data *key,

                               Lisp_Object binding,
                               void *fn_arg),
             void *fn_arg)
                               Lisp_Object binding,
                               void *fn_arg),
             void *fn_arg)

@@ -3020,11 +3009,11 @@ struct accessible_keymaps_closure
 
 static void
 accessible_keymaps_mapper_1 (Lisp_Object keysym, Lisp_Object contents,
 
 static void
 accessible_keymaps_mapper_1 (Lisp_Object keysym, Lisp_Object contents,

-                             unsigned int modifiers,
+                             int modifiers,

                              struct accessible_keymaps_closure *closure)
 {
   /* This function can GC */
                              struct accessible_keymaps_closure *closure)
 {
   /* This function can GC */

-  unsigned int subbits = MODIFIER_HASH_KEY_BITS (keysym);
+  int subbits = MODIFIER_HASH_KEY_BITS (keysym);

 
   if (subbits != 0)
     {
 
   if (subbits != 0)
     {

@@ -3104,23 +3093,28 @@ then the value includes only maps for prefixes that start with PREFIX.
   c.tail = Qnil;
   GCPRO4 (accessible_keymaps, c.tail, prefix, keymap);
 
   c.tail = Qnil;
   GCPRO4 (accessible_keymaps, c.tail, prefix, keymap);
 

- retry:

   keymap = get_keymap (keymap, 1, 1);
   keymap = get_keymap (keymap, 1, 1);

+
+ retry:

   if (NILP (prefix))
   if (NILP (prefix))

-    prefix = make_vector (0, Qnil);
-  else if (!VECTORP (prefix) || STRINGP (prefix))

     {
     {

-      prefix = wrong_type_argument (Qarrayp, prefix);
-      goto retry;
+      prefix = make_vector (0, Qnil);

     }
     }

-  else
+  else if (VECTORP (prefix) || STRINGP (prefix))

     {
       int len = XINT (Flength (prefix));
     {
       int len = XINT (Flength (prefix));

-      Lisp_Object def = Flookup_key (keymap, prefix, Qnil);
+      Lisp_Object def;

       Lisp_Object p;
       int iii;
       struct gcpro ngcpro1;
 
       Lisp_Object p;
       int iii;
       struct gcpro ngcpro1;
 

+      if (len == 0)
+       {
+         prefix = Qnil;
+         goto retry;
+       }
+
+      def = Flookup_key (keymap, prefix, Qnil);

       def = get_keymap (def, 0, 1);
       if (!KEYMAPP (def))
        goto RETURN;
       def = get_keymap (def, 0, 1);
       if (!KEYMAPP (def))
        goto RETURN;

@@ -3137,12 +3131,16 @@ then the value includes only maps for prefixes that start with PREFIX.
       NUNGCPRO;
       prefix = p;
     }
       NUNGCPRO;
       prefix = p;
     }

+  else
+    {
+      prefix = wrong_type_argument (Qarrayp, prefix);
+      goto retry;
+    }

 
   accessible_keymaps = list1 (Fcons (prefix, keymap));
 
 
   accessible_keymaps = list1 (Fcons (prefix, keymap));
 

-  /* For each map in the list maps,
-     look at any other maps it points to
-     and stick them at the end if they are not already in the list */
+  /* For each map in the list maps, look at any other maps it points
+     to and stick them at the end if they are not already in the list */

 
   for (c.tail = accessible_keymaps;
        !NILP (c.tail);
 
   for (c.tail = accessible_keymaps;
        !NILP (c.tail);

@@ -3187,9 +3185,9 @@ spaces are put between sequence elements, etc...
       for (i = 0; i < size; i++)
        {
          Lisp_Object s2 = Fsingle_key_description
       for (i = 0; i < size; i++)
        {
          Lisp_Object s2 = Fsingle_key_description

-           (((STRINGP (keys))
-             ? make_char (string_char (XSTRING (keys), i))
-             : XVECTOR_DATA (keys)[i]));
+           (STRINGP (keys)
+            ? make_char (string_char (XSTRING (keys), i))
+            : XVECTOR_DATA (keys)[i]);

 
          if (i == 0)
            string = s2;
 
          if (i == 0)
            string = s2;

@@ -3220,7 +3218,7 @@ of a key read from the user rather than a character from a buffer.
       char buf [255];
       if (!EVENTP (key))
        {
       char buf [255];
       if (!EVENTP (key))
        {

-         struct Lisp_Event event;
+         Lisp_Event event;

          event.event_type = empty_event;
          CHECK_CHAR_COERCE_INT (key);
          character_to_event (XCHAR (key), &event,
          event.event_type = empty_event;
          CHECK_CHAR_COERCE_INT (key);
          character_to_event (XCHAR (key), &event,

@@ -3269,7 +3267,7 @@ of a key read from the user rather than a character from a buffer.
 #endif
                strcpy (bufp, (char *) string_data (XSYMBOL (keysym)->name));
              if (!NILP (XCDR (rest)))
 #endif
                strcpy (bufp, (char *) string_data (XSYMBOL (keysym)->name));
              if (!NILP (XCDR (rest)))

-               signal_simple_error ("invalid key description",
+               signal_simple_error ("Invalid key description",

                                     key);
            }
        }
                                     key);
            }
        }

@@ -3469,7 +3467,7 @@ static void
 format_raw_keys (struct key_data *keys, int count, char *buf)
 {
   int i;
 format_raw_keys (struct key_data *keys, int count, char *buf)
 {
   int i;

-  struct Lisp_Event event;
+  Lisp_Event event;

   event.event_type = key_press_event;
   event.channel = Vselected_console;
   for (i = 0; i < count; i++)
   event.event_type = key_press_event;
   event.channel = Vselected_console;
   for (i = 0; i < count; i++)

@@ -3493,7 +3491,7 @@ format_raw_keys (struct key_data *keys, int count, char *buf)
    keys_so_far and modifiers_so_far describe which map we're looking in;
    If we're in the "meta" submap of the map that "C-x 4" is bound to,
    then keys_so_far will be {(control x), \4}, and modifiers_so_far
    keys_so_far and modifiers_so_far describe which map we're looking in;
    If we're in the "meta" submap of the map that "C-x 4" is bound to,
    then keys_so_far will be {(control x), \4}, and modifiers_so_far

-   will be MOD_META.  That is, keys_so_far is the chain of keys that we
+   will be XEMACS_MOD_META.  That is, keys_so_far is the chain of keys that we

    have followed, and modifiers_so_far_so_far is the bits (partial keys)
    beyond that.
 
    have followed, and modifiers_so_far_so_far is the bits (partial keys)
    beyond that.
 

@@ -3511,7 +3509,7 @@ struct where_is_closure
     int shadow_count;
     int firstonly;
     int keys_count;
     int shadow_count;
     int firstonly;
     int keys_count;

-    unsigned int modifiers_so_far;
+    int modifiers_so_far;

     char *target_buffer;
     struct key_data *keys_so_far;
     int keys_so_far_total_size;
     char *target_buffer;
     struct key_data *keys_so_far;
     int keys_so_far_total_size;

@@ -3526,9 +3524,9 @@ where_is_recursive_mapper (Lisp_Object map, void *arg)
   /* This function can GC */
   struct where_is_closure *c = (struct where_is_closure *) arg;
   Lisp_Object definition = c->definition;
   /* This function can GC */
   struct where_is_closure *c = (struct where_is_closure *) arg;
   Lisp_Object definition = c->definition;

-  CONST int firstonly = c->firstonly;
-  CONST unsigned int keys_count = c->keys_count;
-  CONST unsigned int modifiers_so_far = c->modifiers_so_far;
+  const int firstonly = c->firstonly;
+  const int keys_count = c->keys_count;
+  const int modifiers_so_far = c->modifiers_so_far;

   char *target_buffer = c->target_buffer;
   Lisp_Object keys = Fgethash (definition,
                                XKEYMAP (map)->inverse_table,
   char *target_buffer = c->target_buffer;
   Lisp_Object keys = Fgethash (definition,
                                XKEYMAP (map)->inverse_table,

@@ -3546,7 +3544,7 @@ where_is_recursive_mapper (Lisp_Object map, void *arg)
 
       for (;;) /* loop over all keys that match */
        {
 
       for (;;) /* loop over all keys that match */
        {

-         Lisp_Object k = ((CONSP (keys)) ? XCAR (keys) : keys);
+         Lisp_Object k = CONSP (keys) ? XCAR (keys) : keys;

          int i;
 
          so_far [keys_count].keysym = k;
          int i;
 
          so_far [keys_count].keysym = k;

@@ -3601,9 +3599,9 @@ where_is_recursive_mapper (Lisp_Object map, void *arg)
     {
       Lisp_Object key    = XCAR (XCAR (submaps));
       Lisp_Object submap = XCDR (XCAR (submaps));
     {
       Lisp_Object key    = XCAR (XCAR (submaps));
       Lisp_Object submap = XCDR (XCAR (submaps));

-      unsigned int lower_modifiers;
+      int lower_modifiers;

       int lower_keys_count = keys_count;
       int lower_keys_count = keys_count;

-      unsigned int bucky;
+      int bucky;

 
       submap = get_keymap (submap, 0, 0);
 
 
       submap = get_keymap (submap, 0, 0);
 

@@ -3644,7 +3642,7 @@ where_is_recursive_mapper (Lisp_Object map, void *arg)
          if (! c->keys_so_far_malloced)
            {
              struct key_data *new = xnew_array (struct key_data, size);
          if (! c->keys_so_far_malloced)
            {
              struct key_data *new = xnew_array (struct key_data, size);

-             memcpy ((void *)new, (CONST void *)c->keys_so_far,
+             memcpy ((void *)new, (const void *)c->keys_so_far,

                      c->keys_so_far_total_size * sizeof (struct key_data));
            }
          else
                      c->keys_so_far_total_size * sizeof (struct key_data));
            }
          else

@@ -3752,7 +3750,7 @@ Fifth argument MOUSE-ONLY-P says to only print bindings for mouse clicks.
 }
 
 
 }
 
 

-/* Insert a desription of the key bindings in STARTMAP,
+/* Insert a description of the key bindings in STARTMAP,

     followed by those of all maps reachable through STARTMAP.
    If PARTIAL is nonzero, omit certain "uninteresting" commands
     (such as `undefined').
     followed by those of all maps reachable through STARTMAP.
    If PARTIAL is nonzero, omit certain "uninteresting" commands
     (such as `undefined').

@@ -3897,7 +3895,7 @@ struct describe_map_closure
 
 struct describe_map_shadow_closure
   {
 
 struct describe_map_shadow_closure
   {

-    CONST struct key_data *raw_key;
+    const struct key_data *raw_key;

     Lisp_Object self;
   };
 
     Lisp_Object self;
   };
 

@@ -3926,7 +3924,7 @@ keymap_lookup_inherited_mapper (Lisp_Object km, void *arg)
 
 
 static void
 
 
 static void

-describe_map_mapper (CONST struct key_data *key,
+describe_map_mapper (const struct key_data *key,

                      Lisp_Object binding,
                     void *describe_map_closure)
 {
                      Lisp_Object binding,
                     void *describe_map_closure)
 {

@@ -3934,9 +3932,9 @@ describe_map_mapper (CONST struct key_data *key,
   struct describe_map_closure *closure =
     (struct describe_map_closure *) describe_map_closure;
   Lisp_Object keysym = key->keysym;
   struct describe_map_closure *closure =
     (struct describe_map_closure *) describe_map_closure;
   Lisp_Object keysym = key->keysym;

-  unsigned int modifiers = key->modifiers;
+  int modifiers = key->modifiers;

 
 

-  /* Dont mention suppressed commands.  */
+  /* Don't mention suppressed commands.  */

   if (SYMBOLP (binding)
       && !NILP (closure->partial)
       && !NILP (Fget (binding, closure->partial, Qnil)))
   if (SYMBOLP (binding)
       && !NILP (closure->partial)
       && !NILP (Fget (binding, closure->partial, Qnil)))

@@ -4008,7 +4006,7 @@ describe_map_sort_predicate (Lisp_Object obj1, Lisp_Object obj2,
      ( ( <keysym> . <modifiers> ) . <binding> )
      keysym and modifiers are used, binding is ignored.
    */
      ( ( <keysym> . <modifiers> ) . <binding> )
      keysym and modifiers are used, binding is ignored.
    */

-  unsigned int bit1, bit2;
+  int bit1, bit2;

   obj1 = XCAR (obj1);
   obj2 = XCAR (obj2);
   bit1 = XINT (XCDR (obj1));
   obj1 = XCAR (obj1);
   obj2 = XCAR (obj2);
   bit1 = XINT (XCDR (obj1));

@@ -4128,22 +4126,28 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
        {
           Lisp_Object elt = XCAR (XCAR (list));
          Lisp_Object keysym = XCAR (elt);
        {
           Lisp_Object elt = XCAR (XCAR (list));
          Lisp_Object keysym = XCAR (elt);

-         unsigned int modifiers = XINT (XCDR (elt));
+         int modifiers = XINT (XCDR (elt));

 
          if (!NILP (elt_prefix))
            buffer_insert_lisp_string (buf, elt_prefix);
 
 
          if (!NILP (elt_prefix))
            buffer_insert_lisp_string (buf, elt_prefix);
 

-         if (modifiers & MOD_META)    buffer_insert_c_string (buf, "M-");
-         if (modifiers & MOD_CONTROL) buffer_insert_c_string (buf, "C-");
-         if (modifiers & MOD_SUPER)   buffer_insert_c_string (buf, "S-");
-         if (modifiers & MOD_HYPER)   buffer_insert_c_string (buf, "H-");
-         if (modifiers & MOD_ALT)     buffer_insert_c_string (buf, "Alt-");
-         if (modifiers & MOD_SHIFT)   buffer_insert_c_string (buf, "Sh-");
+         if (modifiers & XEMACS_MOD_META)
+           buffer_insert_c_string (buf, "M-");
+         if (modifiers & XEMACS_MOD_CONTROL)
+           buffer_insert_c_string (buf, "C-");
+         if (modifiers & XEMACS_MOD_SUPER)
+           buffer_insert_c_string (buf, "S-");
+         if (modifiers & XEMACS_MOD_HYPER)
+           buffer_insert_c_string (buf, "H-");
+         if (modifiers & XEMACS_MOD_ALT)
+           buffer_insert_c_string (buf, "Alt-");
+         if (modifiers & XEMACS_MOD_SHIFT)
+           buffer_insert_c_string (buf, "Sh-");

          if (SYMBOLP (keysym))
            {
              Lisp_Object code = Fget (keysym, Vcharacter_set_property, Qnil);
              Emchar c = (CHAR_OR_CHAR_INTP (code)
          if (SYMBOLP (keysym))
            {
              Lisp_Object code = Fget (keysym, Vcharacter_set_property, Qnil);
              Emchar c = (CHAR_OR_CHAR_INTP (code)

-                         ? XCHAR_OR_CHAR_INT (code) : -1);
+                         ? XCHAR_OR_CHAR_INT (code) : (Emchar) -1);

              /* Calling Fsingle_key_description() would cons more */
 #if 0                           /* This is bogus */
              if (EQ (keysym, QKlinefeed))
              /* Calling Fsingle_key_description() would cons more */
 #if 0                           /* This is bogus */
              if (EQ (keysym, QKlinefeed))

@@ -4205,6 +4209,8 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
 void
 syms_of_keymap (void)
 {
 void
 syms_of_keymap (void)
 {

+  INIT_LRECORD_IMPLEMENTATION (keymap);
+

   defsymbol (&Qminor_mode_map_alist, "minor-mode-map-alist");
 
   defsymbol (&Qkeymapp, "keymapp");
   defsymbol (&Qminor_mode_map_alist, "minor-mode-map-alist");
 
   defsymbol (&Qkeymapp, "keymapp");

@@ -4286,6 +4292,7 @@ syms_of_keymap (void)
   defsymbol (&QRET, "RET");
   defsymbol (&QESC, "ESC");
   defsymbol (&QDEL, "DEL");
   defsymbol (&QRET, "RET");
   defsymbol (&QESC, "ESC");
   defsymbol (&QDEL, "DEL");

+  defsymbol (&QSPC, "SPC");

   defsymbol (&QBS, "BS");
 }
 
   defsymbol (&QBS, "BS");
 }
 

@@ -4325,10 +4332,12 @@ Keymap of key translations that can override keymaps.
 This keymap works like `function-key-map', but comes after that,
 and applies even for keys that have ordinary bindings.
 */ );
 This keymap works like `function-key-map', but comes after that,
 and applies even for keys that have ordinary bindings.
 */ );

+  Vkey_translation_map = Qnil;

 
   DEFVAR_LISP ("vertical-divider-map", &Vvertical_divider_map /*
 Keymap which handles mouse clicks over vertical dividers.
 */ );
 
   DEFVAR_LISP ("vertical-divider-map", &Vvertical_divider_map /*
 Keymap which handles mouse clicks over vertical dividers.
 */ );

+  Vvertical_divider_map = Qnil;

 
   DEFVAR_INT ("keymap-tick", &keymap_tick /*
 Incremented for each change to any keymap.
 
   DEFVAR_INT ("keymap-tick", &keymap_tick /*
 Incremented for each change to any keymap.

@@ -4337,7 +4346,7 @@ Incremented for each change to any keymap.
 
   staticpro (&Vcurrent_global_map);
 
 
   staticpro (&Vcurrent_global_map);
 

-  Vsingle_space_string = make_pure_string ((CONST Bufbyte *) " ", 1, Qnil, 1);
+  Vsingle_space_string = make_string ((const Bufbyte *) " ", 1);

   staticpro (&Vsingle_space_string);
 }
 
   staticpro (&Vsingle_space_string);
 }
 

@@ -4353,7 +4362,7 @@ complex_vars_of_keymap (void)
   meta_disgustitute = Fmake_keymap (Qnil);
   Ffset (ESC_prefix, meta_disgustitute);
   /* no need to protect meta_disgustitute, though */
   meta_disgustitute = Fmake_keymap (Qnil);
   Ffset (ESC_prefix, meta_disgustitute);
   /* no need to protect meta_disgustitute, though */

-  keymap_store_internal (MAKE_MODIFIER_HASH_KEY (MOD_META),
+  keymap_store_internal (MAKE_MODIFIER_HASH_KEY (XEMACS_MOD_META),

                          XKEYMAP (Vcurrent_global_map),
                          meta_disgustitute);
   XKEYMAP (Vcurrent_global_map)->sub_maps_cache = Qt;
                          XKEYMAP (Vcurrent_global_map),
                          meta_disgustitute);
   XKEYMAP (Vcurrent_global_map)->sub_maps_cache = Qt;