projects / chise / xemacs-chise.git.1 / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
XEmacs 21.2.27 "Hera".
[chise/xemacs-chise.git.1] / src / keymap.c
diff --git a/src/keymap.c b/src/keymap.c
index e2a5152..2fd38ef 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"
@@ -157,7 +156,7 @@ Boston, MA 02111-1307, USA.  */
 
  */
 
 
  */
 
-struct keymap
+typedef struct Lisp_Keymap
 {
   struct lcrecord_header header;
   Lisp_Object parents;         /* Keymaps to be searched after this one
 {
   struct lcrecord_header header;
   Lisp_Object parents;         /* Keymaps to be searched after this one
@@ -183,12 +182,7 @@ struct keymap
                                   This should be the same as the fullness
                                   of the `table', but hash.c is broken. */
   Lisp_Object name;             /* Just for debugging convenience */
                                   This should be the same as the fullness
                                   of the `table', but hash.c is broken. */
   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)
+} Lisp_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)
@@ -258,15 +252,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,7 +268,7 @@ 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];
   int size = XINT (Fkeymap_fullness (obj));
   if (print_readably)
   char buf[200];
   int size = XINT (Fkeymap_fullness (obj));
   if (print_readably)
@@ -284,17 +278,24 @@ print_keymap (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
     print_internal (keymap->name, printcharfun, 1);
   /* #### Yuck!  This is no way to form plural!  --hniksic */
   sprintf (buf, "%s%d entr%s 0x%x>",
     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)) ? "" : " "),
+           (NILP (keymap->name) ? "" : " "),
            size,
            ((size == 1) ? "y" : "ies"),
            keymap->header.uid);
   write_c_string (buf, printcharfun);
 }
 
            size,
            ((size == 1) ? "y" : "ies"),
            keymap->header.uid);
   write_c_string (buf, printcharfun);
 }
 
+static const struct lrecord_description keymap_description[] = {
+  { XD_LISP_OBJECT, offsetof(Lisp_Keymap, parents), 6 },
+  { XD_LISP_OBJECT, offsetof(Lisp_Keymap, name), 1 },
+  { 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                  */
@@ -475,7 +476,7 @@ static Lisp_Object
 keymap_lookup_directly (Lisp_Object keymap,
                         Lisp_Object keysym, unsigned int modifiers)
 {
 keymap_lookup_directly (Lisp_Object keymap,
                         Lisp_Object keysym, unsigned int modifiers)
 {
-  struct keymap *k;
+  Lisp_Keymap *k;
 
   if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
                      | MOD_ALT | MOD_SHIFT)) != 0)
 
   if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
                      | MOD_ALT | MOD_SHIFT)) != 0)
@@ -534,7 +535,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
@@ -584,7 +585,7 @@ keymap_delete_inverse_internal (Lisp_Object inverse_table,
 
 
 static void
 
 
 static void
-keymap_store_internal (Lisp_Object keysym, struct keymap *keymap,
+keymap_store_internal (Lisp_Object keysym, Lisp_Keymap *keymap,
                       Lisp_Object value)
 {
   Lisp_Object prev_value = Fgethash (keysym, keymap->table, Qnil);
                       Lisp_Object value)
 {
   Lisp_Object prev_value = Fgethash (keysym, keymap->table, Qnil);
@@ -613,7 +614,7 @@ keymap_store_internal (Lisp_Object keysym, struct keymap *keymap,
 
 
 static Lisp_Object
 
 
 static Lisp_Object
-create_bucky_submap (struct keymap *k, unsigned int modifiers,
+create_bucky_submap (Lisp_Keymap *k, unsigned 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);
@@ -634,7 +635,7 @@ keymap_store (Lisp_Object keymap, CONST struct key_data *key,
 {
   Lisp_Object keysym = key->keysym;
   unsigned int modifiers = key->modifiers;
 {
   Lisp_Object keysym = key->keysym;
   unsigned int modifiers = key->modifiers;
-  struct keymap *k;
+  Lisp_Keymap *k;
 
   if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
                      | MOD_ALT | MOD_SHIFT)) != 0)
 
   if ((modifiers & ~(MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER
                      | MOD_ALT | MOD_SHIFT)) != 0)
@@ -683,32 +684,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 +715,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 +746,31 @@ 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->fullness        = 0;
+  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;
 }
 
@@ -1114,38 +1113,35 @@ 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->fullness       = keymap->fullness;
   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 +1155,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;
 }
 
@@ -1284,12 +1276,12 @@ define_key_check_and_coerce_keysym (Lisp_Object spec,
       /* #### This bites!  I want to be able to write (control shift a) */
       if (modifiers & MOD_SHIFT)
        signal_simple_error
       /* #### This bites!  I want to be able to write (control shift a) */
       if (modifiers & MOD_SHIFT)
        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",
+      signal_simple_error ("Unknown keysym specifier",
                           *keysym);
     }
 
                           *keysym);
     }
 
@@ -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 */
@@ -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;
@@ -1621,6 +1615,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
@@ -1636,9 +1636,6 @@ define_key_alternate_name (struct key_data *key,
   unsigned int modifiers_sans_meta = (modifiers & (~MOD_META));
   returned_value->keysym = Qnil; /* By default, no "alternate" key */
   returned_value->modifiers = 0;
   unsigned int modifiers_sans_meta = (modifiers & (~MOD_META));
   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 EQ (keysym, QKspace)
   if (modifiers_sans_meta == MOD_CONTROL)
     {
       if EQ (keysym, QKspace)
@@ -1970,7 +1967,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) &&
@@ -2057,7 +2054,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)
@@ -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.
  */
 
@@ -2751,26 +2747,22 @@ struct map_keymap_unsorted_closure
 
 /* 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;
   unsigned int modifiers = closure->modifiers;
   unsigned int mod_bit;
   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);
   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;
 }
 
@@ -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);
@@ -3187,9 +3176,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;
@@ -3269,7 +3258,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);
            }
        }
@@ -3546,7 +3535,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;
@@ -3752,7 +3741,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').
@@ -3936,7 +3925,7 @@ describe_map_mapper (CONST struct key_data *key,
   Lisp_Object keysym = key->keysym;
   unsigned int modifiers = key->modifiers;
 
   Lisp_Object keysym = key->keysym;
   unsigned 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)))
@@ -4143,7 +4132,7 @@ describe_map (Lisp_Object keymap, Lisp_Object elt_prefix,
            {
              Lisp_Object code = Fget (keysym, Vcharacter_set_property, Qnil);
              Emchar c = (CHAR_OR_CHAR_INTP (code)
            {
              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))
@@ -4286,6 +4275,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");
 }
 
@@ -4339,7 +4329,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);
 }