Expr.h

#ifndef gridripper_math_expr_Expr_h
#define gridripper_math_expr_Expr_h

#include "StkArg.h"
#include <gridripper/lang/Exception.h>
#include <gridripper/tvector.h>
#include <string>

namespace gridripper { namespace math { namespace expr {

class StkOpRepository;
class StkConst;
class StkVar;

using namespace std;

class Expr: public StkFunc
{
public:

    class Error: public Exception {
    public:
        Error(const Error& other): Exception(other) { }

        Error(const string& what, const string& where): Exception(what, where) { }
    };

private:
    string exprString;
    tvector<StkArg*> functionArgs;
    StkOp** program;
    bool myFuncRep;
    StkOpRepository* funcRep;
    tvector<StkOp*> funcs;
    tvector<StkConst*> nums;
    tvector<bool> varUsed;
    tvector<Expr*> myOwnExpressions;
    int stackSize;
    int maxStackSize;
    GReal_t* stack;

public:
    Expr(const string& s) throw(Error&);

    Expr(const string& s, const tvector<StkOp*>& funcs,
         StkOpRepository* funcRep = NULL) throw(Error&);

    ~Expr();

private:
    Expr(const Expr& other);

public:
    const string& getString() const { return exprString; }

    string getProgramListString() const;

    GReal_t eval();

    bool isConstant() const;

    bool dependsOn(const StkOp& f) const;

    bool dependsOnVariables() const;

    void replaceVar(const string& name, StkVar& var);

    void evalStack(GReal_t*& stack) const;

    StkOp** getInternalProgram() const { return program; }

    virtual string getClassName() const { return "Expr"; }

public:
    static string::size_type findExprEnd(const string& str,
                                         string::size_type i);

private:
    void init();
    void create() throw(Error&);
    void parseFunc(const string& s) throw(Error&);
    void parseExpr(tvector<StkOp*>& progvec, const string& s)
        throw(Error&);
    void parseExpr0(tvector<StkOp*>& progvec, const string& s,
                string::const_iterator& K, StkOp** stk, StkOp**& stkp)
        throw(Error&);
    void createProgram(const tvector<StkOp*>& progvec) throw(Error&);
    void destruct();
    void checkSyntax(const string& s) throw(Error&);
    void addFunc(tvector<StkOp*>& progvec, StkOp* f);
    int findVar(const string& str, string::size_type k) const;
    int findFunc(const string& name) const;

    string getProgramListString0() const;

    void independ();

    void collectExprsRecursively(tvector<Expr*>& oldxprs) const;

    void replaceExprsInProgram(const tvector<Expr*>& oldxprs,
                               const tvector<Expr*>& newxprs);

    static string convertConditionOps(const string& str) throw(Error&);

    static string::size_type findConditionColon(const string& str,
                                                string::size_type i);

    static string convertEqualityOps(const string& str);
};

} } } /* namespace gridripper::math::expr */

#endif /* gridripper_math_expr_Expr_h */