From 7a8b3aa0ea4571c278d68cea51c4ccd10fc7a011 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Fri, 8 Oct 2010 21:22:24 +0200
Subject: vim_mode: Fix display of 'more' statusbar when scrolling.

Reported by estragib.
---
 vim-mode/vim_mode.pl | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 28e254d..feea4c6 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1300,6 +1300,8 @@ sub cmd_ctrl_d {
         $count = $window->{height} / 2;
     }
     $window->view()->scroll($count);
+
+    Irssi::statusbar_items_redraw('more');
     return (undef, undef);
 }
 sub cmd_ctrl_u {
@@ -1311,6 +1313,8 @@ sub cmd_ctrl_u {
         $count = $window->{height} / 2;
     }
     $window->view()->scroll($count * -1);
+
+    Irssi::statusbar_items_redraw('more');
     return (undef, undef);
 }
 sub cmd_ctrl_f {
@@ -1318,13 +1322,14 @@ sub cmd_ctrl_f {
 
     my $window = Irssi::active_win();
     $window->view()->scroll($count * $window->{height});
+
+    Irssi::statusbar_items_redraw('more');
     return (undef, undef);
 }
 sub cmd_ctrl_b {
     my ($count, $pos, $repeat) = @_;
 
-    cmd_ctrl_f($count * -1, $pos, $repeat);
-    return (undef, undef);
+    return cmd_ctrl_f($count * -1, $pos, $repeat);
 }
 
 sub cmd_ctrl_wj {
-- 
cgit v1.2.3


From 61f3be581251267d6d10969e28771505889b20ba Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Fri, 8 Oct 2010 21:35:37 +0200
Subject: vim_mode: Fix :map with {rhs} with only one char.

---
 vim-mode/vim_mode.pl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index feea4c6..5d6dfe1 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1574,7 +1574,7 @@ sub ex_map {
     my ($arg_str) = @_;
 
     # :map {lhs} {rhs}
-    if ($arg_str =~ /^map (\S+) (\S.+)$/) {
+    if ($arg_str =~ /^map (\S+) (\S.*)$/) {
         my $lhs = _parse_mapping($1);
         my $rhs = $2;
 
@@ -1683,7 +1683,7 @@ sub ex_source {
 
         chomp $line;
         # :map {lhs} {rhs}, keep in sync with ex_map()
-        if ($line =~ /^\s*map (\S+) (\S.+)$/) {
+        if ($line =~ /^\s*map (\S+) (\S.*)$/) {
             ex_map($line);
         } else {
             _warn_ex('source', "command not supported: $line");
-- 
cgit v1.2.3


From 38f9d6cd9bee0940367500ae0223b2320edf80c2 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Fri, 8 Oct 2010 22:27:33 +0200
Subject: vim_mode: :map supports <Nop> in {rhs}.

---
 vim-mode/vim_mode.pl | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 5d6dfe1..07968d4 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -82,14 +82,15 @@
 #
 # {lhs} is the key combination to be mapped, {rhs} the target. The <> notation
 # is used (e.g. <C-F> is Ctrl-F), case is ignored. Supported <> keys:
-# <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>. Mapping ex-mode and irssi commands
-# is supported. Only default mappings can be used in {rhs}.
+# <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>, <Nop>. Mapping ex-mode and irssi
+# commands is supported. Only default mappings can be used in {rhs}.
 # Examples:
 #     :map w  W      # to remap w to work like W
 #     :map gb :bnext # to map gb to call :bnext
 #     :map gB :bprev
 #     :map <C-L> /clear # map Ctrl-L to irssi command /clear
 #     :map <C-G> /window goto 1
+#     :map <C-E> <Nop> - disable <C-E>, it does nothing now
 #
 #
 # The following irssi settings are available:
@@ -243,6 +244,8 @@ sub C_INSERT () { 4 }
 sub C_EX () { 5 }
 # irssi commands
 sub C_IRSSI () { 6 }
+# does nothing
+sub C_NOP () { 7 }
 
 # word and non-word regex, keep in sync with setup_changed()!
 my $word     = qr/[\w_]/o;
@@ -1598,6 +1601,12 @@ sub ex_map {
                          func => substr($rhs, 1),
                          type => C_IRSSI,
                        };
+        # <Nop> does nothing
+        } elsif (lc $rhs eq '<nop>') {
+            $command = { char => '<Nop>',
+                         func => undef,
+                         type => C_NOP,
+                       };
         # command-mode command
         } else {
             $rhs = _parse_mapping($2);
@@ -2044,6 +2053,10 @@ sub handle_command_cmd {
         print "Processing irssi-command: $map->{char} ($cmd->{char})" if DEBUG;
         Irssi::command($cmd->{func});
         return 1; # call _stop();
+    # <Nop> does nothing.
+    } elsif ($cmd->{type} == C_NOP) {
+        print "Processing <Nop>: $map->{char}" if DEBUG;
+        return 1; # call _stop();
     }
 
     # text-objects (i a) are simulated with $movement
-- 
cgit v1.2.3


From e369746edd750d429fc1c98f798350f811709dc7 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Fri, 8 Oct 2010 22:33:05 +0200
Subject: vim_mode: Update documentation.

---
 vim-mode/vim_mode.pl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 07968d4..3a2bdec 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -67,7 +67,7 @@
 #                      :bp[rev] - switch to previous window
 # * Close window:      :bd[elete]
 # * Display windows:   :ls :buffers
-# * Display registers: :reg[isters] :di[splay] {args}
+# * Display registers: :reg[isters] {args} :di[splay] {args}
 # * Display undolist:  :undol[ist] (mostly used for debugging)
 # * Source files       :so[urce] - only sources vim_moderc at the moment,
 #                                  {file} not supported
@@ -85,10 +85,10 @@
 # <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>, <Nop>. Mapping ex-mode and irssi
 # commands is supported. Only default mappings can be used in {rhs}.
 # Examples:
-#     :map w  W      # to remap w to work like W
-#     :map gb :bnext # to map gb to call :bnext
+#     :map w  W      - to remap w to work like W
+#     :map gb :bnext - to map gb to call :bnext
 #     :map gB :bprev
-#     :map <C-L> /clear # map Ctrl-L to irssi command /clear
+#     :map <C-L> /clear - map Ctrl-L to irssi command /clear
 #     :map <C-G> /window goto 1
 #     :map <C-E> <Nop> - disable <C-E>, it does nothing now
 #
-- 
cgit v1.2.3


From d2263ffcb0d32517a60c3093e87702179cff5a9d Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Fri, 8 Oct 2010 22:58:22 +0200
Subject: vim_mode: Add :mkv[imrc].

---
 vim-mode/vim_mode.pl | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 3a2bdec..f18fb09 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -73,6 +73,7 @@
 #                                  {file} not supported
 # * Mappings:          :map             - display custom mappings
 #                      :map {lhs} {rhs} - add mapping
+# * Save mappings:     :mkv[imrc] - like in Vim, but [file] not supported
 # * Substitute:        :s/// - i and g are supported as flags, only /// can be
 #                              used as separator, uses Perl regex instead of
 #                              Vim regex
@@ -383,6 +384,8 @@ my $commands_ex
      map       => { char => ':map',       func => \&ex_map,        type => C_EX },
      source    => { char => ':source',    func => \&ex_source,     type => C_EX },
      so        => { char => ':so',        func => \&ex_source,     type => C_EX },
+     mkvimrc   => { char => ':mkvimrc',   func => \&ex_mkvimrc,    type => C_EX },
+     mkv       => { char => ':mkv',       func => \&ex_mkvimrc,    type => C_EX },
     };
 
 # MAPPINGS
@@ -1700,6 +1703,29 @@ sub ex_source {
     }
 }
 
+sub ex_mkvimrc {
+    # :mkv[imrc], [file] not supported
+
+    my $vim_moderc = Irssi::get_irssi_dir(). '/vim_moderc';
+    if (-f $vim_moderc) {
+        return _warn_ex('mkvimrc', "$vim_moderc already exists");
+    }
+
+    open my $file, '>', $vim_moderc or return;
+
+    # copied from ex_map()
+    foreach my $key (sort keys %$maps) {
+        my $map = $maps->{$key};
+        my $cmd = $map->{cmd};
+        if (defined $cmd) {
+            next if $map->{char} eq $cmd->{char}; # skip default mappings
+            print $file "$map->{char} $cmd->{char}\n";
+        }
+    }
+
+    close $file;
+}
+
 sub _warn_ex {
     my ($command, $description) = @_;
     my $message = "Error in ex-mode command $command";
-- 
cgit v1.2.3


From ff5fb6c40953421e40f4118473547096474f35de Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 01:17:49 +0200
Subject: vim_mode: Fix :map with ex-commands.

Broken in d736f605126e368124b3ff8ed4db5b28f83b650f.
---
 vim-mode/vim_mode.pl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index f18fb09..065411e 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -2072,7 +2072,7 @@ sub handle_command_cmd {
     # ex-mode command doesn't need any additional arguments.
     if ($cmd->{type} == C_EX) {
         print "Processing ex-command: $map->{char} ($cmd->{char})" if DEBUG;
-        $cmd->{func}->($cmd->{char});
+        $cmd->{func}->(substr $cmd->{char}, 1);
         return 1; # call _stop()
     # As can irssi commands.
     } elsif ($cmd->{type} == C_IRSSI) {
-- 
cgit v1.2.3


From 3389ded1e95cb545ac83f5c8194ef4c0dbd43429 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 01:20:03 +0200
Subject: vim_mode: Fix :mkv[imrc].

---
 vim-mode/vim_mode.pl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 065411e..6f219dc 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1719,7 +1719,7 @@ sub ex_mkvimrc {
         my $cmd = $map->{cmd};
         if (defined $cmd) {
             next if $map->{char} eq $cmd->{char}; # skip default mappings
-            print $file "$map->{char} $cmd->{char}\n";
+            print $file "map $map->{char} $cmd->{char}\n";
         }
     }
 
-- 
cgit v1.2.3


From da1f8fac4198a8fa88f9e5e61e1fd1283b914b50 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 01:29:08 +0200
Subject: vim_moderc: Add [!] to :mkv[imrc].

---
 vim-mode/vim_mode.pl | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 6f219dc..575d697 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -73,7 +73,7 @@
 #                                  {file} not supported
 # * Mappings:          :map             - display custom mappings
 #                      :map {lhs} {rhs} - add mapping
-# * Save mappings:     :mkv[imrc] - like in Vim, but [file] not supported
+# * Save mappings:     :mkv[imrc][!] - like in Vim, but [file] not supported
 # * Substitute:        :s/// - i and g are supported as flags, only /// can be
 #                              used as separator, uses Perl regex instead of
 #                              Vim regex
@@ -1704,10 +1704,12 @@ sub ex_source {
 }
 
 sub ex_mkvimrc {
-    # :mkv[imrc], [file] not supported
+    my ($arg_str) = @_;
+
+    # :mkv[imrc][!], [file] not supported
 
     my $vim_moderc = Irssi::get_irssi_dir(). '/vim_moderc';
-    if (-f $vim_moderc) {
+    if (-f $vim_moderc and $arg_str !~ /^mkv(?:imrc)?!$/) {
         return _warn_ex('mkvimrc', "$vim_moderc already exists");
     }
 
-- 
cgit v1.2.3


From a676f809891739c143f52c52c72e28ef296ccc15 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 01:57:10 +0200
Subject: vim_mode: Fix vim_mode.pl crash with invalid regex in :b.

---
 vim-mode/vim_mode.pl | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 575d697..4eacf55 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1520,10 +1520,16 @@ sub ex_buffer {
             Irssi::command('window last');
         # Go to best regex matching window.
         } else {
-            my $matches = _matching_windows($buffer);
-            if (scalar @$matches > 0) {
-                $window = @$matches[0]->{window};
-                $item = @$matches[0]->{item};
+            eval {
+                my $matches = _matching_windows($buffer);
+                if (scalar @$matches > 0) {
+                    $window = @$matches[0]->{window};
+                    $item = @$matches[0]->{item};
+                }
+            };
+            # Catch errors in /$buffer/ regex.
+            if ($@) {
+                _warn($@);
             }
         }
 
@@ -1831,8 +1837,14 @@ sub b_windows_cb {
         my $buffer = $1;
         if ($buffer !~ /^[0-9]$/ and $buffer ne '#') {
             # Display matching windows.
-            my $matches = _matching_windows($buffer);
-            $windows = join ',', map { $_->{text} } @$matches;
+            eval {
+                my $matches = _matching_windows($buffer);
+                $windows = join ',', map { $_->{text} } @$matches;
+            };
+            # Catch errors in /$buffer/ regex.
+            if ($@) {
+                _warn($@);
+            }
         }
     }
 
-- 
cgit v1.2.3


From 2fc2e4fb9822362c9a94e3222ca5e4d10813faf3 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 02:27:17 +0200
Subject: vim_mode: Remove unnecessary sub cmd_space(), use cmd_l().

---
 vim-mode/vim_mode.pl | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 4eacf55..9cc1ae4 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -269,7 +269,7 @@ my $commands
      # arrow like movement
       h  => { char => 'h', func => \&cmd_h, type => C_NORMAL },
       l  => { char => 'l', func => \&cmd_l, type => C_NORMAL },
-     ' ' => { char => '<Space>', func => \&cmd_space, type => C_NORMAL },
+     ' ' => { char => '<Space>', func => \&cmd_l, type => C_NORMAL },
      # history movement
      j  => { char => 'j',  func => \&cmd_j,  type => C_NORMAL },
      k  => { char => 'k',  func => \&cmd_k,  type => C_NORMAL },
@@ -627,10 +627,6 @@ sub cmd_l {
     $pos = _fix_input_pos($pos, $length);
     return (undef, $pos);
 }
-sub cmd_space {
-    my ($count, $pos, $repeat) = @_;
-    return cmd_l($count, $pos);
-}
 
 # later history (down)
 sub cmd_j {
-- 
cgit v1.2.3


From 9acb5260382391d327a85566e1addcf1dcea5af8 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 15:33:24 +0200
Subject: vim_mode: Prevent invalid operator/command combinations.

---
 vim-mode/vim_mode.pl | 85 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 54 insertions(+), 31 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 9cc1ae4..ad75ede 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -271,11 +271,14 @@ my $commands
       l  => { char => 'l', func => \&cmd_l, type => C_NORMAL },
      ' ' => { char => '<Space>', func => \&cmd_l, type => C_NORMAL },
      # history movement
-     j  => { char => 'j',  func => \&cmd_j,  type => C_NORMAL },
-     k  => { char => 'k',  func => \&cmd_k,  type => C_NORMAL },
-     gg => { char => 'gg', func => \&cmd_gg, type => C_NORMAL },
+     j  => { char => 'j',  func => \&cmd_j,  type => C_NORMAL,
+             no_operator => 1 },
+     k  => { char => 'k',  func => \&cmd_k,  type => C_NORMAL,
+             no_operator => 1 },
+     gg => { char => 'gg', func => \&cmd_gg, type => C_NORMAL,
+             no_operator => 1 },
      G  => { char => 'G',  func => \&cmd_G,  type => C_NORMAL,
-             needs_count => 1 },
+             needs_count => 1, no_operator => 1 },
      # char movement, take an additional parameter and use $movement
       f  => { char => 'f', func => \&cmd_f, type => C_NEEDSKEY,
               selection_needs_move_right => 1 },
@@ -307,58 +310,71 @@ my $commands
      '$' => { char => '$', func => \&cmd_dollar, type => C_NORMAL },
      # delete chars
      x => { char => 'x', func => \&cmd_x, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      X => { char => 'X', func => \&cmd_X, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
+          # C_NORMAL is correct, operator c takes care of insert mode
      s => { char => 's', func => \&cmd_s, type => C_NORMAL,
-            repeatable => 1 }, # operator c takes care of insert mode
+            repeatable => 1, no_operator => 1 },
+          # C_NORMAL is correct, operator c takes care of insert mode
      S => { char => 'S', func => \&cmd_S, type => C_NORMAL,
-            repeatable => 1 }, # operator c takes care of insert mode
+            repeatable => 1, no_operator => 1 },
      # insert mode
      i => { char => 'i', func => \&cmd_i, type => C_INSERT,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      I => { char => 'I', func => \&cmd_I, type => C_INSERT,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      a => { char => 'a', func => \&cmd_a, type => C_INSERT,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      A => { char => 'A', func => \&cmd_A, type => C_INSERT,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      # replace
      r => { char => 'r', func => \&cmd_r, type => C_NEEDSKEY,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      # paste
      p => { char => 'p', func => \&cmd_p, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      P => { char => 'P', func => \&cmd_P, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      # to end of line
      C => { char => 'C', func => \&cmd_C, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      D => { char => 'D', func => \&cmd_D, type => C_NORMAL,
-            repeatable => 1 },
+            repeatable => 1, no_operator => 1 },
      # scrolling
-     "\x05" => { char => '<C-E>', func => \&cmd_ctrl_d, type => C_NORMAL },
+     "\x05" => { char => '<C-E>', func => \&cmd_ctrl_d, type => C_NORMAL,
+                 no_operator => 1 },
      "\x04" => { char => '<C-D>', func => \&cmd_ctrl_d, type => C_NORMAL,
-                 needs_count => 1 },
-     "\x19" => { char => '<C-Y>', func => \&cmd_ctrl_u, type => C_NORMAL },
+                 needs_count => 1, no_operator => 1 },
+     "\x19" => { char => '<C-Y>', func => \&cmd_ctrl_u, type => C_NORMAL,
+                 no_operator => 1 },
      "\x15" => { char => '<C-U>', func => \&cmd_ctrl_u, type => C_NORMAL,
-                 needs_count => 1 },
-     "\x06" => { char => '<C-F>', func => \&cmd_ctrl_f, type => C_NORMAL },
-     "\x02" => { char => '<C-B>', func => \&cmd_ctrl_b, type => C_NORMAL },
+                 needs_count => 1, no_operator => 1 },
+     "\x06" => { char => '<C-F>', func => \&cmd_ctrl_f, type => C_NORMAL,
+                 no_operator => 1 },
+     "\x02" => { char => '<C-B>', func => \&cmd_ctrl_b, type => C_NORMAL,
+                 no_operator => 1 },
      # window switching
-     "\x17j" => { char => '<C-W>j', func => \&cmd_ctrl_wj, type => C_NORMAL },
-     "\x17k" => { char => '<C-W>k', func => \&cmd_ctrl_wk, type => C_NORMAL },
-     "\x1e"  => { char => '<C-^>',  func => \&cmd_ctrl_6,  type => C_NORMAL },
+     "\x17j" => { char => '<C-W>j', func => \&cmd_ctrl_wj, type => C_NORMAL,
+                  no_operator => 1 },
+     "\x17k" => { char => '<C-W>k', func => \&cmd_ctrl_wk, type => C_NORMAL,
+                  no_operator => 1 },
+     "\x1e"  => { char => '<C-^>',  func => \&cmd_ctrl_6,  type => C_NORMAL,
+                  no_operator => 1 },
      # misc
      '~'  => { char => '~', func => \&cmd_tilde, type => C_NORMAL,
-               repeatable => 1 },
-     '"'  => { char => '"', func => \&cmd_register, type => C_NEEDSKEY },
-     '.'  => { char => '.', type => C_NORMAL, repeatable => 1 },
+               repeatable => 1, no_operator => 1 },
+     '"'  => { char => '"', func => \&cmd_register, type => C_NEEDSKEY,
+               no_operator => 1 },
+     '.'  => { char => '.', type => C_NORMAL, repeatable => 1,
+               no_operator => 1 },
      ':'  => { char => ':', type => C_NORMAL },
      "\n" => { char => '<CR>', type => C_NORMAL }, # return
      # undo
-     'u'    => { char => 'u',     func => \&cmd_undo, type => C_NORMAL },
-     "\x12" => { char => '<C-R>', func => \&cmd_redo, type => C_NORMAL },
+     'u'    => { char => 'u',     func => \&cmd_undo, type => C_NORMAL,
+                 no_operator => 1 },
+     "\x12" => { char => '<C-R>', func => \&cmd_redo, type => C_NORMAL,
+                 no_operator => 1 },
     };
 
 # All available commands in Ex-Mode.
@@ -2174,6 +2190,13 @@ sub handle_command_cmd {
             }
         }
 
+        # Ignore invalid operator/command combinations.
+        if ($operator and $cmd->{no_operator}) {
+            print "Invalid operator/command: $operator->{char} $cmd->{char}"
+                if DEBUG;
+            $skip = 1;
+        }
+
         if ($skip) {
             print "Skipping movement and operator." if DEBUG;
         } else {
-- 
cgit v1.2.3


From dd2e9a766e4fc7de278681f4658ba42c8b74e2a5 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sat, 9 Oct 2010 15:59:31 +0200
Subject: vim_mode: Add :unm[ap] {lhs}.

---
 vim-mode/vim_mode.pl | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index ad75ede..9d8e04b 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -73,6 +73,7 @@
 #                                  {file} not supported
 # * Mappings:          :map             - display custom mappings
 #                      :map {lhs} {rhs} - add mapping
+#                      :unm[ap] {lhs}   - remove custom mapping
 # * Save mappings:     :mkv[imrc][!] - like in Vim, but [file] not supported
 # * Substitute:        :s/// - i and g are supported as flags, only /// can be
 #                              used as separator, uses Perl regex instead of
@@ -92,6 +93,7 @@
 #     :map <C-L> /clear - map Ctrl-L to irssi command /clear
 #     :map <C-G> /window goto 1
 #     :map <C-E> <Nop> - disable <C-E>, it does nothing now
+#     :unmap <C-E>     - restore default behavior of <C-E> after disabling it
 #
 #
 # The following irssi settings are available:
@@ -398,6 +400,8 @@ my $commands_ex
      undolist  => { char => ':undolist',  func => \&ex_undolist,   type => C_EX },
      undol     => { char => ':undol',     func => \&ex_undolist,   type => C_EX },
      map       => { char => ':map',       func => \&ex_map,        type => C_EX },
+     unmap     => { char => ':unmap',     func => \&ex_unmap,      type => C_EX },
+     unm       => { char => ':unm',       func => \&ex_unmap,      type => C_EX },
      source    => { char => ':source',    func => \&ex_source,     type => C_EX },
      so        => { char => ':so',        func => \&ex_source,     type => C_EX },
      mkvimrc   => { char => ':mkvimrc',   func => \&ex_mkvimrc,    type => C_EX },
@@ -1657,6 +1661,25 @@ sub ex_map {
         _warn_ex('map');
     }
 }
+sub ex_unmap {
+    my ($arg_str) = @_;
+
+    # :unm[ap] {lhs}
+    if ($arg_str !~ /^unm(?:ap)? (\S+)$/) {
+        return _warn_ex('unmap');
+    }
+
+    my $lhs = _parse_mapping($1);
+    if (not defined $lhs) {
+        return _warn_ex('unmap', 'invalid {lhs}');
+    # Prevent unmapping of unknown or default mappings.
+    } elsif (not exists $maps->{$lhs} or not defined $maps->{$lhs}->{cmd} or
+             ($commands->{$lhs} and $maps->{$lhs}->{cmd} == $commands->{$lhs})) {
+        return _warn_ex('unmap', "$1 not found");
+    }
+
+    delete_map($lhs);
+}
 sub _parse_mapping {
     my ($string) = @_;
 
@@ -2485,6 +2508,45 @@ sub add_map {
     $maps->{$keys}->{char} = _parse_mapping_reverse($keys);
     $maps->{$keys}->{cmd} = $command;
 }
+sub delete_map {
+    my ($keys) = @_;
+
+    # Abort for non-existent mappings or placeholder mappings.
+    return if not exists $maps->{$keys} or not defined $maps->{$keys}->{cmd};
+
+    my @add = ();
+
+    # If no maps need the current key, then remove it and all other
+    # unnecessary keys in the "tree".
+    if (keys %{$maps->{$keys}->{maps}} == 0) {
+        my $tmp = $keys;
+        while (length $tmp > 1) {
+            my $map = substr $tmp, -1, 1, '';
+            delete $maps->{$tmp}->{maps}->{$tmp . $map};
+            if (not $maps->{$tmp}->{cmd} and keys %{$maps->{$tmp}->{maps}} == 0) {
+                push @add, $tmp;
+                delete $maps->{$tmp};
+            } else {
+                last;
+            }
+        }
+    }
+
+    if (keys %{$maps->{$keys}->{maps}} > 0) {
+        $maps->{$keys}->{cmd} = undef;
+    } else {
+        delete $maps->{$keys};
+    }
+    push @add, $keys;
+
+    # Restore default keybindings in case we :unmaped a <Nop> or a remapped
+    # key.
+    foreach my $key (@add) {
+        if (exists $commands->{$key}) {
+            add_map($key, $commands->{$key});
+        }
+    }
+}
 
 
 sub _commit_line {
-- 
cgit v1.2.3


From a89e3f5572c010a02a498a542affb0c014c2807e Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 00:35:23 +0200
Subject: vim_mode: Support counts with mapped ex-commands.

---
 vim-mode/vim_mode.pl | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 9d8e04b..fad440a 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -49,7 +49,9 @@
 # * Switch split windows: Ctrl-W j Ctrl-W k
 # * Undo/Redo: u Ctrl-R
 #
-# Counts and combinations work as well, e.g. d5fx or 3iabc<esc>
+# Counts and combinations work as well, e.g. d5fx or 3iabc<esc>. Counts also
+# work with mapped ex-commands (see below), e.g. if you map gb to do :bn, then
+# 2gb will switch to the second next buffer.
 # Repeat also supports counts.
 #
 # The following insert mode mappings are supported:
@@ -2121,7 +2123,15 @@ sub handle_command_cmd {
     # ex-mode command doesn't need any additional arguments.
     if ($cmd->{type} == C_EX) {
         print "Processing ex-command: $map->{char} ($cmd->{char})" if DEBUG;
-        $cmd->{func}->(substr $cmd->{char}, 1);
+
+        if (not $numeric_prefix) {
+            $numeric_prefix = 1;
+        }
+        while ($numeric_prefix-- > 0) {
+            $cmd->{func}->(substr $cmd->{char}, 1);
+        }
+        $numeric_prefix = undef;
+
         return 1; # call _stop()
     # As can irssi commands.
     } elsif ($cmd->{type} == C_IRSSI) {
-- 
cgit v1.2.3


From fb0e4bbaaf74e9072b5af9d32f9fded2b4a0d50c Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 00:36:22 +0200
Subject: vim_mode: Mapped irssi and <Nop> commands reset count.

---
 vim-mode/vim_mode.pl | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index fad440a..e866a23 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -2137,10 +2137,14 @@ sub handle_command_cmd {
     } elsif ($cmd->{type} == C_IRSSI) {
         print "Processing irssi-command: $map->{char} ($cmd->{char})" if DEBUG;
         Irssi::command($cmd->{func});
+
+        $numeric_prefix = undef;
         return 1; # call _stop();
     # <Nop> does nothing.
     } elsif ($cmd->{type} == C_NOP) {
         print "Processing <Nop>: $map->{char}" if DEBUG;
+
+        $numeric_prefix = undef;
         return 1; # call _stop();
     }
 
-- 
cgit v1.2.3


From 143ae36a262401892e6fff8f610375ed9c67ffdb Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 01:05:22 +0200
Subject: vim_mode: Allow mappings with numbers.

But not as the first key.
---
 vim-mode/vim_mode.pl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index e866a23..181d854 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -2066,8 +2066,8 @@ sub handle_command_cmd {
     }
 
     # Counts
-    if (!$movement and ($char =~ m/[1-9]/ or
-                        ($numeric_prefix && $char =~ m/[0-9]/))) {
+    if (!$movement and !$pending_map and
+        ($char =~ m/[1-9]/ or ($numeric_prefix && $char =~ m/[0-9]/))) {
         print "Processing numeric prefix: $char" if DEBUG;
         handle_numeric_prefix($char);
         return 1; # call _stop()
-- 
cgit v1.2.3


From bb2167d04668a8537afdd3217d3786e353048eaa Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 01:11:06 +0200
Subject: vim_mode: Support arguments to mapped ex-arguments.

---
 vim-mode/vim_mode.pl | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 181d854..879f0e0 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -92,6 +92,7 @@
 #     :map w  W      - to remap w to work like W
 #     :map gb :bnext - to map gb to call :bnext
 #     :map gB :bprev
+#     :map g1 :b 1   - to map g1 to switch to buffer 1
 #     :map <C-L> /clear - map Ctrl-L to irssi command /clear
 #     :map <C-G> /window goto 1
 #     :map <C-E> <Nop> - disable <C-E>, it does nothing now
@@ -1616,11 +1617,14 @@ sub ex_map {
         my $command;
         # Ex-mode command
         if (index($rhs, ':') == 0) {
-            $rhs = substr $rhs, 1;
-            if (not exists $commands_ex->{$rhs}) {
-                return _warn_ex('map', "$2 not found");
+            $rhs =~ /^:(\S+)(\s.+)?$/;
+            if (not exists $commands_ex->{$1}) {
+                return _warn_ex('map', "$rhs not found");
             } else {
-                $command = $commands_ex->{$rhs};
+                $command = { char => $rhs,
+                             func => $commands_ex->{$1}->{func},
+                             type => C_EX,
+                           };
             }
         # Irssi command
         } elsif (index($rhs, '/') == 0) {
@@ -2119,8 +2123,7 @@ sub handle_command_cmd {
         return 1; # call _stop()
     }
 
-    # Ex-mode commands can also be bound in command mode. Works only if the
-    # ex-mode command doesn't need any additional arguments.
+    # Ex-mode commands can also be bound in command mode.
     if ($cmd->{type} == C_EX) {
         print "Processing ex-command: $map->{char} ($cmd->{char})" if DEBUG;
 
-- 
cgit v1.2.3


From b5f5fceb141736dcfb667f2d5935e0791b9546c6 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 01:26:18 +0200
Subject: vim_mode: Whitespace only change.

---
 vim-mode/vim_mode.pl | 72 ++++++++++++++++++++++++++++++++++------------------
 1 file changed, 48 insertions(+), 24 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 879f0e0..1746c3b 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -385,30 +385,54 @@ my $commands
 # All available commands in Ex-Mode.
 my $commands_ex
   = {
-     s         => { char => ':s',         func => \&ex_substitute, type => C_EX },
-     bnext     => { char => ':bnext',     func => \&ex_bnext,      type => C_EX },
-     bn        => { char => ':bn',        func => \&ex_bnext,      type => C_EX },
-     bprev     => { char => ':bprev',     func => \&ex_bprev,      type => C_EX },
-     bp        => { char => ':bp',        func => \&ex_bprev,      type => C_EX },
-     bdelete   => { char => ':bdelete',   func => \&ex_bdelete,    type => C_EX },
-     bd        => { char => ':bd',        func => \&ex_bdelete,    type => C_EX },
-     buffer    => { char => ':buffer',    func => \&ex_buffer,     type => C_EX },
-     b         => { char => ':b',         func => \&ex_buffer,     type => C_EX },
-     registers => { char => ':registers', func => \&ex_registers,  type => C_EX },
-     reg       => { char => ':reg',       func => \&ex_registers,  type => C_EX },
-     display   => { char => ':display',   func => \&ex_registers,  type => C_EX },
-     di        => { char => ':di',        func => \&ex_registers,  type => C_EX },
-     buffers   => { char => ':buffer',    func => \&ex_buffers,    type => C_EX },
-     ls        => { char => ':ls',        func => \&ex_buffers,    type => C_EX },
-     undolist  => { char => ':undolist',  func => \&ex_undolist,   type => C_EX },
-     undol     => { char => ':undol',     func => \&ex_undolist,   type => C_EX },
-     map       => { char => ':map',       func => \&ex_map,        type => C_EX },
-     unmap     => { char => ':unmap',     func => \&ex_unmap,      type => C_EX },
-     unm       => { char => ':unm',       func => \&ex_unmap,      type => C_EX },
-     source    => { char => ':source',    func => \&ex_source,     type => C_EX },
-     so        => { char => ':so',        func => \&ex_source,     type => C_EX },
-     mkvimrc   => { char => ':mkvimrc',   func => \&ex_mkvimrc,    type => C_EX },
-     mkv       => { char => ':mkv',       func => \&ex_mkvimrc,    type => C_EX },
+     s         => { char => ':s',         func => \&ex_substitute,
+                    type => C_EX },
+     bnext     => { char => ':bnext',     func => \&ex_bnext,
+                    type => C_EX },
+     bn        => { char => ':bn',        func => \&ex_bnext,
+                    type => C_EX },
+     bprev     => { char => ':bprev',     func => \&ex_bprev,
+                    type => C_EX },
+     bp        => { char => ':bp',        func => \&ex_bprev,
+                    type => C_EX },
+     bdelete   => { char => ':bdelete',   func => \&ex_bdelete,
+                    type => C_EX },
+     bd        => { char => ':bd',        func => \&ex_bdelete,
+                    type => C_EX },
+     buffer    => { char => ':buffer',    func => \&ex_buffer,
+                    type => C_EX },
+     b         => { char => ':b',         func => \&ex_buffer,
+                    type => C_EX },
+     registers => { char => ':registers', func => \&ex_registers,
+                    type => C_EX },
+     reg       => { char => ':reg',       func => \&ex_registers,
+                    type => C_EX },
+     display   => { char => ':display',   func => \&ex_registers,
+                    type => C_EX },
+     di        => { char => ':di',        func => \&ex_registers,
+                    type => C_EX },
+     buffers   => { char => ':buffer',    func => \&ex_buffers,
+                    type => C_EX },
+     ls        => { char => ':ls',        func => \&ex_buffers,
+                    type => C_EX },
+     undolist  => { char => ':undolist',  func => \&ex_undolist,
+                    type => C_EX },
+     undol     => { char => ':undol',     func => \&ex_undolist,
+                    type => C_EX },
+     map       => { char => ':map',       func => \&ex_map,
+                    type => C_EX },
+     unmap     => { char => ':unmap',     func => \&ex_unmap,
+                    type => C_EX },
+     unm       => { char => ':unm',       func => \&ex_unmap,
+                    type => C_EX },
+     source    => { char => ':source',    func => \&ex_source,
+                    type => C_EX },
+     so        => { char => ':so',        func => \&ex_source,
+                    type => C_EX },
+     mkvimrc   => { char => ':mkvimrc',   func => \&ex_mkvimrc,
+                    type => C_EX },
+     mkv       => { char => ':mkv',       func => \&ex_mkvimrc,
+                    type => C_EX },
     };
 
 # MAPPINGS
-- 
cgit v1.2.3


From 7d6d8c7f375ab15e587809773c3af014ed55135f Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 01:51:23 +0200
Subject: vim_mode: Display command in statusbar after flushing pending map.

Reported by estragib.
---
 vim-mode/vim_mode.pl | 1 +
 1 file changed, 1 insertion(+)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 1746c3b..4101579 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -2064,6 +2064,7 @@ sub flush_pending_map {
               $pending_map ne $old_pending_map;
 
     handle_command_cmd(undef);
+    Irssi::statusbar_items_redraw("vim_mode");
 }
 
 sub handle_numeric_prefix {
-- 
cgit v1.2.3


From d01581b027fa24fba5a0c1cd73667a1c1fa5a7bb Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 02:47:09 +0200
Subject: vim_mode: Support counts with ex-commands.

This supports e.g. :5b, :5bd, :bd 5.
---
 vim-mode/vim_mode.pl | 117 ++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 84 insertions(+), 33 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 4101579..828f5a8 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -60,14 +60,14 @@
 #
 # Ex-mode supports (activated by : in command mode) the following commands:
 #
-# * Switching buffers: :b <num> - switch to channel number
-#                      :b#      - switch to last channel
+# * Switching buffers: :[N]b [N] - switch to channel number
+#                      :b#       - switch to last channel
 #                      :b <partial-channel-name>
 #                      :b <partial-server>/<partial-channel>
 #                      :buffer {args} (same as :b)
-#                      :bn[ext] - switch to next window
-#                      :bp[rev] - switch to previous window
-# * Close window:      :bd[elete]
+#                      :[N]bn[ext] [N] - switch to next window
+#                      :[N]bp[rev] [N] - switch to previous window
+# * Close window:      :[N]bd[elete] [N]
 # * Display windows:   :ls :buffers
 # * Display registers: :reg[isters] {args} :di[splay] {args}
 # * Display undolist:  :undol[ist] (mostly used for debugging)
@@ -93,6 +93,7 @@
 #     :map gb :bnext - to map gb to call :bnext
 #     :map gB :bprev
 #     :map g1 :b 1   - to map g1 to switch to buffer 1
+#     :map gb :b     - to map gb to :b, 1gb switches to buffer 1, 5gb to 5
 #     :map <C-L> /clear - map Ctrl-L to irssi command /clear
 #     :map <C-G> /window goto 1
 #     :map <C-E> <Nop> - disable <C-E>, it does nothing now
@@ -388,21 +389,21 @@ my $commands_ex
      s         => { char => ':s',         func => \&ex_substitute,
                     type => C_EX },
      bnext     => { char => ':bnext',     func => \&ex_bnext,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      bn        => { char => ':bn',        func => \&ex_bnext,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      bprev     => { char => ':bprev',     func => \&ex_bprev,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      bp        => { char => ':bp',        func => \&ex_bprev,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      bdelete   => { char => ':bdelete',   func => \&ex_bdelete,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      bd        => { char => ':bd',        func => \&ex_bdelete,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      buffer    => { char => ':buffer',    func => \&ex_buffer,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      b         => { char => ':b',         func => \&ex_buffer,
-                    type => C_EX },
+                    type => C_EX, uses_count => 1 },
      registers => { char => ':registers', func => \&ex_registers,
                     type => C_EX },
      reg       => { char => ':reg',       func => \&ex_registers,
@@ -1490,19 +1491,26 @@ sub _fix_input_pos {
 sub cmd_ex_command {
     my $arg_str = join '', @ex_buf;
 
-    if ($arg_str !~ /^([a-z]+)/) {
+    if ($arg_str !~ /^(\d*)?([a-z]+)/) {
         return _warn("Invalid Ex-mode command!");
     }
 
-    if (not exists $commands_ex->{$1}) {
-        return _warn("Ex-mode $1 doesn't exist!");
+    # Abort if command doesn't exist or used with count for unsupported
+    # commands.
+    if (not exists $commands_ex->{$2} or
+        ($1 ne '' and not $commands_ex->{$2}->{uses_count})) {
+        return _warn("Ex-mode $1$2 doesn't exist!");
     }
 
-    $commands_ex->{$1}->{func}($arg_str);
+    my $count = $1;
+    if ($count eq '') {
+        $count = undef;
+    }
+    $commands_ex->{$2}->{func}($arg_str, $count);
 }
 
 sub ex_substitute {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :s///
     if ($arg_str =~ m|^s/(.+)/(.*)/([ig]*)|) {
@@ -1538,25 +1546,67 @@ sub ex_substitute {
 }
 
 sub ex_bnext {
-    Irssi::command('window next');
+    my ($arg_str, $count) = @_;
+
+    if (not defined $count) {
+        if ($arg_str =~ /^bn(?:ext)?\s(\d+)$/) {
+            $count = $1;
+        } else {
+            $count = 1;
+        }
+    }
+
+    while ($count-- > 0) {
+        Irssi::command('window next');
+    }
 }
 sub ex_bprev {
-    Irssi::command('window previous');
+    my ($arg_str, $count) = @_;
+
+    if (not defined $count) {
+        if ($arg_str =~ /^bp(?:rev)?\s(\d+)$/) {
+            $count = $1;
+        } else {
+            $count = 1;
+        }
+    }
+
+    while ($count-- > 0) {
+        Irssi::command('window previous');
+    }
 }
 sub ex_bdelete {
+    my ($arg_str, $count) = @_;
+
+    if (not defined $count) {
+        if ($arg_str =~ /^bd(?:elete)?\s(\d+)$/) {
+            $count = $1;
+        }
+    }
+
+    if (defined $count) {
+        my $window = Irssi::window_find_refnum($count);
+        if (not $window) {
+            return;
+        }
+        $window->set_active();
+    }
     Irssi::command('window close');
 }
 sub ex_buffer {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :b[buffer] {args}
-    if ($arg_str =~ m|^b(?:uffer)?\s*(.+)$|) {
+    if ($arg_str =~ m|^b(?:uffer)?\s*(.+)$| or defined $count) {
         my $window;
         my $item;
         my $buffer = $1;
 
+        # :[N]:b[uffer]
+        if (defined $count) {
+            $window = Irssi::window_find_refnum($count);
         # Go to window number.
-        if ($buffer =~ /^[0-9]+$/) {
+        } elsif ($buffer =~ /^[0-9]+$/) {
             $window = Irssi::window_find_refnum($buffer);
         # Go to previous window.
         } elsif ($buffer eq '#') {
@@ -1588,7 +1638,7 @@ sub ex_buffer {
 }
 
 sub ex_registers {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :reg[isters] {arg} and :di[splay] {arg}
     if ($arg_str =~ /^(?:reg(?:isters)?|di(?:splay)?)(?:\s+(.+)$)?/) {
@@ -1618,15 +1668,19 @@ sub ex_registers {
 }
 
 sub ex_buffers {
+    my ($arg_str, $count) = @_;
+
     Irssi::command('window list');
 }
 
 sub ex_undolist {
+    my ($arg_str, $count) = @_;
+
     _print_undo_buffer();
 }
 
 sub ex_map {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :map {lhs} {rhs}
     if ($arg_str =~ /^map (\S+) (\S.*)$/) {
@@ -1692,7 +1746,7 @@ sub ex_map {
     }
 }
 sub ex_unmap {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :unm[ap] {lhs}
     if ($arg_str !~ /^unm(?:ap)? (\S+)$/) {
@@ -1757,6 +1811,8 @@ sub _parse_mapping_reverse {
 }
 
 sub ex_source {
+    my ($arg_str, $count) = @_;
+
     # :so[urce], but only loads the vim_moderc file at the moment
 
     open my $file, '<', Irssi::get_irssi_dir() . '/vim_moderc' or return;
@@ -1775,7 +1831,7 @@ sub ex_source {
 }
 
 sub ex_mkvimrc {
-    my ($arg_str) = @_;
+    my ($arg_str, $count) = @_;
 
     # :mkv[imrc][!], [file] not supported
 
@@ -2152,12 +2208,7 @@ sub handle_command_cmd {
     if ($cmd->{type} == C_EX) {
         print "Processing ex-command: $map->{char} ($cmd->{char})" if DEBUG;
 
-        if (not $numeric_prefix) {
-            $numeric_prefix = 1;
-        }
-        while ($numeric_prefix-- > 0) {
-            $cmd->{func}->(substr $cmd->{char}, 1);
-        }
+        $cmd->{func}->(substr($cmd->{char}, 1), $numeric_prefix);
         $numeric_prefix = undef;
 
         return 1; # call _stop()
-- 
cgit v1.2.3


From 34fd58554a4369523a02bde26bdd75bf09c76ff0 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 03:13:22 +0200
Subject: vim_mode: Fix :bd from displaying buffers matching d.

---
 vim-mode/vim_mode.pl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 828f5a8..2eefd66 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1952,9 +1952,10 @@ sub b_windows_cb {
 
     my $windows = '';
 
-    # A little code duplication of cmd_ex_command()!
+    # A little code duplication of cmd_ex_command(), but \s+ instead of \s* so
+    # :bd doesn't display buffers matching d.
     my $arg_str = join '', @ex_buf;
-    if ($arg_str =~ m|^b(?:uffer)?\s*(.+)$|) {
+    if ($arg_str =~ m|^b(?:uffer)?\s+(.+)$|) {
         my $buffer = $1;
         if ($buffer !~ /^[0-9]$/ and $buffer ne '#') {
             # Display matching windows.
-- 
cgit v1.2.3


From 5e058e0b5780e504043c75fd5b0af6fca9f99d65 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 03:18:39 +0200
Subject: vim_mode: Document :mapping ex-commands doesn't need <Cr>.

---
 vim-mode/vim_mode.pl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 2eefd66..17e7454 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -87,7 +87,8 @@
 # {lhs} is the key combination to be mapped, {rhs} the target. The <> notation
 # is used (e.g. <C-F> is Ctrl-F), case is ignored. Supported <> keys:
 # <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>, <Nop>. Mapping ex-mode and irssi
-# commands is supported. Only default mappings can be used in {rhs}.
+# commands is supported. When mapping ex-mode commands the trailing <Cr> is
+# not necessary. Only default mappings can be used in {rhs}.
 # Examples:
 #     :map w  W      - to remap w to work like W
 #     :map gb :bnext - to map gb to call :bnext
-- 
cgit v1.2.3


From def8af6d0454a8feae873d7df3afedb550807222 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 03:40:37 +0200
Subject: vim_mode: Add known bug.

---
 vim-mode/vim_mode.pl | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 17e7454..f84c523 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -165,6 +165,9 @@
 # Known bugs:
 #
 # * count before register doesn't work: e.g. 3"ap doesn't work, but "a3p does
+# * mapping an incomplete ex-command doesn't open the ex-mode with the partial
+#   command (e.g. :map gb :b causes an error instead of opening the ex-mode
+#   and displaying :b<cursor>)
 # * undo/redo positions are mostly wrong
 #
 #
-- 
cgit v1.2.3


From b97f23c09096d3c40bf15417dad1f6a1e3c447c7 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 03:42:29 +0200
Subject: vim_mode: :map {lhs} displays matching mappings.

---
 vim-mode/vim_mode.pl | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index f84c523..f2bd978 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -74,6 +74,7 @@
 # * Source files       :so[urce] - only sources vim_moderc at the moment,
 #                                  {file} not supported
 # * Mappings:          :map             - display custom mappings
+#                      :map {lhs}       - display mappings starting with {lhs}
 #                      :map {lhs} {rhs} - add mapping
 #                      :unm[ap] {lhs}   - remove custom mapping
 # * Save mappings:     :mkv[imrc][!] - like in Vim, but [file] not supported
@@ -1733,14 +1734,18 @@ sub ex_map {
         }
         add_map($lhs, $command);
 
-    # :map
-    } elsif ($arg_str eq 'map') {
+    # :map [lhs]
+    } elsif ($arg_str eq 'map' or $arg_str =~ /^map (\S+)$/) {
+        # Necessary for case insensitive matchings. lc alone won't work.
+        my $search = _parse_mapping_reverse(_parse_mapping($1));
+
         my $active_window = Irssi::active_win();
         foreach my $key (sort keys %$maps) {
             my $map = $maps->{$key};
             my $cmd = $map->{cmd};
             if (defined $cmd) {
                 next if $map->{char} eq $cmd->{char}; # skip default mappings
+                next if $map->{char} !~ /^\Q$search\E/; # skip non-matches
                 $active_window->print(sprintf "%-15s %s", $map->{char},
                                                           $cmd->{char});
             }
-- 
cgit v1.2.3


From aee98a7b35bba8c93c027ed9042ff24f117e1b2e Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 03:57:52 +0200
Subject: vim_mode: Add <BS> in command mode.

<BS> is also mappable now.
---
 vim-mode/vim_mode.pl | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index f2bd978..77a4908 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -87,9 +87,9 @@
 #
 # {lhs} is the key combination to be mapped, {rhs} the target. The <> notation
 # is used (e.g. <C-F> is Ctrl-F), case is ignored. Supported <> keys:
-# <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>, <Nop>. Mapping ex-mode and irssi
-# commands is supported. When mapping ex-mode commands the trailing <Cr> is
-# not necessary. Only default mappings can be used in {rhs}.
+# <C-A>-<C-Z>, <C-^>, <C-6>, <Space>, <CR>, <BS>, <Nop>. Mapping ex-mode and
+# irssi commands is supported. When mapping ex-mode commands the trailing <Cr>
+# is not necessary. Only default mappings can be used in {rhs}.
 # Examples:
 #     :map w  W      - to remap w to work like W
 #     :map gb :bnext - to map gb to call :bnext
@@ -278,9 +278,10 @@ my $commands
             repeatable => 1 },
 
      # arrow like movement
-      h  => { char => 'h', func => \&cmd_h, type => C_NORMAL },
-      l  => { char => 'l', func => \&cmd_l, type => C_NORMAL },
-     ' ' => { char => '<Space>', func => \&cmd_l, type => C_NORMAL },
+      h     => { char => 'h',       func => \&cmd_h, type => C_NORMAL },
+      l     => { char => 'l',       func => \&cmd_l, type => C_NORMAL },
+     "\x7F" => { char => '<BS>',    func => \&cmd_h, type => C_NORMAL },
+     ' '    => { char => '<Space>', func => \&cmd_l, type => C_NORMAL },
      # history movement
      j  => { char => 'j',  func => \&cmd_j,  type => C_NORMAL,
              no_operator => 1 },
@@ -1799,6 +1800,9 @@ sub _parse_mapping_bracket {
     # <CR>
     } elsif ($string eq 'cr') {
         $string = "\n";
+    # <BS>
+    } elsif ($string eq 'bs') {
+        $string = chr(127);
     # Invalid char, return special string to recognize the error.
     } else {
         $string = '<invalid>';
@@ -1811,6 +1815,7 @@ sub _parse_mapping_reverse {
     # Convert char to <char-name>.
     $string =~ s/ /<Space>/g;
     $string =~ s/\n/<CR>/g;
+    $string =~ s/\x7F/<BS>/g;
     # Convert Ctrl-X to <C-X>.
     $string =~ s/([\x01-\x1A])/"<C-" . chr(ord($1) + 64) . ">"/ge;
     # Convert Ctrl-6 and Ctrl-^ to <C-^>.
-- 
cgit v1.2.3


From a46cff6a006ce5c7488057432fa4e239e0d8519a Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 04:07:09 +0200
Subject: vim_mode: Add <BS> to movement docs.

---
 vim-mode/vim_mode.pl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 77a4908..e1e92f2 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -22,7 +22,7 @@
 # * Insert/Command mode. Escape and Ctrl-C enter command mode.
 #   /set vim_mode_cmd_seq j allows to use jj as Escape (any other character
 #   can be used as well).
-# * Cursor motion: h l 0 ^ $ <space> f t F T
+# * Cursor motion: h l 0 ^ $ <Space> <BS> f t F T
 # * History motion: j k gg G
 #   gg moves to the oldest (first) history line.
 #   G without a count moves to the current input line, with a count it goes to
-- 
cgit v1.2.3


From 1b68997bf5ea9e2bfbb317a12ed9371ee478d494 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 18:16:28 +0200
Subject: vim_mode: Fix B with operators.

---
 vim-mode/vim_mode.pl | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index e1e92f2..4fe334f 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -308,8 +308,7 @@ my $commands
      ge => { char => 'ge', func => \&cmd_ge, type => C_NORMAL,
              selection_needs_move_right => 1 },
      W  => { char => 'W',  func => \&cmd_W,  type => C_NORMAL },
-     B  => { char => 'B',  func => \&cmd_B,  type => C_NORMAL,
-             selection_needs_move_right => 1 },
+     B  => { char => 'B',  func => \&cmd_B,  type => C_NORMAL },
      E  => { char => 'E',  func => \&cmd_E,  type => C_NORMAL },
      gE => { char => 'gE', func => \&cmd_gE, type => C_NORMAL,
              selection_needs_move_right => 1 },
-- 
cgit v1.2.3


From 8291c7aa38cebf5884e919c8a81e884e9b3bc809 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 18:26:09 +0200
Subject: vim_mode: Correctly display pending text-objects.

---
 vim-mode/vim_mode.pl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 4fe334f..3dbdebc 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -313,8 +313,8 @@ my $commands
      gE => { char => 'gE', func => \&cmd_gE, type => C_NORMAL,
              selection_needs_move_right => 1 },
      # text-objects, leading _ means can't be mapped!
-     _i => { char => '_i', func => \&cmd__i, type => C_TEXTOBJECT },
-     _a => { char => '_a', func => \&cmd__a, type => C_TEXTOBJECT },
+     _i => { char => 'i', func => \&cmd__i, type => C_TEXTOBJECT },
+     _a => { char => 'a', func => \&cmd__a, type => C_TEXTOBJECT },
      # line movement
      '0' => { char => '0', func => \&cmd_0, type => C_NORMAL },
      '^' => { char => '^', func => \&cmd_caret, type => C_NORMAL },
-- 
cgit v1.2.3


From 7f0cebd0197ebfd93d6b9c7c9f58c7dd10581e9f Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 18:45:08 +0200
Subject: vim_mode: Fix pasting registers containing only "0".

Reported by estragib.
---
 vim-mode/vim_mode.pl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 3dbdebc..20562a7 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -561,7 +561,7 @@ sub insert_ctrl_r {
     my ($key) = @_;
 
     my $char = chr($key);
-    return if not defined $registers->{$char} or not $registers->{$char};
+    return if not defined $registers->{$char} or $registers->{$char} eq '';
 
     my $pos = _insert_at_position($registers->{$char}, 1, _input_pos());
     _input_pos($pos + 1);
@@ -1329,7 +1329,7 @@ sub cmd_P {
 sub _paste_at_position {
     my ($count, $pos) = @_;
 
-    return if not $registers->{$register};
+    return if $registers->{$register} eq '';
     return _insert_at_position($registers->{$register}, $count, $pos);
 }
 
-- 
cgit v1.2.3


From ecf7327440954c61e65027b983489b76002a0436 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Sun, 10 Oct 2010 22:39:07 +0200
Subject: vim_mode: Fix warning when mapping :map.

---
 vim-mode/vim_mode.pl | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 20562a7..f9bb2ff 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -1737,7 +1737,9 @@ sub ex_map {
     # :map [lhs]
     } elsif ($arg_str eq 'map' or $arg_str =~ /^map (\S+)$/) {
         # Necessary for case insensitive matchings. lc alone won't work.
-        my $search = _parse_mapping_reverse(_parse_mapping($1));
+        my $search = $1;
+        $search = '' if not defined $search;
+        $search = _parse_mapping_reverse(_parse_mapping($search));
 
         my $active_window = Irssi::active_win();
         foreach my $key (sort keys %$maps) {
-- 
cgit v1.2.3


From ee9ce3db10956e86dc667ccb700e46ebdf34660e Mon Sep 17 00:00:00 2001
From: Tom Feist <shabble@metavore.org>
Date: Wed, 13 Oct 2010 12:56:04 +0100
Subject: switched vim_mode to using uberprompt

---
 vim-mode/vim_mode.pl | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index f9bb2ff..a00421a 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -2261,8 +2261,11 @@ sub handle_command_cmd {
         if ($operator) {
             # But allow cc/dd/yy.
             if ($operator == $cmd) {
-                print "Processing line operator: $map->{char} ($cmd->{char})"
+                print "Processing line operator: ",
+                  $map->{char}, " (",
+                  $cmd->{char} ,")"
                     if DEBUG;
+
                 my $pos = _input_pos();
                 $cmd->{func}->(0, _input_len(), undef, 0);
                 # Restore position for yy.
@@ -2284,8 +2287,8 @@ sub handle_command_cmd {
 
     # Start Ex mode.
     } elsif ($cmd == $commands->{':'}) {
-        if (not script_is_loaded('prompt_info')) {
-            _warn("Warning: Ex mode requires the 'prompt_info' script. " .
+        if (not script_is_loaded('uberprompt')) {
+            _warn("Warning: Ex mode requires the 'uberprompt' script. " .
                     "Please load it and try again.");
         } else {
             _update_mode(M_EX);
@@ -2783,7 +2786,7 @@ sub _set_prompt {
     my $msg = shift;
     # add a leading space unless we're trying to clear it entirely.
     $msg = ' ' . $msg if length $msg;
-    Irssi::signal_emit('change prompt', $msg);
+    Irssi::signal_emit('change prompt', $msg, 'UP_INNER');
 }
 
 sub _warn {
-- 
cgit v1.2.3


From 1c802f8cbfbc93c868fbc4eb2517be749b971068 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Thu, 14 Oct 2010 21:53:29 +0200
Subject: vim_mode: Move all settings to $settings hash.

---
 vim-mode/vim_mode.pl | 52 +++++++++++++++++++++++++++++++---------------------
 1 file changed, 31 insertions(+), 21 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index a00421a..ac859a2 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -454,12 +454,20 @@ foreach my $char (keys %$commands) {
 
 # GLOBAL VARIABLES
 
-my $DEBUG_ENABLED = 0;
-
-sub DEBUG { $DEBUG_ENABLED }
+# all vim_mode settings, must be enabled in vim_mode_init() before usage
+my $settings
+  = {
+     # print debug output
+     debug          => 0,
+     # use UTF-8 internally for string calculations/manipulations
+     utf8           => 1,
+     # esc-shortcut in insert mode
+     cmd_seq        => '',
+     # not used yet
+     max_undo_lines => 50,
+    };
 
-# use UTF-8 internally for string calculations/manipulations
-my $utf8 = 1;
+sub DEBUG { $settings->{debug} }
 
 # buffer to keep track of the last N keystrokes, used for Esc detection and
 # insert mode mappings
@@ -712,7 +720,7 @@ sub cmd_j {
     } elsif ($history_index >= 0) {
         my $history = $history[$history_index];
         # History is not in UTF-8!
-        if ($utf8) {
+        if ($settings->{utf8}) {
             $history = decode_utf8($history);
         }
         _input($history);
@@ -744,7 +752,7 @@ sub cmd_k {
     if ($history_index >= 0) {
         my $history = $history[$history_index];
         # History is not in UTF-8!
-        if ($utf8) {
+        if ($settings->{utf8}) {
             $history = decode_utf8($history);
         }
         _input($history);
@@ -781,7 +789,7 @@ sub cmd_G {
 
     my $history = $history[$history_index];
     # History is not in UTF-8!
-    if ($utf8) {
+    if ($settings->{utf8}) {
         $history = decode_utf8($history);
     }
     _input($history);
@@ -2481,38 +2489,40 @@ sub vim_mode_init {
 sub setup_changed {
     my $value;
 
-    # Delete all possible imaps created by /set vim_mode_cmd_seq.
-    foreach my $char ('a' .. 'z') {
-        delete $imaps->{$char};
+    if ($settings->{cmd_seq} ne '') {
+        delete $imaps->{$settings->{cmd_seq}};
     }
-
     $value = Irssi::settings_get_str('vim_mode_cmd_seq');
-    if ($value) {
+    if ($value eq '') {
+        $settings->{cmd_seq} = $value;
+    } else {
         if (length $value == 1) {
             $imaps->{$value} = { 'map'  => $value,
                                  'func' => sub { _update_mode(M_CMD) }
                                };
+            $settings->{cmd_seq} = $value;
         } else {
             _warn("Error: vim_mode_cmd_seq must be a single character");
         }
     }
 
-    $DEBUG_ENABLED = Irssi::settings_get_bool('vim_mode_debug');
+    $settings->{debug} = Irssi::settings_get_bool('vim_mode_debug');
 
     my $new_utf8 = Irssi::settings_get_bool('vim_mode_utf8');
-
-    if ($new_utf8 != $utf8) {
+    if ($new_utf8 != $settings->{utf8}) {
         # recompile the patterns when switching to/from utf-8
         $word     = qr/[\w_]/o;
         $non_word = qr/[^\w_\s]/o;
-    }
 
+        $settings->{utf8} = $new_utf8;
+    }
     if ($new_utf8 and (!$^V or $^V lt v5.8.1)) {
         _warn("Warning: UTF-8 isn't supported very well in perl < 5.8.1! " .
               "Please disable the vim_mode_utf8 setting.");
     }
 
-    $utf8 = $new_utf8;
+    $settings->{max_undo_lines}
+        = Irssi::settings_get_int('vim_mode_max_undo_lines');
 }
 
 sub UNLOAD {
@@ -2545,7 +2555,7 @@ sub _add_undo_entry {
         unshift @undo_buffer, [$line, $pos];
         $undo_index = 0;
     }
-    my $max = Irssi::settings_get_int('vim_mode_max_undo_lines');
+    my $max = $settings->{max_undo_lines};
 }
 
 sub _restore_undo_entry {
@@ -2671,12 +2681,12 @@ sub _input {
 
     my $current_data = Irssi::parse_special('$L', 0, 0);
 
-    if ($utf8) {
+    if ($settings->{utf8}) {
         $current_data = decode_utf8($current_data);
     }
 
     if (defined $data) {
-        if ($utf8) {
+        if ($settings->{utf8}) {
             Irssi::gui_input_set(encode_utf8($data));
         } else {
             Irssi::gui_input_set($data);
-- 
cgit v1.2.3


From c0af8a14674404f878c0c97bfc684e98ec0a2289 Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Thu, 14 Oct 2010 22:31:42 +0200
Subject: vim_mode: Add :se[t].

---
 vim-mode/vim_mode.pl | 105 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 82 insertions(+), 23 deletions(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index ac859a2..58d153f 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -81,6 +81,9 @@
 # * Substitute:        :s/// - i and g are supported as flags, only /// can be
 #                              used as separator, uses Perl regex instead of
 #                              Vim regex
+# * Settings:          :se[t]                  - display all options
+#                      :se[t] {option}         - display all matching options
+#                      :se[t] {option} {value} - change option to value
 #
 #
 # Mappings:
@@ -102,11 +105,19 @@
 #     :unmap <C-E>     - restore default behavior of <C-E> after disabling it
 #
 #
-# The following irssi settings are available:
+# Settings:
+#
+# The settings are stored as irssi settings and can be set using /set as usual
+# (prepend vim_mode_ to setting name) or using the :set ex-command. The
+# following settings are available:
+#
+# * utf8: support UTF-8 characters, boolean, default on
+# * debug: enable debug output, boolean, default off
+# * cmd_seq: char that when double-pressed simulates <esc>, string, default ''
+#
+# In contrast to irssi's settings, :set accepts 0 and 1 as values for boolean
+# settings.
 #
-# * vim_mode_utf8: support UTF-8 characters, default on
-# * vim_mode_debug: enable debug output, default off
-# * vim_mode_cmd_seq: char that when double-pressed simulates <esc>
 #
 # The following statusbar items are available:
 #
@@ -259,6 +270,11 @@ sub C_IRSSI () { 6 }
 # does nothing
 sub C_NOP () { 7 }
 
+# setting types, match irssi types as they are stored as irssi settings
+sub S_BOOL () { 0 }
+sub S_INT  () { 1 }
+sub S_STR  () { 2 }
+
 # word and non-word regex, keep in sync with setup_changed()!
 my $word     = qr/[\w_]/o;
 my $non_word = qr/[^\w_\s]/o;
@@ -439,6 +455,10 @@ my $commands_ex
                     type => C_EX },
      mkv       => { char => ':mkv',       func => \&ex_mkvimrc,
                     type => C_EX },
+     se        => { char => ':se',        func => \&ex_set,
+                    type => C_EX },
+     set       => { char => ':set',       func => \&ex_set,
+                    type => C_EX },
     };
 
 # MAPPINGS
@@ -458,16 +478,16 @@ foreach my $char (keys %$commands) {
 my $settings
   = {
      # print debug output
-     debug          => 0,
+     debug          => { type => S_BOOL, value => 0 },
      # use UTF-8 internally for string calculations/manipulations
-     utf8           => 1,
+     utf8           => { type => S_BOOL, value => 1 },
      # esc-shortcut in insert mode
-     cmd_seq        => '',
+     cmd_seq        => { type => S_STR,  value => '' },
      # not used yet
-     max_undo_lines => 50,
+     max_undo_lines => { type => S_INT,  value => 50 },
     };
 
-sub DEBUG { $settings->{debug} }
+sub DEBUG { $settings->{debug}->{value} }
 
 # buffer to keep track of the last N keystrokes, used for Esc detection and
 # insert mode mappings
@@ -720,7 +740,7 @@ sub cmd_j {
     } elsif ($history_index >= 0) {
         my $history = $history[$history_index];
         # History is not in UTF-8!
-        if ($settings->{utf8}) {
+        if ($settings->{utf8}->{value}) {
             $history = decode_utf8($history);
         }
         _input($history);
@@ -752,7 +772,7 @@ sub cmd_k {
     if ($history_index >= 0) {
         my $history = $history[$history_index];
         # History is not in UTF-8!
-        if ($settings->{utf8}) {
+        if ($settings->{utf8}->{value}) {
             $history = decode_utf8($history);
         }
         _input($history);
@@ -789,7 +809,7 @@ sub cmd_G {
 
     my $history = $history[$history_index];
     # History is not in UTF-8!
-    if ($settings->{utf8}) {
+    if ($settings->{utf8}->{value}) {
         $history = decode_utf8($history);
     }
     _input($history);
@@ -1878,6 +1898,45 @@ sub ex_mkvimrc {
     close $file;
 }
 
+sub ex_set {
+    my ($arg_str, $count) = @_;
+
+    # :se[t] [option] [value]
+    if ($arg_str =~ /^se(?:t)?(?:\s(\S+)(?:\s(.+)$)?)?/) {
+        # :se[t] {option} {value}
+        if (defined $1 and defined $2) {
+            if (not exists $settings->{$1}) {
+                return _warn_ex('map', "setting '$1' not found");
+            }
+            my $name = $1;
+            my $value = $2;
+            # Also accept numeric values for boolean options.
+            if ($settings->{$name}->{type} == S_BOOL and
+                    $value !~ /^(on|off)$/) {
+                $value = $value ? 'on' : 'off';
+            }
+            Irssi::command("set vim_mode_$name $value");
+
+        # :se[t] [option]
+        } else {
+            my $search = defined $1 ? $1 : '';
+            my $active_window = Irssi::active_win();
+            foreach my $setting (sort keys %$settings) {
+                next if $setting !~ /^\Q$search\E/; # skip non-matches
+                my $value = $settings->{$setting}->{value};
+                # Irssi only accepts 'on' and 'off' as values for boolean
+                # options.
+                if ($settings->{$setting}->{type} == S_BOOL) {
+                    $value = $value ? 'on' : 'off';
+                }
+                $active_window->print($setting . '=' . $value);
+            }
+        }
+    } else {
+        _warn_ex('map');
+    }
+}
+
 sub _warn_ex {
     my ($command, $description) = @_;
     my $message = "Error in ex-mode command $command";
@@ -2489,39 +2548,39 @@ sub vim_mode_init {
 sub setup_changed {
     my $value;
 
-    if ($settings->{cmd_seq} ne '') {
-        delete $imaps->{$settings->{cmd_seq}};
+    if ($settings->{cmd_seq}->{value} ne '') {
+        delete $imaps->{$settings->{cmd_seq}->{value}};
     }
     $value = Irssi::settings_get_str('vim_mode_cmd_seq');
     if ($value eq '') {
-        $settings->{cmd_seq} = $value;
+        $settings->{cmd_seq}->{value} = $value;
     } else {
         if (length $value == 1) {
             $imaps->{$value} = { 'map'  => $value,
                                  'func' => sub { _update_mode(M_CMD) }
                                };
-            $settings->{cmd_seq} = $value;
+            $settings->{cmd_seq}->{value} = $value;
         } else {
             _warn("Error: vim_mode_cmd_seq must be a single character");
         }
     }
 
-    $settings->{debug} = Irssi::settings_get_bool('vim_mode_debug');
+    $settings->{debug}->{value} = Irssi::settings_get_bool('vim_mode_debug');
 
     my $new_utf8 = Irssi::settings_get_bool('vim_mode_utf8');
-    if ($new_utf8 != $settings->{utf8}) {
+    if ($new_utf8 != $settings->{utf8}->{value}) {
         # recompile the patterns when switching to/from utf-8
         $word     = qr/[\w_]/o;
         $non_word = qr/[^\w_\s]/o;
 
-        $settings->{utf8} = $new_utf8;
+        $settings->{utf8}->{value} = $new_utf8;
     }
     if ($new_utf8 and (!$^V or $^V lt v5.8.1)) {
         _warn("Warning: UTF-8 isn't supported very well in perl < 5.8.1! " .
               "Please disable the vim_mode_utf8 setting.");
     }
 
-    $settings->{max_undo_lines}
+    $settings->{max_undo_lines}->{value}
         = Irssi::settings_get_int('vim_mode_max_undo_lines');
 }
 
@@ -2555,7 +2614,7 @@ sub _add_undo_entry {
         unshift @undo_buffer, [$line, $pos];
         $undo_index = 0;
     }
-    my $max = $settings->{max_undo_lines};
+    my $max = $settings->{max_undo_lines}->{value};
 }
 
 sub _restore_undo_entry {
@@ -2681,12 +2740,12 @@ sub _input {
 
     my $current_data = Irssi::parse_special('$L', 0, 0);
 
-    if ($settings->{utf8}) {
+    if ($settings->{utf8}->{value}) {
         $current_data = decode_utf8($current_data);
     }
 
     if (defined $data) {
-        if ($settings->{utf8}) {
+        if ($settings->{utf8}->{value}) {
             Irssi::gui_input_set(encode_utf8($data));
         } else {
             Irssi::gui_input_set($data);
-- 
cgit v1.2.3


From d1447815225b8c60db83dd687661e203314f707f Mon Sep 17 00:00:00 2001
From: Simon Ruderich <simon@ruderich.org>
Date: Thu, 14 Oct 2010 22:33:36 +0200
Subject: vim_mode: Mention that :set only sets vim_mode settings.

---
 vim-mode/vim_mode.pl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'vim-mode/vim_mode.pl')

diff --git a/vim-mode/vim_mode.pl b/vim-mode/vim_mode.pl
index 58d153f..6ff8c78 100644
--- a/vim-mode/vim_mode.pl
+++ b/vim-mode/vim_mode.pl
@@ -116,7 +116,7 @@
 # * cmd_seq: char that when double-pressed simulates <esc>, string, default ''
 #
 # In contrast to irssi's settings, :set accepts 0 and 1 as values for boolean
-# settings.
+# settings, but only vim_mode's settings can be set/displayed.
 #
 #
 # The following statusbar items are available:
-- 
cgit v1.2.3