SReadline.hpp

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) {
      const std::string lPattern = *k;
      if (lPattern == "%file") {
        continue;
      }

      const std::string lInput = *j;
      if (lPattern != lInput) {
        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;

    // Set of token separators
    boost::char_separator<char> Separators (" \t\n");
    // Tokens provider
    TokenizerType Tokenizer (Source, Separators);
        
    Container.clear();
    for (TokenizerType::const_iterator k (Tokenizer.begin());
         k != Tokenizer.end(); ++k) {
      // Temporary storage for the token, in order to trim that latter
      std::string 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() == true) {
      return NULL;
    }

    // Memorise 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) {
      const TokensStorage& lTokenStorage = *k;
      if (AreTokensEqual (lTokenStorage, Tokens) == false) {
        continue;
      }

      if (lTokenStorage.size() > Tokens.size()) {
        FoundPretender = true;
        if (lTokenStorage [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) {
      const TokensStorage& lCompletion = *Iterator;
      if (AreTokensEqual (lCompletion, Tokens) == false) {
        continue;
      }

      if (lCompletion.size() > Tokens.size()) {
        if (lCompletion [Tokens.size()] == "%file") {
          continue;
        }
            
        const char* lCompletionCharStr (lCompletion [Tokens.size()].c_str());
        if (strncmp (text, lCompletionCharStr, Length) == 0) {
          // Readline will free the allocated memory
          const size_t lCompletionSize = strlen (lCompletionCharStr) + 1;
          char* NewString (static_cast<char*> (malloc (lCompletionSize)));
          strcpy (NewString, lCompletionCharStr);

          ++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:
    // Readline keymap
    Keymap keymap;
            
  public:
    explicit SKeymap (bool PrintableBound = false) : keymap (NULL) {
      if (PrintableBound == true) {
        // Printable characters are bound
        keymap = rl_make_keymap();
        
      } else {
        // Empty keymap
        keymap = rl_make_bare_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); ReadLine = NULL;

      boost::algorithm::trim (Input);
      if (Input.empty() == false) {
        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() == true) {
        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() == true) {
        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;
        const std::string& kStr = static_cast<std::string> (*k);

        SplitTokens (kStr, OneLine);
        Completions.push_back (OneLine);
      }
    }

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


  private:
    // /////////////////////////// Attributes /////////////////////////
    const size_t HistoryLimit;

    const std::string HistoryFileName;

    rl_completion_func_t* OriginalCompletion;
  };

}; // namespace swift

#endif