cExpressionExec.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cExpressionExec_H
#define _INC_cExpressionExec_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cExpressionContext.h"
#include "cExpressionBase.h"
 
#ifdef USE_EXPRESSION
#include "../Variant/cVariant.h"
 
namespace GrayLib
{
        enum EXP_PARSE_TYPE_    // flags
        {
                EXP_PARSE_0 = 0,                
                EXP_PARSE_STR1 = 0x08,  
                EXP_PARSE_PROP = 0x10,  
                EXP_PARSE_FUNC = 0x20,  
                EXP_PARSE_SLOP = 0x40,  
 
                EXP_PARSE_IGNORE_EXTRA = 0x80,  
                EXP_PARSE_GLOBALS = 0x100, 
 
        };
        typedef WORD EXP_PARSE_MASK_t;  
 
        class GRAYLIB_LINK cExpressionExec : public cExpressionBase
        {
 
                typedef cExpressionBase SUPER_t;
 
        public:
                // default to use cExpressionBase if there is no other exec engine.
                static cExpressionExec* sm_pExpExecBest;                
 
        protected:
                EXP_PARSE_MASK_t m_wParseFlags;         
 
        private:
                // Get the current expression Context (thread safe).
                // Used to parse expression strings passed into sub functions.
                cExpressionContext* m_pExpContext;              
                cExpressionContext* m_pExpContextPrev;  
 
        protected:
                // This appears to be a symbolic of some sort.
                HRESULT ParseArgV(const ATOMCHAR_t*& rpszExp, OUT cVariant& vArgsRet, EXP_PARSE_MASK_t uParseFlags);
 
                cExpressionContext* get_ContextCurrent() const
                {
                        if (m_pExpContext != nullptr) 
                        {
                                return m_pExpContext;
                        }
                        return cExpressionContextMgr::GetContextCurrent(); 
                }
 
        public:
                explicit cExpressionExec(cExpressionContext* pContext);
                virtual ~cExpressionExec();
 
                virtual HRESULT ExecuteFunctionInt(const ATOMCHAR_t*& rpszExp, OUT cVariant& vValRet, EXP_PARSE_MASK_t uParseFlags);
 
                HRESULT ExecuteCommand(const ATOMCHAR_t* pszCommand, OUT cVariant& vValRet);
 
                HRESULT GetVarRef1(const ATOMCHAR_t*& rpszExp, OUT cVariant& vValRet);
 
                static HRESULT GRAYCALL DoMathOp2(cVariant& vVal, const cVariant& vVal2, ATOMCHAR_t chOp);
                HRESULT DoMathOp1(cVariant& vVal, const ATOMCHAR_t*& rpszExp);
 
                virtual HRESULT GetVarRef2(const ATOMCHAR_t*& rpszExp, OUT cVariant& vValRet, bool bInArray) override;
 
                cVariant GetVarComplexRef(const ATOMCHAR_t*& rpszExp);
                cVariant GetVarComplex(const ATOMCHAR_t* pszExp)
                {
                        return GetVarComplexRef(pszExp);
                }
 
#define EXP_GET_TYPE(a,b) a GetComplex##b( const ATOMCHAR_t* pszExp ) { return GetVarComplexRef( pszExp ).get_##b(); }
                EXP_GET_TYPE(bool, Bool)
                EXP_GET_TYPE(int, Int)
                EXP_GET_TYPE(UINT32, DWord)
                EXP_GET_TYPE(float, Float)
                EXP_GET_TYPE(double, Double)
#undef EXP_GET_TYPE
 
#define EXP_GET_X_TYPE(a,b) static inline a GetX##b( const ATOMCHAR_t* pszExp ) { return sm_pExpExecBest->GetVarComplexRef( pszExp ).get_##b(); }
                EXP_GET_X_TYPE(int, Int)
                EXP_GET_X_TYPE(UINT32, DWord)
                EXP_GET_X_TYPE(float, Float)
#undef EXP_GET_X_TYPE
        };
}
 
#endif // USE_EXPRESSION
#endif // _INC_cExpressionExec_H