Return to readlinebuf.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline / examples

Annotation of embedaddon/readline/examples/readlinebuf.h, revision 1.1.1.1

1.1       misho       1: /*******************************************************************************
                      2:  * $Revision: 1.2 $
                      3:  * $Date: 2001/09/11 06:19:36 $
                      4:  * $Author: vyzo $
                      5:  *
                      6:  * Contents: A streambuf which uses the GNU readline library for line I/O
                      7:  * (c) 2001 by Dimitris Vyzovitis [vyzo@media.mit.edu]
                      8:  *
                      9:  * This program is free software; you can redistribute it and/or modify
                     10:  * it under the terms of the GNU General Public License as published by
                     11:  * the Free Software Foundation; either version 2  of the License, or
                     12:  * (at your option) any later version.
                     13:  *
                     14:  * This program is distributed in the hope that it will be useful,
                     15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                     16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                     17:  * General Public License for more details.
                     18:  *
                     19:  * You should have received a copy of the GNU General Public
                     20:  * License along with this program; if not, write to the Free
                     21:  * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
                     22:  * MA 02111-1307 USA
                     23:  *
                     24:  ******************************************************************************/
                     25: 
                     26: #ifndef _READLINEBUF_H_
                     27: #define _READLINEBUF_H_
                     28: 
                     29: #include <iostream>
                     30: #include <cstring>
                     31: #include <cassert>
                     32: #include <cstdlib>
                     33: #include <cstdio>
                     34: 
                     35: #include <readline/readline.h>
                     36: #include <readline/history.h>
                     37: 
                     38: #if (defined __GNUC__) && (__GNUC__ < 3)
                     39: #include <streambuf.h>
                     40: #else
                     41: #include <streambuf>
                     42: using std::streamsize;
                     43: using std::streambuf;
                     44: #endif
                     45: 
                     46: class readlinebuf : public streambuf {
                     47: public:
                     48: #if (defined __GNUC__) && (__GNUC__ < 3)
                     49:        typedef char char_type;
                     50:        typedef int int_type;
                     51:        typedef streampos pos_type;
                     52:        typedef streamoff off_type;
                     53: #endif
                     54:        static const int_type eof = EOF; // this is -1
                     55:        static const int_type not_eof = 0;
                     56: 
                     57: private:
                     58:        const char* prompt_;
                     59:        bool history_;
                     60:        char* line_;
                     61:        int low_;
                     62:        int high_;
                     63: 
                     64: protected:
                     65:                
                     66:        virtual int_type showmanyc() const { return high_ - low_; }
                     67:                
                     68:        virtual streamsize xsgetn( char_type* buf, streamsize n ) {
                     69:                int rd = n > (high_ - low_)? (high_ - low_) : n;
                     70:                memcpy( buf, line_, rd );
                     71:                low_ += rd;
                     72:                        
                     73:                if ( rd < n ) {
                     74:                        low_ = high_ = 0;
                     75:                        free( line_ ); // free( NULL ) is a noop
                     76:                        line_ = readline( prompt_ );
                     77:                        if ( line_ ) {
                     78:                                high_ = strlen( line_ );
                     79:                                if ( history_ && high_ ) add_history( line_ );
                     80:                                rd += xsgetn( buf + rd, n - rd );
                     81:                        }
                     82:                }
                     83:                        
                     84:                return rd; 
                     85:        }
                     86:                
                     87:        virtual int_type underflow() {
                     88:                if ( high_ == low_ ) {
                     89:                        low_ = high_ = 0;
                     90:                        free( line_ ); // free( NULL ) is a noop
                     91:                        line_ = readline( prompt_ );
                     92:                        if ( line_ ) {
                     93:                                high_ = strlen( line_ );
                     94:                                if ( history_ && high_ ) add_history( line_ );
                     95:                        }
                     96:                }
                     97:                        
                     98:                if ( low_ < high_ ) return line_[low_];
                     99:                else return eof;
                    100:        }
                    101:                
                    102:        virtual int_type uflow() {
                    103:                int_type c = underflow();
                    104:                if ( c != eof ) ++low_;
                    105:                return c;
                    106:        }
                    107:                
                    108:        virtual int_type pbackfail( int_type c = eof ) {
                    109:                if ( low_ > 0 ) --low_;
                    110:                else if ( c != eof ) {
                    111:                        if ( high_ > 0 ) {
                    112:                                char* nl = (char*)realloc( line_, high_ + 1 );
                    113:                                if ( nl ) {
                    114:                                        line_ = (char*)memcpy( nl + 1, line_, high_ );
                    115:                                        high_ += 1;
                    116:                                        line_[0] = char( c );
                    117:                                } else return eof;
                    118:                        } else {
                    119:                                assert( !line_ );
                    120:                                line_ = (char*)malloc( sizeof( char ) );
                    121:                                *line_ = char( c );
                    122:                                high_ = 1;
                    123:                        }
                    124:                } else return eof;
                    125: 
                    126:                return not_eof;
                    127:        }
                    128:                
                    129: public:
                    130:        readlinebuf( const char* prompt = NULL, bool history = true ) 
                    131:                : prompt_( prompt ), history_( history ),
                    132:                  line_( NULL ), low_( 0 ), high_( 0 ) {
                    133:                setbuf( 0, 0 );
                    134:        }
                    135:                
                    136:                
                    137: };
                    138: 
                    139: #endif