--- rxvt-unicode/src/keyboard.C	2005/02/12 18:55:04	1.12
+++ rxvt-unicode/src/keyboard.C	2005/11/28 19:35:04	1.17
@@ -8,6 +8,38 @@
 #include "keyboard.h"
 #include "command.h"
 
+/* an intro to the data structure:
+ *
+ * vector keymap[] is grouped.
+ *
+ * inside each group, elements are sorted by the criteria given by compare_priority().
+ * the lookup of keysym is done in two steps:
+ * 1) locate the group corresponds to the keysym;
+ * 2) do a linear search inside the group.
+ *
+ * array hash[] effectively defines a map from a keysym to a group in keymap[].
+ *
+ * each group has its address(the index of first group element in keymap[]),
+ * which is computed and stored in hash[].
+ * hash[] stores the addresses in the form of:
+ * index: 0      I1       I2       I3            In
+ * value: 0...0, A1...A1, A2...A2, A3...A3, ..., An...An
+ * where
+ * A1 = 0;
+ * Ai+1 = N1 + N2 + ... + Ni.
+ * it is computed from hash_budget_size[]:
+ * index: 0      I1         I2         I3             In
+ * value: 0...0, N1, 0...0, N2, 0...0, N3,    ...,    Nn, 0...0
+ *        0...0, 0.......0, N1.....N1, N1+N2...N1+N2, ... (the compution of hash[])
+ * or we can say
+ * hash_budget_size[Ii] = Ni; hash_budget_size[elsewhere] = 0,
+ * where
+ * set {I1, I2, ..., In} = { hashkey of keymap[0]->keysym, ..., keymap[keymap.size-1]->keysym }
+ * where hashkey of keymap[i]->keysym = keymap[i]->keysym & KEYSYM_HASH_MASK
+ *       n(the number of groups) = the number of non-zero member of hash_budget_size[];
+ *       Ni(the size of group i) = hash_budget_size[Ii].
+ */
+
 #if STOCK_KEYMAP
 ////////////////////////////////////////////////////////////////////////////////
 // default keycode translation map and keyevent handlers
@@ -85,7 +117,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 // return: #bits of '1'
 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3)
-# define bitcount(n) (__extension__ ({ uint32_t n__ = (n); __builtin_popcount (n); }))
+# define bitcount(n) (__extension__ ({ uint32_t n__ = (n); __builtin_popcount (n__); }))
 #else
 static int
 bitcount (uint16_t n)
@@ -185,6 +217,8 @@
           else
             rxvt_warn ("cannot parse list-type keysym '%s', treating as normal keysym.\n", translation);
         }
+      else if (strncmp (translation, "builtin:", 8) == 0)
+        key->type = keysym_t::BUILTIN;
 
       user_keymap.push_back (key);
       user_translations.push_back (translation);
@@ -230,6 +264,8 @@
 {
   assert (hash[0] == 0 && "register_done() need to be called");
 
+  state &= OtherModMask; // mask out uninteresting modifiers
+
   if (state & term->ModMetaMask)    state |= MetaMask;
   if (state & term->ModNumLockMask) state |= NumLockMask;
   if (state & term->ModLevel3Mask)  state |= Level3Mask;
@@ -243,64 +279,67 @@
     {
       const keysym_t &key = *keymap [index];
 
-      int keysym_offset = keysym - key.keysym;
-
-      wchar_t *wc = rxvt_utf8towcs (key.str);
-      char *str = rxvt_wcstombs (wc);
-      // TODO: do (some) translations, unescaping etc, here (allow \u escape etc.)
-      free (wc);
-
-      switch (key.type)
+      if (key.type != keysym_t::BUILTIN)
         {
-         case keysym_t::NORMAL:
-            output_string (term, str);
-            break;
+          int keysym_offset = keysym - key.keysym;
 
-          case keysym_t::RANGE:
-            {
-              char buf[STRING_MAX];
+          wchar_t *wc = rxvt_utf8towcs (key.str);
+          char *str = rxvt_wcstombs (wc);
+          // TODO: do (some) translations, unescaping etc, here (allow \u escape etc.)
+          free (wc);
 
-              if (format_keyrange_string (str, keysym_offset, buf, sizeof (buf)) > 0)
-                output_string (term, buf);
-            }
-            break;
-
-          case keysym_t::RANGE_META8:
+          switch (key.type)
             {
-              int len;
-              char buf[STRING_MAX];
-
-              len = format_keyrange_string (str, keysym_offset, buf, sizeof (buf));
-              if (len > 0)
-                output_string_meta8 (term, state, buf, len);
+              case keysym_t::NORMAL:
+                output_string (term, str);
+                break;
+
+              case keysym_t::RANGE:
+                {
+                  char buf[STRING_MAX];
+
+                  if (format_keyrange_string (str, keysym_offset, buf, sizeof (buf)) > 0)
+                    output_string (term, buf);
+                }
+                break;
+
+              case keysym_t::RANGE_META8:
+                {
+                  int len;
+                  char buf[STRING_MAX];
+
+                  len = format_keyrange_string (str, keysym_offset, buf, sizeof (buf));
+                  if (len > 0)
+                    output_string_meta8 (term, state, buf, len);
+                }
+                break;
+
+              case keysym_t::LIST:
+                {
+                  char buf[STRING_MAX];
+
+                  char *prefix, *middle, *suffix;
+
+                  prefix = str;
+                  middle = strchr  (prefix + 1, *prefix);
+                  suffix = strrchr (middle + 1, *prefix);
+
+                  memcpy (buf, prefix + 1, middle - prefix - 1);
+                  buf [middle - prefix - 1] = middle [keysym_offset + 1];
+                  strcpy (buf + (middle - prefix), suffix + 1);
+
+                  output_string (term, buf);
+                }
+                break;
             }
-            break;
 
-          case keysym_t::LIST:
-            {
-              char buf[STRING_MAX];
+          free (str);
 
-              char *prefix, *middle, *suffix;
-
-              prefix = str;
-              middle = strchr  (prefix + 1, *prefix);
-              suffix = strrchr (middle + 1, *prefix);
-
-              memcpy (buf, prefix + 1, middle - prefix - 1);
-              buf [middle - prefix - 1] = middle [keysym_offset + 1];
-              strcpy (buf + (middle - prefix), suffix + 1);
-
-              output_string (term, buf);
-            }
-            break;
+          return true;
         }
-
-      free (str);
-
-      return true;
     }
-  else
-    return false;
+
+  return false;
 }
 
 // purge duplicate keymap entries