CommandParser.h

/***************************************************************************
 *
 *   Copyright (C) 2002, 2006 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
#ifndef __CommandParser_h
#define __CommandParser_h
 
#include "TextInterfaceParser.h"
#include "Error.h"
 
#include <vector>
#include <string>
#include <iostream>
 
class CommandParser : public Reference::Able {
 
 public:
 
  static bool debug;
 
  std::string prompt;
 
  std::ostream* out;
 
  CommandParser ();
 
  ~CommandParser ();
 
  void initialize_readline (const char*);
 
  std::string readline ();
 
  virtual std::string script (const std::string& filename);
 
  virtual std::string script (const std::vector<std::string>& commands);
 
  void standard_input (const std::string& prompt);
 
  std::string help (const std::string& command = "");
 
  std::string parse (const std::string& commandargs);
 
  std::string parse2 (const std::string& command, const std::string& args);
 
  std::string if_command (const std::string& condition_command);
 
  std::string while_command (const std::string& condition_command);
 
  std::string loop (const std::string& indeces_command);
  
  virtual bool evaluate (const std::string& expression);
 
  virtual std::string empty ();
 
  bool quit = false;
 
  int verbose = 0;
 
  bool abort = false;
 
  class Method;
 
 protected:
 
  bool interactive = true;
 
  bool fault = false;
 
  std::string nested;
 
  template <class Parser>
    void add_command (std::string (Parser::*method)(const std::string&),
                      const std::string& command,
                      const std::string& help,
                      const std::string& detailed_help = "",
                      char shortcut = 0);
 
  template <class Parser>
    void add_command (std::string (Parser::*method)(const std::string&),
                      char shortcut,
                      const std::string& command,
                      const std::string& help,
                      const std::string& detailed_help = "")
    { add_command (method, command, help, detailed_help, shortcut); }
 
  void import (CommandParser*);
 
  void import (CommandParser*,
               const std::string& command,
               const std::string& help,
               char shortcut = 0);
 
  class Nested;
 
  void add_command (Method*);
 
  std::string get_command () const { return current_command; }
 
  std::string usage () { return help(current_command); }
 
  void conditional (const std::string& text,
                    std::string& condition,
                    std::string& command);
 
  virtual TextInterface::Parser* get_interface () { return 0; }
 
 private:
 
  std::vector<Method*> commands;
 
  std::string current_command;
 
  bool startCommand, endCommand;
 
  // readline interface
  static char** completion (const char *text, int start, int end);
  
  // readline interface
  static char* command_generator (const char* text, int state);
 
  std::string loop_command;
  std::string loop_result;
  void loop_parse ();
};
 
class CommandParser::Method {
 public:
  Method() {}
  virtual ~Method () {}
 
  virtual std::string execute (const std::string& command) = 0;
 
  virtual std::string detail () const = 0;
 
  std::string command;
  std::string help;
  char shortcut;
};
 
class CommandParser::Nested : public Method {
 public:
  Nested( CommandParser*,
          const std::string& command,
          const std::string& help,
          char shortcut );
  std::string execute (const std::string& command);
  std::string detail () const;
 protected:
  Reference::To<CommandParser, false> parser;
};
 
template <class Parser> class Command : public CommandParser::Method 
{
  friend class CommandParser;
  
  typedef std::string (Parser::*Method) (const std::string&);
  
 public:
  
  Command (Parser* _instance, Method _method, const std::string& _command,
           const std::string& _help, const std::string& _detailed_help,
           char _shortcut)
    {
      command  = _command;
      help     = _help;
      shortcut = _shortcut;
 
      detailed_help = _detailed_help;
      instance      = _instance;
      method        = _method;
    }
 
  std::string execute (const std::string& args)
    { return (instance->*method) (args); }
 
  std::string detail () const
    { return detailed_help; }
 
 protected:
  Method method;
 
  Parser* instance;
 
  std::string detailed_help;
};
 
template<class P>
void CommandParser::add_command (std::string (P::*method) (const std::string&),
                                 const std::string& cmd,
                                 const std::string& help, 
                                 const std::string& detailed_help,
                                 char shortcut)
{
  if (debug)
    std::cerr << "CommandParser::add_command \"" << cmd << "\"" << std::endl;
 
  P* instance = dynamic_cast<P*> (this);
  if (!instance)
    throw Error (InvalidState, "CommandParser::add_command",
                 "instance/method mis-match");
 
  if (debug)
    std::cerr << "CommandParser::add_command new Command<P>" << std::endl;
 
  add_command (new Command<P> 
               (instance, method, cmd, help, detailed_help, shortcut));
}
 
 
#endif