eienexpr.hpp

浏览该文件的文档.

#ifndef __EIENEXPR_HPP__
#define __EIENEXPR_HPP__

#include "winux.hpp"

namespace eienexpr
{
#ifdef EIENEXPR_DLL_USE
    #if defined(_MSC_VER) || defined(WIN32)
        #pragma warning( disable: 4251 )
        #ifdef EIENEXPR_DLL_EXPORTS
            #define EIENEXPR_DLL  __declspec(dllexport)
        #else
            #define EIENEXPR_DLL  __declspec(dllimport)
        #endif

        #define EIENEXPR_API __stdcall
    #else
        #define EIENEXPR_DLL
        #define EIENEXPR_API
    #endif
#else
    #define EIENEXPR_DLL
    #define EIENEXPR_API
#endif

#define EIENEXPR_FUNC_DECL(ret) EIENEXPR_DLL ret EIENEXPR_API
#define EIENEXPR_FUNC_IMPL(ret) ret EIENEXPR_API

class EIENEXPR_DLL ExprError : public winux::Error
{
public:
    enum
    {
        eeNone,                
        eeExprParseError,      
        eeStringParseError,    
        eeOperandTypeError,    
        eeValueTypeError,      
        eeFuncParamTypeError,  
        eeFuncParamCountError, 
        eeVarCtxNotFound,      
        eeVarNotFound,         
        eeFuncNotFound,        
        eeEvaluateFailed,      
        eeOutOfArrayBound      
    };

    ExprError( int errNo, winux::AnsiString const & err ) throw() : winux::Error( errNo, err ) { }
};

class EIENEXPR_DLL ExprAtom
{
public:
    enum ExprAtomType
    {
        eatOperator, 
        eatOperand   
    };

    ExprAtom();
    virtual ~ExprAtom();

    ExprAtomType getAtomType() const { return this->_atomType; }

    virtual ExprAtom * clone() const = 0;

    virtual winux::String toString() const = 0;

protected:
    ExprAtomType _atomType; // 表达式原子类型

    friend class ExprParser;
};

class ExprOperand;
class VarContext;
class ExprPackage;
class Expression;

class EIENEXPR_DLL ExprOperator : public ExprAtom
{
public:
    // 操作符函数类型
    typedef bool (* OperatorFunction)( Expression * e, ExprOperand * arOperands[], short n, winux::SimplePointer<ExprOperand> * outRetValue, void * data );

    static bool Possibility( ExprPackage * package, winux::String const & str );

    ExprOperator( winux::String const & oprStr = "", bool isUnary = false, bool isRight = false, short level = 0, OperatorFunction oprFn = NULL );
    virtual ~ExprOperator();

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;

    int nexus( ExprOperator const & opr ) const;

    bool isUnary() const { return _isUnary; }
    bool isRight() const { return _isRight; }
    winux::String const & getStr() const { return _oprStr; }

    bool operator == ( ExprOperator const & opr ) const
    {
        return (
            this->_oprStr == opr._oprStr &&
            this->_isUnary == opr._isUnary &&
            this->_level == opr._level &&
            this->_isRight == opr._isRight &&
            this->_oprFn == opr._oprFn
        );
    }

    bool isSameLevel( ExprOperator const & opr ) const { return _level == opr._level && _isRight == opr._isRight; }

protected:
    winux::String _oprStr; // 算符文本
    bool _isUnary; // 是否一元
    short _level;  // 优先级别
    bool _isRight;  // 是否右结合
    OperatorFunction _oprFn; // 对应函数

    friend class Expression;
    friend class ExprPackage;
    friend class ExprParser;
};

class EIENEXPR_DLL ExprOperand : public ExprAtom
{
public:
    enum ExprOperandType
    {
        eotLiteral,    
        eotIdentifier, 
        eotReference,  
        eotFunction,   
        eotExpression  
    };

    ExprOperand();
    virtual ~ExprOperand();
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result ) = 0;
    winux::Mixed val();

    //bool evaluateUntil( ExprOperandType const * types, int n, winux::SimplePointer<ExprOperand> * result );

    bool evaluateMixedPtr( winux::Mixed ** ppv );

    ExprOperandType getOperandType() const;

protected:
    ExprOperandType _operandType; // 操作数类型

    friend class ExprParser;
};

class EIENEXPR_DLL ExprLiteral : public ExprOperand
{
public:
    ExprLiteral();
    ExprLiteral( winux::Mixed const & val );
    virtual ~ExprLiteral();

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result );

    winux::Mixed::MixedType getValueType() const;
    winux::Mixed const & getValue() const;
    winux::Mixed & getValue();
    void setValue( winux::Mixed const & val );

    static bool NumberPossibility( winux::String const & str, bool * isFloat = NULL, bool * isExp = NULL/*, bool * isMinus = NULL*/ );
protected:
    winux::Mixed _val;

    friend class ExprParser;
};

class EIENEXPR_DLL ExprIdentifier : public ExprOperand
{
public:
    ExprIdentifier( Expression * exprObj, winux::String const & name );
    virtual ~ExprIdentifier();

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result );

    winux::String const & getName() const { return _name; }

    void setVar( winux::Mixed const & val );

    winux::Mixed const & getVar() const;

    VarContext * getVarContext() const;

    Expression * getExprObj() const { return _exprObj; }

    static bool Possibility( winux::String const & str );

protected:
    Expression * _exprObj;  // 所属表达式对象
    winux::String _name; // 名称

    friend class ExprParser;
};

class EIENEXPR_DLL ExprReference : public ExprOperand
{
public:
    ExprReference( winux::Mixed & ref, winux::String const & syntax );
    virtual ~ExprReference();

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result );

    winux::Mixed & getRef() const { return *this->_ref; }
protected:

    winux::Mixed * _ref;
    winux::String _syntax;
};

class EIENEXPR_DLL ExprFunc : public ExprOperand
{
public:
    // 函数类型
    typedef bool (* FuncFunction)( Expression * e, std::vector<Expression *> & params, winux::SimplePointer<ExprOperand> * outRetValue, void * data );
    // 字符串=>函数映射
    typedef std::map< winux::String, FuncFunction > StringFuncMap;

    ExprFunc( Expression * exprObj, winux::String const & funcName );
    virtual ~ExprFunc();
    ExprFunc( ExprFunc const & other );
    ExprFunc & operator = ( ExprFunc const & other );

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result );

//protected:
    Expression * _exprObj;  
    winux::String _funcName; 
    std::vector<Expression *> _params; 

    void _clear();
    void _addParam( Expression * param );


    friend class ExprParser;
};

class EIENEXPR_DLL Expression : public ExprOperand
{
public:
    Expression( ExprPackage * package, VarContext * ctx, Expression * parent, void * data );
    virtual ~Expression();
    Expression( Expression const & other );
    Expression & operator = ( Expression const & other );

    virtual ExprAtom * clone() const;
    virtual winux::String toString() const;
    virtual bool evaluate( winux::SimplePointer<ExprOperand> * result );

    winux::String toSuffixString() const;

    bool isEmpty() const { return this->_suffixAtoms.empty(); }

    ExprPackage * getPackage() const { return this->_package; }

    VarContext * getVarContext() const;

    void * getDataPtr() const;

    bool getVar( winux::String const & name, winux::Mixed * * outVarPtr, VarContext * * outVarCtx = nullptr ) const;
    winux::Mixed const & getVar( winux::String const & name, VarContext * * outVarCtx = nullptr ) const;

    void setVar( winux::String const & name, winux::Mixed const & val );

    void clear();

//protected:
    std::vector<ExprAtom *> _suffixAtoms; 
    ExprPackage * _package; 
    VarContext * _varCtx; 
    Expression * _parent; 
    void * _data; 

    void _addAtom( ExprAtom * atom );

    friend class ExprIdentifier;
    friend class ExprParser;
};

class EIENEXPR_DLL VarContext
{
public:
    struct VariableStruct
    {
        winux::Mixed * p;
        bool isNewAlloc; 

        VariableStruct() : p(NULL), isNewAlloc(false)
        {
        }
    };

    VarContext( winux::Mixed * collection = nullptr );

    virtual ~VarContext();

    VarContext( VarContext const & other );

    VarContext & operator = ( VarContext const & other );

    void setMixedCollection( winux::Mixed * collection );

    void set( winux::String const & name, winux::Mixed const & v );

    winux::Mixed & set( winux::String const & name );

    void setPtr( winux::String const & name, winux::Mixed * v );

    winux::Mixed * & setPtr( winux::String const & name );

    bool unset( winux::String const & name );

    bool has( winux::String const & name ) const;

    bool get( winux::String const & name, winux::Mixed * * outVarPtr ) const;

    winux::Mixed const & get( winux::String const & name ) const;

    void clear();

    winux::Mixed dump() const;

protected:
    winux::Mixed * _collection;
    std::map< winux::String, VariableStruct > _vars;

    friend class ExprParser;
};

class EIENEXPR_DLL ExprPackage
{
public:
    ExprPackage();

    bool oprPossibility( winux::String const & str ) const;

    void addOpr( winux::String const & oprStr, bool isUnary, bool isRight, short level, ExprOperator::OperatorFunction oprFn );
    bool delOpr( winux::String const & oprStr, bool isUnary, bool isRight );
    bool modifyOpr( int i, winux::String const & oprStr, bool isUnary, bool isRight, short level, ExprOperator::OperatorFunction oprFn );
    int findOpr( ExprOperator * opr, winux::String const & oprStr, bool isUnary = false, bool isRight = false ) const;

    int getOpr( winux::String const & oprStr, ExprOperator * oprArr, int n ) const;
    int getAllOprs( ExprOperator * oprArr, int n ) const;


    void setFunc( winux::String const & funcName, ExprFunc::FuncFunction fn );
    bool delFunc( winux::String const & funcName );
    bool modifyFunc( winux::String const & funcName, winux::String const & newFuncName, ExprFunc::FuncFunction newFn );
    bool findFunc( winux::String const & funcName, ExprFunc::FuncFunction * fn ) const;
    int getAllFuncs( std::vector< std::pair< winux::String, ExprFunc::FuncFunction > > * funcs ) const;

private:
    std::vector<ExprOperator> _operators; // 支持的运算符
    ExprFunc::StringFuncMap _funcsMap; // 支持的函数

    friend class ExprFunc;
    friend class Expression;
    friend class ExprParser;
};

class EIENEXPR_DLL ExprParser
{
public:
    ExprParser();
    virtual ~ExprParser();

    void parse( Expression * e, winux::String const & str );

    //winux::String const & error() const { return _errStr; }
    //int errNo() const { return _errNo; }
private:
    //int _errNo;
    //winux::String _errStr;
    enum ExprParseContext
    {
        epcExpr, epcFuncParams, epcString, epcStrAntiSlashes
    };
    void _parseExpr( Expression * e, winux::String const & str, int & i, std::vector<ExprParseContext> & epc );
    void _parseString( winux::String * v, winux::String const & str, int & i, std::vector<ExprParseContext> & epc );
    void _parseStrAntiSlashes( winux::String * v, winux::String const & str, int & i, std::vector<ExprParseContext> & epc );
    void _parseFuncParams( Expression * exprOwner, ExprFunc * funcAtom, winux::String const & str, int & i, std::vector<ExprParseContext> & epc );

};

} // namespace eienexpr

#endif //__EIENEXPR_HPP__