---

ih.h

Go to the documentation of this file.

#ifndef ih_h
#define ih_h

#include <string>
#include <list>
#include "script.h"
#include "file.h"

class Interpreter
{
public:

  class Type
  {
  public:
    enum EType
      {
        UNKNOWN,    
        JAVASCRIPT, 
        DEFAULT     
      };

  private:
    EType type;
    std::string name;     
    std::string command;  

    bool valid;
  public:
    Type() : type( UNKNOWN ), valid( false ) {}
    Type( std::string type, std::string name = "", std::string command="" );

    std::string get_name() const { return name; }
    std::string get_command() const { return command; }
    EType get_type() const { return type; }
    bool operator!() const { return !valid; }
    bool is_valid() const { return valid; }
  };
  
  struct Error
  {
    std::string what;
    Error( std::string what ) : what( what ) {}
  };
  
protected:
  Type type;
  bool default_int;
  
  std::istream* in;
  std::ostream* out;
  std::ostream* err;
  
  bool valid;

public:
  Type get_type() const { return type; }
  bool is_default() const { return default_int; }
  
  Interpreter();
  Interpreter( Type type, bool default_int,  std::istream& in, std::ostream& out, std::ostream& err );
  virtual ~Interpreter();

  virtual bool exec()=0;
  virtual bool exec( std::string buffer )=0;

  bool operator!() const { return !valid; }
  bool is_valid() const { return valid; }

  void set_io( std::istream& in, std::ostream& out, std::ostream& err );
  void set_out( std::ostream& out );
  
  std::ostream& get_out() const { return *out; }
  std::istream& get_in()  const { return *in; }
  std::ostream& get_err() const { return *err; }
};

bool operator==( const Interpreter::Type &t1, const Interpreter::Type &t2 );

inline bool operator==( const Interpreter::Type &t1, const Interpreter::Type::EType t2 )
{
  return t1.get_type() == t2;
}

class Precompiler;

class InterpreterHandler
{
private:
  typedef std::list<Interpreter*> interpreter_list;
  typedef interpreter_list::iterator interpreter_list_it;

  interpreter_list il;

  Precompiler &precompiler;
public:
  InterpreterHandler( Precompiler &precompiler ) : precompiler( precompiler ) {}
  ~InterpreterHandler();

  bool have_one( Interpreter::Type type );


  Interpreter* get_default();


  bool add( Interpreter* ip );

  bool have_default();


  Interpreter* get_one( Interpreter::Type type );
  Interpreter* get_one( std::string name );


  bool create_one( Interpreter::Type type, std::istream& in, std::ostream& out, std::ostream& err, bool default_int = false );
};

class Precompiler;

class ScriptHandler
{
public:
  
  // handles Script sources
  class Script
  {
  private:
    Interpreter::Type type;
    File buffer;
    ScriptStart start;

    bool valid;
  public:
    Script( Interpreter::Type type, File buffer, ScriptStart start );

    template <class T> void operator<<( T t ) { buffer << t; }
    template <class T> void operator>>( T& t ) { buffer >> t; }

    bool operator!() const { return !valid; }
    bool is_valid() const { return valid; }

    File get_buffer() const { return buffer; }

    Interpreter::Type get_type() const { return type; }
    ScriptStart get_start() const { return start; }
  };

  typedef std::list<Script> script_list;
  typedef script_list::iterator script_list_it;

private:

  script_list sl;

  Precompiler* precompiler;

public:

  ScriptHandler( Precompiler* precompiler );

  bool add( ScriptStart ss, File buffer );

  script_list get_scripts() const { return sl; }

private:
  ScriptHandler(){}

};

#endif

---