nodes.h

表达式计算expression evaluate expression evaluate expression evaluate

/******************************************************************************
文件名          :Nodes.h
版本号          : 1.0
作者            : Amos Peng
生成日期        :2008-07-08
最近修改        :
功能描述        :CNode基类与CNode派生出的子类
函数列表        :

*******************************************************************************/
#ifndef _NODES_H_
#define _NODES_H_

// Includes
#include <vector>
#include <new>
#include <memory>
#include <cmath>
#include <cerrno>


#include "Expression.h"
#include "ValueList.h"
#include "FunctionList.h"
#include "Except.h"

#include "Parser.h"

// Part of expreval namespace
namespace ExprEval
{
    // Forward declarations
    class CExpression;
    class CFunctionFactory;

    
    // Node class
    //--------------------------------------------------------------------------
    class CNode
    {
        public:
            CNode(CExpression *expr);
            virtual ~CNode();
        
            virtual double DoEvaluate() = 0;
            virtual void Parse(CParser& parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0) = 0;
                
            double Evaluate(); // Calls Expression::TestAbort, then DoEvaluate
        
        protected:
            CExpression *m_expr;    
    };
        
    // General function node class
    //--------------------------------------------------------------------------
    class CFunctionNode : public CNode
    {
        public:
            CFunctionNode(CExpression *expr);
            ~CFunctionNode();
        
            // Parse nodes and references
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
        private:
            // Function factory
            CFunctionFactory *m_factory;
        
            // Argument count
            long m_argMin;
            long m_argMax;
            long m_refMin;
            long m_refMax;

        protected:
            // Set argument count (called in derived constructors)
            void SetArgumentCount(long argMin = 0, long argMax = 0, long refMin = 0, long refMax = 0);

            // Function name (using factory)
            ::std::string GetName() const;
    
            // Normal, reference, and data parameters
            ::std::vector<CNode*> m_nodes;
            ::std::vector<double*> m_refs;

        friend class CFunctionFactory;
    };
        
    // Mulit-expression node
    //--------------------------------------------------------------------------
    class CMultiNode : public CNode
    {
        public:
            CMultiNode(CExpression *expr);
            ~CMultiNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
        private:
            ::std::vector<CNode*> m_nodes;
    };
        
    // Assign node
    //--------------------------------------------------------------------------
    class CAssignNode : public CNode
    {
        public:
            CAssignNode(CExpression *expr);
            ~CAssignNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
        private:
            double *m_var;
            CNode *m_rhs;
    };
        
    // Add node
    //--------------------------------------------------------------------------
    class CAddNode : public CNode
    {
        public:
            CAddNode(CExpression *expr);
            ~CAddNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            CNode *m_lhs;
            CNode *m_rhs;
    };
        
    // Subtract node
    //--------------------------------------------------------------------------
    class CSubtractNode : public CNode
    {
        public:
            CSubtractNode(CExpression *expr);
            ~CSubtractNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
        private:
            CNode *m_lhs;
            CNode *m_rhs;
    };
        
    // Multiply node
    //--------------------------------------------------------------------------
    class CMultiplyNode : public CNode
    {
        public:
            CMultiplyNode(CExpression *expr);
            ~CMultiplyNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            CNode *m_lhs;
            CNode *m_rhs;
    };
        
    // Divide node
    //--------------------------------------------------------------------------
    class CDivideNode : public CNode
    {
        public:
            CDivideNode(CExpression *expr);
            ~CDivideNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            CNode *m_lhs;
            CNode *m_rhs;
    };
        
    // Negate node
    //--------------------------------------------------------------------------
    class CNegateNode : public CNode
    {
        public:
            CNegateNode(CExpression *expr);
            ~CNegateNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            CNode *m_rhs;
    };
        
    // Exponent node
    //--------------------------------------------------------------------------
    class CExponentNode : public CNode
    {
        public:
            CExponentNode(CExpression *expr);
            ~CExponentNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            CNode *m_lhs;
            CNode *m_rhs;
    };
        
    // Variable node (also used for constants)
    //--------------------------------------------------------------------------
    class CVariableNode : public CNode
    {
        public:
            CVariableNode(CExpression *expr);
            ~CVariableNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            double *m_var;
    };
        
    // Value node
    //--------------------------------------------------------------------------
    class CValueNode : public CNode
    {
        public:
            CValueNode(CExpression *expr);
            ~CValueNode();
        
            double DoEvaluate();
            void Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1 = 0);
                
        private:
            double m_val;
    };        
        
} // namespace ExprEval
    
#endif