--- rxvt-unicode/src/keyboard.C	2005/01/16 23:55:42	1.7
+++ rxvt-unicode/src/keyboard.C	2005/02/03 10:24:10	1.10
@@ -13,35 +13,33 @@
 
 keysym_t keyboard_manager::stock_keymap[] = {
   /* examples */
-  /*        keysym,                state, range,        handler,             str */
-//{XK_ISO_Left_Tab,                    0,     1,         NORMAL,           "\033[Z"},
-//{            'a',                    0,    26,    RANGE_META8,           "a" "%c"},
-//{            'a',          ControlMask,    26,    RANGE_META8,          "
" "%c"},
-//{        XK_Left,                    0,     4,           LIST,   "DACBZ" "\033[Z"},
-//{        XK_Left,            ShiftMask,     4,           LIST,   "dacbZ" "\033[Z"},
-//{        XK_Left,          ControlMask,     4,           LIST,   "dacbZ" "\033OZ"},
-//{         XK_Tab,          ControlMask,     1,         NORMAL,      "\033<C-Tab>"},
-//{  XK_apostrophe,          ControlMask,     1,         NORMAL,        "\033<C-'>"},
-//{       XK_slash,          ControlMask,     1,         NORMAL,        "\033<C-/>"},
-//{   XK_semicolon,          ControlMask,     1,         NORMAL,        "\033<C-;>"},
-//{       XK_grave,          ControlMask,     1,         NORMAL,        "\033<C-`>"},
-//{       XK_comma,          ControlMask,     1,         NORMAL,     "\033<C-\054>"},
-//{      XK_Return,          ControlMask,     1,         NORMAL,    "\033<C-Return>"},
-//{      XK_Return,            ShiftMask,     1,         NORMAL,    "\033<S-Return>"},
-//{            ' ',            ShiftMask,     1,         NORMAL,    "\033<S-Space>"},
-//{            '.',          ControlMask,     1,         NORMAL,        "\033<C-.>"},
-//{            '0',          ControlMask,    10,          RANGE,   "0" "\033<C-%c>"},
-//{            '0', MetaMask|ControlMask,    10,          RANGE, "0" "\033<M-C-%c>"},
-//{            'a', MetaMask|ControlMask,    26,          RANGE, "a" "\033<M-C-%c>"},
+  /*        keysym,                state, range,               handler,              str */
+//{XK_ISO_Left_Tab,                    0,     1,      keysym_t::NORMAL,           "\033[Z"},
+//{            'a',                    0,    26, keysym_t::RANGE_META8,           "a" "%c"},
+//{            'a',          ControlMask,    26, keysym_t::RANGE_META8,          "
" "%c"},
+//{        XK_Left,                    0,     4,        keysym_t::LIST,     ".\033[.DACB."},
+//{        XK_Left,            ShiftMask,     4,        keysym_t::LIST,     ".\033[.dacb."},
+//{        XK_Left,          ControlMask,     4,        keysym_t::LIST,     ".\033O.dacb."},
+//{         XK_Tab,          ControlMask,     1,      keysym_t::NORMAL,      "\033<C-Tab>"},
+//{  XK_apostrophe,          ControlMask,     1,      keysym_t::NORMAL,        "\033<C-'>"},
+//{       XK_slash,          ControlMask,     1,      keysym_t::NORMAL,        "\033<C-/>"},
+//{   XK_semicolon,          ControlMask,     1,      keysym_t::NORMAL,        "\033<C-;>"},
+//{       XK_grave,          ControlMask,     1,      keysym_t::NORMAL,        "\033<C-`>"},
+//{       XK_comma,          ControlMask,     1,      keysym_t::NORMAL,     "\033<C-\054>"},
+//{      XK_Return,          ControlMask,     1,      keysym_t::NORMAL,   "\033<C-Return>"},
+//{      XK_Return,            ShiftMask,     1,      keysym_t::NORMAL,   "\033<S-Return>"},
+//{            ' ',            ShiftMask,     1,      keysym_t::NORMAL,    "\033<S-Space>"},
+//{            '.',          ControlMask,     1,      keysym_t::NORMAL,        "\033<C-.>"},
+//{            '0',          ControlMask,    10,       keysym_t::RANGE,   "0" "\033<C-%c>"},
+//{            '0', MetaMask|ControlMask,    10,       keysym_t::RANGE, "0" "\033<M-C-%c>"},
+//{            'a', MetaMask|ControlMask,    26,       keysym_t::RANGE, "a" "\033<M-C-%c>"},
 };
 
 static void
 output_string (rxvt_term *rt, const char *str)
 {
-  assert (rt && str);
-
-  if (strncmp (str, "proto:", 6) == 0)
-    rt->cmd_write ((unsigned char *)str + 6, strlen (str) - 6);
+  if (strncmp (str, "command:", 8) == 0)
+    rt->cmd_write ((unsigned char *)str + 8, strlen (str) - 8);
   else
     rt->tt_write ((unsigned char *)str, strlen (str));
 }
@@ -103,8 +101,6 @@
 static int
 compare_priority (keysym_t *a, keysym_t *b)
 {
-  assert (a && b);
-
   // (the more '1's in state; the less range): the greater priority
   int ca = bitcount (a->state /* & OtherModMask */);
   int cb = bitcount (b->state /* & OtherModMask */);
@@ -159,11 +155,8 @@
 void
 keyboard_manager::register_user_translation (KeySym keysym, unsigned int state, const char *trans)
 {
-  assert (trans);
-
   keysym_t *key = new keysym_t;
   wchar_t *wc = rxvt_mbstowcs (trans);
-printf ("CONV <%s> %x %x %x %x\n", trans, (int)wc[0], (int)wc[1], (int)wc[2], (int)wc[3]);
   const char *translation = rxvt_wcstoutf8 (wc);
   free (wc);
 
@@ -206,9 +199,6 @@
 void
 keyboard_manager::register_keymap (keysym_t *key)
 {
-  assert (key);
-  assert (key->range >= 1);
-
   if (keymap.size () == keymap.capacity ())
     keymap.reserve (keymap.size () * 2);
 
@@ -349,13 +339,12 @@
   // count keysyms for corresponding hash budgets
   for (i = 0; i < keymap.size (); ++i)
     {
-      assert (keymap [i]);
-      hashkey = (keymap [i]->keysym & KEYSYM_HASH_MASK);
+      hashkey = keymap [i]->keysym & KEYSYM_HASH_MASK;
       ++hash_budget_size [hashkey];
     }
 
-  // keysym A with range>1 is counted one more time for
-  // every keysym B lies in its range
+  // a keysym_t with range>1 is counted one more time for every keysym that
+  // lies in its range
   for (i = 0; i < keymap.size (); ++i)
     {
       if (keymap[i]->range > 1)
@@ -379,7 +368,6 @@
     }
 
   // and allocate just enough space
-  //sorted_keymap.reserve (hash[i - 1] + hash_budget_size[i - 1]);
   sorted_keymap.insert (sorted_keymap.begin (), index + hash_budget_size [i - 1], 0);
 
   // fill in sorted_keymap
@@ -436,7 +424,7 @@
           assert (index >= 0);
           keysym_t *b = keymap [index];
           assert (i == (signed) index ||	// the normally expected result
-            (a->keysym + j) >= b->keysym && (a->keysym + j) <= (b->keysym + b->range) && compare_priority (a, b) <= 0);	// is effectively the same
+            (a->keysym + j) >= b->keysym && (a->keysym + j) <= (b->keysym + b->range) && compare_priority (a, b) <= 0);	// is effectively the same or a closer match
         }
     }
 #endif
@@ -451,13 +439,12 @@
   for (; index < keymap.size (); ++index)
     {
       keysym_t *key = keymap [index];
-      assert (key);
 
       if (key->keysym <= keysym && key->keysym + key->range > keysym
           // match only the specified bits in state and ignore others
           && (key->state & state) == key->state)
         return index;
-      else if (key->keysym > keysym && key->range == 1)
+      else if ((key->keysym & KEYSYM_HASH_MASK) > hashkey && key->range == 1)
         return -1;
     }