expression.hh

/*
  expression.hh, copyright (c) 2006 by Vincent Fourmond: 
  The main header file for SCalc.
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details (in the COPYING file).
  
*/

namespace SCalc {
  // I like Javadoc-like comments the best

  class Expression;
  class FuncDef;
  class SyntaxError;

  class ParserResult {
    Session * sess;
  public:
    ParserResult(Session * s) {sess = s;};
    virtual ~ParserResult() {;};

    Session * session() { return sess;};

    // A whole set of what am I functions, all returning false 
    // (so that the children don't actually need to redefine anything.
    
    

    virtual int is_expression() { return 0;}

    Expression * to_expression() { 
      if(is_expression())
        return (Expression *) this;
      else
        return NULL;
    };


    virtual int is_syntax_error() { return 0;}

    SyntaxError * to_syntax_error() { 
      if(is_syntax_error())
        return (SyntaxError *) this;
      else
        return NULL;
    };

    virtual int is_func_def() { return 0;}

    FuncDef * to_func_def() { 
      if(is_func_def())
        return (FuncDef *) this;
      else
        return NULL;
    };



    virtual std::string pretty_print() = 0;

    virtual int can_delete() { return 1;};
  };


  class Expression : public ParserResult{
  public:
    Expression(Session * s) : ParserResult(s) {;};
    virtual ~Expression() {;};

    virtual int is_expression() { return 1;};

    virtual double evaluate(const double * values, 
                            const double * s = NULL) = 0;
    
    virtual void dump(::std::ostream & stream = ::std::cerr);

    virtual std::set<int> used_variables() { std::set<int> a; return a;};

    int evaluable() { return session()->evaluable(this);};
    double evaluate();

    virtual int is_null() { return 0;};

    virtual int is_id() { return 0;};

    virtual int is_const() { return 0;};

    virtual int is_valid() { return 1;};

    virtual Expression * derive(int id);

    virtual Expression * copy() { return NULL;};

    virtual std::string pretty_print() = 0;


    virtual Expression * simplify() { return copy();};

    virtual double * mass_evaluate(int nb, double * target, const double **variables);

    
    static Expression * add(Expression *, Expression* );
    static Expression * sub(Expression *, Expression* );
    static Expression * mul(Expression *, Expression* );
    static Expression * div(Expression *, Expression* );
  };


};