source: trunk/FACT++/src/Readline.cc@ 10496

Last change on this file since 10496 was 10496, checked in by tbretz, 14 years ago
Removed usage of Tools::Form.
File size: 31.4 KB
Line 
1// **************************************************************************
2/** @class Readline
3
4@brief C++ wrapper for GNU's readline library
5
6This class is meant as a C++ wrapper around GNU's readline library.
7Note that because readline uses a global namespace only one instance
8of this class can exist at a time. Instantiating a second object after
9a first one was deleted might show unexpected results.
10
11When the object is instantiated readline's history is read from a file.
12At destruction the history in memory is copied back to that file.
13The history file will be truncated to fMaxLines.
14
15By overloading the Readline class the function used for auto-completion
16can be overwritten.
17
18Simple example:
19
20\code
21
22 Readline rl("MyProg"); // will read the history from "MyProg.his"
23 while (1)
24 {
25 string txt = rl.Prompt("prompt> ");
26 if (txt=="quit)
27 break;
28
29 // ... do something ...
30
31 rl.AddHistory(txt);
32 }
33
34 // On destruction the history will be written to the file
35
36\endcode
37
38Simpler example (you need to implement the Process() function)
39
40\code
41
42 Readline rl("MyProg"); // will read the history from "MyProg.his"
43 rl.Run("prompt> ");
44
45 // On destruction the history will be written to the file
46
47\endcode
48
49@section References
50
51 - <A HREF="http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html">GNU Readline</A>
52
53 */
54// **************************************************************************
55#include "Readline.h"
56
57#include <fstream>
58#include <iostream>
59
60#include <readline/readline.h>
61#include <readline/history.h>
62
63#include "tools.h"
64
65using namespace std;
66
67Readline *Readline::This = 0;
68
69// --------------------------------------------------------------------------
70//
71//! Construct a Readline object. The constructor reads the history from a
72//! history file. The filename is compiled by adding ".his" to the
73//! supplied argument. The name oif the history file is stored in fName.
74//!
75//! Since readline has a global namespace, the creation of only one
76//! Readline instance is allowed.
77//!
78//! The provided program name is supplied to readline by means of
79//! rl_readline_name.
80//!
81//! Readlines default callback frunction for completions is redirected
82//! to CompletionImp which in turn will call Completion, which can be
83//! overwritten by the user.
84//!
85//! Bind some default key sequences like Page-up/-down for searching forward
86//! and backward in history.
87//!
88//! @param prgname
89//! The prefix of the history filename. Usually the program name, which
90//! can be initialized by argv[0].
91//
92Readline::Readline(const char *prgname) :
93 fMaxLines(500), fLine(0), fCompletion(0)
94{
95 if (This)
96 {
97 cout << "ERROR - Readline can only be instatiated once!" << endl;
98 exit(-1);
99 }
100
101 This = this;
102
103 // Alternative completion function
104 rl_attempted_completion_function = rl_ncurses_completion_function;
105
106 // Program name
107 rl_readline_name = prgname;
108
109 // Compile filename for history file
110 fName = string(prgname)+".his";
111
112 // Read history file
113 if (read_history(fName.c_str()))
114 cout << "WARNING - Reading " << fName << ": " << strerror(errno) << endl;
115
116 // Setup the readline callback which are needed to redirect
117 // the otuput properly to our ncurses panel
118 rl_getc_function = rl_ncurses_getc;
119 rl_startup_hook = rl_ncurses_startup;
120 rl_redisplay_function = rl_ncurses_redisplay;
121 rl_event_hook = rl_ncurses_event_hook;
122 rl_completion_display_matches_hook = rl_ncurses_completion_display;
123
124 // Bind delete, page up, page down
125 rl_bind_keyseq("\e[3~", rl_named_function("delete-char"));
126 rl_bind_keyseq("\e[5~", rl_named_function("history-search-backward"));
127 rl_bind_keyseq("\e[6~", rl_named_function("history-search-forward"));
128 rl_bind_keyseq("\033[1;3F", rl_named_function("kill-line"));
129 rl_bind_keyseq("\033[1;5D", rl_named_function("backward-word"));
130 rl_bind_keyseq("\033[1;5C", rl_named_function("forward-word"));
131 rl_bind_key(25, rl_named_function("kill-whole-line"));
132
133 //for (int i=0; i<10; i++) cout << (int)getchar() << endl;
134}
135
136// --------------------------------------------------------------------------
137//
138//! Writes the current history to the file with the name stored in fName.
139//! In addition the written file is truncated to fMaxLines to keep the
140//! file of a reasonable size. The number of lines fMaxLines can be set
141//! by SetMaxLines before the destructor is called. Setting fMaxLines
142//! to 0 or a negative value switches automatic truncation off.
143//
144Readline::~Readline()
145{
146 // Write current history to file
147 if (write_history(fName.c_str()))
148 cout << "WARNING - Write " << fName.c_str() << ": " << strerror(errno) << endl;
149
150 // Truncate file
151 if (fMaxLines>0 && history_truncate_file(fName.c_str(), fMaxLines))
152 cout << "WARNING - Truncate " << fName.c_str() << ": " << strerror(errno) << endl;
153}
154
155// --------------------------------------------------------------------------
156//
157//! This wraps the given readline function such that the output can be
158//! redirected from thr rl_outstream to the given C++ ostream.
159//!
160//! @param out
161//! The stream to which the output should be redirected.
162//!
163//! @param function
164//! Takes a function of type bool(*)() as argument
165//!
166//! @returns
167//! The return value of the function
168//
169bool Readline::RedirectionWrapper(ostream &out, bool (*function)())
170{
171 FILE *save = SetStreamOut(tmpfile());
172 const bool rc = function();
173 FILE *file = SetStreamOut(save);
174
175 const bool empty = ftell(file)==0;
176
177 rewind(file);
178
179 if (empty)
180 {
181 out << " <empty>" << endl;
182 fclose(file);
183 return rc;
184 }
185
186 while (1)
187 {
188 const int c = getc(file);
189 if (feof(file))
190 break;
191 out << (char)c;
192 }
193 out << endl;
194
195 fclose(file);
196
197 return rc;
198}
199
200// --------------------------------------------------------------------------
201//
202//! Redirected from rl_getc_function, calls Getc
203//
204int Readline::rl_ncurses_getc(FILE *f)
205{
206 return This->Getc(f);
207}
208
209// --------------------------------------------------------------------------
210//
211//! Redirected from rl_startup_hook, calls Startup.
212//! A function called just before readline prints the first prompt.
213//
214int Readline::rl_ncurses_startup()
215{
216 This->Startup();
217 return 0; // What is this for?
218}
219
220// --------------------------------------------------------------------------
221//
222//! Redirected from rl_redisplay_function, calls Redisplay.
223//! Readline will call indirectly to update the display with the current
224//! contents of the editing buffer.
225//
226void Readline::rl_ncurses_redisplay()
227{
228 This->Redisplay();
229}
230
231// --------------------------------------------------------------------------
232//
233//! Redirected from rl_event_hook, calls Update().
234//! A function called periodically when readline is waiting for
235//! terminal input.
236//!
237int Readline::rl_ncurses_event_hook()
238{
239 This->EventHook();
240 return 0;
241}
242
243// --------------------------------------------------------------------------
244//
245//! Redirected from rl_completion_display_matches_hook,
246//! calls CompletionDisplayImp
247//!
248//! A function to be called when completing a word would normally display
249//! the list of possible matches. This function is called in lieu of
250//! Readline displaying the list. It takes three arguments:
251//! (char **matches, int num_matches, int max_length) where matches is
252//! the array of matching strings, num_matches is the number of strings
253//! in that array, and max_length is the length of the longest string in
254//! that array. Readline provides a convenience function,
255//! rl_display_match_list, that takes care of doing the display to
256//! Readline's output stream.
257//
258void Readline::rl_ncurses_completion_display(char **matches, int num, int max)
259{
260 This->CompletionDisplay(matches, num, max);
261}
262
263char **Readline::rl_ncurses_completion_function(const char *text, int start, int end)
264{
265 return This->Completion(text, start, end);
266}
267
268// --------------------------------------------------------------------------
269//
270//! Calls the default rl_getc function.
271//
272int Readline::Getc(FILE *f)
273{
274 return rl_getc(f);
275}
276
277// --------------------------------------------------------------------------
278//
279//! Default: Do nothing.
280//
281void Readline::Startup()
282{
283}
284
285// --------------------------------------------------------------------------
286//
287//! The default is to redisplay the prompt which is gotten from
288//! GetUpdatePrompt(). If GetUpdatePrompt() returns an empty string the
289//! prompt is kept untouched. This can be used to keep a prompt updated
290//! with some information (e.g. time) just by overwriting GetUpdatePrompt()
291//!
292void Readline::EventHook()
293{
294 const string p = GetUpdatePrompt();
295 if (p.empty())
296 return;
297
298 UpdatePrompt("");
299 Redisplay();
300 UpdatePrompt(p);
301 Redisplay();
302}
303
304// --------------------------------------------------------------------------
305//
306//! Called from Prompt and PromptEOF after readline has returned. It is
307//! meant as the opposite of Startup (called after readline finsihes)
308//! The default is to do nothing.
309//!
310//! @param buf
311//! A pointer to the buffer returned by readline
312//
313void Readline::Shutdown(const char *)
314{
315}
316
317// --------------------------------------------------------------------------
318//
319//! Default: call rl_redisplay()
320//
321void Readline::Redisplay()
322{
323 rl_redisplay();
324}
325
326// --------------------------------------------------------------------------
327//
328//! Default: call rl_completion_display_matches()
329//
330void Readline::CompletionDisplay(char **matches, int num, int max)
331{
332 rl_display_match_list(matches, num, max);
333}
334
335// --------------------------------------------------------------------------
336//
337//! This is a static helper for the compilation of a completion-list.
338//! It compares the two inputs (str and txt) to a maximum of the size of
339//! txt. If they match, memory is allocated with malloc and a pointer to
340//! the null-terminated version of str is returned.
341//!
342//! @param str
343//! A reference to the string which is checked (e.g. "Makefile.am")
344//!
345//! @param txt
346//! A reference to the part of the string the user has already typed,
347//! e.g. "Makef"
348//!
349//! @returns
350//! A pointer to memory allocated with malloc containing the string str
351//
352char *Readline::Compare(const string &str, const string &txt)
353{
354 /*return strncmp(str.c_str(), txt.c_str(), txt.length())==0 ? */
355 return strncasecmp(str.c_str(), txt.c_str(), txt.length())==0 ?
356 strndup(str.c_str(), str.length()) : 0;
357}
358
359char **Readline::CompletionMatches(const char *text, char *(*func)(const char*, int))
360{
361 return rl_completion_matches(text, func);
362}
363
364// --------------------------------------------------------------------------
365//
366//! The given vector should be a reference to a vector of strings
367//! containing all possible matches. The actual match-making is then
368//! done in Complete(const char *, int)
369//!
370//! The pointer fCompletion is redirected to the vector for the run time
371//! of the function, but restored afterwards. So by this you can set a
372//! default completion list in case Complete is not called or Completion
373//! not overloaded.
374//!
375//! @param v
376//! reference to a vector of strings with all possible matches
377//!
378//! @param text
379//! the text which should be matched (it is just propagated to
380//! Readline::Completion)
381//!
382char **Readline::Complete(const vector<string> &v, const char *text)
383{
384 const vector<string> *save = fCompletion;
385
386 fCompletion = &v;
387 char **rc = rl_completion_matches(const_cast<char*>(text), CompleteImp);
388 fCompletion = save;
389
390 return rc;
391}
392
393// --------------------------------------------------------------------------
394//
395//! If fCompletion==0 the default is to call readline's
396//! rl_filename_completion_function. Otherwise the contents of fCompletion
397//! are returned. To change fCompletion either initialize it via
398//! SetCompletion() (in this case you must ensure the life time of the
399//! object) or call
400//! Complete(const vector<string>&, const char*)
401//! from
402//! Completion(const char * int, int)
403//!
404//! This is the so called generator function, the readline manual says
405//! about this function:
406//!
407//! The generator function is called repeatedly from
408//! rl_completion_matches(), returning a string each time. The arguments
409//! to the generator function are text and state. text is the partial word
410//! to be completed. state is zero the first time the function is called,
411//! allowing the generator to perform any necessary initialization, and a
412//! positive non-zero integer for each subsequent call. The generator
413//! function returns (char *)NULL to inform rl_completion_matches() that
414//! there are no more possibilities left. Usually the generator function
415//! computes the list of possible completions when state is zero, and
416//! returns them one at a time on subsequent calls. Each string the
417//! generator function returns as a match must be allocated with malloc();
418//! Readline frees the strings when it has finished with them.
419//
420char *Readline::Complete(const char* text, int state)
421{
422 if (fCompletion==0)
423 return rl_filename_completion_function(text, state);
424
425 static vector<string>::const_iterator pos;
426 if (state==0)
427 pos = fCompletion->begin();
428
429 while (pos!=fCompletion->end())
430 {
431 char *rc = Compare(*pos++, text);
432 if (rc)
433 return rc;
434 }
435
436 return 0;
437}
438
439// --------------------------------------------------------------------------
440//
441//! Calls Complete()
442//
443char *Readline::CompleteImp(const char* text, int state)
444{
445 return This->Complete(text, state);
446}
447
448// --------------------------------------------------------------------------
449//
450//! The readline manual says about this function:
451//!
452//! A pointer to an alternative function to create matches. The
453//! function is called with text, start, and end. start and end are
454//! indices in rl_line_buffer saying what the boundaries of text are.
455//! If this function exists and returns NULL, or if this variable is
456//! set to NULL, then rl_complete() will call the value of
457//! rl_completion_entry_function to generate matches, otherwise the
458//! array of strings returned will be used.
459//!
460//! This function is virtual and can be overwritten. It defaults to
461//! a call to rl_completion_matches with CompleteImp as an argument
462//! which defaults to filename completion, but can also be overwritten.
463//!
464//! It is suggested that you call
465//! Complete(const vector<string>&, const char*)
466//! from here.
467//!
468//! @param text
469//! A pointer to a char array conatining the text which should be
470//! completed. The text is null-terminated.
471//!
472//! @param start
473//! The start index within readline's line buffer rl_line_buffer,
474//! at which the text starts which presumably should be completed.
475//!
476//! @param end
477//! The end index within readline's line buffer rl_line_buffer,
478//! at which the text ends which presumably should be completed.
479//!
480//! @returns
481//! An array of strings which were allocated with malloc and which
482//! will be freed by readline with the possible matches.
483//
484char **Readline::Completion(const char *text, int /*start*/, int /*end*/)
485{
486 // To do filename completion call
487 return rl_completion_matches((char*)text, CompleteImp);
488}
489
490// --------------------------------------------------------------------------
491//
492//! Adds the given string to the history buffer of readline's history by
493//! calling add_history.
494//!
495//! @param str
496//! A reference to a string which should be added to readline's
497//! history.
498//!
499//! @param skip
500//! If skip is 1 and str matches the last added entry in the history,
501//! the entry is skipped. If skip==2, all entries matching str are
502//! removed from the history before the new entry is added as last one.
503//! <skip==2 is the default>
504//
505void Readline::AddToHistory(const string &str, int skip)
506{
507 if (skip==1 && fLastLine==str)
508 return;
509
510 if (str.empty())
511 return;
512
513 int p = -1;
514 while (skip==2)
515 {
516 p = history_search_pos(str.c_str(), 0, p+1);
517 if (p<0)
518 break;
519
520 // It seems like history_search_pos works more like
521 // history_search_prefix, therefore the identity is checked again
522 const HIST_ENTRY *e = history_get(p+1);
523 if (e && str==e->line)
524 free(remove_history(p));
525 }
526
527 add_history(str.c_str());
528 fLastLine = str;
529}
530
531// --------------------------------------------------------------------------
532//
533//! @returns
534//! a string containing [{fLine}]
535//
536string Readline::GetLinePrompt() const
537{
538 string rc = "[";
539 rc += fLine;
540 return rc+"]";
541}
542
543// --------------------------------------------------------------------------
544//
545//! Calls rl_set_prompt. This can be used from readline's callback function
546//! to change the prompt while a call to the readline function is in
547//! progress.
548//!
549//! @param prompt
550//! The new prompt to be shown
551//
552void Readline::UpdatePrompt(const string &prompt) const
553{
554 rl_set_prompt(prompt.c_str());
555}
556
557// --------------------------------------------------------------------------
558//
559//! This function is used to bind a key sequence via a call to
560//! rl_bind_keyseq.
561//!
562//! Readline's manual says about this function:
563//!
564//! Bind the key sequence represented by the string keyseq to the
565//! function function, beginning in the current keymap. This makes
566//! new keymaps as necessary. The return value is non-zero if keyseq
567//! is invalid.
568//!
569//! Key sequences are escaped sequences of characters read from an input
570//! stream when a special key is pressed. This is necessary because
571//! there are usually more keys and possible combinations than ascii codes.
572//!
573//! Possible key sequences are for example:
574//! "\033OP" F1
575//! "\033[1;5A" Ctrl+up
576//! "\033[1;5B" Ctrl+down
577//! "\033[1;3A" Alt+up
578//! "\033[1;3B" Alt+down
579//! "\033[5;3~" Alt+page up
580//! "\033[6;3~" Alt+page down
581//! "\033+" Alt++
582//! "\033-" Alt+-
583//! "\033\t" Alt+tab
584//! "\033[1~" Alt+tab
585//!
586//! @param seq
587//! The key sequence to be bound
588//!
589//! @param func
590//! A function of type "int func(int, int)
591//
592void Readline::BindKeySequence(const char *seq, int (*func)(int, int))
593{
594 rl_bind_keyseq(seq, func);
595}
596
597// --------------------------------------------------------------------------
598//
599//! Calls rl_variable_dumper(1)
600//!
601//! Print the readline variable names and their current values
602//! to rl_outstream. If readable is non-zero, the list is formatted
603//! in such a way that it can be made part of an inputrc file and
604//! re-read.
605//!
606//! rl_outstream can be redirected using SetStreamOut()
607//!
608//! @returns
609//! always true
610//
611bool Readline::DumpVariables()
612{
613 rl_variable_dumper(1);
614 return true;
615}
616
617// --------------------------------------------------------------------------
618//
619//! Calls rl_function_dumper(1)
620//!
621//! Print the readline function names and the key sequences currently
622//! bound to them to rl_outstream. If readable is non-zero, the list
623//! is formatted in such a way that it can be made part of an inputrc
624//! file and re-read.
625//!
626//! rl_outstream can be redirected using SetStreamOut()
627//!
628//! @returns
629//! always true
630//
631bool Readline::DumpFunctions()
632{
633 rl_function_dumper(1);
634 return true;
635}
636
637// --------------------------------------------------------------------------
638//
639//! Calls rl_list_funmap_names()
640//!
641//! Print the names of all bindable Readline functions to rl_outstream.
642//!
643//! rl_outstream can be redirected using SetStreamOut()
644//!
645//! @returns
646//! always true
647//
648bool Readline::DumpFunmap()
649{
650 rl_list_funmap_names();
651 return true;
652}
653
654// --------------------------------------------------------------------------
655//
656//! Sets rl_outstream (the stdio stream to which Readline performs output)
657//! to the new stream.
658//!
659//! @param f
660//! The new stdio stream to which readline should perform its output
661//!
662//! @return
663//! The old stream to which readline was performing output
664//
665FILE *Readline::SetStreamOut(FILE *f)
666{
667 FILE *rc = rl_outstream;
668 rl_outstream = f;
669 return rc;
670}
671
672// --------------------------------------------------------------------------
673//
674//! Sets rl_instream (the stdio stream from which Readline reads input)
675//! to the new stream.
676//!
677//! @param f
678//! The new stdio stream from which readline should read its input
679//!
680//! @return
681//! The old stream from which readline was reading it input
682//
683FILE *Readline::SetStreamIn(FILE *f)
684{
685 FILE *rc = rl_instream;
686 rl_instream = f;
687 return rc;
688}
689
690// --------------------------------------------------------------------------
691//
692//! return rl_display_prompt (the prompt which should currently be
693//! displayed on the screen) while a readline command is in progress
694//
695string Readline::GetPrompt()
696{
697 return rl_display_prompt;
698}
699
700// --------------------------------------------------------------------------
701//
702//! return rl_line_buffer (the current input line which should currently be
703//! displayed on the screen) while a readline command is in progress
704//!
705//! The length of the current line buffer (rl_end) is available as
706//! GetLineBuffer().size()
707//!
708//! Note that after readline has returned the contents of rl_end might
709//! not reflect the correct buffer length anymore, hence, the returned buffer
710//! might be truncated.
711//
712string Readline::GetBuffer()
713{
714 return string(rl_line_buffer, rl_end);
715}
716
717// --------------------------------------------------------------------------
718//
719//! return rl_point (the current cursor position within the line buffer)
720//
721int Readline::GetCursor()
722{
723 return rl_point;
724}
725
726// --------------------------------------------------------------------------
727//
728//! return strlen(rl_display_prompt) + rl_point
729//
730int Readline::GetAbsCursor()
731{
732 return strlen(rl_display_prompt) + rl_point;
733}
734
735// --------------------------------------------------------------------------
736//
737//! return rl_end (the current total length of the line buffer)
738//! Note that after readline has returned the contents of rl_end might
739//! not reflect the correct buffer length anymore.
740//
741int Readline::GetBufferLength()
742{
743 return rl_end;
744}
745
746// --------------------------------------------------------------------------
747//
748//! return the length of the prompt plus the length of the line buffer
749//
750int Readline::GetLineLength()
751{
752 return strlen(rl_display_prompt) + rl_end;
753}
754
755// --------------------------------------------------------------------------
756//
757//! Calls: Function: void rl_resize_terminal()
758//! Update Readline's internal screen size by reading values from the kernel.
759//
760void Readline::Resize()
761{
762 rl_resize_terminal();
763}
764
765// --------------------------------------------------------------------------
766//
767//! Calls: Function: void rl_set_screen_size (int rows, int cols)
768//! Set Readline's idea of the terminal size to rows rows and cols columns.
769//!
770//! @param width
771//! Number of columns
772//!
773//! @param height
774//! Number of rows
775//
776void Readline::Resize(int width, int height)
777{
778 rl_set_screen_size(height, width);
779}
780
781// --------------------------------------------------------------------------
782//
783//! Get the number of cols readline assumes the screen size to be
784//
785int Readline::GetCols() const
786{
787 int rows, cols;
788 rl_get_screen_size(&rows, &cols);
789 return cols;
790}
791
792// --------------------------------------------------------------------------
793//
794//! Get the number of rows readline assumes the screen size to be
795//
796int Readline::GetRows() const
797{
798 int rows, cols;
799 rl_get_screen_size(&rows, &cols);
800 return rows;
801}
802
803// --------------------------------------------------------------------------
804//
805//! Return a list of pointer to the history contents
806//
807vector<const char*> Readline::GetHistory() const
808{
809 HIST_ENTRY **next = history_list();
810
811 vector<const char*> v;
812
813 for (; *next; next++)
814 v.push_back((*next)->line);
815
816 return v;
817}
818
819// --------------------------------------------------------------------------
820//
821//! Clear readline history (calls clear_history())
822//!
823//! @returns
824//! always true
825//
826bool Readline::ClearHistory()
827{
828 clear_history();
829 return true;
830}
831
832// --------------------------------------------------------------------------
833//
834//! Displays the current history on rl_outstream
835//!
836//! rl_outstream can be redirected using SetStreamOut()
837//!
838//! @returns
839//! always true
840//
841bool Readline::DumpHistory()
842{
843 HIST_ENTRY **next = history_list();
844
845 if (!next)
846 return true;
847
848 for (; *next; next++)
849 fprintf(rl_outstream, "%s\n", (*next)->line);
850
851 return true;
852}
853
854// --------------------------------------------------------------------------
855//
856//! Print the available commands. This is intended for being overwritten
857//! by deriving classes.
858//!
859//! rl_outstream can be redirected using SetStreamOut()
860//!
861//! @returns
862//! always true
863//
864//
865bool Readline::PrintCommands()
866{
867 fprintf(rl_outstream, "\n");
868 fprintf(rl_outstream, " Commands:\n");
869 fprintf(rl_outstream, " No application specific commands defined.\n");
870 fprintf(rl_outstream, "\n");
871 return true;
872}
873
874// --------------------------------------------------------------------------
875//
876//! Print a general help message. This is intended for being overwritten
877//! by deriving classes.
878//!
879//!
880//! rl_outstream can be redirected using SetStreamOut()
881//!
882//! @returns
883//! always true
884//
885//
886bool Readline::PrintGeneralHelp()
887{
888 fprintf(rl_outstream, "\n");
889 fprintf(rl_outstream, " General help:\n");
890 fprintf(rl_outstream, " h,help Print this help message\n");
891 fprintf(rl_outstream, " clear Clear history buffer\n");
892 fprintf(rl_outstream, " lh,history Dump the history buffer to the screen\n");
893 fprintf(rl_outstream, " v,variables Dump readline variables\n");
894 fprintf(rl_outstream, " f,functions Dump readline functions\n");
895 fprintf(rl_outstream, " m,funmap Dump readline funmap\n");
896 fprintf(rl_outstream, " c,commands Dump available commands\n");
897 fprintf(rl_outstream, " k,keylist Dump key bindings\n");
898 fprintf(rl_outstream, " .q,quit Quit\n");
899 fprintf(rl_outstream, "\n");
900 fprintf(rl_outstream, " The command history is automatically loaded and saves to\n");
901 fprintf(rl_outstream, " and from %s.\n", GetName().c_str());
902 fprintf(rl_outstream, "\n");
903 return true;
904}
905
906// --------------------------------------------------------------------------
907//
908//! Print a help text about key bindings. This is intended for being
909//! overwritten by deriving classes.
910//!
911//!
912//! rl_outstream can be redirected using SetStreamOut()
913//!
914//! @returns
915//! always true
916//
917//
918bool Readline::PrintKeyBindings()
919{
920 fprintf(rl_outstream, "\n");
921 fprintf(rl_outstream, " Key bindings:\n");
922 fprintf(rl_outstream, " Page-up Search backward in history\n");
923 fprintf(rl_outstream, " Page-dn Search forward in history\n");
924 fprintf(rl_outstream, " Ctrl-left One word backward\n");
925 fprintf(rl_outstream, " Ctrl-right One word forward\n");
926 fprintf(rl_outstream, " Ctrl-d Quit\n");
927 fprintf(rl_outstream, " Ctrl-y Delete line\n");
928 fprintf(rl_outstream, " Alt-end/Ctrl-k Delete until the end of the line\n");
929 fprintf(rl_outstream, " F1 Toggle visibility of upper panel\n");
930 fprintf(rl_outstream, "\n");
931 fprintf(rl_outstream, " Default key-bindings are identical with your bash.\n");
932 fprintf(rl_outstream, "\n");
933 return true;
934}
935
936// --------------------------------------------------------------------------
937//
938//!
939//
940bool Readline::Process(const string &str)
941{
942 // ----------- Readline static -------------
943
944 if (str=="clear")
945 return ClearHistory();
946
947 if (str=="lh" || str=="history")
948 return DumpHistory();
949
950 if (str=="v" || str=="variables")
951 return DumpVariables();
952
953 if (str=="f" || str=="functions")
954 return DumpFunctions();
955
956 if (str=="m" || str=="funmap")
957 return DumpFunmap();
958
959 // ---------- Readline virtual -------------
960
961 if (str=="h" || str=="help")
962 return PrintGeneralHelp();
963
964 if (str=="c" || str=="commands")
965 return PrintCommands();
966
967 if (str=="k" || str=="keylist")
968 return PrintKeyBindings();
969
970 return false;
971}
972
973// --------------------------------------------------------------------------
974//
975//! This function is a wrapper around the call to readline. It encapsultes
976//! the return buffer into a std::string and deletes the memory allocated
977//! by readline. Furthermore, it removes leading and trailing whitespaces
978//! before return the result. The result is returned in the given
979//! argument containing the prompt. Before the function returns Shutdown()
980//! is called (as opposed to Startup when readline starts)
981//!
982//! @param str
983//! The prompt which is to be shown by the readline libarary. it is
984//! directly given to the call to readline. The result of the
985//! readline call is returned in this string.
986//!
987//! @returns
988//! true if the call succeeded as usual, false if EOF was detected
989//! by the readline call.
990//
991bool Readline::PromptEOF(string &str)
992{
993 char *buf = readline(str.c_str());
994 Shutdown(buf);
995
996 // Happens when EOF is encountered
997 if (!buf)
998 return false;
999
1000 str = Tools::Trim(buf);
1001
1002 free(buf);
1003
1004 return true;
1005}
1006
1007// --------------------------------------------------------------------------
1008//
1009//! This function is a wrapper around the call to readline. It encapsultes
1010//! the return buffer into a std::string and deletes the memory allocated
1011//! by readline. Furthermore, it removes leading and trailing whitespaces
1012//! before return the result. Before the function returns Shutdown() is
1013//! called (as opposed to Startup when readline starts)
1014//!
1015//! @param prompt
1016//! The prompt which is to be shown by the readline libarary. it is
1017//! directly given to the call to readline.
1018//!
1019//! @returns
1020//! The result of the readline call
1021//
1022string Readline::Prompt(const string &prompt)
1023{
1024 char *buf = readline(prompt.c_str());
1025
1026 Shutdown(buf ? buf : "");
1027
1028 const string str = !buf || (rl_done && rl_pending_input==4)
1029 ? ".q" : Tools::Trim(buf);
1030
1031 free(buf);
1032
1033 return str;
1034}
1035
1036// --------------------------------------------------------------------------
1037//
1038//! This implements a loop over readline calls. A prompt to issue can be
1039//! given. If it is NULL, the prompt is retrieved from GetUpdatePrompt().
1040//! It is updated regularly by means of calls to GetUpdatePrompt() from
1041//! EventHook(). If Prompt() returns with "quit" or ".q" the loop is
1042//! exited. If ".qqq" is entered exit(-1) is called. In case of ".qqqqqq"
1043//! abort(). Both ways to exit the program are not recommended. Empty
1044//! inputs are ignored. After that Process() with the returned string
1045//! is called. If Process returns true the input is not counted and not
1046//! added to the history, otherwise the line counter is increased
1047//! and the input is added to the history.
1048//!
1049//! @param prompt
1050//! The prompt to be issued or NULL if GetUPdatePrompt should be used
1051//! instead.
1052//!
1053void Readline::Run(const char *prompt)
1054{
1055 fLine = 0;
1056 while (1)
1057 {
1058 // Before we start we have to make sure that the
1059 // screen looks like and is ordered like expected.
1060 const string str = Prompt(prompt?prompt:GetUpdatePrompt());
1061 if (str.empty())
1062 continue;
1063
1064 if (str=="quit" || str==".q")
1065 break;
1066
1067 if (str==".qqq")
1068 exit(-1);
1069
1070 if (str==".qqqqqq")
1071 abort();
1072
1073 if (Process(str))
1074 continue;
1075
1076 fLine++;
1077
1078 AddToHistory(str);
1079 }
1080}
1081
1082void Readline::Stop()
1083{
1084 rl_done = 1;
1085 rl_pending_input = 4; // EOT (end of transmission, ctrl-d)
1086}
Note: See TracBrowser for help on using the repository browser.