AnyEvent-ReadLine/ReadLine.pm

=head1 NAME

AnyEvent::ReadLine - simple but versatile readline implementation

=head1 SYNOPSIS

 use AnyEvent::ReadLine;

=head1 DESCRIPTION

This module implements some kind of readline interface - something that
allows you to read a (command-) line entered by the user, and allows the
user to comfortably (hopefully) edit it.

Basically, this module implements something like perl's C<readline>
function, except potentially with user editing.

There are a multitude of readline modules and -implementations available
for Perl. The difference of this module to others is that it takes pipes,
network sockets and other generic file handles into account, in addition
to traditional tty interfaces.

=over 4

=cut

package AnyEvent::ReadLine;

use common::sense;
use Scalar::Util ();
use Errno ();
use Term::Terminfo ();
use AnyEvent;

our $VERSION = '0.0';

=item $rl = new AnyEvent::ReadLine key => value...

Creates a new AnyEvent::ReadLine object.

The key value pairs that are understood are the following:

=over 4

=item fh => $fh

The file handle used to read user input from.

=item ofh => $fh

The file handle used to write feedback to - defaults to C<fh>.

=item mode => "none"|"termios"|"telnet"

Governs how the terminal is driven. Defaults to C<termios> when
C<fh> is connected to a tty, C<none> otherwise.

=item term => $terminfo

The terminfo name of the attached terminal - in termios mode, defaults
to C<$ENV{TERM}>, otherwise the default is C<ansi> which works in most
situations.

=item prompt => $prompt

The prompt string to use (default: C<< > >>). C<$prompt> can also be
a code reference that returns the prompt, and will be called on every
redisplay.

=item timeout => $seconds

After how many seconds a key sequence is considered complete. To
differentiate between, say, the escape key and typical arrow key sequences
a timeout needs to be used. The default is 0.02 in termios mode, and 0.1
in all others.

=item encoding => $encoding

The encoding of the terminal. Only "utf-8" and "iso-8859-1" are supported
at the moment, because Perl apparently has no incremental decoding
facilities (Encode can't do it, perlio can't do it).

The default is utf-8, until I can find out how to detect if a filehandle
is in utf-8 mode without resorting to undocumented functionality.

=item width => $width

=item height => $height

The width and height of the screen - these will be updated to the true
widht and height if possible.

=item on_read => $cb->($rl, $string)

Called each time the user is finished entering a line. The string is in
unicode format.

=item on_eof => $cb->($rl)

Called when an EOF is detected on the input file handle. Must eventually
destroy the object.

=item on_error => $cb->($rl, "$!")

Called on any unhandled error that occured. Second argument is a string
describing the saituation, C<$!> contains the actual error.

=item on_change => $cb->($rl, $string, $pos)

When specified, C<ofh> is ignored - each time the presentation changes,
this callback is called with the string to display (including any prompt)
and the position of the cursor inside the string.

The string is in unicode (and thus C<$pos> is a character position) - to
output it, you normally must encode it first.

=item on_key_XXX => $cb->($rl, $key)

Each time a key XXX in the keymap is entered, this callback will be
invoked if it exists. It may want to invoke the original C<key_XXX>
method.

=back

=cut

sub new {
   my $class = shift;

   my $self = bless {
      prompt => "> ",
      @_,
      raw    => 0,
   }, $class;

   $self->{ofh}  ||= $self->{fh};
   $self->{mode} ||= -t $self->{fh} ? "termios" : "none";

   $self->{timeout} ||= $self->{mode} eq "termios" ? 0.02 : 0.1;
   $self->{encoding} ||= "utf-8";

   $self->set_term ((delete $self->{term}) || ($self->{mode} eq "termios" && $ENV{TERM}) || "ansi");

   {
      Scalar::Util::weaken (my $self = $self);

      $self->{tcb} = sub {
         delete $self->{tw};
         $self->feed;
      };

      $self->{rcb} = sub {
         my $len = sysread $self->{fh}, $self->{rbuf}, 1, length $self->{rbuf};
         if ($len) {
            $self->{tw} = AE::timer $self->{timeout}, 0, $self->{tcb};
         } elsif (defined $len) {
            $self->{on_eof}
               ? $self->{on_eof}($self)
               : $self->{on_error}($self, 0, "unexpected end of file");
         } elsif ($! != Errno::EAGAIN && $! != Errno::EINTR) {
            $self->{on_error}($self, $!, "$!");
         }
      };

      $self->{wcb} = sub {
         my $len = syswrite $self->{ofh}, $self->{wbuf};
         substr $self->{wbuf}, 0, $len, "";
         delete $self->{ww} unless length $self->{wbuf};
         # todo error handling
      };
   }

   $self->enable;

   $self
}

sub DESTROY {
   my ($self) = @_;

   $self->disable;
}

sub default_keymap {
   my ($self) = @_;

   my %keymap;

   for (0..31) {
      $keymap{chr $_      } = "ctrl$_";
      $keymap{chr $_ + 128} = "hctrl$_";
   }

   $keymap{"\x03"} = "intr";
   $keymap{"\x04"} = "eof";
   $keymap{"\x08"} = "backspace"; # common
   $keymap{"\x0a"} = "enter";
   $keymap{"\x0c"} = "redraw";
   $keymap{"\x0d"} = "enter";
   $keymap{"\x15"} = "kill";
   $keymap{"\x17"} = "werase";
   $keymap{"\x1a"} = "susp";
   $keymap{"\x1b"} = "esc";
   $keymap{"\x1c"} = "quit";
   $keymap{"\x7f"} = "backspace"; # correct

   if (my $ti =  $self->{ti}) {
#      for my $func (qw(up down left right enter backspace dc)) {
#         $keymap{$ti->str_by_varname ("key_$func")} = $func;
#      }
      # we bind all keys that have known sequences, to avoid
      # inserting their raw codes when we don't understand them
      for my $key (grep s/^key_//, $ti->str_varnames) {
         my $str = $ti->str_by_varname ("key_$key");
         $key =~ y/a-z0-9_//cd; # increase security - these are used for method calls
         $keymap{$str} = $key;
      }
   }

   if ($self->{mode} eq "termios") {
      require POSIX;

      my $tio = POSIX::Termios->new;
      if ($tio->getattr (fileno $self->{fh})) {
         $keymap{chr $tio->getcc (&POSIX::VINTR )} = "intr";
         $keymap{chr $tio->getcc (&POSIX::VSUSP )} = "susp";
         $keymap{chr $tio->getcc (&POSIX::VEOF  )} = "eof";
         $keymap{chr $tio->getcc (&POSIX::VEOL  )} = "enter";
         $keymap{chr $tio->getcc (&POSIX::VKILL )} = "kill";
         $keymap{chr $tio->getcc (&POSIX::VERASE)} = "backspace";
         $keymap{chr $tio->getcc (&POSIX::VQUIT )} = "quit";
      }
   }

   # delete some garbage the above might create
   delete $keymap{""};
   delete $keymap{"\0"};

   # keymap MUST be nonempty (which must be the case by now)

   $self->{keymap} = \%keymap;
   delete $self->{ckm};
}

sub set_term {
   my ($self, $term) = @_;

   return if $self->{term} eq $term;

   $self->{term} = $term;
   $self->{ti} = new Term::Terminfo $term;

   $self->default_keymap;
}

sub enable {
   my ($self) = @_;

   return if $self->{raw};

   if ($self->{mode} eq "termios") {
      require POSIX;

      $self->{tio} = POSIX::Termios->new;
      $self->{tio}->getattr (fileno $self->{fh})
         or return;

      my $tio = POSIX::Termios->new;
      $tio->getattr (fileno $self->{fh})
         or return;

      $tio->setiflag ($tio->getiflag
         & ~&POSIX::BRKINT
         & ~&POSIX::IGNBRK
         & ~&POSIX::ISTRIP
      );
      $tio->setlflag ($tio->getlflag
         & ~&POSIX::ECHO
         & ~&POSIX::ECHONL
         & ~&POSIX::ICANON
#         & ~&POSIX::ISIG #d#
      );

      $tio->setattr (fileno $self->{fh});
   }

   $self->line_draw unless $self->{on_change};

   $self->{rw} = AE::io $self->{fh}, 0, $self->{rcb};

   $self->{raw} = 1;
}

sub disable {
   my ($self) = @_;

   return unless $self->{raw};

   $self->line_erase unless $self->{on_change};

   delete $self->{rw};

   if ($self->{mode} eq "termios") {
      (delete $self->{tio})->setattr (fileno $self->{fh});
   }

   $self->{raw} = 0;
}

sub strwidth {
   scalar (my @dummy = $_[0] =~ /\p{Print}/g)
   - scalar (my @dummy = $_[0] =~ /\p{Mark}/g)
   + scalar (my @dummy = $_[0] =~ /\p{East_Asian_Width=Wide}/g)
}

sub write {
   my ($self, $data) = @_;

   $self->{wbuf} .= $data;

   $self->{ww} ||= AE::io $self->{ofh}, 1, $self->{wcb};
}

sub line_erase {
   my ($self) = @_;

   $self->write (
      ("\x08" x $self->{bpos})
    . (" "    x $self->{blen})
    . ("\x08" x $self->{blen})
   );

   $self->{bpos} = 0;
   $self->{blen} = 0;
}

sub line_draw {
   my ($self) = @_;

   my $prompt = $self->{prompt};
   $prompt = $prompt->($self) if ref $prompt;

   my $l = $prompt . substr $self->{lbuf}, 0, $self->{pos};
   my $r =           substr $self->{lbuf}, $self->{pos};

   for ($l, $r) {
      s/(\P{Print})/sprintf "\\x{%x}", ord $1/ge;
   }

   my $wl = strwidth $l;
   my $wr = strwidth $r;

   $self->{blen} = $wl + $wr + 6; # erase a bit more, to feel better
   $self->{bpos} = $wl;

   my $buf = $prompt . $self->{lbuf};

   utf8::encode $buf if $self->{encoding} eq "utf-8";

   $self->write ($buf . ("\x08" x $wr));
}

sub refresh {
   my ($self) = @_;

   if ($self->{on_change}) {
      $self->{on_change}($self, $self->{lbuf}, $self->{pos});
   } else {
      $self->line_erase;
      $self->line_draw;
   }
}

sub msg {
   my ($self, $msg) = @_;

   return if $self->{on_change};

   $self->disable;
   $self->write ("$msg\x0d\x0a");
   $self->enable;
}

sub feed {
   my ($self) = @_;

   # TODO: telnet

   # decode the input bytes into unicode

   if ($self->{encoding} eq "utf-8") {
      while ($self->{rbuf} =~ s/^([\x00-\x7f]|[\x80-\xff]+)//) {
         my $c = $1;
         utf8::decode $c; # if fails, we use $c as-is
         $self->{input} .= $c;
      }
   } else {
      $self->{input} .= delete $self->{rbuf};
   }

   # compile keymap, if not done yet

   $self->{ckm} ||= do {
      # compile keymap
      my $re = join "|", map quotemeta, reverse sort keys %{ $self->{keymap} };
      qr<^($re)>
   };

   # now try to match input sequences

   for ($self->{input}) {
      while () {
         if (s/$self->{ckm}//) {
            if (my $key = $self->{keymap}{$1}) {
               ($self->{"on_$key"}
                || (UNIVERSAL::can $self, "key_$key")
                || sub { $self->msg ("$_[1]: unsupported key") }
               )->($self, $key);
            }
         } elsif (s/^(.)//) {
            substr $self->{lbuf}, $self->{pos}, 0, $1;
            $self->{pos} += length $1; # always 1

            $self->refresh;
         } else {
            last;
         }
      }
   }
}

#############################################################################

my $rl = new AnyEvent::ReadLine
   fh  => \*STDIN,
   ofh => \*STDOUT,
   term => "ansi",
   prompt => sub { AE::time . "> " },
   on_eof => sub { die "eof" },
   on_error => sub { die "<@_>" },
;

my $t = AE::timer 5, 0, sub { $rl->disable; exit };
$rl->enable;

AE::cv->recv;

1;

=back

=head1 AUTHOR AND CONTACT

 Marc Lehmann <schmorp@schmorp.de>
 http://software.schmorp.de/pkg/AnyEvent-Readline.html

=cut

Revision:	1.1
Committed:	Sat May 26 10:47:26 2012 UTC (12 years ago) by root
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	=head1 NAME
2
3			AnyEvent::ReadLine - simple but versatile readline implementation
4
5			=head1 SYNOPSIS
6
7			use AnyEvent::ReadLine;
8
9			=head1 DESCRIPTION
10
11			This module implements some kind of readline interface - something that
12			allows you to read a (command-) line entered by the user, and allows the
13			user to comfortably (hopefully) edit it.
14
15			Basically, this module implements something like perl's C<readline>
16			function, except potentially with user editing.
17
18			There are a multitude of readline modules and -implementations available
19			for Perl. The difference of this module to others is that it takes pipes,
20			network sockets and other generic file handles into account, in addition
21			to traditional tty interfaces.
22
23			=over 4
24
25			=cut
26
27			package AnyEvent::ReadLine;
28
29			use common::sense;
30			use Scalar::Util ();
31			use Errno ();
32			use Term::Terminfo ();
33			use AnyEvent;
34
35			our $VERSION = '0.0';
36
37			=item $rl = new AnyEvent::ReadLine key => value...
38
39			Creates a new AnyEvent::ReadLine object.
40
41			The key value pairs that are understood are the following:
42
43			=over 4
44
45			=item fh => $fh
46
47			The file handle used to read user input from.
48
49			=item ofh => $fh
50
51			The file handle used to write feedback to - defaults to C<fh>.
52
53			=item mode => "none"\|"termios"\|"telnet"
54
55			Governs how the terminal is driven. Defaults to C<termios> when
56			C<fh> is connected to a tty, C<none> otherwise.
57
58			=item term => $terminfo
59
60			The terminfo name of the attached terminal - in termios mode, defaults
61			to C<$ENV{TERM}>, otherwise the default is C<ansi> which works in most
62			situations.
63
64			=item prompt => $prompt
65
66			The prompt string to use (default: C<< > >>). C<$prompt> can also be
67			a code reference that returns the prompt, and will be called on every
68			redisplay.
69
70			=item timeout => $seconds
71
72			After how many seconds a key sequence is considered complete. To
73			differentiate between, say, the escape key and typical arrow key sequences
74			a timeout needs to be used. The default is 0.02 in termios mode, and 0.1
75			in all others.
76
77			=item encoding => $encoding
78
79			The encoding of the terminal. Only "utf-8" and "iso-8859-1" are supported
80			at the moment, because Perl apparently has no incremental decoding
81			facilities (Encode can't do it, perlio can't do it).
82
83			The default is utf-8, until I can find out how to detect if a filehandle
84			is in utf-8 mode without resorting to undocumented functionality.
85
86			=item width => $width
87
88			=item height => $height
89
90			The width and height of the screen - these will be updated to the true
91			widht and height if possible.
92
93			=item on_read => $cb->($rl, $string)
94
95			Called each time the user is finished entering a line. The string is in
96			unicode format.
97
98			=item on_eof => $cb->($rl)
99
100			Called when an EOF is detected on the input file handle. Must eventually
101			destroy the object.
102
103			=item on_error => $cb->($rl, "$!")
104
105			Called on any unhandled error that occured. Second argument is a string
106			describing the saituation, C<$!> contains the actual error.
107
108			=item on_change => $cb->($rl, $string, $pos)
109
110			When specified, C<ofh> is ignored - each time the presentation changes,
111			this callback is called with the string to display (including any prompt)
112			and the position of the cursor inside the string.
113
114			The string is in unicode (and thus C<$pos> is a character position) - to
115			output it, you normally must encode it first.
116
117			=item on_key_XXX => $cb->($rl, $key)
118
119			Each time a key XXX in the keymap is entered, this callback will be
120			invoked if it exists. It may want to invoke the original C<key_XXX>
121			method.
122
123			=back
124
125			=cut
126
127			sub new {
128			my $class = shift;
129
130			my $self = bless {
131			prompt => "> ",
132			@_,
133			raw => 0,
134			}, $class;
135
136			$self->{ofh} \|\|= $self->{fh};
137			$self->{mode} \|\|= -t $self->{fh} ? "termios" : "none";
138
139			$self->{timeout} \|\|= $self->{mode} eq "termios" ? 0.02 : 0.1;
140			$self->{encoding} \|\|= "utf-8";
141
142			$self->set_term ((delete $self->{term}) \|\| ($self->{mode} eq "termios" && $ENV{TERM}) \|\| "ansi");
143
144			{
145			Scalar::Util::weaken (my $self = $self);
146
147			$self->{tcb} = sub {
148			delete $self->{tw};
149			$self->feed;
150			};
151
152			$self->{rcb} = sub {
153			my $len = sysread $self->{fh}, $self->{rbuf}, 1, length $self->{rbuf};
154			if ($len) {
155			$self->{tw} = AE::timer $self->{timeout}, 0, $self->{tcb};
156			} elsif (defined $len) {
157			$self->{on_eof}
158			? $self->{on_eof}($self)
159			: $self->{on_error}($self, 0, "unexpected end of file");
160			} elsif ($! != Errno::EAGAIN && $! != Errno::EINTR) {
161			$self->{on_error}($self, $!, "$!");
162			}
163			};
164
165			$self->{wcb} = sub {
166			my $len = syswrite $self->{ofh}, $self->{wbuf};
167			substr $self->{wbuf}, 0, $len, "";
168			delete $self->{ww} unless length $self->{wbuf};
169			# todo error handling
170			};
171			}
172
173			$self->enable;
174
175			$self
176			}
177
178			sub DESTROY {
179			my ($self) = @_;
180
181			$self->disable;
182			}
183
184			sub default_keymap {
185			my ($self) = @_;
186
187			my %keymap;
188
189			for (0..31) {
190			$keymap{chr $_ } = "ctrl$_";
191			$keymap{chr $_ + 128} = "hctrl$_";
192			}
193
194			$keymap{"\x03"} = "intr";
195			$keymap{"\x04"} = "eof";
196			$keymap{"\x08"} = "backspace"; # common
197			$keymap{"\x0a"} = "enter";
198			$keymap{"\x0c"} = "redraw";
199			$keymap{"\x0d"} = "enter";
200			$keymap{"\x15"} = "kill";
201			$keymap{"\x17"} = "werase";
202			$keymap{"\x1a"} = "susp";
203			$keymap{"\x1b"} = "esc";
204			$keymap{"\x1c"} = "quit";
205			$keymap{"\x7f"} = "backspace"; # correct
206
207			if (my $ti = $self->{ti}) {
208			# for my $func (qw(up down left right enter backspace dc)) {
209			# $keymap{$ti->str_by_varname ("key_$func")} = $func;
210			# }
211			# we bind all keys that have known sequences, to avoid
212			# inserting their raw codes when we don't understand them
213			for my $key (grep s/^key_//, $ti->str_varnames) {
214			my $str = $ti->str_by_varname ("key_$key");
215			$key =~ y/a-z0-9_//cd; # increase security - these are used for method calls
216			$keymap{$str} = $key;
217			}
218			}
219
220			if ($self->{mode} eq "termios") {
221			require POSIX;
222
223			my $tio = POSIX::Termios->new;
224			if ($tio->getattr (fileno $self->{fh})) {
225			$keymap{chr $tio->getcc (&POSIX::VINTR )} = "intr";
226			$keymap{chr $tio->getcc (&POSIX::VSUSP )} = "susp";
227			$keymap{chr $tio->getcc (&POSIX::VEOF )} = "eof";
228			$keymap{chr $tio->getcc (&POSIX::VEOL )} = "enter";
229			$keymap{chr $tio->getcc (&POSIX::VKILL )} = "kill";
230			$keymap{chr $tio->getcc (&POSIX::VERASE)} = "backspace";
231			$keymap{chr $tio->getcc (&POSIX::VQUIT )} = "quit";
232			}
233			}
234
235			# delete some garbage the above might create
236			delete $keymap{""};
237			delete $keymap{"\0"};
238
239			# keymap MUST be nonempty (which must be the case by now)
240
241			$self->{keymap} = \%keymap;
242			delete $self->{ckm};
243			}
244
245			sub set_term {
246			my ($self, $term) = @_;
247
248			return if $self->{term} eq $term;
249
250			$self->{term} = $term;
251			$self->{ti} = new Term::Terminfo $term;
252
253			$self->default_keymap;
254			}
255
256			sub enable {
257			my ($self) = @_;
258
259			return if $self->{raw};
260
261			if ($self->{mode} eq "termios") {
262			require POSIX;
263
264			$self->{tio} = POSIX::Termios->new;
265			$self->{tio}->getattr (fileno $self->{fh})
266			or return;
267
268			my $tio = POSIX::Termios->new;
269			$tio->getattr (fileno $self->{fh})
270			or return;
271
272			$tio->setiflag ($tio->getiflag
273			& ~&POSIX::BRKINT
274			& ~&POSIX::IGNBRK
275			& ~&POSIX::ISTRIP
276			);
277			$tio->setlflag ($tio->getlflag
278			& ~&POSIX::ECHO
279			& ~&POSIX::ECHONL
280			& ~&POSIX::ICANON
281			# & ~&POSIX::ISIG #d#
282			);
283
284			$tio->setattr (fileno $self->{fh});
285			}
286
287			$self->line_draw unless $self->{on_change};
288
289			$self->{rw} = AE::io $self->{fh}, 0, $self->{rcb};
290
291			$self->{raw} = 1;
292			}
293
294			sub disable {
295			my ($self) = @_;
296
297			return unless $self->{raw};
298
299			$self->line_erase unless $self->{on_change};
300
301			delete $self->{rw};
302
303			if ($self->{mode} eq "termios") {
304			(delete $self->{tio})->setattr (fileno $self->{fh});
305			}
306
307			$self->{raw} = 0;
308			}
309
310			sub strwidth {
311			scalar (my @dummy = $_[0] =~ /\p{Print}/g)
312			- scalar (my @dummy = $_[0] =~ /\p{Mark}/g)
313			+ scalar (my @dummy = $_[0] =~ /\p{East_Asian_Width=Wide}/g)
314			}
315
316			sub write {
317			my ($self, $data) = @_;
318
319			$self->{wbuf} .= $data;
320
321			$self->{ww} \|\|= AE::io $self->{ofh}, 1, $self->{wcb};
322			}
323
324			sub line_erase {
325			my ($self) = @_;
326
327			$self->write (
328			("\x08" x $self->{bpos})
329			. (" " x $self->{blen})
330			. ("\x08" x $self->{blen})
331			);
332
333			$self->{bpos} = 0;
334			$self->{blen} = 0;
335			}
336
337			sub line_draw {
338			my ($self) = @_;
339
340			my $prompt = $self->{prompt};
341			$prompt = $prompt->($self) if ref $prompt;
342
343			my $l = $prompt . substr $self->{lbuf}, 0, $self->{pos};
344			my $r = substr $self->{lbuf}, $self->{pos};
345
346			for ($l, $r) {
347			s/(\P{Print})/sprintf "\\x{%x}", ord $1/ge;
348			}
349
350			my $wl = strwidth $l;
351			my $wr = strwidth $r;
352
353			$self->{blen} = $wl + $wr + 6; # erase a bit more, to feel better
354			$self->{bpos} = $wl;
355
356			my $buf = $prompt . $self->{lbuf};
357
358			utf8::encode $buf if $self->{encoding} eq "utf-8";
359
360			$self->write ($buf . ("\x08" x $wr));
361			}
362
363			sub refresh {
364			my ($self) = @_;
365
366			if ($self->{on_change}) {
367			$self->{on_change}($self, $self->{lbuf}, $self->{pos});
368			} else {
369			$self->line_erase;
370			$self->line_draw;
371			}
372			}
373
374			sub msg {
375			my ($self, $msg) = @_;
376
377			return if $self->{on_change};
378
379			$self->disable;
380			$self->write ("$msg\x0d\x0a");
381			$self->enable;
382			}
383
384			sub feed {
385			my ($self) = @_;
386
387			# TODO: telnet
388
389			# decode the input bytes into unicode
390
391			if ($self->{encoding} eq "utf-8") {
392			while ($self->{rbuf} =~ s/^([\x00-\x7f]\|[\x80-\xff]+)//) {
393			my $c = $1;
394			utf8::decode $c; # if fails, we use $c as-is
395			$self->{input} .= $c;
396			}
397			} else {
398			$self->{input} .= delete $self->{rbuf};
399			}
400
401			# compile keymap, if not done yet
402
403			$self->{ckm} \|\|= do {
404			# compile keymap
405			my $re = join "\|", map quotemeta, reverse sort keys %{ $self->{keymap} };
406			qr<^($re)>
407			};
408
409			# now try to match input sequences
410
411			for ($self->{input}) {
412			while () {
413			if (s/$self->{ckm}//) {
414			if (my $key = $self->{keymap}{$1}) {
415			($self->{"on_$key"}
416			\|\| (UNIVERSAL::can $self, "key_$key")
417			\|\| sub { $self->msg ("$_[1]: unsupported key") }
418			)->($self, $key);
419			}
420			} elsif (s/^(.)//) {
421			substr $self->{lbuf}, $self->{pos}, 0, $1;
422			$self->{pos} += length $1; # always 1
423
424			$self->refresh;
425			} else {
426			last;
427			}
428			}
429			}
430			}
431
432			#############################################################################
433
434			my $rl = new AnyEvent::ReadLine
435			fh => \*STDIN,
436			ofh => \*STDOUT,
437			term => "ansi",
438			prompt => sub { AE::time . "> " },
439			on_eof => sub { die "eof" },
440			on_error => sub { die "<@_>" },
441			;
442
443			my $t = AE::timer 5, 0, sub { $rl->disable; exit };
444			$rl->enable;
445
446			AE::cv->recv;
447
448			1;
449
450			=back
451
452			=head1 AUTHOR AND CONTACT
453
454			Marc Lehmann <schmorp@schmorp.de>
455			http://software.schmorp.de/pkg/AnyEvent-Readline.html
456
457			=cut
458