home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December (Special) / PCWorld_2005-12_Special_cd.bin / Bezpecnost / lsti / lsti.exe / framework-2.5.exe / Gnu.pm < prev    next >
Text File  |  2004-10-17  |  48KB  |  1,912 lines
  1. #
  2. #    Gnu.pm --- The GNU Readline/History Library wrapper module
  3. #
  4. #    $Id: Gnu.pm,v 1.95 2004-10-17 12:44:43-05 hiroo Exp $
  5. #
  6. #    Copyright (c) 2004 Hiroo Hayashi.  All rights reserved.
  7. #
  8. #    This program is free software; you can redistribute it and/or
  9. #    modify it under the same terms as Perl itself.
  10. #
  11. #    Some of documentation strings in this file are cited from the
  12. #    GNU Readline/History Library Manual.
  13.  
  14. package Term::ReadLine::Gnu;
  15.  
  16. =head1 NAME
  17.  
  18. Term::ReadLine::Gnu - Perl extension for the GNU Readline/History Library
  19.  
  20. =head1 SYNOPSIS
  21.  
  22.   use Term::ReadLine;
  23.   $term = new Term::ReadLine 'ProgramName';
  24.   while ( defined ($_ = $term->readline('prompt>')) ) {
  25.     ...
  26.   }
  27.  
  28. =head1 DESCRIPTION
  29.  
  30. =head2 Overview
  31.  
  32. This is an implementation of Term::ReadLine using the GNU
  33. Readline/History Library.
  34.  
  35. For basic functions object oriented interface is provided. These are
  36. described in the section L<"Standard Methods"|"Standard Methods"> and
  37. L<"C<Term::ReadLine::Gnu> Functions"|"C<Term::ReadLine::Gnu> Functions">.
  38.  
  39. This package also has the interface with the almost all functions and
  40. variables which are documented in the GNU Readline/History Library
  41. Manual.  They are documented in the section
  42. L<"C<Term::ReadLine::Gnu> Functions"|"C<Term::ReadLine::Gnu> Functions">
  43. and
  44. L<"C<Term::ReadLine::Gnu> Variables"|"C<Term::ReadLine::Gnu> Variables">
  45. briefly.  For more detail of the GNU Readline/History Library, see
  46. 'GNU Readline Library Manual' and 'GNU History Library Manual'.
  47.  
  48. The sample programs under C<eg/> directory and test programs under
  49. C<t/> directory in the C<Term::ReadLine::Gnu> distribution include
  50. many example of this module.
  51.  
  52. =head2 Standard Methods
  53.  
  54. These methods are standard methods defined by B<Term::ReadLine>.
  55.  
  56. =cut
  57.  
  58. use strict;
  59. use Carp;
  60.  
  61. # This module can't be loaded directly.
  62. BEGIN {
  63.     if (not defined $Term::ReadLine::VERSION) {
  64.         croak <<END;
  65. It is invalid to load Term::ReadLine::Gnu directly.  Please consult
  66. the Term::ReadLine documentation for more information.
  67. END
  68.     }
  69. }
  70.  
  71. {
  72.     use Exporter ();
  73.     use DynaLoader;
  74.     use vars qw($VERSION @ISA @EXPORT_OK);
  75.  
  76.     $VERSION = '1.15';
  77.  
  78.     # Term::ReadLine::Gnu::AU makes a function in
  79.     # `Term::ReadLine::Gnu::XS' as a method.
  80.     # The namespace of Term::ReadLine::Gnu::AU is searched before ones
  81.     # of other classes
  82.     @ISA = qw(Term::ReadLine::Gnu::AU Term::ReadLine::Stub
  83.           Exporter DynaLoader);
  84.  
  85.     @EXPORT_OK = qw(RL_PROMPT_START_IGNORE RL_PROMPT_END_IGNORE
  86.             NO_MATCH SINGLE_MATCH MULT_MATCH
  87.             ISFUNC ISKMAP ISMACR
  88.             UNDO_DELETE UNDO_INSERT UNDO_BEGIN UNDO_END
  89.             RL_STATE_NONE RL_STATE_INITIALIZING
  90.             RL_STATE_INITIALIZED RL_STATE_TERMPREPPED
  91.             RL_STATE_READCMD RL_STATE_METANEXT
  92.             RL_STATE_DISPATCHING RL_STATE_MOREINPUT
  93.             RL_STATE_ISEARCH RL_STATE_NSEARCH
  94.             RL_STATE_SEARCH RL_STATE_NUMERICARG
  95.             RL_STATE_MACROINPUT RL_STATE_MACRODEF
  96.             RL_STATE_OVERWRITE RL_STATE_COMPLETING
  97.             RL_STATE_SIGHANDLER RL_STATE_UNDOING
  98.             RL_STATE_DONE);
  99.  
  100.     bootstrap Term::ReadLine::Gnu $VERSION; # DynaLoader
  101. }
  102. require Term::ReadLine::Gnu::XS;
  103.  
  104. #    Global Variables
  105.  
  106. use vars qw(%Attribs %Features);
  107.  
  108. # Each variable in the GNU Readline Library is tied to an entry of
  109. # this hash (%Attribs).  By accessing the hash entry, you can read
  110. # and/or write the variable in the GNU Readline Library.  See the
  111. # package definition of Term::ReadLine::Gnu::Var and following code
  112. # for more details.
  113.  
  114. # Normal (non-tied) entries
  115. %Attribs  = (
  116.          MinLength => 1,
  117.          do_expand => 0,
  118.          completion_word => [],
  119.          term_set => ['', '', '', ''],
  120.         );
  121. %Features = (
  122.          appname => 1, minline => 1, autohistory => 1,
  123.          getHistory => 1, setHistory => 1, addHistory => 1,
  124.          readHistory => 1, writeHistory => 1,
  125.          preput => 1, attribs => 1, newTTY => 1,
  126.          tkRunning => Term::ReadLine::Stub->Features->{'tkRunning'},
  127.          ornaments => Term::ReadLine::Stub->Features->{'ornaments'},
  128.          stiflehistory => 1,
  129.         );
  130.  
  131. sub Attribs { \%Attribs; }
  132. sub Features { \%Features; }
  133.  
  134. #
  135. #    GNU Readline/History Library constant definition
  136. #    These are included in @EXPORT_OK.
  137.  
  138. # I can define these variables in XS code to use the value defined in
  139. # readline.h, etc.  But it needs some calling convention change and
  140. # will cause compatiblity problem. I hope the definition of these
  141. # constant value will not be changed.
  142.  
  143. # for non-printing characters in prompt string
  144. sub RL_PROMPT_START_IGNORE    { "\001"; }
  145. sub RL_PROMPT_END_IGNORE    { "\002"; }
  146.  
  147. # for rl_filename_quoting_function
  148. sub NO_MATCH     { 0; }
  149. sub SINGLE_MATCH { 1; }
  150. sub MULT_MATCH   { 2; }
  151.  
  152. # for rl_generic_bind, rl_function_of_keyseq
  153. sub ISFUNC    { 0; }
  154. sub ISKMAP    { 1; }
  155. sub ISMACR    { 2; }
  156.  
  157. # for rl_add_undo
  158. sub UNDO_DELETE    { 0; }
  159. sub UNDO_INSERT    { 1; }
  160. sub UNDO_BEGIN    { 2; }
  161. sub UNDO_END    { 3; }
  162.  
  163. # for rl_readline_state
  164. sub RL_STATE_NONE        { 0x00000; } # no state; before first call
  165. sub RL_STATE_INITIALIZING    { 0x00001; } # initializing
  166. sub RL_STATE_INITIALIZED    { 0x00002; } # initialization done
  167. sub RL_STATE_TERMPREPPED    { 0x00004; } # terminal is prepped
  168. sub RL_STATE_READCMD        { 0x00008; } # reading a command key
  169. sub RL_STATE_METANEXT        { 0x00010; } # reading input after ESC
  170. sub RL_STATE_DISPATCHING    { 0x00020; } # dispatching to a command
  171. sub RL_STATE_MOREINPUT        { 0x00040; } # reading more input in a command function
  172. sub RL_STATE_ISEARCH        { 0x00080; } # doing incremental search
  173. sub RL_STATE_NSEARCH        { 0x00100; } # doing non-inc search
  174. sub RL_STATE_SEARCH        { 0x00200; } # doing a history search
  175. sub RL_STATE_NUMERICARG        { 0x00400; } # reading numeric argument
  176. sub RL_STATE_MACROINPUT        { 0x00800; } # getting input from a macro
  177. sub RL_STATE_MACRODEF        { 0x01000; } # defining keyboard macro
  178. sub RL_STATE_OVERWRITE        { 0x02000; } # overwrite mode
  179. sub RL_STATE_COMPLETING        { 0x04000; } # doing completion
  180. sub RL_STATE_SIGHANDLER        { 0x08000; } # in readline sighandler
  181. sub RL_STATE_UNDOING        { 0x10000; } # doing an undo
  182. sub RL_STATE_DONE        { 0x80000; } # done; accepted line
  183.  
  184. #
  185. #    Methods Definition
  186. #
  187.  
  188. =over 4
  189.  
  190. =item C<ReadLine>
  191.  
  192. returns the actual package that executes the commands. If you have
  193. installed this package,  possible value is C<Term::ReadLine::Gnu>.
  194.  
  195. =cut
  196.  
  197. sub ReadLine { 'Term::ReadLine::Gnu'; }
  198.  
  199. =item C<new(NAME,[IN[,OUT]])>
  200.  
  201. returns the handle for subsequent calls to following functions.
  202. Argument is the name of the application.  Optionally can be followed
  203. by two arguments for C<IN> and C<OUT> file handles. These arguments
  204. should be globs.
  205.  
  206. =cut
  207.  
  208. # The origin of this function is Term::ReadLine::Perl.pm by Ilya Zakharevich.
  209. sub new {
  210.     my $this = shift;        # Package
  211.     my $class = ref($this) || $this;
  212.  
  213.     my $name = shift;
  214.  
  215.     my $self = \%Attribs;
  216.     bless $self, $class;
  217.  
  218.     # set rl_readline_name before .inputrc is read in rl_initialize()
  219.     $Attribs{readline_name} = $name;
  220.  
  221.     # some version of Perl cause segmentation fault, if XS module
  222.     # calls setenv() before the 1st assignment to $ENV{}.
  223.     $ENV{_TRL_DUMMY} = '';
  224.  
  225.     # initialize the GNU Readline Library and termcap library
  226.     $self->initialize();
  227.  
  228.     # enable ornaments to be compatible with perl5.004_05(?)
  229.     unless ($ENV{PERL_RL} and $ENV{PERL_RL} =~ /\bo\w*=0/) {
  230.     local $^W = 0;        # Term::ReadLine is not warning flag free
  231.     # Without the next line Term::ReadLine::Stub::ornaments is used.
  232.     # Why does Term::ReadLine::Gnu::AU selects it at first?!!!
  233.     # If you know why this happens, please let me know.  Thanks.
  234.     undef &Term::ReadLine::Gnu::ornaments;
  235.     $self->ornaments(1);
  236.     }
  237.  
  238.     if (!@_) {
  239.     my ($IN,$OUT) = $self->findConsole();
  240.     open(IN,"<$IN")   || croak "Cannot open $IN for read";
  241.     open(OUT,">$OUT") || croak "Cannot open $OUT for write";
  242.     # borrowed from Term/ReadLine.pm
  243.     my $sel = select(OUT);
  244.     $| = 1;                # for DB::OUT
  245.     select($sel);
  246.     $Attribs{instream} = \*IN;
  247.     $Attribs{outstream} = \*OUT;
  248.     } else {
  249.     $Attribs{instream} = shift;
  250.     $Attribs{outstream} = shift;
  251.     }
  252.  
  253.     $self;
  254. }
  255.  
  256. sub DESTROY {}
  257.  
  258. =item C<readline(PROMPT[,PREPUT])>
  259.  
  260. gets an input line, with actual C<GNU Readline> support.  Trailing
  261. newline is removed.  Returns C<undef> on C<EOF>.  C<PREPUT> is an
  262. optional argument meaning the initial value of input.
  263.  
  264. The optional argument C<PREPUT> is granted only if the value C<preput>
  265. is in C<Features>.
  266.  
  267. C<PROMPT> may include some escape sequences.  Use
  268. C<RL_PROMPT_START_IGNORE> to begin a sequence of non-printing
  269. characters, and C<RL_PROMPT_END_IGNORE> to end of such a sequence.
  270.  
  271. =cut
  272.  
  273. # to peacify -w
  274. $Term::ReadLine::registered = $Term::ReadLine::registered;
  275.  
  276. sub readline {            # should be ReadLine
  277.     my $self = shift;
  278.     my ($prompt, $preput) = @_;
  279.  
  280.     # ornament support (now prompt only)
  281.     $prompt = ${$Attribs{term_set}}[0] . $prompt . ${$Attribs{term_set}}[1];
  282.  
  283.     # `completion_function' support for compatibility with
  284.     # Term:ReadLine::Perl.  Prefer $completion_entry_function, since a
  285.     # program which uses $completion_entry_function should know
  286.     # Term::ReadLine::Gnu and have better completion function using
  287.     # the variable.
  288.     $Attribs{completion_entry_function} = $Attribs{_trp_completion_function}
  289.     if (!defined $Attribs{completion_entry_function}
  290.         && defined $Attribs{completion_function});
  291.  
  292.     # TkRunning support
  293.     if (not $Term::ReadLine::registered and $Term::ReadLine::toloop
  294.     and defined &Tk::DoOneEvent) {
  295.     $self->register_Tk;
  296.     $Attribs{getc_function} = $Attribs{Tk_getc};
  297.     }
  298.  
  299.     # call readline()
  300.     my $line;
  301.     if (defined $preput) {
  302.     my $saved_startup_hook = $Attribs{startup_hook};
  303.     $Attribs{startup_hook} = sub {
  304.         $self->rl_insert_text($preput);
  305.         &$saved_startup_hook
  306.         if defined $saved_startup_hook;
  307.     };
  308.     $line = $self->rl_readline($prompt);
  309.     $Attribs{startup_hook} = $saved_startup_hook;
  310.     } else {
  311.     $line = $self->rl_readline($prompt);
  312.     }
  313.     return undef unless defined $line;
  314.  
  315.     # history expansion
  316.     if ($Attribs{do_expand}) {
  317.     my $result;
  318.     ($result, $line) = $self->history_expand($line);
  319.     my $outstream = $Attribs{outstream};
  320.     print $outstream "$line\n" if ($result);
  321.  
  322.     # return without adding line into history
  323.     if ($result < 0 || $result == 2) {
  324.         return '';        # don't return `undef' which means EOF.
  325.     }
  326.     }
  327.  
  328.     # add to history buffer
  329.     $self->add_history($line)
  330.     if (defined $self->{MinLength} && $self->{MinLength} > 0
  331.         && length($line) >= $self->{MinLength});
  332.  
  333.     return $line;
  334. }
  335.  
  336. =item C<AddHistory(LINE1, LINE2, ...)>
  337.  
  338. adds the lines to the history of input, from where it can be used if
  339. the actual C<readline> is present.
  340.  
  341. =cut
  342.  
  343. use vars '*addhistory';
  344. *addhistory = \&AddHistory;    # for backward compatibility
  345.  
  346. sub AddHistory {
  347.     my $self = shift;
  348.     foreach (@_) {
  349.     $self->add_history($_);
  350.     }
  351. }
  352.  
  353. =item C<IN>, C<OUT>
  354.  
  355. return the file handles for input and output or C<undef> if
  356. C<readline> input and output cannot be used for Perl.
  357.  
  358. =cut
  359.  
  360. sub IN  { $Attribs{instream}; }
  361. sub OUT { $Attribs{outstream}; }
  362.  
  363. =item C<MinLine([MAX])>
  364.  
  365. If argument C<MAX> is specified, it is an advice on minimal size of
  366. line to be included into history.  C<undef> means do not include
  367. anything into history.  Returns the old value.
  368.  
  369. =cut
  370.  
  371. sub MinLine {
  372.     my $self = shift;
  373.     my $old_minlength = $self->{MinLength};
  374.     $self->{MinLength} = shift;
  375.     $old_minlength;
  376. }
  377.  
  378. # findConsole is defined in ReadLine.pm.
  379.  
  380. =item C<findConsole>
  381.  
  382. returns an array with two strings that give most appropriate names for
  383. files for input and output using conventions C<"E<lt>$in">, C<"E<gt>$out">.
  384.  
  385. =item C<Attribs>
  386.  
  387. returns a reference to a hash which describes internal configuration
  388. (variables) of the package.  Names of keys in this hash conform to
  389. standard conventions with the leading C<rl_> stripped.
  390.  
  391. See section "Variables" for supported variables.
  392.  
  393. =item C<Features>
  394.  
  395. Returns a reference to a hash with keys being features present in
  396. current implementation. Several optional features are used in the
  397. minimal interface: C<appname> should be present if the first argument
  398. to C<new> is recognized, and C<minline> should be present if
  399. C<MinLine> method is not dummy.  C<autohistory> should be present if
  400. lines are put into history automatically (maybe subject to
  401. C<MinLine>), and C<addHistory> if C<AddHistory> method is not dummy. 
  402. C<preput> means the second argument to C<readline> method is processed.
  403. C<getHistory> and C<setHistory> denote that the corresponding methods are 
  404. present. C<tkRunning> denotes that a Tk application may run while ReadLine
  405. is getting input.
  406.  
  407. =cut
  408.  
  409. # Not tested yet.  How do I use this?
  410. sub newTTY {
  411.     my ($self, $in, $out) = @_;
  412.     $Attribs{instream}  = $in;
  413.     $Attribs{outstream} = $out;
  414.     my $sel = select($out);
  415.     $| = 1;            # for DB::OUT
  416.     select($sel);
  417. }
  418.  
  419. =back
  420.  
  421. =cut
  422.  
  423. # documented later
  424. sub CallbackHandlerInstall {
  425.     my $self = shift;
  426.     my ($prompt, $lhandler) = @_;
  427.  
  428.     $Attribs{_callback_handler} = $lhandler;
  429.  
  430.     # ornament support (now prompt only)
  431.     $prompt = ${$Attribs{term_set}}[0] . $prompt . ${$Attribs{term_set}}[1];
  432.  
  433.     $Attribs{completion_entry_function} = $Attribs{_trp_completion_function}
  434.     if (!defined $Attribs{completion_entry_function}
  435.         && defined $Attribs{completion_function});
  436.  
  437.     $self->rl_callback_handler_install($prompt,
  438.                        \&Term::ReadLine::Gnu::XS::_ch_wrapper);
  439. }
  440.  
  441.  
  442. #
  443. #    Additional Supported Methods
  444. #
  445.  
  446. # Documentation is after '__END__' for efficiency.
  447.  
  448. # for backward compatibility
  449. use vars qw(*AddDefun *BindKey *UnbindKey *ParseAndBind *StifleHistory);
  450. *AddDefun = \&add_defun;
  451. *BindKey = \&bind_key;
  452. *UnbindKey = \&unbind_key;
  453. *ParseAndBind = \&parse_and_bind;
  454. *StifleHistory = \&stifle_history;
  455.  
  456. sub SetHistory {
  457.     my $self = shift;
  458.     $self->clear_history();
  459.     $self->AddHistory(@_);
  460. }
  461.  
  462. sub GetHistory {
  463.     my $self = shift;
  464.     $self->history_list();
  465. }
  466.  
  467. sub ReadHistory {
  468.     my $self = shift;
  469.     ! $self->read_history_range(@_);
  470. }
  471.  
  472. sub WriteHistory {
  473.     my $self = shift;
  474.     ! $self->write_history(@_);
  475. }
  476.  
  477. #
  478. #    Access Routines for GNU Readline/History Library Variables
  479. #
  480. package Term::ReadLine::Gnu::Var;
  481. use Carp;
  482. use strict;
  483. use vars qw(%_rl_vars);
  484.  
  485. %_rl_vars
  486.     = (
  487.        rl_line_buffer                => ['S', 0],
  488.        rl_prompt                => ['S', 1],
  489.        rl_library_version            => ['S', 2],
  490.        rl_terminal_name                => ['S', 3],
  491.        rl_readline_name                => ['S', 4],
  492.        rl_basic_word_break_characters        => ['S', 5],
  493.        rl_basic_quote_characters        => ['S', 6],
  494.        rl_completer_word_break_characters    => ['S', 7],
  495.        rl_completer_quote_characters        => ['S', 8],
  496.        rl_filename_quote_characters        => ['S', 9],
  497.        rl_special_prefixes            => ['S', 10],
  498.        history_no_expand_chars            => ['S', 11],
  499.        history_search_delimiter_chars        => ['S', 12],
  500.        rl_executing_macro            => ['S', 13], # GRL4.2
  501.        history_word_delimiters            => ['S', 14], # GRL4.2
  502.  
  503.        rl_point                    => ['I', 0],
  504.        rl_end                    => ['I', 1],
  505.        rl_mark                    => ['I', 2],
  506.        rl_done                    => ['I', 3],
  507.        rl_pending_input                => ['I', 4],
  508.        rl_completion_query_items        => ['I', 5],
  509.        rl_completion_append_character        => ['C', 6],
  510.        rl_ignore_completion_duplicates        => ['I', 7],
  511.        rl_filename_completion_desired        => ['I', 8],
  512.        rl_filename_quoting_desired        => ['I', 9],
  513.        rl_inhibit_completion            => ['I', 10],
  514.        history_base                => ['I', 11],
  515.        history_length                => ['I', 12],
  516.        history_max_entries            => ['I', 13],
  517.        max_input_history            => ['I', 13], # before GRL 4.2
  518.        history_write_timestamps            => ['I', 14], # GRL 5.0
  519.        history_expansion_char            => ['C', 15],
  520.        history_subst_char            => ['C', 16],
  521.        history_comment_char            => ['C', 17],
  522.        history_quotes_inhibit_expansion        => ['I', 18],
  523.        rl_erase_empty_line            => ['I', 19], # GRL 4.0
  524.        rl_catch_signals                => ['I', 20], # GRL 4.0
  525.        rl_catch_sigwinch            => ['I', 21], # GRL 4.0
  526.        rl_already_prompted            => ['I', 22], # GRL 4.1
  527.        rl_num_chars_to_read            => ['I', 23], # GRL 4.2
  528.        rl_dispatching                => ['I', 24], # GRL 4.2
  529.        rl_gnu_readline_p            => ['I', 25], # GRL 4.2
  530.        rl_readline_state            => ['I', 26], # GRL 4.2
  531.        rl_explicit_arg                => ['I', 27], # GRL 4.2
  532.        rl_numeric_arg                => ['I', 28], # GRL 4.2
  533.        rl_editing_mode                => ['I', 29], # GRL 4.2
  534.        rl_attempted_completion_over        => ['I', 30], # GRL 4.2
  535.        rl_completion_type            => ['I', 31], # GRL 4.2
  536.        rl_readline_version            => ['I', 32], # GRL 4.2a
  537.        rl_completion_suppress_append        => ['I', 33], # GRL 4.3
  538.        rl_completion_quote_character        => ['C', 34], # GRL 5.0
  539.        rl_completion_suppress_quote        => ['I', 35], # GRL 5.0
  540.        rl_completion_found_quote        => ['I', 36], # GRL 5.0
  541.        rl_completion_mark_symlink_dirs        => ['I', 37], # GRL 4.3
  542.  
  543.        rl_startup_hook                => ['F', 0],
  544.        rl_event_hook                => ['F', 1],
  545.        rl_getc_function                => ['F', 2],
  546.        rl_redisplay_function            => ['F', 3],
  547.        rl_completion_entry_function        => ['F', 4],
  548.        rl_attempted_completion_function        => ['F', 5],
  549.        rl_filename_quoting_function        => ['F', 6],
  550.        rl_filename_dequoting_function        => ['F', 7],
  551.        rl_char_is_quoted_p            => ['F', 8],
  552.        rl_ignore_some_completions_function    => ['F', 9],
  553.        rl_directory_completion_hook        => ['F', 10],
  554.        history_inhibit_expansion_function    => ['F', 11],
  555.        rl_pre_input_hook            => ['F', 12], # GRL 4.0
  556.        rl_completion_display_matches_hook    => ['F', 13], # GRL 4.0
  557.        rl_completion_word_break_hook        => ['F', 14], # GRL 5.0
  558.        rl_prep_term_function            => ['F', 15], # GRL 4.2
  559.        rl_deprep_term_function            => ['F', 16], # GRL 4.2
  560.  
  561.        rl_instream                => ['IO', 0],
  562.        rl_outstream                => ['IO', 1],
  563.  
  564.        rl_executing_keymap            => ['K', 0],
  565.        rl_binding_keymap            => ['K', 1],
  566.  
  567.        rl_last_func                             => ['LF', 0],
  568.       );
  569.  
  570. sub TIESCALAR {
  571.     my $class = shift;
  572.     my $name = shift;
  573.     return bless \$name, $class;
  574. }
  575.  
  576. sub FETCH {
  577.     my $self = shift;
  578.     confess "wrong type" unless ref $self;
  579.  
  580.     my $name = $$self;
  581.     if (! defined $_rl_vars{$name}) {
  582.     confess "Term::ReadLine::Gnu::Var::FETCH: Unknown variable name `$name'\n";
  583.     return undef ;
  584.     }
  585.  
  586.     my ($type, $id) = @{$_rl_vars{$name}};
  587.     if ($type eq 'S') {
  588.     return _rl_fetch_str($id);
  589.     } elsif ($type eq 'I') {
  590.     return _rl_fetch_int($id);
  591.     } elsif ($type eq 'C') {
  592.     return chr(_rl_fetch_int($id));
  593.     } elsif ($type eq 'F') {
  594.     return _rl_fetch_function($id);
  595.     } elsif ($type eq 'IO') {
  596.     return _rl_fetch_iostream($id);
  597.     } elsif ($type eq 'K') {
  598.     return _rl_fetch_keymap($id);
  599.     } elsif ($type eq 'LF') {
  600.         return _rl_fetch_last_func();
  601.     } else {
  602.     carp "Term::ReadLine::Gnu::Var::FETCH: Illegal type `$type'\n";
  603.     return undef;
  604.     }
  605. }
  606.  
  607. sub STORE {
  608.     my $self = shift;
  609.     confess "wrong type" unless ref $self;
  610.  
  611.     my $name = $$self;
  612.     if (! defined $_rl_vars{$name}) {
  613.     confess "Term::ReadLine::Gnu::Var::STORE: Unknown variable name `$name'\n";
  614.     return undef ;
  615.     }
  616.  
  617.     my $value = shift;
  618.     my ($type, $id) = @{$_rl_vars{$name}};
  619.     if ($type eq 'S') {
  620.     if ($name eq 'rl_line_buffer') {
  621.         return _rl_store_rl_line_buffer($value);
  622.     } else {
  623.         return _rl_store_str($value, $id);
  624.     }
  625.     } elsif ($type eq 'I') {
  626.     return _rl_store_int($value, $id);
  627.     } elsif ($type eq 'C') {
  628.     return chr(_rl_store_int(ord($value), $id));
  629.     } elsif ($type eq 'F') {
  630.     return _rl_store_function($value, $id);
  631.     } elsif ($type eq 'IO') {
  632.     return _rl_store_iostream($value, $id);
  633.     } elsif ($type eq 'K' || $type eq 'LF') {
  634.     carp "Term::ReadLine::Gnu::Var::STORE: read only variable `$name'\n";
  635.     return undef;
  636.     } else {
  637.     carp "Term::ReadLine::Gnu::Var::STORE: Illegal type `$type'\n";
  638.     return undef;
  639.     }
  640. }
  641.  
  642. package Term::ReadLine::Gnu;
  643. use Carp;
  644. use strict;
  645.  
  646. #
  647. #    set value of %Attribs
  648. #
  649.  
  650. #    Tie all Readline/History variables
  651. foreach (keys %Term::ReadLine::Gnu::Var::_rl_vars) {
  652.     my $name;
  653.     ($name = $_) =~ s/^rl_//;    # strip leading `rl_'
  654.     tie $Attribs{$name},  'Term::ReadLine::Gnu::Var', $_;
  655. }
  656.  
  657. #    add reference to some functions
  658. {
  659.     my ($name, $fname);
  660.     no strict 'refs';        # allow symbolic reference
  661.     map {
  662.     ($name = $_) =~ s/^rl_//; # strip leading `rl_'
  663.     $fname = 'Term::ReadLine::Gnu::XS::' . $_;
  664.     $Attribs{$name} = \&$fname; # symbolic reference
  665.     } qw(rl_getc
  666.      rl_redisplay
  667.      rl_callback_read_char
  668.      rl_display_match_list
  669.      rl_filename_completion_function
  670.      rl_username_completion_function
  671.      list_completion_function
  672.          _trp_completion_function);
  673.     # auto-split subroutine cannot be processed in the map loop above
  674.     use strict 'refs';
  675.     $Attribs{shadow_redisplay} = \&Term::ReadLine::Gnu::XS::shadow_redisplay;
  676.     $Attribs{Tk_getc} = \&Term::ReadLine::Gnu::XS::Tk_getc;
  677.     $Attribs{list_completion_function} = \&Term::ReadLine::Gnu::XS::list_completion_function;
  678. }
  679.  
  680. package Term::ReadLine::Gnu::AU;
  681. use Carp;
  682. no strict qw(refs vars);
  683.  
  684. sub AUTOLOAD {
  685.     { $AUTOLOAD =~ s/.*:://; }    # preserve match data
  686.     my $name;
  687.     if (exists $Term::ReadLine::Gnu::XS::{"rl_$AUTOLOAD"}) {
  688.     $name = "Term::ReadLine::Gnu::XS::rl_$AUTOLOAD";
  689.     } elsif (exists $Term::ReadLine::Gnu::XS::{"$AUTOLOAD"}) {
  690.     $name = "Term::ReadLine::Gnu::XS::$AUTOLOAD";
  691.     } else {
  692.     croak "Cannot do `$AUTOLOAD' in Term::ReadLine::Gnu";
  693.     }
  694.     local $^W = 0;        # Why is this line necessary ?
  695.     *$AUTOLOAD = sub { shift; &$name(@_); };
  696.     goto &$AUTOLOAD;
  697. }
  698. 1;
  699. __END__
  700.  
  701.  
  702. =head2 C<Term::ReadLine::Gnu> Functions
  703.  
  704. All these GNU Readline/History Library functions are callable via
  705. method interface and have names which conform to standard conventions
  706. with the leading C<rl_> stripped.
  707.  
  708. Almost methods have lower level functions in
  709. C<Term::ReadLine::Gnu::XS> package.  To use them full qualified name
  710. is required.  Using method interface is preferred.
  711.  
  712. =over 4
  713.  
  714. =item Readline Convenience Functions
  715.  
  716. =over 4
  717.  
  718. =item Naming Function
  719.  
  720. =over 4
  721.  
  722. =item C<add_defun(NAME, FUNC [,KEY=-1])>
  723.  
  724. Add name to the Perl function C<FUNC>.  If optional argument C<KEY> is
  725. specified, bind it to the C<FUNC>.  Returns reference to
  726. C<FunctionPtr>.
  727.  
  728.   Example:
  729.     # name name `reverse-line' to a function reverse_line(),
  730.     # and bind it to "\C-t"
  731.     $term->add_defun('reverse-line', \&reverse_line, ord "\ct");
  732.  
  733. =back
  734.  
  735. =item Selecting a Keymap
  736.  
  737. =over 4
  738.  
  739. =item C<make_bare_keymap>
  740.  
  741.     Keymap    rl_make_bare_keymap()
  742.  
  743. =item C<copy_keymap(MAP)>
  744.  
  745.     Keymap    rl_copy_keymap(Keymap|str map)
  746.  
  747. =item C<make_keymap>
  748.  
  749.     Keymap    rl_make_keymap()
  750.  
  751. =item C<discard_keymap(MAP)>
  752.  
  753.     Keymap    rl_discard_keymap(Keymap|str map)
  754.  
  755. =item C<get_keymap>
  756.  
  757.     Keymap    rl_get_keymap()
  758.  
  759. =item C<set_keymap(MAP)>
  760.  
  761.     Keymap    rl_set_keymap(Keymap|str map)
  762.  
  763. =item C<get_keymap_by_name(NAME)>
  764.  
  765.     Keymap    rl_get_keymap_by_name(str name)
  766.  
  767. =item C<get_keymap_name(MAP)>
  768.  
  769.     str    rl_get_keymap_name(Keymap map)
  770.  
  771. =back
  772.  
  773. =item Binding Keys
  774.  
  775. =over 4
  776.  
  777. =item C<bind_key(KEY, FUNCTION [,MAP])>
  778.  
  779.     int    rl_bind_key(int key, FunctionPtr|str function,
  780.                 Keymap|str map = rl_get_keymap())
  781.  
  782. Bind C<KEY> to the C<FUNCTION>.  C<FUNCTION> is the name added by the
  783. C<add_defun> method.  If optional argument C<MAP> is specified, binds
  784. in C<MAP>.  Returns non-zero in case of error.
  785.  
  786. =item C<bind_key_if_unbound(KEY, FUNCTION [,MAP])>
  787.  
  788.     int    rl_bind_key_if_unbound(int key, FunctionPtr|str function,
  789.                            Keymap|str map = rl_get_keymap()) #GRL5.0
  790.  
  791. =item C<unbind_key(KEY [,MAP])>
  792.  
  793.     int    rl_unbind_key(int key, Keymap|str map = rl_get_keymap())
  794.  
  795. Bind C<KEY> to the null function.  Returns non-zero in case of error.
  796.  
  797. =item C<unbind_function(FUNCTION [,MAP])>
  798.  
  799.     int    rl_unbind_function(FunctionPtr|str function,
  800.                    Keymap|str map = rl_get_keymap())
  801.  
  802. =item C<unbind_command(COMMAND [,MAP])>
  803.  
  804.     int    rl_unbind_command(str command,
  805.                   Keymap|str map = rl_get_keymap())
  806.  
  807. =item C<bind_keyseq(KEYSEQ, FUNCTION [,MAP])>
  808.  
  809.     int    rl_bind_keyseq(str keyseq, FunctionPtr|str function,
  810.                    Keymap|str map = rl_get_keymap()) # GRL 5.0
  811.  
  812. =item C<set_key(KEYSEQ, FUNCTION [,MAP])>
  813.  
  814.     int    rl_set_key(str keyseq, FunctionPtr|str function,
  815.                Keymap|str map = rl_get_keymap())
  816.  
  817. =item C<bind_keyseq_if_unbound(KEYSEQ, FUNCTION [,MAP])>
  818.  
  819.     int    rl_bind_keyseq_if_unbound(str keyseq, FunctionPtr|str function,
  820.                       Keymap|str map = rl_get_keymap()) # GRL 5.0
  821.  
  822. =item C<generic_bind(TYPE, KEYSEQ, DATA, [,MAP])>
  823.  
  824.     int    rl_generic_bind(int type, str keyseq,
  825.                 FunctionPtr|Keymap|str data,
  826.                 Keymap|str map = rl_get_keymap())
  827.  
  828. =item C<parse_and_bind(LINE)>
  829.  
  830.     void    rl_parse_and_bind(str line)
  831.  
  832. Parse C<LINE> as if it had been read from the F<~/.inputrc> file and
  833. perform any key bindings and variable assignments found.  For more
  834. detail see 'GNU Readline Library Manual'.
  835.  
  836. =item C<read_init_file([FILENAME])>
  837.  
  838.     int    rl_read_init_file(str filename = '~/.inputrc')
  839.  
  840. =back
  841.  
  842. =item Associating Function Names and Bindings
  843.  
  844. =over 4
  845.  
  846. =item C<named_function(NAME)>
  847.  
  848.     FunctionPtr rl_named_function(str name)
  849.  
  850. =item C<get_function_name(FUNCTION)>
  851.  
  852.     str    rl_get_function_name(FunctionPtr function)
  853.  
  854. =item C<function_of_keyseq(KEYMAP [,MAP])>
  855.  
  856.     (FunctionPtr|Keymap|str data, int type)
  857.         rl_function_of_keyseq(str keyseq,
  858.                       Keymap|str map = rl_get_keymap())
  859.  
  860. =item C<invoking_keyseqs(FUNCTION [,MAP])>
  861.  
  862.     (@str)    rl_invoking_keyseqs(FunctionPtr|str function,
  863.                     Keymap|str map = rl_get_keymap())
  864.  
  865. =item C<function_dumper([READABLE])>
  866.  
  867.     void    rl_function_dumper(int readable = 0)
  868.  
  869. =item C<list_funmap_names>
  870.  
  871.     void    rl_list_funmap_names()
  872.  
  873. =item C<funmap_names>
  874.  
  875.     (@str)    rl_funmap_names()
  876.  
  877. =item C<add_funmap_entry(NAME, FUNCTION)>
  878.  
  879.     int    rl_add_funmap_entry(char *name, FunctionPtr|str function)
  880.  
  881. =back
  882.  
  883. =item Allowing Undoing
  884.  
  885. =over 4
  886.  
  887. =item C<begin_undo_group>
  888.  
  889.     int    rl_begin_undo_group()
  890.  
  891. =item C<end_undo_group>
  892.  
  893.     int    rl_end_undo_group()
  894.  
  895. =item C<add_undo(WHAT, START, END, TEXT)>
  896.  
  897.     int    rl_add_undo(int what, int start, int end, str text)
  898.  
  899. =item C<free_undo_list>
  900.  
  901.     void    rl_free_undo_list()
  902.  
  903. =item C<do_undo>
  904.  
  905.     int    rl_do_undo()
  906.  
  907. =item C<modifying([START [,END]])>
  908.  
  909.     int    rl_modifying(int start = 0, int end = rl_end)
  910.  
  911. =back
  912.  
  913. =item Redisplay
  914.  
  915. =over 4
  916.  
  917. =item C<redisplay>
  918.  
  919.     void    rl_redisplay()
  920.  
  921. =item C<forced_update_display>
  922.  
  923.     int    rl_forced_update_display()
  924.  
  925. =item C<on_new_line>
  926.  
  927.     int    rl_on_new_line()
  928.  
  929. =item C<on_new_line_with_prompt>
  930.  
  931.     int    rl_on_new_line_with_prompt()    # GRL 4.1
  932.  
  933. =item C<reset_line_state>
  934.  
  935.     int    rl_reset_line_state()
  936.  
  937. =item C<rl_show_char(C)>
  938.  
  939.     int    rl_show_char(int c)
  940.  
  941. =item C<message(FMT[, ...])>
  942.  
  943.     int    rl_message(str fmt, ...)
  944.  
  945. =item C<crlf>
  946.  
  947.     int    rl_crlf()            # GRL 4.2
  948.  
  949. =item C<clear_message>
  950.  
  951.     int    rl_clear_message()
  952.  
  953. =item C<save_prompt>
  954.  
  955.     void    rl_save_prompt()
  956.  
  957. =item C<restore_prompt>
  958.  
  959.     void    rl_restore_prompt()
  960.  
  961. =item C<expand_prompt(PROMPT)>
  962.  
  963.     int    rl_expand_prompt(str prompt)    # GRL 4.2
  964.  
  965. =item C<set_prompt(PROMPT)>
  966.  
  967.     int    rl_set_prompt(const str prompt)    # GRL 4.2
  968.  
  969. =back
  970.  
  971. =item Modifying Text
  972.  
  973. =over 4
  974.  
  975. =item C<insert_text(TEXT)>
  976.  
  977.     int    rl_insert_text(str text)
  978.  
  979. =item C<delete_text([START [,END]])>
  980.  
  981.     int    rl_delete_text(int start = 0, int end = rl_end)
  982.  
  983. =item C<copy_text([START [,END]])>
  984.  
  985.     str    rl_copy_text(int start = 0, int end = rl_end)
  986.  
  987. =item C<kill_text([START [,END]])>
  988.  
  989.     int    rl_kill_text(int start = 0, int end = rl_end)
  990.  
  991. =item C<push_macro_input(MACRO)>
  992.  
  993.     int    rl_push_macro_input(str macro)
  994.  
  995. =back
  996.  
  997. =item Character Input
  998.  
  999. =over 4
  1000.  
  1001. =item C<read_key>
  1002.  
  1003.     int    rl_read_key()
  1004.  
  1005. =item C<getc(STREAM)>
  1006.  
  1007.     int    rl_getc(FILE *STREAM)
  1008.  
  1009. =item C<stuff_char(C)>
  1010.  
  1011.     int    rl_stuff_char(int c)
  1012.  
  1013. =item C<execute_next(C)>
  1014.  
  1015.     int    rl_execute_next(int c)        # GRL 4.2
  1016.  
  1017. =item C<clear_pending_input()>
  1018.  
  1019.     int    rl_clear_pending_input()    # GRL 4.2
  1020.  
  1021. =item C<set_keyboard_input_timeout(uSEC)>
  1022.  
  1023.     int    rl_set_keyboard_input_timeout(int usec)    # GRL 4.2
  1024.  
  1025. =back
  1026.  
  1027. =item Terminal Management
  1028.  
  1029. =over 4
  1030.  
  1031. =item C<prep_terminal(META_FLAG)>
  1032.  
  1033.     void    rl_prep_terminal(int META_FLAG)    # GRL 4.2
  1034.  
  1035. =item C<deprep_terminal()>
  1036.  
  1037.     void    rl_deprep_terminal()        # GRL 4.2
  1038.  
  1039. =item C<tty_set_default_bindings(KMAP)>
  1040.  
  1041.     void    rl_tty_set_default_bindings([Keymap KMAP])    # GRL 4.2
  1042.  
  1043. =item C<tty_unset_default_bindings(KMAP)>
  1044.  
  1045.     void    rl_tty_unset_default_bindings([Keymap KMAP])    # GRL 5.0
  1046.  
  1047. =item C<reset_terminal([TERMINAL_NAME])>
  1048.  
  1049.     int    rl_reset_terminal(str terminal_name = getenv($TERM)) # GRL 4.2
  1050.  
  1051. =back
  1052.  
  1053. =item Utility Functions
  1054.  
  1055. =over 4
  1056.  
  1057. =item C<replace_line(TEXT [,CLEAR_UNDO]>
  1058.  
  1059.     int    rl_replace_line(str text, int clear_undo)    # GRL 4.3
  1060.  
  1061. =item C<initialize>
  1062.  
  1063.     int    rl_initialize()
  1064.  
  1065. =item C<ding>
  1066.  
  1067.     int    rl_ding()
  1068.  
  1069. =item C<alphabetic(C)>
  1070.  
  1071.     int    rl_alphabetic(int C)
  1072.  
  1073. =item C<display_match_list(MATCHES [,LEN [,MAX]])>
  1074.  
  1075.     void    rl_display_match_list(\@matches, len = $#maches, max) # GRL 4.0
  1076.  
  1077. Since the first element of an array @matches as treated as a possible
  1078. completion, it is not displayed.  See the descriptions of
  1079. C<completion_matches()>.
  1080.  
  1081. When C<MAX> is ommited, the max length of an item in @matches is used.
  1082.  
  1083. =back
  1084.  
  1085. =item Miscellaneous Functions
  1086.  
  1087. =over 4
  1088.  
  1089. =item C<macro_bind(KEYSEQ, MACRO [,MAP])>
  1090.  
  1091.     int    rl_macro_bind(const str keyseq, const str macro, Keymap map)
  1092.  
  1093. =item C<macro_dumper(READABLE)>
  1094.  
  1095.     int    rl_macro_dumper(int readline)
  1096.  
  1097. =item C<variable_bind(VARIABLE, VALUE)>
  1098.  
  1099.     int    rl_variable_bind(const str variable, const str value)
  1100.  
  1101. =item C<variable_dumper(READABLE)>
  1102.  
  1103.     int    rl_variable_dumper(int readline)
  1104.  
  1105. =item C<set_paren_blink_timeout(uSEC)>
  1106.  
  1107.     int    rl_set_paren_blink_timeout(usec)    # GRL 4.2
  1108.  
  1109. =item C<get_termcap(cap)>
  1110.  
  1111.     str    rl_get_termcap(cap)
  1112.  
  1113. =back
  1114.  
  1115. =item Alternate Interface
  1116.  
  1117. =over 4
  1118.  
  1119. =item C<callback_handler_install(PROMPT, LHANDLER)>
  1120.  
  1121.     void    rl_callback_handler_install(str prompt, pfunc lhandler)
  1122.  
  1123. =item C<callback_read_char>
  1124.  
  1125.     void    rl_callback_read_char()
  1126.  
  1127. =item C<callback_handler_remove>
  1128.  
  1129.     void    rl_callback_handler_remove()
  1130.  
  1131. =back
  1132.  
  1133. =back
  1134.  
  1135. =item Readline Signal Handling
  1136.  
  1137. =over 4
  1138.  
  1139. =item C<cleanup_after_signal>
  1140.  
  1141.     void    rl_cleanup_after_signal()    # GRL 4.0
  1142.  
  1143. =item C<free_line_state>
  1144.  
  1145.     void    rl_free_line_state()    # GRL 4.0
  1146.  
  1147. =item C<reset_after_signal>
  1148.  
  1149.     void    rl_reset_after_signal()    # GRL 4.0
  1150.  
  1151. =item C<resize_terminal>
  1152.  
  1153.     void    rl_resize_terminal()    # GRL 4.0
  1154.  
  1155. =item C<set_screen_size(ROWS, COLS)>
  1156.  
  1157.     void    rl_set_screen_size(int ROWS, int COLS)    # GRL 4.2
  1158.  
  1159. =item C<get_screen_size()>
  1160.  
  1161.     (int rows, int cols)    rl_get_screen_size()    # GRL 4.2
  1162.  
  1163. =item C<set_signals>
  1164.  
  1165.     int    rl_set_signals()    # GRL 4.0
  1166.  
  1167. =item C<clear_signals>
  1168.  
  1169.     int    rl_clear_signals()    # GRL 4.0
  1170.  
  1171. =back
  1172.  
  1173. =item Completion Functions
  1174.  
  1175. =over 4
  1176.  
  1177. =item C<complete_internal([WHAT_TO_DO])>
  1178.  
  1179.     int    rl_complete_internal(int what_to_do = TAB)
  1180.  
  1181. =item C<completion_mode(FUNCTION)>
  1182.  
  1183.     int    rl_completion_mode(FunctionPtr|str function)
  1184.  
  1185. =item C<completion_matches(TEXT [,FUNC])>
  1186.  
  1187.     (@str)    rl_completion_matches(str text,
  1188.                       pfunc func = filename_completion_function)
  1189.  
  1190. =item C<filename_completion_function(TEXT, STATE)>
  1191.  
  1192.     str    rl_filename_completion_function(str text, int state)
  1193.  
  1194. =item C<username_completion_function(TEXT, STATE)>
  1195.  
  1196.     str    rl_username_completion_function(str text, int state)
  1197.  
  1198. =item C<list_completion_function(TEXT, STATE)>
  1199.  
  1200.     str    list_completion_function(str text, int state)
  1201.  
  1202. =back
  1203.  
  1204. =item History Functions
  1205.  
  1206. =over 4
  1207.  
  1208. =item Initializing History and State Management
  1209.  
  1210. =over 4
  1211.  
  1212. =item C<using_history>
  1213.  
  1214.     void    using_history()
  1215.  
  1216. =back
  1217.  
  1218. =item History List Management
  1219.  
  1220. =over 4
  1221.  
  1222. =item C<addhistory(STRING[, STRING, ...])>
  1223.  
  1224.     void    add_history(str string)
  1225.  
  1226. =item C<StifleHistory(MAX)>
  1227.  
  1228.     int    stifle_history(int max|undef)
  1229.  
  1230. stifles the history list, remembering only the last C<MAX> entries.
  1231. If C<MAX> is undef, remembers all entries.  This is a replacement
  1232. of unstifle_history().
  1233.  
  1234. =item C<unstifle_history>
  1235.  
  1236.     int    unstifle_history()
  1237.  
  1238. This is equivalent with 'stifle_history(undef)'.
  1239.  
  1240. =item C<SetHistory(LINE1 [, LINE2, ...])>
  1241.  
  1242. sets the history of input, from where it can be used if the actual
  1243. C<readline> is present.
  1244.  
  1245. =item C<add_history_time(STRING)>
  1246.  
  1247.     void    add_history_time(str string)    # GRL 5.0
  1248.  
  1249. =item C<remove_history(WHICH)>
  1250.  
  1251.     str    remove_history(int which)
  1252.  
  1253. =item C<replace_history_entry(WHICH, LINE)>
  1254.  
  1255.     str    replace_history_entry(int which, str line)
  1256.  
  1257. =item C<clear_history>
  1258.  
  1259.     void    clear_history()
  1260.  
  1261. =item C<history_is_stifled>
  1262.  
  1263.     int    history_is_stifled()
  1264.  
  1265. =back
  1266.  
  1267. =item Information About the History List
  1268.  
  1269. =over 4
  1270.  
  1271. =item C<where_history>
  1272.  
  1273.     int    where_history()
  1274.  
  1275. =item C<current_history>
  1276.  
  1277.     str    current_history()
  1278.  
  1279. =item C<history_get(OFFSET)>
  1280.  
  1281.     str    history_get(offset)
  1282.  
  1283. =item C<history_get_time(OFFSET)>
  1284.  
  1285.     time_t    history_get_time(offset)
  1286.  
  1287. =item C<history_total_bytes>
  1288.  
  1289.     int    history_total_bytes()
  1290.  
  1291. =item C<GetHistory>
  1292.  
  1293. returns the history of input as a list, if actual C<readline> is present.
  1294.  
  1295. =back
  1296.  
  1297. =item Moving Around the History List
  1298.  
  1299. =over 4
  1300.  
  1301. =item C<history_set_pos(POS)>
  1302.  
  1303.     int    history_set_pos(int pos)
  1304.  
  1305. =item C<previous_history>
  1306.  
  1307.     str    previous_history()
  1308.  
  1309. =item C<next_history>
  1310.  
  1311.     str    next_history()
  1312.  
  1313. =back
  1314.  
  1315. =item Searching the History List
  1316.  
  1317. =over 4
  1318.  
  1319. =item C<history_search(STRING [,DIRECTION])>
  1320.  
  1321.     int    history_search(str string, int direction = -1)
  1322.  
  1323. =item C<history_search_prefix(STRING [,DIRECTION])>
  1324.  
  1325.     int    history_search_prefix(str string, int direction = -1)
  1326.  
  1327. =item C<history_search_pos(STRING [,DIRECTION [,POS]])>
  1328.  
  1329.     int    history_search_pos(str string,
  1330.                    int direction = -1,
  1331.                    int pos = where_history())
  1332.  
  1333. =back
  1334.  
  1335. =item Managing the History File
  1336.  
  1337. =over 4
  1338.  
  1339. =item C<ReadHistory([FILENAME [,FROM [,TO]]])>
  1340.  
  1341.     int    read_history(str filename = '~/.history',
  1342.                  int from = 0, int to = -1)
  1343.  
  1344.     int    read_history_range(str filename = '~/.history',
  1345.                    int from = 0, int to = -1)
  1346.  
  1347. adds the contents of C<FILENAME> to the history list, a line at a
  1348. time.  If C<FILENAME> is false, then read from F<~/.history>.  Start
  1349. reading at line C<FROM> and end at C<TO>.  If C<FROM> is omitted or
  1350. zero, start at the beginning.  If C<TO> is omitted or less than
  1351. C<FROM>, then read until the end of the file.  Returns true if
  1352. successful, or false if not.  C<read_history()> is an aliase of
  1353. C<read_history_range()>.
  1354.  
  1355. =item C<WriteHistory([FILENAME])>
  1356.  
  1357.     int    write_history(str filename = '~/.history')
  1358.  
  1359. writes the current history to C<FILENAME>, overwriting C<FILENAME> if
  1360. necessary.  If C<FILENAME> is false, then write the history list to
  1361. F<~/.history>.  Returns true if successful, or false if not.
  1362.  
  1363.  
  1364. =item C<append_history(NELEMENTS [,FILENAME])>
  1365.  
  1366.     int    append_history(int nelements, str filename = '~/.history')
  1367.  
  1368. =item C<history_truncate_file([FILENAME [,NLINES]])>
  1369.  
  1370.     int    history_truncate_file(str filename = '~/.history',
  1371.                       int nlines = 0)
  1372.  
  1373. =back
  1374.  
  1375. =item History Expansion
  1376.  
  1377. =over 4
  1378.  
  1379. =item C<history_expand(LINE)>
  1380.  
  1381.     (int result, str expansion) history_expand(str line)
  1382.  
  1383. Note that this function returns C<expansion> in scalar context.
  1384.  
  1385. =item C<get_history_event(STRING, CINDEX [,QCHAR])>
  1386.  
  1387.     (str text, int cindex) = get_history_event(str  string,
  1388.                            int  cindex,
  1389.                            char qchar = '\0')
  1390.  
  1391. =item C<history_tokenize(LINE)>
  1392.  
  1393.     (@str)    history_tokenize(str line)
  1394.  
  1395. =item C<history_arg_extract(LINE, [FIRST [,LAST]])>
  1396.  
  1397.     str history_arg_extract(str line, int first = 0, int last = '$')
  1398.  
  1399. =back
  1400.  
  1401. =back
  1402.  
  1403. =back
  1404.  
  1405. =head2 C<Term::ReadLine::Gnu> Variables
  1406.  
  1407. Following GNU Readline/History Library variables can be accessed from
  1408. Perl program.  See 'GNU Readline Library Manual' and ' GNU History
  1409. Library Manual' for each variable.  You can access them with
  1410. C<Attribs> methods.  Names of keys in this hash conform to standard
  1411. conventions with the leading C<rl_> stripped.
  1412.  
  1413. Examples:
  1414.  
  1415.     $attribs = $term->Attribs;
  1416.     $v = $attribs->{library_version};    # rl_library_version
  1417.     $v = $attribs->{history_base};    # history_base
  1418.  
  1419. =over 4
  1420.  
  1421. =item Readline Variables
  1422.  
  1423.     str rl_line_buffer
  1424.     int rl_point
  1425.     int rl_end
  1426.     int rl_mark
  1427.     int rl_done
  1428.     int rl_num_chars_to_read (GRL 4.2)
  1429.     int rl_pending_input
  1430.     int rl_dispatching (GRL 4.2)
  1431.     int rl_erase_empty_line (GRL 4.0)
  1432.     str rl_prompt (read only)
  1433.     int rl_already_prompted (GRL 4.1)
  1434.     str rl_library_version (read only)
  1435.     int rl_readline_version (read only)
  1436.     int rl_gnu_readline_p (GRL 4.2)
  1437.     str rl_terminal_name
  1438.     str rl_readline_name
  1439.     filehandle rl_instream
  1440.     filehandle rl_outstream
  1441.     pfunc rl_startup_hook
  1442.     pfunc rl_pre_input_hook (GRL 4.0)
  1443.     pfunc rl_event_hook
  1444.     pfunc rl_getc_function
  1445.     pfunc rl_redisplay_function
  1446.     pfunc rl_prep_term_function (GRL 4.2)
  1447.     pfunc rl_deprep_term_function (GRL 4.2)
  1448.     pfunc rl_last_func (GRL 4.2)
  1449.     Keymap rl_executing_keymap (read only)
  1450.     Keymap rl_binding_keymap (read only)
  1451.     str rl_executing_macro (GRL 4.2)
  1452.     int rl_readline_state (GRL 4.2)
  1453.     int rl_explicit_arg (GRL 4.2)
  1454.     int rl_numeric_arg (GRL 4.2)
  1455.     int rl_editing_mode (GRL 4.2)
  1456.  
  1457. =item Signal Handling Variables
  1458.  
  1459.     int rl_catch_signals (GRL 4.0)
  1460.     int rl_catch_sigwinch (GRL 4.0)
  1461.  
  1462. =item Completion Variables
  1463.  
  1464.     pfunc rl_completion_entry_function
  1465.     pfunc rl_attempted_completion_function
  1466.     pfunc rl_filename_quoting_function
  1467.     pfunc rl_filename_dequoting_function
  1468.     pfunc rl_char_is_quoted_p
  1469.     int rl_completion_query_items
  1470.     str rl_basic_word_break_characters
  1471.     str rl_basic_quote_characters
  1472.     str rl_completer_word_break_characters
  1473.     pfunc rl_completion_word_break_hook (GRL 5.0)
  1474.     str rl_completer_quote_characters
  1475.     str rl_filename_quote_characters
  1476.     str rl_special_prefixes
  1477.     int rl_completion_append_character
  1478.     int rl_completion_suppress_append (GRL 4.3)
  1479.     int rl_completion_quote_charactor (GRL 5.0)
  1480.     int rl_completion_suppress_quote (GRL 5.0)
  1481.     int rl_completion_found_quote (GRL 5.0)
  1482.     int rl_completion_mark_symlink_dirs (GRL 4.3)
  1483.     int rl_ignore_completion_duplicates
  1484.     int rl_filename_completion_desired
  1485.     int rl_filename_quoting_desired
  1486.     int rl_attempted_completion_over (GRL 4.2)
  1487.     int rl_completion_type (GRL 4.2)
  1488.     int rl_inhibit_completion
  1489.     pfunc rl_ignore_some_completion_function
  1490.     pfunc rl_directory_completion_hook
  1491.     pfunc rl_completion_display_matches_hook (GRL 4.0)
  1492.  
  1493. =item History Variables
  1494.  
  1495.     int history_base
  1496.     int history_length
  1497.     int history_max_entries (called `max_input_history'. read only)
  1498.     int history_write_timestamps (GRL 5.0)
  1499.     char history_expansion_char
  1500.     char history_subst_char
  1501.     char history_comment_char
  1502.     str history_word_delimiters (GRL 4.2)
  1503.     str history_no_expand_chars
  1504.     str history_search_delimiter_chars
  1505.     int history_quotes_inhibit_expansion
  1506.     pfunc history_inhibit_expansion_function
  1507.  
  1508. =item Function References
  1509.  
  1510.     rl_getc
  1511.     rl_redisplay
  1512.     rl_callback_read_char
  1513.     rl_display_match_list
  1514.     rl_filename_completion_function
  1515.     rl_username_completion_function
  1516.     list_completion_function
  1517.     shadow_redisplay
  1518.     Tk_getc
  1519.  
  1520. =back
  1521.  
  1522. =head2 Custom Completion
  1523.  
  1524. In this section variables and functions for custom completion is
  1525. described with examples.
  1526.  
  1527. Most of descriptions in this section is cited from GNU Readline
  1528. Library manual.
  1529.  
  1530. =over 4
  1531.  
  1532. =item C<rl_completion_entry_function>
  1533.  
  1534. This variable holds reference refers to a generator function for
  1535. C<completion_matches()>.
  1536.  
  1537. A generator function is called repeatedly from
  1538. C<completion_matches()>, returning a string each time.  The arguments
  1539. to the generator function are C<TEXT> and C<STATE>.  C<TEXT> is the
  1540. partial word to be completed.  C<STATE> is zero the first time the
  1541. function is called, allowing the generator to perform any necessary
  1542. initialization, and a positive non-zero integer for each subsequent
  1543. call.  When the generator function returns C<undef> this signals
  1544. C<completion_matches()> that there are no more possibilities left.
  1545.  
  1546. If the value is undef, built-in C<filename_completion_function> is
  1547. used.
  1548.  
  1549. A sample generator function, C<list_completion_function>, is defined
  1550. in Gnu.pm.  You can use it as follows;
  1551.  
  1552.     use Term::ReadLine;
  1553.     ...
  1554.     my $term = new Term::ReadLine 'sample';
  1555.     my $attribs = $term->Attribs;
  1556.     ...
  1557.     $attribs->{completion_entry_function} =
  1558.     $attribs->{list_completion_function};
  1559.     ...
  1560.     $attribs->{completion_word} =
  1561.     [qw(reference to a list of words which you want to use for completion)];
  1562.     $term->readline("custom completion>");
  1563.  
  1564. See also C<completion_matches>.
  1565.  
  1566. =item C<rl_attempted_completion_function>
  1567.  
  1568. A reference to an alternative function to create matches.
  1569.  
  1570. The function is called with C<TEXT>, C<LINE_BUFFER>, C<START>, and
  1571. C<END>.  C<LINE_BUFFER> is a current input buffer string.  C<START>
  1572. and C<END> are indices in C<LINE_BUFFER> saying what the boundaries of
  1573. C<TEXT> are.
  1574.  
  1575. If this function exists and returns null list or C<undef>, or if this
  1576. variable is set to C<undef>, then an internal function
  1577. C<rl_complete()> will call the value of
  1578. C<$rl_completion_entry_function> to generate matches, otherwise the
  1579. array of strings returned will be used.
  1580.  
  1581. The default value of this variable is C<undef>.  You can use it as follows;
  1582.  
  1583.     use Term::ReadLine;
  1584.     ...
  1585.     my $term = new Term::ReadLine 'sample';
  1586.     my $attribs = $term->Attribs;
  1587.     ...
  1588.     sub sample_completion {
  1589.         my ($text, $line, $start, $end) = @_;
  1590.         # If first word then username completion, else filename completion
  1591.         if (substr($line, 0, $start) =~ /^\s*$/) {
  1592.             return $term->completion_matches($text,
  1593.                          $attribs->{'username_completion_function'});
  1594.         } else {
  1595.             return ();
  1596.         }
  1597.     }
  1598.     ...
  1599.     $attribs->{attempted_completion_function} = \&sample_completion;
  1600.  
  1601. =item C<completion_matches(TEXT, ENTRY_FUNC)>
  1602.  
  1603. Returns an array of strings which is a list of completions for
  1604. C<TEXT>.  If there are no completions, returns C<undef>.  The first
  1605. entry in the returned array is the substitution for C<TEXT>.  The
  1606. remaining entries are the possible completions.
  1607.  
  1608. C<ENTRY_FUNC> is a generator function which has two arguments, and
  1609. returns a string.  The first argument is C<TEXT>.  The second is a
  1610. state argument; it is zero on the first call, and non-zero on
  1611. subsequent calls.  C<ENTRY_FUNC> returns a C<undef> to the caller when
  1612. there are no more matches.
  1613.  
  1614. If the value of C<ENTRY_FUNC> is undef, built-in
  1615. C<filename_completion_function> is used.
  1616.  
  1617. C<completion_matches> is a Perl wrapper function of an internal
  1618. function C<completion_matches()>.  See also
  1619. C<$rl_completion_entry_function>.
  1620.  
  1621. =item C<completion_function>
  1622.  
  1623. A variable whose content is a reference to a function which returns a
  1624. list of candidates to complete.
  1625.  
  1626. This variable is compatible with C<Term::ReadLine::Perl> and very easy
  1627. to use.
  1628.  
  1629.     use Term::ReadLine;
  1630.     ...
  1631.     my $term = new Term::ReadLine 'sample';
  1632.     my $attribs = $term->Attribs;
  1633.     ...
  1634.     $attribs->{completion_function} = sub {
  1635.     my ($text, $line, $start) = @_;
  1636.     return qw(a list of candidates to complete);
  1637.     }
  1638.  
  1639. =item C<list_completion_function(TEXT, STATE)>
  1640.  
  1641. A sample generator function defined by C<Term::ReadLine::Gnu>.
  1642. Example code at C<rl_completion_entry_function> shows how to use this
  1643. function.
  1644.  
  1645. =back
  1646.  
  1647. =head2 C<Term::ReadLine::Gnu> Specific Features
  1648.  
  1649. =over 4
  1650.  
  1651. =item C<Term::ReadLine::Gnu> Specific Functions
  1652.  
  1653. =over 4
  1654.  
  1655. =item C<CallbackHandlerInstall(PROMPT, LHANDLER)>
  1656.  
  1657. This method provides the function C<rl_callback_handler_install()>
  1658. with the following addtional feature compatible with C<readline>
  1659. method; ornament feature, C<Term::ReadLine::Perl> compatible
  1660. completion function, histroy expansion, and addition to history
  1661. buffer.
  1662.  
  1663. =item C<call_function(FUNCTION, [COUNT [,KEY]])>
  1664.  
  1665.     int    rl_call_function(FunctionPtr|str function, count = 1, key = -1)
  1666.  
  1667. =item C<rl_get_all_function_names>
  1668.  
  1669. Returns a list of all function names.
  1670.  
  1671. =item C<shadow_redisplay>
  1672.  
  1673. A redisplay function for password input.  You can use it as follows;
  1674.  
  1675.     $attribs->{redisplay_function} = $attribs->{shadow_redisplay};
  1676.     $line = $term->readline("password> ");
  1677.  
  1678. =item C<rl_filename_list>
  1679.  
  1680. Returns candidates of filename to complete.  This function can be used
  1681. with C<completion_function> and is implemented for the compatibility
  1682. with C<Term::ReadLine::Perl>.
  1683.  
  1684. =item C<list_completion_function>
  1685.  
  1686. See the description of section L<"Custom Completion"|"Custom Completion">.
  1687.  
  1688. =back
  1689.  
  1690. =item C<Term::ReadLine::Gnu> Specific Variables
  1691.  
  1692. =over 4
  1693.  
  1694. =item C<do_expand>
  1695.  
  1696. When true, the history expansion is enabled.  By default false.
  1697.  
  1698. =item C<completion_function>
  1699.  
  1700. See the description of section L<"Custom Completion"|"Custom Completion">.
  1701.  
  1702. =item C<completion_word>
  1703.  
  1704. A reference to a list of candidates to complete for
  1705. C<list_completion_function>.
  1706.  
  1707. =back
  1708.  
  1709. =item C<Term::ReadLine::Gnu> Specific Commands
  1710.  
  1711. =over 4
  1712.  
  1713. =item C<history-expand-line>
  1714.  
  1715. The equivalent of the Bash C<history-expand-line> editing command.
  1716.  
  1717. =item C<operate-and-get-next>
  1718.  
  1719. The equivalent of the Korn shell C<operate-and-get-next-history-line>
  1720. editing command and the Bash C<operate-and-get-next>.
  1721.  
  1722. This command is bound to C<\C-o> by default for the compatibility with
  1723. the Bash and C<Term::ReadLine::Perl>.
  1724.  
  1725. =item C<display-readline-version>
  1726.  
  1727. Shows the version of C<Term::ReadLine::Gnu> and the one of the GNU
  1728. Readline Library.
  1729.  
  1730. =item C<change-ornaments>
  1731.  
  1732. Change ornaments interactively.
  1733.  
  1734. =back
  1735.  
  1736. =back
  1737.  
  1738. =head1 FILES
  1739.  
  1740. =over 4
  1741.  
  1742. =item F<~/.inputrc>
  1743.  
  1744. Readline init file.  Using this file it is possible that you would
  1745. like to use a different set of key bindings.  When a program which
  1746. uses the Readline library starts up, the init file is read, and the
  1747. key bindings are set.
  1748.  
  1749. Conditional key binding is also available.  The program name which is
  1750. specified by the first argument of C<new> method is used as the
  1751. application construct.
  1752.  
  1753. For example, when your program call C<new> method like this;
  1754.  
  1755.     ...
  1756.     $term = new Term::ReadLine 'PerlSh';
  1757.     ...
  1758.  
  1759. your F<~/.inputrc> can define key bindings only for it as follows;
  1760.  
  1761.     ...
  1762.     $if PerlSh
  1763.     Meta-Rubout: backward-kill-word
  1764.     "\C-x\C-r": re-read-init-file
  1765.         "\e[11~": "Function Key 1"
  1766.     $endif
  1767.     ...
  1768.  
  1769. =back
  1770.  
  1771. =head1 EXPORTS
  1772.  
  1773. None.
  1774.  
  1775. =head1 SEE ALSO
  1776.  
  1777. =over 4
  1778.  
  1779. =item GNU Readline Library Manual
  1780.  
  1781. =item GNU History Library Manual
  1782.  
  1783. =item C<Term::ReadLine>
  1784.  
  1785. =item C<Term::ReadLine::Perl> (Term-ReadLine-Perl-xx.tar.gz)
  1786.  
  1787. =item F<eg/*> and F<t/*> in the Term::ReadLine::Gnu distribution
  1788.  
  1789. =item Articles related to Term::ReadLine::Gnu
  1790.  
  1791. =over 4
  1792.  
  1793. =item effective perl programming
  1794.  
  1795.     http://www.usenix.org/publications/login/2000-7/features/effective.html
  1796.  
  1797. This article demonstrates how to integrate Term::ReadLine::Gnu into an
  1798. interactive command line program.
  1799.  
  1800. =item eijiro (Japanese)
  1801.  
  1802.     http://bulknews.net/lib/columns/02_eijiro/column.html
  1803.  
  1804. A command line interface to Eijiro, Japanese-English dictionary
  1805. service on WWW.
  1806.  
  1807.  
  1808. =back
  1809.  
  1810. =item Works which use Term::ReadLine::Gnu
  1811.  
  1812. =over 4
  1813.  
  1814. =item Perl Debugger
  1815.  
  1816.     perl -d
  1817.  
  1818. =item The Perl Shell (psh)
  1819.  
  1820.     http://www.focusresearch.com/gregor/psh/
  1821.  
  1822. The Perl Shell is a shell that combines the interactive nature of a
  1823. Unix shell with the power of Perl.
  1824.  
  1825. A programmable completion feature compatible with bash is implemented.
  1826.  
  1827. =item SPP (Synopsys Plus Perl)
  1828.  
  1829.     http://www.stanford.edu/~jsolomon/SPP/
  1830.  
  1831. SPP (Synopsys Plus Perl) is a Perl module that wraps around Synopsys'
  1832. shell programs.  SPP is inspired by the original dc_perl written by
  1833. Steve Golson, but it's an entirely new implementation.  Why is it
  1834. called SPP and not dc_perl?  Well, SPP was written to wrap around any
  1835. of Synopsys' shells.
  1836.  
  1837. =item PFM (Personal File Manager for Unix/Linux)
  1838.  
  1839.     http://p-f-m.sourceforge.net/
  1840.  
  1841. Pfm is a terminal-based file manager written in Perl, based on PFM.COM
  1842. for MS-DOS (originally by Paul Culley and Henk de Heer).
  1843.  
  1844. =item The soundgrab
  1845.  
  1846.     http://rawrec.sourceforge.net/soundgrab/soundgrab.html
  1847.  
  1848. soundgrab is designed to help you slice up a big long raw audio file
  1849. (by default 44.1 kHz 2 channel signed sixteen bit little endian) and
  1850. save your favorite sections to other files. It does this by providing
  1851. you with a cassette player like command line interface.
  1852.  
  1853. =item PDL (The Perl Data Language)
  1854.  
  1855.     http://pdl.perl.org/index_en.html
  1856.  
  1857. PDL (``Perl Data Language'') gives standard Perl the ability to
  1858. compactly store and speedily manipulate the large N-dimensional data
  1859. arrays which are the bread and butter of scientific computing.
  1860.  
  1861. =item PIQT (Perl Interactive DBI Query Tool)
  1862.  
  1863.     http://piqt.sourceforge.net/
  1864.  
  1865. PIQT is an interactive query tool using the Perl DBI database
  1866. interface. It supports ReadLine, provides a built in scripting language
  1867. with a Lisp like syntax, an online help system, and uses wrappers to
  1868. interface to the DBD modules.
  1869.  
  1870. =item Ghostscript Shell
  1871.  
  1872.     http://www.panix.com/~jdf/gshell/
  1873.  
  1874. It provides a friendly way to play with the Ghostscript interpreter,
  1875. including command history and auto-completion of Postscript font names
  1876. and reserved words.
  1877.  
  1878. =item vshnu (the New Visual Shell)
  1879.  
  1880.     http://www.cs.indiana.edu/~kinzler/vshnu/
  1881.  
  1882. A visual shell and CLI shell supplement.
  1883.  
  1884. =back
  1885.  
  1886. If you know any other works which can be listed here, please let me
  1887. know.
  1888.  
  1889. =back
  1890.  
  1891. =head1 AUTHOR
  1892.  
  1893. Hiroo Hayashi C<E<lt>hiroo.hayashi@computer.orgE<gt>>
  1894.  
  1895. C<http://www.perl.org/CPAN/authors/Hiroo_HAYASHI/>
  1896.  
  1897. =head1 TODO
  1898.  
  1899. GTK+ support in addition to Tk.
  1900.  
  1901. =head1 BUGS
  1902.  
  1903. C<rl_add_defun()> can define up to 16 functions.
  1904.  
  1905. Ornament feature works only on prompt strings.  It requires very hard
  1906. hacking of C<display.c:rl_redisplay()> in GNU Readline library to
  1907. ornament input line.
  1908.  
  1909. C<newTTY()> is not tested yet.
  1910.  
  1911. =cut
  1912.