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,      
    };

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

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

    ExprAtom();
    virtual ~ExprAtom();
    virtual ExprAtom * clone() const = 0;
    ExprAtomType getAtomType() const;

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

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

    friend class ExprParser;
};

class ExprOperand;

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

    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; }
protected:
    winux::String _oprStr; // 算符文本
    bool _isUnary; // 是否一元
    short _level;  // 优先级别
    bool _isRight;  // 是否右结合
    OperatorFunction _oprFn; // 对应函数

    static std::vector<ExprOperator> _Operators;

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

    static void AddOpr( winux::String const & oprStr, bool isUnary, bool isRight, short level, OperatorFunction oprFn );
    static bool DelOpr( winux::String const & oprStr, bool isUnary, bool isRight );
    static bool ModifyOpr( int i, winux::String const & oprStr, bool isUnary, bool isRight, short level, OperatorFunction oprFn );
    static int FindOpr( ExprOperator * opr, winux::String const & oprStr, bool isUnary = false, bool isRight = false );

    static int GetOpr( winux::String const & oprStr, ExprOperator * oprArr, int n );
    static int GetAllOprs( ExprOperator * oprArr, int n );

    friend class Expression;
    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();

    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 Expression;
class VarContext;

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 );

    VarContext * getVarContext() const;

    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)( 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; 

    static StringFuncMap _FuncsMap; 

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

public:
    static void SetFunc( winux::String const & funcName, FuncFunction fn );
    static bool DelFunc( winux::String const & funcName );
    static bool ModifyFunc( winux::String const & funcName, winux::String const & newFuncName, FuncFunction newFn );
    static bool FindFunc( winux::String const & funcName, FuncFunction * fn );

    static int GetAllFuncs( std::vector< std::pair< winux::String, FuncFunction > > * funcs );

    friend class ExprParser;
};

class VarContext;

class EIENEXPR_DLL Expression : public ExprOperand
{
public:
    Expression( VarContext * ctx, Expression * owner, 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 );

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

    VarContext * getVarContext() const;
    void * getDataPtr() const;
//protected:
    std::vector<ExprAtom *> _suffixAtoms; 
    VarContext * _varCtx; 
    Expression * _owner; 
    void * _data; 

    void _clear();
    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();
    virtual ~VarContext();
    VarContext( VarContext const & other );
    VarContext & operator = ( VarContext const & other );

    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();
protected:
    std::map< winux::String, VariableStruct > _vars;

    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 );

};

}

#endif //__EIENEXPR_HPP__