From 0bbaef6e48c7a22b59e2c70304f6ccbf17324412 Mon Sep 17 00:00:00 2001
From: Maxime Coste <frrrwww@gmail.com>
Date: Sun, 8 Mar 2015 11:40:50 +0000
Subject: [PATCH] Use a sorted array for keymap rather than an unordered map

with ~100 entry, a binary search finds in < 7 step, unordered map
is overkill.
---
 src/input_handler.cc |  10 +-
 src/main.cc          |   4 +
 src/normal.cc        | 256 +++++++++++++++++++++----------------------
 src/normal.hh        |   5 +-
 4 files changed, 141 insertions(+), 134 deletions(-)

diff --git a/src/input_handler.cc b/src/input_handler.cc
index 6edc61b5..2f67953b 100644
--- a/src/input_handler.cc
+++ b/src/input_handler.cc
@@ -127,13 +127,15 @@ public:
         {
             if (m_hooks_disabled)
                 do_restore_hooks = true;
-            auto it = keymap.find(key);
-            if (it != keymap.end())
+            auto it = std::lower_bound(keymap.begin(), keymap.end(), key,
+                                       [](const NormalCmdDesc& lhs, const Key& rhs)
+                                       { return lhs.key < rhs; });
+            if (it != keymap.end() and it->key == key)
             {
                 if (context().options()["autoinfo"].get<int>() >= 2 and context().has_ui())
-                    context().ui().info_show(key_to_str(key), it->second.docstring, CharCoord{},
+                    context().ui().info_show(key_to_str(key), it->docstring, CharCoord{},
                                              get_face("Information"), InfoStyle::Prompt);
-                it->second.func(context(), m_params);
+                it->func(context(), m_params);
             }
             m_params = { 0, '"' };
         }
diff --git a/src/main.cc b/src/main.cc
index 7f83f802..aa195d0c 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -528,6 +528,10 @@ int main(int argc, char* argv[])
     };
     try
     {
+        std::sort(keymap.begin(), keymap.end(),
+                  [](const NormalCmdDesc& lhs, const NormalCmdDesc& rhs)
+                  { return lhs.key < rhs.key; });
+
         ParametersParser parser(params, param_desc);
 
         if (parser.has_option("p"))
diff --git a/src/normal.cc b/src/normal.cc
index 2cf066d0..a1d0f55d 100644
--- a/src/normal.cc
+++ b/src/normal.cc
@@ -1350,169 +1350,169 @@ void move(Context& context, NormalParams params)
     selections.sort_and_merge_overlapping();
 }
 
-const KeyMap keymap =
+KeyMap keymap =
 {
-    { 'h', { "move left", move<CharCount, Backward> } },
-    { 'j', { "move down", move<LineCount, Forward> } },
-    { 'k', { "move up",  move<LineCount, Backward> } },
-    { 'l', { "move right", move<CharCount, Forward> } },
+    { 'h', "move left", move<CharCount, Backward> },
+    { 'j', "move down", move<LineCount, Forward> },
+    { 'k', "move up",  move<LineCount, Backward> },
+    { 'l', "move right", move<CharCount, Forward> },
 
-    { 'H', { "extend left", move<CharCount, Backward, SelectMode::Extend> } },
-    { 'J', { "extend down", move<LineCount, Forward, SelectMode::Extend> } },
-    { 'K', { "extend up", move<LineCount, Backward, SelectMode::Extend> } },
-    { 'L', { "extend right", move<CharCount, Forward, SelectMode::Extend> } },
+    { 'H', "extend left", move<CharCount, Backward, SelectMode::Extend> },
+    { 'J', "extend down", move<LineCount, Forward, SelectMode::Extend> },
+    { 'K', "extend up", move<LineCount, Backward, SelectMode::Extend> },
+    { 'L', "extend right", move<CharCount, Forward, SelectMode::Extend> },
 
-    { 't', { "select to next character", select_to_next_char<SelectFlags::None> } },
-    { 'f', { "select to next character included", select_to_next_char<SelectFlags::Inclusive> } },
-    { 'T', { "extend to next character", select_to_next_char<SelectFlags::Extend> } },
-    { 'F', { "extend to next character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Extend> } },
-    { alt('t'), { "select to previous character", select_to_next_char<SelectFlags::Reverse> } },
-    { alt('f'), { "select to previous character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Reverse> } },
-    { alt('T'), { "extend to previous character", select_to_next_char<SelectFlags::Extend | SelectFlags::Reverse> } },
-    { alt('F'), { "extend to previous character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Extend | SelectFlags::Reverse> } },
+    { 't', "select to next character", select_to_next_char<SelectFlags::None> },
+    { 'f', "select to next character included", select_to_next_char<SelectFlags::Inclusive> },
+    { 'T', "extend to next character", select_to_next_char<SelectFlags::Extend> },
+    { 'F', "extend to next character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Extend> },
+    { alt('t'), "select to previous character", select_to_next_char<SelectFlags::Reverse> },
+    { alt('f'), "select to previous character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Reverse> },
+    { alt('T'), "extend to previous character", select_to_next_char<SelectFlags::Extend | SelectFlags::Reverse> },
+    { alt('F'), "extend to previous character included", select_to_next_char<SelectFlags::Inclusive | SelectFlags::Extend | SelectFlags::Reverse> },
 
-    { 'd', { "erase selected text", erase_selections } },
-    { 'c', { "change selected text", change } },
-    { 'i', { "insert before selected text", enter_insert_mode<InsertMode::Insert> } },
-    { 'I', { "insert at line begin", enter_insert_mode<InsertMode::InsertAtLineBegin> } },
-    { 'a', { "insert after selected text", enter_insert_mode<InsertMode::Append> } },
-    { 'A', { "insert at line end", enter_insert_mode<InsertMode::AppendAtLineEnd> } },
-    { 'o', { "insert on new line below", enter_insert_mode<InsertMode::OpenLineBelow> } },
-    { 'O', { "insert on new line above", enter_insert_mode<InsertMode::OpenLineAbove> } },
-    { 'r', { "replace with character", replace_with_char } },
+    { 'd', "erase selected text", erase_selections },
+    { 'c', "change selected text", change },
+    { 'i', "insert before selected text", enter_insert_mode<InsertMode::Insert> },
+    { 'I', "insert at line begin", enter_insert_mode<InsertMode::InsertAtLineBegin> },
+    { 'a', "insert after selected text", enter_insert_mode<InsertMode::Append> },
+    { 'A', "insert at line end", enter_insert_mode<InsertMode::AppendAtLineEnd> },
+    { 'o', "insert on new line below", enter_insert_mode<InsertMode::OpenLineBelow> },
+    { 'O', "insert on new line above", enter_insert_mode<InsertMode::OpenLineAbove> },
+    { 'r', "replace with character", replace_with_char },
 
-    { 'g', { "go to location", goto_commands<SelectMode::Replace> } },
-    { 'G', { "extend to location", goto_commands<SelectMode::Extend> } },
+    { 'g', "go to location", goto_commands<SelectMode::Replace> },
+    { 'G', "extend to location", goto_commands<SelectMode::Extend> },
 
-    { 'v', { "move view", view_commands } },
+    { 'v', "move view", view_commands },
 
-    { 'y', { "yank selected text", yank } },
-    { 'p', { "paste after selected text", repeated<paste<InsertMode::Append>> } },
-    { 'P', { "paste before selected text", repeated<paste<InsertMode::Insert>> } },
-    { alt('p'), { "paste every yanked selection after selected text", paste_all<InsertMode::Append> } },
-    { alt('P'), { "paste every yanked selection before selected text", paste_all<InsertMode::Insert> } },
-    { 'R', { "replace selected text with yanked text", paste<InsertMode::Replace> } },
+    { 'y', "yank selected text", yank },
+    { 'p', "paste after selected text", repeated<paste<InsertMode::Append>> },
+    { 'P', "paste before selected text", repeated<paste<InsertMode::Insert>> },
+    { alt('p'), "paste every yanked selection after selected text", paste_all<InsertMode::Append> },
+    { alt('P'), "paste every yanked selection before selected text", paste_all<InsertMode::Insert> },
+    { 'R', "replace selected text with yanked text", paste<InsertMode::Replace> },
 
-    { 's', { "select regex matches in selected text", select_regex } },
-    { 'S', { "split selected text on regex matches", split_regex } },
-    { alt('s'), { "split selected text on line ends", split_lines } },
+    { 's', "select regex matches in selected text", select_regex },
+    { 'S', "split selected text on regex matches", split_regex },
+    { alt('s'), "split selected text on line ends", split_lines },
 
-    { '.', { "repeat last insert command", repeat_last_insert } },
+    { '.', "repeat last insert command", repeat_last_insert },
 
-    { '%', { "select whole buffer", [](Context& context, NormalParams) { select_buffer(context.selections()); } } },
+    { '%', "select whole buffer", [](Context& context, NormalParams) { select_buffer(context.selections()); } },
 
-    { ':', { "enter command prompt", command } },
-    { '|', { "pipe each selection through filter and replace with output", pipe<true> } },
-    { alt('|'), { "pipe each selection through command and ignore output", pipe<false> } },
-    { '!', { "insert command output", insert_output<InsertMode::Insert> } },
-    { alt('!'), { "append command output", insert_output<InsertMode::Append> } },
+    { ':', "enter command prompt", command },
+    { '|', "pipe each selection through filter and replace with output", pipe<true> },
+    { alt('|'), "pipe each selection through command and ignore output", pipe<false> },
+    { '!', "insert command output", insert_output<InsertMode::Insert> },
+    { alt('!'), "append command output", insert_output<InsertMode::Append> },
 
-    { ' ', { "remove all selection except main", [](Context& context, NormalParams p) { keep_selection(context.selections(), p.count ? p.count-1 : context.selections().main_index()); } } },
-    { alt(' '), { "remove main selection", [](Context& context, NormalParams p) { remove_selection(context.selections(), p.count ? p.count-1 : context.selections().main_index()); } } },
-    { ';', { "reduce selections to their cursor", [](Context& context, NormalParams) { clear_selections(context.selections()); } } },
-    { alt(';'), { "swap selections cursor and anchor", [](Context& context, NormalParams) { flip_selections(context.selections()); } } },
+    { ' ', "remove all selection except main", [](Context& context, NormalParams p) { keep_selection(context.selections(), p.count ? p.count-1 : context.selections().main_index()); } },
+    { alt(' '), "remove main selection", [](Context& context, NormalParams p) { remove_selection(context.selections(), p.count ? p.count-1 : context.selections().main_index()); } },
+    { ';', "reduce selections to their cursor", [](Context& context, NormalParams) { clear_selections(context.selections()); } },
+    { alt(';'), "swap selections cursor and anchor", [](Context& context, NormalParams) { flip_selections(context.selections()); } },
 
-    { 'w', { "select to next word start", repeated<&select<SelectMode::Replace, select_to_next_word<Word>>> } },
-    { 'e', { "select to next word end", repeated<select<SelectMode::Replace, select_to_next_word_end<Word>>> } },
-    { 'b', { "select to prevous word start", repeated<select<SelectMode::Replace, select_to_previous_word<Word>>> } },
-    { 'W', { "extend to next word start", repeated<select<SelectMode::Extend, select_to_next_word<Word>>> } },
-    { 'E', { "extend to next word end", repeated<select<SelectMode::Extend, select_to_next_word_end<Word>>> } },
-    { 'B', { "extend to prevous word start", repeated<select<SelectMode::Extend, select_to_previous_word<Word>>> } },
+    { 'w', "select to next word start", repeated<&select<SelectMode::Replace, select_to_next_word<Word>>> },
+    { 'e', "select to next word end", repeated<select<SelectMode::Replace, select_to_next_word_end<Word>>> },
+    { 'b', "select to prevous word start", repeated<select<SelectMode::Replace, select_to_previous_word<Word>>> },
+    { 'W', "extend to next word start", repeated<select<SelectMode::Extend, select_to_next_word<Word>>> },
+    { 'E', "extend to next word end", repeated<select<SelectMode::Extend, select_to_next_word_end<Word>>> },
+    { 'B', "extend to prevous word start", repeated<select<SelectMode::Extend, select_to_previous_word<Word>>> },
 
-    { alt('w'), { "select to next WORD start", repeated<select<SelectMode::Replace, select_to_next_word<WORD>>> } },
-    { alt('e'), { "select to next WORD end", repeated<select<SelectMode::Replace, select_to_next_word_end<WORD>>> } },
-    { alt('b'), { "select to prevous WORD start", repeated<select<SelectMode::Replace, select_to_previous_word<WORD>>> } },
-    { alt('W'), { "extend to next WORD start", repeated<select<SelectMode::Extend, select_to_next_word<WORD>>> } },
-    { alt('E'), { "extend to next WORD end", repeated<select<SelectMode::Extend, select_to_next_word_end<WORD>>> } },
-    { alt('B'), { "extend to prevous WORD start", repeated<select<SelectMode::Extend, select_to_previous_word<WORD>>> } },
+    { alt('w'), "select to next WORD start", repeated<select<SelectMode::Replace, select_to_next_word<WORD>>> },
+    { alt('e'), "select to next WORD end", repeated<select<SelectMode::Replace, select_to_next_word_end<WORD>>> },
+    { alt('b'), "select to prevous WORD start", repeated<select<SelectMode::Replace, select_to_previous_word<WORD>>> },
+    { alt('W'), "extend to next WORD start", repeated<select<SelectMode::Extend, select_to_next_word<WORD>>> },
+    { alt('E'), "extend to next WORD end", repeated<select<SelectMode::Extend, select_to_next_word_end<WORD>>> },
+    { alt('B'), "extend to prevous WORD start", repeated<select<SelectMode::Extend, select_to_previous_word<WORD>>> },
 
-    { alt('l'), { "select to line end", repeated<select<SelectMode::Replace, select_to_eol>> } },
-    { alt('L'), { "extend to line end", repeated<select<SelectMode::Extend, select_to_eol>> } },
-    { alt('h'), { "select to line begin", repeated<select<SelectMode::Replace, select_to_eol_reverse>> } },
-    { alt('H'), { "extend to line begin", repeated<select<SelectMode::Extend, select_to_eol_reverse>> } },
+    { alt('l'), "select to line end", repeated<select<SelectMode::Replace, select_to_eol>> },
+    { alt('L'), "extend to line end", repeated<select<SelectMode::Extend, select_to_eol>> },
+    { alt('h'), "select to line begin", repeated<select<SelectMode::Replace, select_to_eol_reverse>> },
+    { alt('H'), "extend to line begin", repeated<select<SelectMode::Extend, select_to_eol_reverse>> },
 
-    { 'x', { "select line", repeated<select<SelectMode::Replace, select_line>> } },
-    { 'X', { "extend line", repeated<select<SelectMode::Extend, select_line>> } },
-    { alt('x'), { "extend selections to whole lines", select<SelectMode::Replace, select_lines> } },
-    { alt('X'), { "crop selections to whole lines", select<SelectMode::Replace, trim_partial_lines> } },
+    { 'x', "select line", repeated<select<SelectMode::Replace, select_line>> },
+    { 'X', "extend line", repeated<select<SelectMode::Extend, select_line>> },
+    { alt('x'), "extend selections to whole lines", select<SelectMode::Replace, select_lines> },
+    { alt('X'), "crop selections to whole lines", select<SelectMode::Replace, trim_partial_lines> },
 
-    { 'm', { "select to matching character", select<SelectMode::Replace, select_matching> } },
-    { 'M', { "extend to matching character", select<SelectMode::Extend, select_matching> } },
+    { 'm', "select to matching character", select<SelectMode::Replace, select_matching> },
+    { 'M', "extend to matching character", select<SelectMode::Extend, select_matching> },
 
-    { '/', { "select next given regex match", search<SelectMode::Replace, Forward> } },
-    { '?', { "extend with next given regex match", search<SelectMode::Extend, Forward> } },
-    { alt('/'), { "select previous given regex match", search<SelectMode::Replace, Backward> } },
-    { alt('?'), { "extend with previous given regex match", search<SelectMode::Extend, Backward> } },
-    { 'n', { "select next current search pattern match", search_next<SelectMode::Replace, Forward> } },
-    { 'N', { "extend with next current search pattern match", search_next<SelectMode::Append, Forward> } },
-    { alt('n'), { "select previous current search pattern match", search_next<SelectMode::Replace, Backward> } },
-    { alt('N'), { "extend with previous current search pattern match", search_next<SelectMode::Append, Backward> } },
-    { '*', { "set search pattern to main selection content", use_selection_as_search_pattern<true> } },
-    { alt('*'), { "set search pattern to main selection content, do not detect words", use_selection_as_search_pattern<false> } },
+    { '/', "select next given regex match", search<SelectMode::Replace, Forward> },
+    { '?', "extend with next given regex match", search<SelectMode::Extend, Forward> },
+    { alt('/'), "select previous given regex match", search<SelectMode::Replace, Backward> },
+    { alt('?'), "extend with previous given regex match", search<SelectMode::Extend, Backward> },
+    { 'n', "select next current search pattern match", search_next<SelectMode::Replace, Forward> },
+    { 'N', "extend with next current search pattern match", search_next<SelectMode::Append, Forward> },
+    { alt('n'), "select previous current search pattern match", search_next<SelectMode::Replace, Backward> },
+    { alt('N'), "extend with previous current search pattern match", search_next<SelectMode::Append, Backward> },
+    { '*', "set search pattern to main selection content", use_selection_as_search_pattern<true> },
+    { alt('*'), "set search pattern to main selection content, do not detect words", use_selection_as_search_pattern<false> },
 
-    { 'u', { "undo", undo } },
-    { 'U', { "redo", redo } },
+    { 'u', "undo", undo },
+    { 'U', "redo", redo },
 
-    { alt('i'), { "select inner object", select_object<ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner> } },
-    { alt('a'), { "select whole object", select_object<ObjectFlags::ToBegin | ObjectFlags::ToEnd> } },
-    { '[', { "select to object start", select_object<ObjectFlags::ToBegin> } },
-    { ']', { "select to object end", select_object<ObjectFlags::ToEnd> } },
-    { '{', { "extend to object start", select_object<ObjectFlags::ToBegin, SelectMode::Extend> } },
-    { '}', { "extend to object end", select_object<ObjectFlags::ToEnd, SelectMode::Extend> } },
-    { alt('['), { "select to inner object start", select_object<ObjectFlags::ToBegin | ObjectFlags::Inner> } },
-    { alt(']'), { "select to inner object end", select_object<ObjectFlags::ToEnd | ObjectFlags::Inner> } },
-    { alt('{'), { "extend to inner object start", select_object<ObjectFlags::ToBegin | ObjectFlags::Inner, SelectMode::Extend> } },
-    { alt('}'), { "extend to inner object end", select_object<ObjectFlags::ToEnd | ObjectFlags::Inner, SelectMode::Extend> } },
+    { alt('i'), "select inner object", select_object<ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner> },
+    { alt('a'), "select whole object", select_object<ObjectFlags::ToBegin | ObjectFlags::ToEnd> },
+    { '[', "select to object start", select_object<ObjectFlags::ToBegin> },
+    { ']', "select to object end", select_object<ObjectFlags::ToEnd> },
+    { '{', "extend to object start", select_object<ObjectFlags::ToBegin, SelectMode::Extend> },
+    { '}', "extend to object end", select_object<ObjectFlags::ToEnd, SelectMode::Extend> },
+    { alt('['), "select to inner object start", select_object<ObjectFlags::ToBegin | ObjectFlags::Inner> },
+    { alt(']'), "select to inner object end", select_object<ObjectFlags::ToEnd | ObjectFlags::Inner> },
+    { alt('{'), "extend to inner object start", select_object<ObjectFlags::ToBegin | ObjectFlags::Inner, SelectMode::Extend> },
+    { alt('}'), "extend to inner object end", select_object<ObjectFlags::ToEnd | ObjectFlags::Inner, SelectMode::Extend> },
 
-    { alt('j'), { "join lines", join_lines } },
-    { alt('J'), { "join lines and select spaces", join_lines_select_spaces } },
+    { alt('j'), "join lines", join_lines },
+    { alt('J'), "join lines and select spaces", join_lines_select_spaces },
 
-    { alt('k'), { "keep selections matching given regex", keep<true> } },
-    { alt('K'), { "keep selections not matching given regex", keep<false> } },
-    { '$', { "pipe each selection through shell command and keep the ones whose command succeed", keep_pipe } },
+    { alt('k'), "keep selections matching given regex", keep<true> },
+    { alt('K'), "keep selections not matching given regex", keep<false> },
+    { '$', "pipe each selection through shell command and keep the ones whose command succeed", keep_pipe },
 
-    { '<', { "deindent", deindent<true> } },
-    { '>', { "indent", indent<false> } },
-    { alt('>'), { "indent, including empty lines", indent<true> } },
-    { alt('<'), { "deindent, not including incomplete indent", deindent<false> } },
+    { '<', "deindent", deindent<true> },
+    { '>', "indent", indent<false> },
+    { alt('>'), "indent, including empty lines", indent<true> },
+    { alt('<'), "deindent, not including incomplete indent", deindent<false> },
 
-    { ctrl('i'), { "jump forward in jump list",jump<Forward> } },
-    { ctrl('o'), { "jump backward in jump list", jump<Backward> } },
-    { ctrl('s'), { "push current selections in jump list", save_selections } },
+    { ctrl('i'), "jump forward in jump list",jump<Forward> },
+    { ctrl('o'), "jump backward in jump list", jump<Backward> },
+    { ctrl('s'), "push current selections in jump list", save_selections },
 
-    { alt('r'), { "rotate main selection", rotate_selections } },
-    { alt('R'), { "rotate selections content", rotate_selections_content } },
+    { alt('r'), "rotate main selection", rotate_selections },
+    { alt('R'), "rotate selections content", rotate_selections_content },
 
-    { 'q', { "replay recorded macro", replay_macro } },
-    { 'Q', { "start or end macro recording", start_or_end_macro_recording } },
+    { 'q', "replay recorded macro", replay_macro },
+    { 'Q', "start or end macro recording", start_or_end_macro_recording },
 
-    { Key::Escape, { "end macro recording", end_macro_recording } },
+    { Key::Escape, "end macro recording", end_macro_recording },
 
-    { '`', { "convert to lower case in selections", for_each_char<to_lower> } },
-    { '~', { "convert to upper case in selections", for_each_char<to_upper> } },
-    { alt('`'),  { "swap case in selections", for_each_char<swap_case> } },
+    { '`', "convert to lower case in selections", for_each_char<to_lower> },
+    { '~', "convert to upper case in selections", for_each_char<to_upper> },
+    { alt('`'),  "swap case in selections", for_each_char<swap_case> },
 
-    { '&', { "align selection cursors", align } },
-    { alt('&'), { "copy indentation", copy_indent } },
+    { '&', "align selection cursors", align },
+    { alt('&'), "copy indentation", copy_indent },
 
-    { '@', { "convert tabs to spaces in selections", tabs_to_spaces } },
-    { alt('@'), { "convert spaces to tabs in selections", spaces_to_tabs } },
+    { '@', "convert tabs to spaces in selections", tabs_to_spaces },
+    { alt('@'), "convert spaces to tabs in selections", spaces_to_tabs },
 
-    { 'C', { "copy selection on next lines", copy_selections_on_next_lines<Forward> } },
-    { alt('C'), { "copy selection on previous lines", copy_selections_on_next_lines<Backward> } },
+    { 'C', "copy selection on next lines", copy_selections_on_next_lines<Forward> },
+    { alt('C'), "copy selection on previous lines", copy_selections_on_next_lines<Backward> },
 
-    { ',', { "user mappings", exec_user_mappings } },
+    { ',', "user mappings", exec_user_mappings },
 
-    { Key::Left,  { "move left", move<CharCount, Backward> } },
-    { Key::Down,  { "move down", move<LineCount, Forward> } },
-    { Key::Up,    { "move up", move<LineCount, Backward> } },
-    { Key::Right, { "move right", move<CharCount, Forward> } },
+    { Key::Left,  "move left", move<CharCount, Backward> },
+    { Key::Down,  "move down", move<LineCount, Forward> },
+    { Key::Up,    "move up", move<LineCount, Backward> },
+    { Key::Right, "move right", move<CharCount, Forward> },
 
-    { ctrl('b'), { "scroll one page up", scroll<Key::PageUp> } },
-    { ctrl('f'), { "scroll one page down", scroll<Key::PageDown> } },
+    { ctrl('b'), "scroll one page up", scroll<Key::PageUp> },
+    { ctrl('f'), "scroll one page down", scroll<Key::PageDown> },
 
-    { Key::PageUp,   { "scroll one page up", scroll<Key::PageUp> } },
-    { Key::PageDown, { "scroll one page down", scroll<Key::PageDown> } },
+    { Key::PageUp,   "scroll one page up", scroll<Key::PageUp> },
+    { Key::PageDown, "scroll one page down", scroll<Key::PageDown> },
 };
 
 }
diff --git a/src/normal.hh b/src/normal.hh
index 7f90075d..4a453415 100644
--- a/src/normal.hh
+++ b/src/normal.hh
@@ -18,12 +18,13 @@ struct NormalParams
 
 struct NormalCmdDesc
 {
+    Key key;
     StringView docstring;
     void (*func)(Context& context, NormalParams params);
 };
 
-using KeyMap = UnorderedMap<Key, NormalCmdDesc>;
-extern const KeyMap keymap;
+using KeyMap = Vector<NormalCmdDesc>;
+extern KeyMap keymap;
 
 }