---

define.h

Go to the documentation of this file.

#ifndef define_h
#define define_h

#include "tag.h"
#include "strings.h"
#include "file.h"

class DefineOpen : private Tag
{
public:
  enum Type
    {
      SIMPLE_TAG,
      OPEN_CLOSE_TAG
    };
  
  struct Parameter
  {
    enum Type
      {
        STRING,
        TYPE
      };

    std::string value;
    std::string default_value;
    bool has_default;
    Type type;

    Parameter() {}

    Parameter( std::string v, Type t ) : 
      value( v ), type( t ), has_default(false) {}

    Parameter( std::string v, Type t, std::string default_value ) : 
      value( v ), type( t ), default_value( default_value ), has_default(true) {}

  };

  typedef std::list<Parameter> parameter_list;
  typedef parameter_list::iterator parameter_list_it;

private:

  struct Par : public Parameter
  {
    int number;

    Par() {}

    Par( int n, std::string& v, Type t ) 
      : Parameter( v, t ),
        number( n )
    {}

    Par( int n, std::string& v, Type t, std::string default_value ) 
      : Parameter( v, t, default_value ),
        number( n )
    {}
  };

  typedef std::list<Par> par_list;
  typedef par_list::iterator par_list_it;

  struct DPAR {
    int number;
    std::string value;
  };

  typedef std::list<DPAR> dpar_list;
  typedef dpar_list::iterator dpar_list_it;


private:

  std::string name;
  mutable parameter_list parameters;
  std::string init_class;
  std::string function;
  std::string interpreter;
  Type type;
  bool nested;

  int level;

  bool real_tag; 

public:
  DefineOpen( Line& line );
  DefineOpen() : Tag() {}

  bool operator!() const { return !is_valid_tag; }
  bool is_valid() const { return is_valid_tag; }
  
  std::string get_name() const { return name; }

  parameter_list get_parameters() const { return parameters; }

  std::string get_init_class() const { return init_class; }

  std::string get_function() const { return function; }

  std::string get_interpreter() const { return interpreter; }

  Type get_type() const { return type; }

  int get_level() const { return level; }

  Line get_line() const { return Tag::get_line(); }

  /*** on error it returns an empty string 
       usally it should return something like this:
       "foobar( "hello", 12.3 );"
  */
  std::string get_command( Tag& user_tag ) const;

  bool is_nested() const { return nested; }

  bool get_real_tag() const { return real_tag; }

private:
  bool extract_type( std::string type );
  void extract_parameters();
  static bool par_comp( Par& a, Par& b) { return a.number < b.number; }
  static bool dpar_comp( DPAR& a, DPAR& b ) { return a.number < b.number; }

public:
  friend bool operator!=( const DPAR& d, const int n );
};

class DefineClose : private Tag
{
public:
  DefineClose( Line& line );

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

inline bool operator==( const DefineOpen& defo, DefineOpen::Type type )
{
  return defo.get_type() == type;
}


class Interpreter;

/*** The File will be given to the function as it's first argument */
bool define_call( DefineOpen def, Interpreter* ip, File arg, Tag user_tag );

inline bool operator!=( const DefineOpen::DPAR& d, const int n )
{ return d.number != n; }

#endif

---