SReadline.h

Go to the documentation of this file.

//
// Date:      17 December 2005
//            03 April    2006
//            20 April    2006
//            07 May      2006
//
// Copyright (c) Sergey Satskiy 2005 - 2006
//               <sergesatsky@yahoo.com>
//
// Permission to copy, use, modify, sell and distribute this software 
// is granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//

#ifndef SREADLINE_H
#define SREADLINE_H

#include <stdio.h>

#include <readline/readline.h>
#include <readline/history.h>
#include <readline/keymaps.h>

#include <string>
#include <fstream>
#include <vector>
#include <stdexcept>
#include <map>

#include <boost/algorithm/string/trim.hpp>
#include <boost/tokenizer.hpp>
#include <boost/function.hpp>


namespace
{
    typedef std::vector< std::string >              TokensStorage;
    typedef std::vector< TokensStorage >            CompletionsStorage;
    typedef boost::function< int ( int, int ) >     KeyCallback;
    typedef std::map< int, KeyCallback >            KeysBind;

    
    const size_t                    DefaultHistoryLimit( 64 );  
    CompletionsStorage              Completions;                
    TokensStorage                   Tokens;                     
    std::map< Keymap, KeysBind >    Keymaps;                    

    bool                            KeymapWasSetup( false );    

    Keymap                          Earlykeymap( 0 );           


    char * Generator( const char *  text, int  State );

    
    char ** UserCompletion( const char * text,
                            int          start,
                            int          end );


    int  KeyDispatcher( int  Count, int  Key );


    int  StartupHook( void );

    
    template < typename  Container >
    bool AreTokensEqual( const Container &  Pattern, 
                         const Container &  Input )
    {
        if ( Input.size() > Pattern.size() ) return false;

        typename Container::const_iterator  k( Pattern.begin() );
        typename Container::const_iterator  j( Input.begin() );
        for ( ; j != Input.end(); ++k, ++j )
        {
            if ( *k == "%file" ) continue;
            if ( *k != *j )      return false;
        }
        return true;
    }


        // See description near the prototype
    template < typename  ContainerType >
    void SplitTokens( const std::string &  Source, ContainerType &  Container )
    {
        typedef boost::tokenizer< boost::char_separator< char > >       TokenizerType;

        boost::char_separator<char>     Separators( " \t\n" );              // Set of token separators
        TokenizerType                   Tokenizer( Source, Separators );    // Tokens provider
        std::string                     SingleToken;                        // Temporary storage for a token
        
        Container.clear();
        for ( TokenizerType::const_iterator  k( Tokenizer.begin() ); k != Tokenizer.end(); ++k )
        {
            SingleToken = *k;
            boost::algorithm::trim( SingleToken );
            Container.push_back( SingleToken );
        }
    }

    
        // See description near the prototype
    char ** UserCompletion( const char *  text, int  start, int  end )
    {
            // No default completion at all
        rl_attempted_completion_over = 1;

        if ( Completions.empty() )  return NULL;

            // Memorize all the previous tokens
        std::string     PreInput( rl_line_buffer, start );
        SplitTokens( PreInput, Tokens );


            // Detect whether we should call the standard file name completer or a custom one
        bool    FoundPretender( false );

        for ( CompletionsStorage::const_iterator  k( Completions.begin() ); k != Completions.end(); ++k )
        {
            if ( ! AreTokensEqual( *k, Tokens ) ) continue;

            if ( (*k).size() > Tokens.size() )
            {
                FoundPretender = true;
                if ( (*k)[ Tokens.size() ] == "%file" )
                {
                        // Standard file name completer - called for the "%file" keyword
                    return rl_completion_matches( text, rl_filename_completion_function );
                }
            }
        }
        
        if ( FoundPretender )
        {
            return rl_completion_matches( text, Generator );
        }
        return NULL;
    }
    
   

        // See description near the prototype
    char * Generator( const char *  text, int  State )
    {
        static int                                  Length;
        static CompletionsStorage::const_iterator   Iterator;

        
        if ( State == 0 )
        {
            Iterator = Completions.begin();
            Length = strlen( text );
        }

        for ( ; Iterator != Completions.end(); ++Iterator )
        {
            if ( ! AreTokensEqual( *Iterator, Tokens ) ) continue;

            if ( (*Iterator).size() > Tokens.size() )
            {
                if ( (*Iterator)[ Tokens.size() ] == "%file" ) continue;

            
                if ( strncmp( text, (*Iterator)[ Tokens.size() ].c_str(), Length ) == 0 )
                {
                        // readline will free the allocated memory
                    char *  NewString( (char*)malloc( strlen( (*Iterator)[ Tokens.size() ].c_str() ) + 1 ) );
                    strcpy( NewString, (*Iterator)[ Tokens.size() ].c_str() );
                    ++Iterator;
                    return NewString;
                }
            }
        }
       
        return NULL;
    }

    
        // See the description near the prototype
    int  KeyDispatcher( int  Count, int  Key )
    {
        std::map< Keymap, KeysBind >::iterator  Set( Keymaps.find( rl_get_keymap() ) );
        if ( Set == Keymaps.end() )
        {
                // Most probably it happens bacause the header was 
                // included into many compilation units and the
                // keymap setting calls were made in different files.
                // This is the problem of "global" data.
                // The storage of all the registered keymaps is in anonymous
                // namespace.
            throw std::runtime_error( "Error selecting a keymap." );
        }

        (Set->second)[ Key ]( Count, Key );
        return 0;
    }


        // See the description near the prototype
    int  StartupHook( void )
    {
        if ( KeymapWasSetup )
        {
            rl_set_keymap( Earlykeymap );
        }
        return 0;
    }

}   // Anonymous namespace




namespace swift 
{

    class SKeymap
    {
        private:
            Keymap      keymap;     // Readline keymap
            
        public:
            explicit SKeymap( bool  PrintableBound = false ) : 
                keymap( NULL )
            {
                if ( PrintableBound )
                {
                    keymap = rl_make_keymap();      // Printable characters are bound
                }
                else
                {
                    keymap = rl_make_bare_keymap(); // Empty keymap
                }

                if ( keymap == NULL )
                {
                    throw std::runtime_error( "Cannot allocate keymap." );
                }

                    // Register a new keymap in the global list
                Keymaps[ keymap ] = KeysBind();
            }
            
            explicit SKeymap( Keymap   Pattern ) :
                keymap( rl_copy_keymap( Pattern ) )
            {
                if ( keymap == NULL )
                {
                    throw std::runtime_error( "Cannot allocate keymap." );
                }
                
                    // Register a new keymap in the global list
                Keymaps[ keymap ] = KeysBind();
            }

            ~SKeymap()
            {
                    // Deregister the keymap
                Keymaps.erase( keymap );
                rl_discard_keymap( keymap );
            }

            void Bind( int  Key, KeyCallback  Callback )
            {
                Keymaps[ keymap ][ Key ] = Callback;
                if ( rl_bind_key_in_map( Key, KeyDispatcher, keymap ) != 0 )
                {
                        // Remove from the map just bound key
                    Keymaps[ keymap ].erase( Key );
                    throw std::runtime_error( "Invalid key." );
                }
            }


            void Unbind( int  Key )
            {
                rl_unbind_key_in_map( Key, keymap );
                Keymaps[ keymap ].erase( Key );
            }

            // void Bind( const std::string &  Sequence, boost::function< int ( int, int ) > );
            // void Unbind( std::string &  Sequence );

        public:
            SKeymap( const SKeymap &  rhs )
            {
                if ( this == & rhs )
                {
                    return;
                }
                keymap = rl_copy_keymap( rhs.keymap );
            }

            SKeymap &  operator=( const SKeymap &  rhs )
            {
                if ( this == & rhs )
                {
                    return *this;
                }
                keymap = rl_copy_keymap( rhs.keymap );
                return *this;
            }
            
            friend class SReadline;
    };
    

    class SReadline
    {
        public:
            SReadline( const size_t  Limit = DefaultHistoryLimit ) : 
                HistoryLimit( Limit ),
                HistoryFileName( "" ), 
                OriginalCompletion( rl_attempted_completion_function )
            {
                rl_startup_hook = StartupHook;
                rl_attempted_completion_function = UserCompletion;
                using_history();
            }
            
            SReadline( const std::string &  historyFileName,
                       const size_t  Limit = DefaultHistoryLimit ) :
                HistoryLimit( Limit ),
                HistoryFileName( historyFileName ),
                OriginalCompletion( rl_attempted_completion_function )
            {
                rl_startup_hook = StartupHook;
                rl_attempted_completion_function = UserCompletion;
                using_history();
                LoadHistory( HistoryFileName );
            }

            ~SReadline()
            {
                rl_attempted_completion_function = OriginalCompletion;
                SaveHistory( HistoryFileName );
            }

            std::string  GetLine( const std::string &  Prompt )
            {
                bool    Unused;
                return GetLine( Prompt, Unused );
            }
            

            template < typename  Container >
            std::string  GetLine( const std::string &  Prompt,
                                  Container &          ReadTokens )
            {
                bool    Unused;
                return GetLine( Prompt, ReadTokens, Unused );
            }


            template < typename  Container >
            std::string  GetLine( const std::string &  Prompt,
                                  Container &          ReadTokens,
                                  bool &               BreakOut )
            {
                std::string     Input( GetLine( Prompt, BreakOut ) );
                SplitTokens( Input, ReadTokens );
                return Input;
            }


            std::string  GetLine( const std::string &  Prompt, 
                                  bool &               BreakOut )
            {
                BreakOut = true;

                char *  ReadLine( readline( Prompt.c_str() ) );
                if ( ReadLine == NULL ) return std::string();
                
                    // It's OK
                BreakOut = false;
                std::string     Input( ReadLine );
                free( ReadLine );

                boost::algorithm::trim( Input );
                if ( !Input.empty() )
                {
                    if ( (history_length == 0) ||
                         (Input != history_list()[ history_length - 1 ]->line)
                       )
                    {
                        add_history( Input.c_str() );
                        if ( history_length >= static_cast< int >( HistoryLimit ) )
                        {
                            stifle_history( HistoryLimit );
                        }
                    }
                }

                return Input;
            }


            template < typename ContainerType >
            void GetHistory( ContainerType &  Container )
            {
                for ( int  k( 0 ); k < history_length; ++k )
                {
                    Container.push_back( history_list()[ k ]->line );
                }
            }

            bool SaveHistory( std::ostream & OS )
            {
                if ( ! OS ) return false;
                for ( int  k( 0 ); k < history_length; ++k )
                {
                    OS << history_list()[ k ]->line << std::endl;
                }
                return true;
            }

            bool SaveHistory( const std::string &  FileName )
            {
                if ( FileName.empty() ) return false;

                std::ofstream  OS( FileName.c_str() );
                return SaveHistory( OS );
            }

            void ClearHistory()
            {
                clear_history();
            }
            

            bool LoadHistory( std::istream &  IS )
            {
                if ( ! IS ) return false;

                ClearHistory();
                std::string     OneLine;

                while ( ! getline( IS, OneLine ).eof() )
                {
                    boost::algorithm::trim( OneLine );
                    if ( (history_length == 0) ||
                         (OneLine != history_list()[ history_length - 1 ]->line)
                       )
                    {
                        add_history( OneLine.c_str() );
                    }
                }
                stifle_history( HistoryLimit );
                return true;
            }
            
            bool LoadHistory( const std::string &  FileName )
            {
                if ( FileName.empty() ) return false;

                std::ifstream   IS( FileName.c_str() );
                return LoadHistory( IS );
            }

            template < typename  ContainerType >
            void RegisterCompletions( const ContainerType &  Container )
            {
                Completions.clear();
                for ( typename ContainerType::const_iterator  k( Container.begin() );
                      k != Container.end(); ++k )
                {
                    std::vector< std::string >  OneLine;
                    SplitTokens( static_cast<std::string>(*k), OneLine );
                    Completions.push_back( OneLine );
                }
            }

                
            void  SetKeymap( SKeymap &  NewKeymap )
            {
                rl_set_keymap( NewKeymap.keymap );
                KeymapWasSetup = true;
                Earlykeymap = NewKeymap.keymap;
            }

        private:
            const size_t            HistoryLimit;       
            const std::string       HistoryFileName;    
            rl_completion_func_t *  OriginalCompletion; 
    };


}; // namespace swift

#endif 

---