有限状态机

#pragma once
#include "....dscript	able.h"
#include "....dscript	ableD_resEditListCtrl.h"
#include "..PropertyGridExDrawLotsDlg.h"
#include "..dbase_header.h"
#include <afx.h>
#include "....dscriptdscript_enum_header.h"
#include "....dscriptgNewPbCalcRulecountDeal.h"

using namespace std;
class Cfyq_expression;
class Cfyq_Name;
class Cfyq_node;
class Cfyq_Var;
class Cfyq_scope;
class Cfyq_const;
class Cfyq_offset;
class Cfyq_jzj;
class Cfyq_opt;
class Cfyq_set;
typedef std::vector<Cfyq_node*>    vec_fyq_Node;
typedef std::vector<Cfyq_Var*>    vec_fyq_Var;
typedef std::vector<Cfyq_const*>    vec_fyq_Const;
typedef std::vector<Cfyq_scope*>    vec_fyq_Scope;
typedef std::vector<Cfyq_opt*>    vec_fyq_opt;
typedef std::vector<Cfyq_set*>    vec_fyq_set;
enum CFyq_NodeKind{FNK_Name, FNK_Param, FNK_Scope, FNK_Const, FNK_Value, FNK_Set, FNK_Define, FNK_Offset,FNK_Node,FNK_Jzj};

class   Cfyq_Interpreter : public CTableRow
{

public:
    Cfyq_Interpreter();
    ~Cfyq_Interpreter();
public:
    bool Interpreter(const CString& strFormula);
    void backInterpreter(Cfyq_node* startName,CString& backstr);
    void pushback(Cfyq_node* startName, CString& backstr);
    bool push( char input );
    void ChangeNode(Cfyq_node* pState);
    void ChangeBackNode(Cfyq_node* pstate);

    bool NextStrIs(const CString& str);
    bool NextStrIsIgnoreSpace(const CString& str);
    bool LastStrIsIgnoreSpace(const CString& str);
    static bool IsTrueChar(char c);
    static bool IsChineseChar(char c);
    virtual bool toString(CString& txt);
    bool CheckName(  CString& title );
    bool CheckParam( CString& title );
    bool CheckConst( CString& title );
public:
    Cfyq_node* GetCurNode(){ return m_pCurNode; }
    Cfyq_Name* GetCurName(){ return m_pCurName; }
    Cfyq_node* GetCurBackNode();
    Cfyq_node* CreateNode(CFyq_NodeKind kind);
    vec_fyq_Node& GetvecExpression(){ return m_vecExpression; }
public:
    //检查集合
    vecSysCodeKindDataInfo m_param_obj;
    vecSysCodeKindDataInfo m_name_obj;
    vecSysCodeKindDataInfo m_const_obj;
private:
    CString m_strFormula;//公式
    UINT m_nCurIndex;//当前索引
    Cfyq_node* m_pCurNode;//当前状态
    Cfyq_Name* m_pCurName;//当前name
    Cfyq_node* m_pCurBackNode;//反解析当前状态
    vec_fyq_Node m_vecExpression;//State存放集合
};
//节点
class  Cfyq_node : public CTableRow
{
    DECLARE_SERIAL_EXTDLL( Cfyq_node )
public:
    Cfyq_node();
    virtual ~Cfyq_node();
public:
    virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
    virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    virtual void NextBackNode(Cfyq_node* startName,CString& str, Cfyq_Interpreter* pInterpreter,bool bLast);
    virtual CFyq_NodeKind GetNodeGrade();
    virtual void ErrorMsg(CString& str);
    void Serialize(CArchive& ar);
public:
    CString& GetContent();
public:
    vec_fyq_Node m_vecSubNode;
    double m_dValue;
    CString m_sValue;
    CString m_strContent;
    bool m_bStateInputChar;
protected:
    Cfyq_Interpreter* m_pInterpreter;
};

//元素
class  Cfyq_element : public Cfyq_node
{
    DECLARE_SERIAL_EXTDLL( Cfyq_element )
public:
    Cfyq_element();
    ~Cfyq_element(){};
public:
    bool IsClose();;
    void SetClose(bool val);
    int AppendChar( Cfyq_Interpreter* pInterpreter, char input );
    void Serialize(CArchive& ar);
private:
    bool m_bIsCloseFlag;
};

//常量
class  Cfyq_const : public Cfyq_element
{
    DECLARE_SERIAL_EXTDLL( Cfyq_const )
public:
    Cfyq_const(){}
    ~Cfyq_const(){}
public:
    int Accept( Cfyq_Interpreter* pInterpreter, char input );
    bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
    virtual CFyq_NodeKind GetNodeGrade() {return FNK_Const;}
    virtual void ErrorMsg(CString& str);
    void Serialize(CArchive& ar);
};

//用户变量 {kjb:正偏离扣减}
class  Cfyq_Var : public Cfyq_element
{
    DECLARE_SERIAL_EXTDLL( Cfyq_Var )
public:
    CString m_sEngName;//英文名
    bool m_bInited;//是否被赋值
    CString m_sExplain;//中文解释
    CString m_dValueToStr; //数字字符串
    int m_nLifePeriod;//生命周期 0是测试阶段 1是代理阶段
public:
    Cfyq_Var();
    ~Cfyq_Var(){};
    void SetEngName(CString name);
    void SetExplain(CString Explain);
    int Accept( Cfyq_Interpreter* pInterpreter, char input );
    bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );

    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);

    virtual CFyq_NodeKind GetNodeGrade() {return FNK_Value;}

    virtual void ErrorMsg(CString& str);

    void Serialize(CArchive& ar);
};

//:取值范围
class  Cfyq_scope : public Cfyq_element
{
    DECLARE_SERIAL_EXTDLL( Cfyq_scope )
public:
    Cfyq_scope();
    ~Cfyq_scope();
protected:
    int m_bFlag;//0:- 范围用法；1：,去除用法
    int  m_MinMax[105][4]; //最大可支持105个范围区间
    int m_nrow;
public:

    int GetMinCount(int index);
    int GetMaxCount(int index);
    int GetMin(int index);
    int GetMax(int index);

    void SetRow(int row);
    int GetRow();
    bool SetScope();
    bool ReplaceScope(CString strTemp);
    bool SetScopeToName(Cfyq_Interpreter* pInterpreter);
    int GetFlag();
    void Serialize(CArchive& ar);
    virtual void ErrorMsg(CString& str);
public:
    int Accept( Cfyq_Interpreter* pInterpreter, char input );
    bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    virtual CFyq_NodeKind GetNodeGrade();
};


class  Cfyq_Name : public Cfyq_element
{
    DECLARE_SERIAL_EXTDLL( Cfyq_Name )
public:
    Cfyq_Name();
    ~Cfyq_Name();
protected:
    CString        m_sParam;
    Cfyq_scope*    m_pScope;
    Cfyq_jzj*   m_pjzj;
public:
    virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
    virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);

    CString GetParam();
    void SetParam(CString val);
    Cfyq_scope* GetScope();
    void SetScope(Cfyq_scope* val);
    Cfyq_jzj* Getjzj() const;
    void Setjzj(Cfyq_jzj* jzj);

    virtual void ErrorMsg(CString& str);

    virtual CFyq_NodeKind GetNodeGrade();

    void Serialize(CArchive& ar);
public:
    int m_bcanSerial;
    int m_bcanSerialjzj;
};

class  Cfyq_jzj : public Cfyq_element
{
    DECLARE_SERIAL_DSCRIPT( Cfyq_jzj )
public:
    Cfyq_jzj();
    ~Cfyq_jzj();
    int Accept(Cfyq_Interpreter* pInterpreter, char input);
    bool NextNode(Cfyq_Interpreter* pInterpreter, char  input);
    virtual CFyq_NodeKind GetNodeGrade();
    void Serialize(CArchive& ar);
    bool SetjzjToName(Cfyq_Interpreter* pInterpreter);
public:
    long m_nkind;
};

//参数
class  Cfyq_Param: public Cfyq_element
{
    DECLARE_SERIAL_EXTDLL( Cfyq_Param )
public:
    Cfyq_Param();
    ~Cfyq_Param(){}
public:
    bool SetParamToName(Cfyq_Interpreter* pInterpreter);
    virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
    virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    virtual CFyq_NodeKind GetNodeGrade();
    virtual void ErrorMsg(CString& str);
    void Serialize(CArchive& ar);
};

//操作符
class  Cfyq_opt: public Cfyq_node
{
    DECLARE_SERIAL_EXTDLL( Cfyq_opt )
public:
    Cfyq_opt();
    ~Cfyq_opt();
protected:
    vec_fyq_Node m_nodes; 
public:
    void Serialize(CArchive& ar);
};


//:定义
class  Cfyq_define: public Cfyq_opt
{
    DECLARE_SERIAL_EXTDLL( Cfyq_define )
public:
    Cfyq_define();
    ~Cfyq_define(){}
public:
    virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
    virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    virtual CFyq_NodeKind GetNodeGrade();
    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
    void Serialize(CArchive& ar);
};

//=赋值
class  Cfyq_set: public Cfyq_opt
{
    DECLARE_SERIAL_EXTDLL( Cfyq_set )
public:
    Cfyq_set();
    ~Cfyq_set();
    virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
    virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
    virtual CFyq_NodeKind GetNodeGrade();
    void Serialize(CArchive& ar);
};


//=偏差计算： 左侧为引入的系统变量，右侧为固定的用户参数分别 偏离范围，正偏离扣分，右偏离扣分
class  Cfyq_offset: public Cfyq_opt
{
    DECLARE_SERIAL_EXTDLL( Cfyq_offset )
public:
    Cfyq_offset();
    ~Cfyq_offset(){}
    Cfyq_Name* m_pName;
    int m_bcanSerial;
public:
    int Accept( Cfyq_Interpreter* pInterpreter, char input );
    bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
    virtual CFyq_NodeKind GetNodeGrade() {return FNK_Offset;}
    void Serialize(CArchive& ar);
    void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
    void SetFyqName(Cfyq_Name* val);
    Cfyq_Name* GetFyqName();
};

/*

=  赋值操作
+->偏差赋值 分两种形式，+>大于基准价，偏离;->小于基准价，偏离
[] 取值范围分两种形式：1、“，”标志去除 例如[1,2]去掉1个最高，2个最低分
        “-”标志的范围[1,2]，例如[0-3]表示0-3分,可简写为[3]
()入口参数

*/


/*表达式 名称 描述了表达式的基本功能界面

文法示例：
zz(corp)[3]:pf,nomark;  
企业资质（暗标）3分  
xmbz:ml;                          项目班子成员目录
bj(tbbj)[10]=jzj(1,2) -> bj>jzj ? {kja}/{step} : {kjb}/{step};  
投标报价满分10，正偏离基准价{step}扣减{kja}，负偏离基准价{step}扣减{kjb}

*/

class FLY_DBASE_API  Cfyq_expression : public Cfyq_Name
{
    DECLARE_SERIAL_EXTDLL(Cfyq_expression)
public:
    Cfyq_expression();
    ~Cfyq_expression();
    //字符串到对象
    bool InitExpression(const CString& expression );
    //对象到字符串
    void BackExpression();
    //将基准价范围用文字的形式表现出来
    virtual bool toString();
    //目前计算不通过表达式计算
    virtual void Calc(CString& str);

    void Serialize(CArchive& ar);

    //范围相关-------去高去低
    void FindScope(vec_fyq_Scope& m_vecScope, Cfyq_node* node);
    vec_fyq_Scope& GetScopeFromTree();
    double GetScopeFromVec(int Flag, int index, int row);
    void SetVecVarNode(vecVarNode_ZBFileInfo& vecVarNode) { m_vecVarNode = vecVarNode; }
    std::vector<std::vector<int>>& GetScopeMinMax();
    vecCountDeal& GetCountDeal();


    //变量相关
    void FindVar(vec_fyq_Var& m_VecVar, Cfyq_node* node);
    vec_fyq_Var& GetVarFromTree();
    void AddVar(CString explain, CString doublestr);
    void AddVar(vec_fyq_Var& m_VecVar, Cfyq_node* node, CString explain, CString doublestr);
    double GetdVar(int index);
    void ChangeVecVarFromTree(const CString& strVar, CString str);
    void ChangeVecVarFromTree(const CString& strVar, double dval);

    //常量相关
    bool IsExistConst(const CString& strVar);
    void FindConst(vec_fyq_Const& m_VecConst,Cfyq_node *node);
    vec_fyq_Const& GetConstFromTree();
    //增加常量主要针对k,q,m
    void AddConst(CString str);
    void AddConst(vec_fyq_Const& m_vecConst, Cfyq_node* node, CString str);

    //显示当前的计算方法
    void AddJzjKind(long kind);
    void AddJzjKind(Cfyq_node* node,long kind);
    long GetJzjKind() {    return m_njzjKind;}

public:
    vec_fyq_Var m_vecVar;
    vec_fyq_Const m_vecConst;
    vec_fyq_Scope m_vecScope;
    Cfyq_Interpreter *m_pInterpreter;
    std::vector<std::vector<int>> vecScope;
    vecVarNode_ZBFileInfo m_vecVarNode;
    vecCountDeal m_vecCountDeal;
    int m_nrow;
    int m_njzjKind;
    CString m_strToDB;
}; 

#include "StdAfx.h"
#include "fyq_interpreter.h"
#include <afx.h>


IMPLEMENT_SERIAL( Cfyq_node, CTableRow, 0)
Cfyq_node::Cfyq_node()
{
    m_dValue = 0;        
    m_bStateInputChar = false;
    m_pInterpreter = NULL;
};


Cfyq_node::~Cfyq_node()
{

}

//  1、没有必要空格是忽略的
//     2、有必要（字符之间是有必要，符号之间->之间是有必要）
//     3、开闭 ),] 状态 是否闭合 -》  
//  
//     进入字符状态，且未闭合
int Cfyq_node::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    return 0;
}

bool Cfyq_node::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    return false;
}

void Cfyq_node::NextBackNode(Cfyq_node* startName, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    return;
}

CFyq_NodeKind Cfyq_node::GetNodeGrade()
{
    return FNK_Node;
}

void Cfyq_node::ErrorMsg(CString& str)
{
    return;
}

void Cfyq_node::Serialize(CArchive& ar)
{
    int rightcode = 1;
    if( ar.IsStoring() )
    { 
        ar << rightcode;
        ar << m_dValue;
        ar << m_sValue;
        ar << m_strContent;
        ar << m_vecSubNode;
    }
    else
    {
        ar >> rightcode;
        ar >> m_dValue;
        ar >> m_sValue;
        ar >> m_strContent;
        ar >> m_vecSubNode;
    }
}

CString& Cfyq_node::GetContent()
{
    return m_strContent;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

IMPLEMENT_SERIAL( Cfyq_const, Cfyq_element, 0)
int Cfyq_const::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return AppendChar(pInterpreter, input);

    switch( input )
    {
    case ',':
    case ';':
            return 2;
    }

    return 0;
}

bool Cfyq_const::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!pInterpreter->CheckConst(m_strContent))
        return false;

    switch( input )
    {
    case ',':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Const));
            return true;
        }
    case ';':
        {
            return true;
        }
    default:
        return false;
    }
}


void Cfyq_const::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    CString strTemp;
    if (bLast)
        strTemp.Format("%s", m_strContent);
    else
        strTemp.Format("%s,", m_strContent);
    str += strTemp;
    pInterpreter->ChangeBackNode(node);
}

void Cfyq_const::ErrorMsg(CString& str)
{
    CString strTmp = "常量出现错误！
";
    str += strTmp;
}

void Cfyq_const::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize(ar);
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }
}

IMPLEMENT_SERIAL( Cfyq_Var, Cfyq_element, 0)
Cfyq_Var::Cfyq_Var()
{
    m_bInited = false;
    CString m_sEngName = "";
    CString m_sExplain = "";
    CString m_dValueToStr = "";
    m_nLifePeriod = 0;
}



void Cfyq_Var::SetEngName(CString name)
{
    m_sEngName = name;
}

void Cfyq_Var::SetExplain(CString Explain)
{
    m_sExplain = Explain;
}

int Cfyq_Var::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) || Cfyq_Interpreter::IsChineseChar( input ) || (':' == input && !IsClose()) )
        return AppendChar(pInterpreter, input);

    switch( input )
    {
    case ')':
        SetClose(true);

        
        if(m_strContent.Find(":") == -1)
        {
            SetEngName(m_strContent);
            SetExplain("");
        }
        else
        {
            CString strleft = m_strContent.Left(m_strContent.Find(":"));
            CString strRight = m_strContent.Mid(m_strContent.Find(":")+1,m_strContent.GetLength());
            SetEngName(strleft);
            SetExplain(strRight);
        }
        

        {
            if(pInterpreter->NextStrIsIgnoreSpace(",$(")||pInterpreter->NextStrIsIgnoreSpace(";")||pInterpreter->NextStrIsIgnoreSpace(":"))
                return 3;
            else
                return 0;
        }
    case ',':
        {
            if(pInterpreter->NextStrIsIgnoreSpace("$("))
                return 3;
            else 
                return 0;
        }
    case '$':
        {
            if(pInterpreter->NextStrIsIgnoreSpace("("))
                return 2;
            else 
                return 0;
        }
    case '(':
        {
            if(pInterpreter->LastStrIsIgnoreSpace("$"))
                return 3;
            else
                return 0;
        }
    case ':':
        {
            return 2;
        }
    case ';':
        {
            return 2;
        }
    }

    return 0;
}

bool Cfyq_Var::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!IsClose())
        return false;

    switch( input )
    {
    case '$':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Value));
            return true;
        }
    case ':':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
            return true;
        }
    case ';':
        {
            return true;
        }
    default:
        return false;
    }
}

void Cfyq_Var::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    CString strTemp;
    if (bLast)
    {
        if (!m_dValueToStr.IsEmpty())
            strTemp.Format("$(%s:%s)", m_sExplain, m_dValueToStr);
        else
            strTemp.Format("$(%s:%s)", m_sExplain, m_sEngName);
    }
    else
    {
        if (!m_dValueToStr.IsEmpty())
            strTemp.Format("$(%s:%s),", m_sExplain, m_dValueToStr);
        else
            strTemp.Format("$(%s:%s),", m_sExplain, m_sEngName);
    }
    str += strTemp;
    pInterpreter->ChangeBackNode(node);
}

void Cfyq_Var::ErrorMsg(CString& str)
{
    CString strTmp = "变量出现错误！
";
    str += strTmp;
}

void Cfyq_Var::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize(ar);
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
        ar << m_sEngName;
        ar << m_sExplain;
        ar << m_nLifePeriod;
    }
    else
    {
        ar >> rightcode;
        ar >> m_sEngName;
        ar >> m_sExplain;
        ar >> m_nLifePeriod;
    }
}

int Cfyq_scope::GetMinCount(int index)
{
    return m_MinMax[index][0];
}

int Cfyq_scope::GetMaxCount(int index)
{
    return m_MinMax[index][1];
}

int Cfyq_scope::GetMin(int index)
{
    return m_MinMax[index][2];
}

int Cfyq_scope::GetMax(int index)
{
    return m_MinMax[index][3];
}

void Cfyq_scope::SetRow(int row)
{
    m_nrow = row;
}

int Cfyq_scope::GetRow()
{
    return m_nrow;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_SERIAL( Cfyq_scope, Cfyq_element, 0)
//解析范围
bool Cfyq_scope::SetScope()
{
    CString strLeft,strMid,strRight,strLast;
    int nMidIndex;
    //上下限
    if(m_strContent == m_strContent.SpanIncluding("0123456789.-"))
    {
        if(m_strContent == m_strContent.SpanIncluding("0123456789."))
        {
            m_MinMax[0][0] = 0;
            m_MinMax[0][1] = atoi(m_strContent);
            return true;
        }
        else
        {    
            nMidIndex = m_strContent.Find("-");
            strLeft =  m_strContent.Left(nMidIndex);
            strRight = m_strContent.Mid(nMidIndex + 1,m_strContent.GetLength() -1 );
            if(strLeft == strLeft.SpanIncluding("0123456789.")
                && strRight == strRight.SpanIncluding("0123456789."))
            {
                m_MinMax[0][0] = atoi(strLeft);
                m_MinMax[0][1] = atoi(strRight);
                m_MinMax[0][2] = 0;
                return true;
            }
            else
            {
                return false;
            }
        }
        m_bFlag = 0;
        SetRow(0);
    }
    //数轴
    else
    {
        if(m_strContent.Find(";") == -1)
        {
            int nMidIndex = m_strContent.Find(',') == -1;
            if(nMidIndex != -1)
            {
                SetRow(1);
                if( m_strContent.Find(',') != -1)
                {    
                    CString strTmp;
                    int ipos = 0;
                    while(AfxExtractSubString(strTmp,m_strContent,ipos,','))
                    {
                        ipos++;
                        switch(ipos)
                        {
                        case 1:
                            strLeft = strTmp;
                            break;
                        case 2:
                            strMid = strTmp;
                            break;
                        case 3:
                            strRight = strTmp;
                            break;
                        case 4:
                            strLast = strTmp;
                        }
                    }
                    if(strLeft == strLeft.SpanIncluding("0123456789.")
                        && strRight == strRight.SpanIncluding("0123456789.") 
                        && strMid == strMid.SpanIncluding("0123456789.")
                        && strLast == strLast.SpanIncluding("0123456789."))
                    {
                        m_MinMax[0][0] = atoi(strLeft);
                        m_MinMax[0][1] = atoi(strMid);
                        m_MinMax[0][2] = atoi(strRight);
                        m_MinMax[0][3] = atoi(strLast);
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }

            }

            else
            {
                return false;
            }
        }
        else
        {
            int i = 0;
            CString strTmp;
            while(AfxExtractSubString(strTmp,m_strContent,i,';'))
            {
                CString strTmpdot;
                int ipos = 0;
                while(AfxExtractSubString(strTmpdot,strTmp,ipos,','))
                {
                    ipos++;
                    switch(ipos)
                    {
                    case 1:
                        strLeft = strTmpdot;
                        break;
                    case 2:
                        strMid = strTmpdot;
                        break;
                    case 3:
                        strRight = strTmpdot;
                        break;
                    case 4:
                        strLast = strTmpdot;
                        break;
                    }
                }
                if (strLeft == strLeft.SpanIncluding("0123456789.")
                    && strRight == strRight.SpanIncluding("0123456789.")
                    && strMid == strMid.SpanIncluding("0123456789.")
                    && strLast == strLast.SpanIncluding("0123456789."))
                {
                    m_MinMax[i][0] = atoi(strLeft);
                    m_MinMax[i][1] = atoi(strMid);
                    m_MinMax[i][2] = atoi(strRight);
                    m_MinMax[i][3] = atoi(strLast);
                    i++;
                    continue;
                }
                else
                {
                    return false;
                }
            }
            SetRow(i);
        }
        m_bFlag = 1;
    }
    return true;
}

bool Cfyq_scope::ReplaceScope(CString strTemp)
{
    m_strContent = strTemp;
    memset(m_MinMax, -1, sizeof(m_MinMax));
    CString strLeft, strMid, strRight, strLast;
    int nMidIndex;
    //上下限
    if (m_strContent == m_strContent.SpanIncluding("0123456789.-"))
    {
        if (m_strContent == m_strContent.SpanIncluding("0123456789."))
        {
            m_MinMax[0][0] = 0;
            m_MinMax[0][1] = atoi(m_strContent);
            return true;
        }
        else
        {
            nMidIndex = m_strContent.Find("-");
            strLeft = m_strContent.Left(nMidIndex);
            strRight = m_strContent.Mid(nMidIndex + 1, m_strContent.GetLength() - 1);
            if (strLeft == strLeft.SpanIncluding("0123456789.")
                && strRight == strRight.SpanIncluding("0123456789."))
            {
                m_MinMax[0][0] = atoi(strLeft);
                m_MinMax[0][1] = atoi(strRight);
                m_MinMax[0][2] = 0;
                return true;
            }
            else
            {
                return false;
            }
        }
        m_bFlag = 0;
        SetRow(0);
    }
    //数轴
    else
    {
        if (m_strContent.Find(";") == -1)
        {
            int nMidIndex = m_strContent.Find(',') == -1;
            if (nMidIndex != -1)
            {
                SetRow(1);
                if (m_strContent.Find(',') != -1)
                {
                    CString strTmp;
                    int ipos = 0;
                    while (AfxExtractSubString(strTmp, m_strContent, ipos, ','))
                    {
                        ipos++;
                        switch (ipos)
                        {
                        case 1:
                            strLeft = strTmp;
                            break;
                        case 2:
                            strMid = strTmp;
                            break;
                        case 3:
                            strRight = strTmp;
                            break;
                        case 4:
                            strLast = strTmp;
                        }
                    }
                    if (strLeft == strLeft.SpanIncluding("0123456789.")
                        && strRight == strRight.SpanIncluding("0123456789.")
                        && strMid == strMid.SpanIncluding("0123456789.")
                        && strLast == strLast.SpanIncluding("0123456789."))
                    {
                        m_MinMax[0][0] = atoi(strLeft);
                        m_MinMax[0][1] = atoi(strMid);
                        m_MinMax[0][2] = atoi(strRight);
                        m_MinMax[0][3] = atoi(strLast);
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                }

            }

            else
            {
                return false;
            }
        }
        else
        {
            int i = 0;
            CString strTmp;
            while (AfxExtractSubString(strTmp, m_strContent, i, ';'))
            {
                CString strTmpdot;
                int ipos = 0;
                while (AfxExtractSubString(strTmpdot, strTmp, ipos, ','))
                {
                    ipos++;
                    switch (ipos)
                    {
                    case 1:
                        strLeft = strTmpdot;
                        break;
                    case 2:
                        strMid = strTmpdot;
                        break;
                    case 3:
                        strRight = strTmpdot;
                        break;
                    case 4:
                        strLast = strTmpdot;
                        break;
                    }
                }
                if (strLeft == strLeft.SpanIncluding("0123456789.")
                    && strRight == strRight.SpanIncluding("0123456789.")
                    && strMid == strMid.SpanIncluding("0123456789.")
                    && strLast == strLast.SpanIncluding("0123456789."))
                {
                    m_MinMax[i][0] = atoi(strLeft);
                    m_MinMax[i][1] = atoi(strMid);
                    m_MinMax[i][2] = atoi(strRight);
                    m_MinMax[i][3] = atoi(strLast);
                    i++;
                    continue;
                }
                else
                {
                    return false;
                }
            }
            SetRow(i);
        }
        m_bFlag = 1;
    }
    return true;
}

bool Cfyq_scope::SetScopeToName(Cfyq_Interpreter* pInterpreter)
{
    pInterpreter->GetCurName()->SetScope(this);
    return true;
}

int Cfyq_scope::GetFlag()
{
    return m_bFlag;
}

void Cfyq_scope::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize(ar);
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
        ar << m_bFlag;
        ar << m_nrow;
        if(m_nrow)
        for(int i = 0;i < m_nrow;++i)
            for(int j = 0;j < 4;++j)
        {
            ar << m_MinMax[i][j];
        }
    }
    else
    {
        ar >> rightcode;
        ar >> m_bFlag;
        ar >> m_nrow;
        if (m_nrow)
        for (int i = 0; i < m_nrow; ++i)
            for (int j = 0; j < 4; ++j)
            {
                ar >> m_MinMax[i][j];
            }
    }
    
}

void Cfyq_scope::ErrorMsg(CString& str)
{
    CString strTmp = "范围出现错误！
";
    str += strTmp;
}

int Cfyq_scope::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return AppendChar(pInterpreter, input);

    switch( input )
    {
    case '=':
    case ':':
    case '{':
            return 2;
    case ']':
        {
            SetClose(true);

            if(pInterpreter->NextStrIsIgnoreSpace("=")||pInterpreter->NextStrIsIgnoreSpace(":")||pInterpreter->NextStrIsIgnoreSpace("->")
            ||pInterpreter->NextStrIsIgnoreSpace("{"))
                return 3;
            else
                return 0;
        }
    case '-':
        {
            if(pInterpreter->NextStrIs(">"))
                return 2;
            m_strContent += input;
            return 1;
        }
    case ',':
        {
            m_strContent += input;
            return 1;
        }
    case ';':
        {
            m_strContent += input;
            return 1;
        }
    }

    return 0;
}

bool Cfyq_scope::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!IsClose())
        return false;
    if(!SetScope())
        return false;
    else
        SetScopeToName(pInterpreter);
    switch( input )
    {
    case '=':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
            return true;
        }
    case '-':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
            return true;
        }
    case ':':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
            return true;
        }
    case '{':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Jzj));
            return true;
        }
    default:
        return false;
    }
}


CFyq_NodeKind Cfyq_scope::GetNodeGrade()
{
    return FNK_Scope;
}

Cfyq_scope::Cfyq_scope()
{
    memset(m_MinMax,-1,sizeof(m_MinMax));
    m_bFlag = -1; 
    m_nrow = 0;
}

Cfyq_scope::~Cfyq_scope()
{

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

IMPLEMENT_SERIAL( Cfyq_opt, Cfyq_node, 0)

void Cfyq_opt::Serialize(CArchive& ar)
{
    int rightcode = 1;
    if( ar.IsStoring() )
    { 
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }

}

Cfyq_opt::Cfyq_opt()
{

}

Cfyq_opt::~Cfyq_opt()
{

}

int Cfyq_offset::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if(input == ' ')
        return 3;
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return 0;

    switch( input )
    {
    case '>':
        {
            if(pInterpreter->NextStrIsIgnoreSpace("$("))
                return 3;
            else
                return 0;
        }
    case '$':
        {
            if(pInterpreter->NextStrIsIgnoreSpace("("))
                return 2;
            else
                return 0;
        }
    }

    return 0;
}

bool Cfyq_offset::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    switch( input )
    {
    case '$':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Value));
            return true;
        }
    default:
        return false;
    }
}
IMPLEMENT_SERIAL( Cfyq_offset, Cfyq_opt, 0)
Cfyq_offset::Cfyq_offset()
{
    Cfyq_Name* m_pName = NULL;
    int m_bcanSerial = 0;
}

void Cfyq_offset::Serialize(CArchive& ar)
{
    int rightcode = 1;
    Cfyq_node::Serialize(ar);
    CString tmpStr;
    if( ar.IsStoring() )
    { 
        ar << rightcode;
        ar << m_bcanSerial;
        if (m_bcanSerial)
        {
            m_pName->Serialize(ar);
        }
    }
    else
    {
        ar >> rightcode;
        ar >> m_bcanSerial;
        if (m_bcanSerial)
        {
            m_pName = new Cfyq_Name();
            m_pName->Serialize(ar);
        }
    }
}

void Cfyq_offset::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    if (m_pName)
    {
        m_pName->NextBackNode(node, str, pInterpreter, 1);
    }
    str += "->";
    pInterpreter->ChangeBackNode(node);
}

void Cfyq_offset::SetFyqName(Cfyq_Name* val)
{
    m_pName = val;
    m_bcanSerial = 1;
}

Cfyq_Name* Cfyq_offset::GetFyqName()
{
    return m_pName;
}

void Cfyq_expression::Calc(CString& str)
{
//     GetVarFromTree();
//     double bj = 1010,jzj = 500;
// 
//     double Acost = (bj - jzj ) / jzj;//偏离率
//     if ( bEqual(Acost, 0 ,MinE))
//     {
//         m_dValue = m_pInterpreter->GetScope(1,1);
//         m_sValue.Format( "基准价：%s，无偏离 ，得分：%s" , GetForamtedNumber(m_dValue), GetForamtedNumber(m_dValue) );
//         str = m_sValue;
//         return;
//     }
// 
//     CString sAcost,sbj,sjzj,sbdiv;
//     sbj = GetForamtedNumber(bj),sjzj = GetForamtedNumber(jzj);
//     sAcost.Format(  "(%s-%s)/%s" ,sbj, sjzj,sjzj );
// 
// 
//     double step   = GetdVar(0);
//     step = step / 100;
//     int bdiv      = Keep0Bit( Acost / step );
//     double kj_zpc = GetdVar(1);
//     double kj_fpc = GetdVar(2);
// 
//     if (Acost > 0) 
//     {
//         m_dValue = m_pInterpreter->GetScope(0,1) - bdiv * kj_zpc;
//         m_sValue.Format( "基准价：%s，偏离率：%s 报价得分：%s - %d*%s" , 
//             GetForamtedNumber(jzj), 
//             GetForamtedNumber(Acost), 
//             GetForamtedNumber(m_pInterpreter->GetScope(0,1)), bdiv, GetForamtedNumber(kj_zpc) );
//     }
//     else
//     {
//         m_dValue = m_pInterpreter->GetScope(0,1) + bdiv * kj_zpc;
//         m_sValue.Format( "基准价：%s，偏离率：%s 报价得分：%s + %d*%s" , 
//             GetForamtedNumber(jzj), 
//             GetForamtedNumber(Acost), 
//             GetForamtedNumber(m_pInterpreter->GetScope(0,1)), bdiv, GetForamtedNumber(kj_zpc) );
//     }
// 
// 
//     if ( m_dValue < 0)
//         m_dValue = 0;
//     str = m_sValue;
//     return ;
};

IMPLEMENT_SERIAL( Cfyq_expression, Cfyq_Name, 0)
Cfyq_expression::Cfyq_expression()
{
    m_pInterpreter = new Cfyq_Interpreter();
    m_nrow = 0;

    //m_pScoringSystemDefine = NULL;
}

Cfyq_expression::~Cfyq_expression()
{ 
    if ( m_pInterpreter )
    {
        delete m_pInterpreter;
        m_pInterpreter = NULL;
    }
    ClearVecPtr(m_vecVar);
}

bool Cfyq_expression::InitExpression(const CString& expression )
{
    //解析公式

    if(!m_pInterpreter->Interpreter(expression))
        return false;        

    //拿到解析到的Vec
    vec_fyq_Node& vecExpression = m_pInterpreter->GetvecExpression();

    //获得根节点
    Cfyq_Name* FirstName = nullptr;

    Cfyq_node* root = this;

    Cfyq_node* pCurNode = root;
    Cfyq_Name* pCurName = nullptr;
    for(auto it = vecExpression.begin(); it!=vecExpression.end(); it++)
    {
        if(!FirstName)
        {
            FirstName = (Cfyq_Name*)(*it);
            this->m_strContent = FirstName->GetContent();
            this->m_sParam = FirstName->GetParam();
            this->m_pScope = FirstName->GetScope();
            continue;
        }
        if (FNK_Set == (*it)->GetNodeGrade())
        {
            root->m_vecSubNode.push_back(*it);
            pCurNode = *it;
        }
        else if( FNK_Define == (*it)->GetNodeGrade())
        {
            root->m_vecSubNode.push_back(*it);
            pCurNode = *it;
        }
        else if( FNK_Offset == (*it)->GetNodeGrade() )
        {
            pCurNode->m_vecSubNode.push_back(*it);
            pCurNode = (*it);
            Cfyq_offset* offset = (Cfyq_offset*)(*it);
            if(!pCurName)
                return false;
            offset->SetFyqName(pCurName);
        }
        else if( FNK_Const == (*it)->GetNodeGrade() || FNK_Value == (*it)->GetNodeGrade() )
        {
            pCurNode->m_vecSubNode.push_back(*it);
        }
        else if( FNK_Name == (*it)->GetNodeGrade() )
        {
            pCurName =  (Cfyq_Name*)(*it);
            m_nrow = pCurName->GetScope()->GetRow();
            m_njzjKind = pCurName->Getjzj()->m_nkind;
        }
    }
    return true;
};//初始化



void Cfyq_expression::BackExpression()
{
    m_strToDB = "";
    m_pInterpreter->backInterpreter(this, m_strToDB);
}

std::vector<std::vector<int>>& Cfyq_expression::GetScopeMinMax()
{
    double dMinCount;
    double dMaxCount;
    double dMaxNumber;
    double dMinNumber;
    int k = 0;
    int curRow = 0;
    GetScopeFromTree();
    vecScope.clear();
    while(1)
    {
        dMinCount = GetScopeFromVec(1, 0, curRow);
        dMaxCount = GetScopeFromVec(1, 1, curRow);
        dMinNumber = GetScopeFromVec(1, 2, curRow);
        dMaxNumber = GetScopeFromVec(1, 3, curRow);
        if (dMinCount == -1 || dMaxCount == -1)
        {
            break;
        }
        vector<int> vec;
        vec.push_back(dMinCount);
        vec.push_back(dMaxCount);
        vec.push_back(dMaxNumber);
        vec.push_back(dMinNumber);
        vecScope.push_back(vec);
        curRow++;
    }
    return vecScope;
}


bool Cfyq_expression::toString()
{
    GetVarFromTree();
    GetScopeFromTree();
    if(m_vecVar.empty())
    {
        m_sValue = "";
        return false;
    }
    double nStep = GetdVar(0);
    double nKja = GetdVar(1);
    double nKjb = GetdVar(2);
    double dMinCount;
    double dMaxCount;
    double dMaxNumber;
    double dMinNumber;
    CString txt1,txt2,txt3;
    CString str;

    int curRow = 0;
    if((dMaxCount = GetScopeFromVec(1,1,curRow++)) > -1)
    {
        str.Format("若有效标书小于等于%.0lf家,则不去掉最高最低价。
", dMaxCount);
        txt1 += str;
    }
    while(curRow < m_nrow)
    {
        dMinCount = GetScopeFromVec(1, 0, curRow);
        dMaxCount = GetScopeFromVec(1, 1, curRow);
        dMinNumber = GetScopeFromVec(1, 2, curRow);
        dMaxNumber = GetScopeFromVec(1, 3, curRow);
        if (curRow == m_nrow - 1)
        {
            str.Format("若有效标书大于等于%.0lf家,则去掉%.0lf个最高价和%.0lf个最低价。
", dMinCount, dMinNumber, dMaxNumber);
            txt1 += str;
            break;
        }
        curRow++;
        str.Format("若有效标书大于等于%.0lf家,小于%.0lf家,则去掉%.0lf个最高价和%.0lf个最低价。
", dMinCount,
            dMaxCount,dMaxNumber,dMinNumber);
        txt1 += str;
    }
    if( nKjb > 0 )
    {
        txt2.Format("每低于 %.2lf％扣 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKjb,nStep,nStep);
    }
    else
    {
        nKjb = 0 - nKjb;
        txt2.Format("每低于 %.2lf％加 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKjb,nStep,nStep);
    }


    if(nKja > 0 )
    {
        txt3.Format("每高于 %.2lf％扣 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKja,nStep,nStep);
    }
    else
    {
        nKja = 0 - nKja;
        txt3.Format("每高于 %.2lf％加 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKja,nStep,nStep);
    }
    m_sValue = txt1 + txt2 + txt3;
    return true;
}


void Cfyq_expression::FindVar(vec_fyq_Var& m_VecVar,Cfyq_node *node)
{
    if(node->GetNodeGrade() == FNK_Value)
    {
        if(std::find(m_VecVar.begin(), m_VecVar.end(), node) == m_VecVar.end())
            m_VecVar.push_back((Cfyq_Var*)node);
        return ;
    }
    for(int i  = 0;i < node->m_vecSubNode.size();++i)
    {
        FindVar(m_VecVar,node->m_vecSubNode[i]);
    }
}

vec_fyq_Var& Cfyq_expression::GetVarFromTree()
{
    //ClearVecPtr(m_vecVar);
    FindVar(m_vecVar,this);
    return m_vecVar;
}

void Cfyq_expression::FindConst(vec_fyq_Const& m_VecConst,Cfyq_node *node)
{
    if(node->GetNodeGrade() == FNK_Const)
    {
        if(std::find(m_vecConst.begin(), m_vecConst.end(), node) == m_vecConst.end())
            m_vecConst.push_back((Cfyq_const*)node);
        return ;
    }
    for(int i  = 0;i < node->m_vecSubNode.size();++i)
    {
        FindConst(m_vecConst,node->m_vecSubNode[i]);
    }
}

vec_fyq_Const& Cfyq_expression::GetConstFromTree()
{
    FindConst(m_vecConst,this);
    return m_vecConst;
}


void Cfyq_expression::Serialize(CArchive& ar)
{
    int rightcode = 1;
    Cfyq_node::Serialize(ar);
    if( ar.IsStoring() )
    { 
        ar << rightcode;
        ar << m_vecVar;
        ar << m_nrow;
    }
    else
    {
        ar >> rightcode;
        ar >> m_vecVar;
        ar >> m_nrow;
    }        
}

double Cfyq_expression::GetdVar(int index)
{
    for(int i = 0;i < m_vecVar.size();++i)
    {
        if(i == index)
        {
            return m_vecVar[i]->m_dValue;
        }
    }
    return -1;
}
void Cfyq_expression::ChangeVecVarFromTree(const CString& strVar,double dval)
{
    if (m_vecVar.empty())
    {
        GetVarFromTree();
    }
    auto it = find_if(m_vecVar.begin(), m_vecVar.end(), [strVar](const Cfyq_Var* var)
    {
        return var->m_sEngName.CompareNoCase(strVar) == 0;
    });
    if(it != m_vecVar.end())
    {
        CString strTemp;
        strTemp.Format("%lf", dval);
        (*it)->m_dValueToStr = strTemp;
        (*it)->m_dValue = dval;
    }
}

void Cfyq_expression::ChangeVecVarFromTree(const CString& strVar, CString str)
{
    if (m_vecVar.empty())
    {
        GetVarFromTree();
    }
    auto it = find_if(m_vecVar.begin(), m_vecVar.end(), [strVar](const Cfyq_Var* var)
    {
        return var->m_sEngName.CompareNoCase(strVar) == 0;
    });
    if (it != m_vecVar.end())
    {
        (*it)->m_dValueToStr = str;
    }
}

void Cfyq_expression::FindScope(vec_fyq_Scope& m_vecScope, Cfyq_node* node)
{
    if (node->GetNodeGrade() == FNK_Offset)
    {
        if (find(m_vecScope.begin(), m_vecScope.end(), ((Cfyq_offset*)node)->GetFyqName()->GetScope())
            == m_vecScope.end())
            m_vecScope.push_back(((Cfyq_offset*)node)->GetFyqName()->GetScope());
        return;
    }
    for_each(node->m_vecSubNode.begin(), node->m_vecSubNode.end(), [&](Cfyq_node* refer) {
        FindScope(m_vecScope, refer);
    });
//     for each(Cfyq_node * tempnode in node->m_vecSubNode)
//     {
//         FindScope(m_vecScope, tempnode);
//     }
//     for (int i = 0; i < node->m_vecSubNode.size(); ++i)
//     {
//         FindScope(m_vecScope, node->m_vecSubNode[i]);
//     }
}

vec_fyq_Scope& Cfyq_expression::GetScopeFromTree()
{
    FindScope(m_vecScope, this);
    return m_vecScope;
}

double Cfyq_expression::GetScopeFromVec(int Flag, int index, int row)
{
    for (auto it = m_vecScope.begin(); it != m_vecScope.end(); it++)
    {
        if ((*it) != NULL && Flag == ((Cfyq_scope*)(*it))->GetFlag())
        {
            switch (index)
            {
            case 0:
                return ((Cfyq_scope*)(*it))->GetMinCount(row);
                break;
            case 1:
                return ((Cfyq_scope*)(*it))->GetMaxCount(row);
                break;
            case 2:
                return  ((Cfyq_scope*)(*it))->GetMin(row);
                break;
            case 3:
                return  ((Cfyq_scope*)(*it))->GetMax(row);
                break;
            }
        }
    }
    return -1;
}

void Cfyq_expression::AddVar(vec_fyq_Var& m_VecVar, Cfyq_node* node, CString explain, CString doublestr)
{
    if (node->GetNodeGrade() == FNK_Offset)
    {
        Cfyq_Var* var = new Cfyq_Var();
        var->m_sExplain = explain;
        var->m_dValueToStr = doublestr;
        var->m_strContent = explain + ":" + doublestr;
        auto vec = ((Cfyq_offset*)(node))->m_vecSubNode;
        auto it1 = find_if(vec.begin(), vec.end(), [var](Cfyq_node* node)
        {
            return var->m_strContent.CompareNoCase(node->m_strContent) == 0;
        });
        if (it1 == vec.end())
        {
            var->m_nLifePeriod = 1;
            ((Cfyq_offset*)(node))->m_vecSubNode.push_back(var);
        }

        auto it2 = find_if(m_VecVar.begin(), m_VecVar.end(), [var](Cfyq_node* node)
        {
            return var->m_strContent.CompareNoCase(node->m_strContent) == 0;
        });
        if (it2 == m_VecVar.end())
        {
            m_VecVar.push_back(var);
        }
        return;
    }
    for (int i = 0; i < node->m_vecSubNode.size(); ++i)
    {
        AddVar(m_VecVar, node->m_vecSubNode[i], explain, doublestr);
    }
}

void Cfyq_expression::AddVar(CString explain, CString doublestr)
{
    GetVarFromTree();
    AddVar(m_vecVar, this, explain, doublestr);
}

vecCountDeal& Cfyq_expression::GetCountDeal()
{
    m_vecCountDeal.clear();
    int dMinCount;
    int dMaxCount;
    int dMaxNumber;
    int dMinNumber;
    int curRow = 0;
    GetScopeFromTree();
    int start = 0;
    while (curRow < m_nrow)
    {
        dMinCount = GetScopeFromVec(1, 0, curRow);
        dMaxCount = GetScopeFromVec(1, 1, curRow);
        dMinNumber= GetScopeFromVec(1, 2, curRow);
        dMaxNumber= GetScopeFromVec(1, 3, curRow);
        CCountDeal deal(dMinCount, dMaxCount, dMinNumber, dMaxNumber);
        m_vecCountDeal.push_back(deal);
        curRow++;
    }
    return m_vecCountDeal;
}

void Cfyq_expression::AddJzjKind(Cfyq_node* node, long kind)
{
    if (node->GetNodeGrade() == FNK_Offset)
    {
        CString str;
        str.Format("%d", kind);
        ((Cfyq_offset*)node)->GetFyqName()->Getjzj()->m_strContent = str;
        ((Cfyq_offset*)node)->GetFyqName()->Getjzj()->m_nkind = kind;
        return;
    }
    for (int i = 0; i < node->m_vecSubNode.size(); ++i)
    {
        AddJzjKind(node->m_vecSubNode[i], kind);
    }
}

void Cfyq_expression::AddJzjKind(long kind)
{
    AddJzjKind(this, kind);
}

void Cfyq_expression::AddConst(vec_fyq_Const& m_vecConst, Cfyq_node* node, CString str)
{

    if (node->GetNodeGrade() == FNK_Define)
    {
        Cfyq_const* pconst = new Cfyq_const();
        pconst->m_strContent = str;
        auto vec = ((Cfyq_offset*)(node))->m_vecSubNode;
        auto it1 = find_if(vec.begin(), vec.end(), [pconst](Cfyq_node* node)
        {
            return pconst->m_strContent.CompareNoCase(node->m_strContent) == 0;
        });
        if (it1 == vec.end())
        {
            ((Cfyq_offset*)(node))->m_vecSubNode.push_back(pconst);
        }

        auto it2 = find_if(m_vecConst.begin(), m_vecConst.end(), [pconst](Cfyq_node* node)
        {
            return pconst->m_strContent.CompareNoCase(node->m_strContent) == 0;
        });
        if (it2 == m_vecConst.end())
        {
            m_vecConst.push_back(pconst);
        }
        return;
    }
    for (int i = 0; i < node->m_vecSubNode.size(); ++i)
    {
        AddConst(m_vecConst, node->m_vecSubNode[i], str);
    }
}

void Cfyq_expression::AddConst(CString str)
{
    GetConstFromTree();
    AddConst(m_vecConst, this, str);
    if (m_vecConst.empty())
    {

    }
}

bool Cfyq_expression::IsExistConst(const CString& strVar)
{
    GetConstFromTree();
    auto it = find_if(m_vecConst.begin(), m_vecConst.end(), [strVar](Cfyq_const* pconst)
    {
        return strVar.CompareNoCase(pconst->m_strContent) == 0;
    });
    if(it == m_vecConst.end())
        return false;
    return true;
}

Cfyq_Interpreter::Cfyq_Interpreter( )
{
    m_nCurIndex = 0;
    m_pCurNode = CreateNode(FNK_Name);
    m_pCurName = (Cfyq_Name*)m_pCurNode;
    m_vecExpression.push_back(GetCurNode());
    m_strFormula = "";

    m_name_obj.push_back( new CSysCodeKindDataInfo(  1, 1,"pdf", "pdf",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo(  2, 1,"rtf", "rtf",0 ) );

    //第二个参数为0不可复制
    m_name_obj.push_back( new CSysCodeKindDataInfo( 11, 0,"zz",     "资质/资格",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 12, 0,"yj",     "业绩",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 13, 0,"db",     "答辩",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 14, 0,"bj",     "报价得分",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 15, 0,"jzj", "基准价",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 16, 0,"hjqk", "获奖情况",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 17, 0,"tbxx", "投标信息",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 18, 0,"cgmx", "采购明细",0 ) );
    m_name_obj.push_back( new CSysCodeKindDataInfo( 19, 0,"khscore", "获奖情况",0 ) );

    m_param_obj.push_back( new CSysCodeKindDataInfo( 1, 1,"tbbj", "投标报价",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 2, 1,"csbj", "措施费用",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 3, 1,"qtbj", "其他费用",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 4, 1,"qd", "清单",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 5, 1,"kzj" , "控制价",0 ) );

    m_param_obj.push_back( new CSysCodeKindDataInfo( 11, 2,"corp", "单位",    0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 12, 2,"emp" , "人员",    0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 13, 2,"fzr" , "负责人",0 ) );

    m_param_obj.push_back( new CSysCodeKindDataInfo( 21, 3,"pf", "打分" ,0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 22, 3,"hg" , "合格",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 23, 3,"pfml" , "打分+目录",0 ) );
    m_param_obj.push_back( new CSysCodeKindDataInfo( 24, 3,"hgml" , "合格+目录",0 ) );


    //const
    //m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"NoCopy" , "不可复制",0 ) );
    m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"OnlyOne" , "重复性检查",0 ) );
    m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"CheckQDZFile" , "检查QDZ是否存在",0 ) );
    m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "ParamChange", "参数是否可以修改", 0));
    m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "CalMethod", "计算方法", 0));
    m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "MaxMin", "去高去低", 0));
    m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "mb", "明标", 0));
    m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "ab", "暗标", 0));
    //m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "Can", "去高去低", 0));
};

Cfyq_Interpreter::~Cfyq_Interpreter()
{
    ClearVecPtr( m_name_obj  );
    ClearVecPtr( m_param_obj );
    ClearVecPtr( m_const_obj );
};

bool Cfyq_Interpreter::CheckName(  CString& title )
{
    for( UINT i=0; i< m_name_obj.size(); i++ )
    {
        if( 0 == title.CompareNoCase( m_name_obj[i]->GetCode() ) )
        {
            return true;
        }
    }
    return false;
};

bool Cfyq_Interpreter::CheckParam( CString& title )
{
    for( UINT i=0; i< m_param_obj.size(); i++ )
    {
        if( 0 == title.CompareNoCase( m_param_obj[i]->GetCode() ) )
        {
            return true;
        }
    }
    return false;    
};

bool Cfyq_Interpreter::CheckConst(CString& title)
{
    for( UINT i=0; i< m_const_obj.size(); i++ )
    {
        if( 0 == title.CompareNoCase( m_const_obj[i]->GetCode() ) )
        {
            return true;
        }
    }
    return false;    
}

bool Cfyq_Interpreter::Interpreter(const CString& strFormula)
{
    ClearVecPtr(m_vecExpression);
    m_strFormula = strFormula;

    m_nCurIndex = 0;
    m_pCurNode = CreateNode(FNK_Name);
    m_pCurName = (Cfyq_Name*)m_pCurNode;
    
    m_vecExpression.push_back(GetCurNode());



    if ( m_strFormula.IsEmpty())
        return false;

    m_strFormula.Trim();
    if(m_strFormula[m_strFormula.GetLength() - 1] != ';')
    {
        AfxMessageBox("表达式没有结束符!");
        return false;
    }

    for( m_nCurIndex=0; m_nCurIndex < m_strFormula.GetLength(); m_nCurIndex++  )
    {
        if( !push( m_strFormula[m_nCurIndex] ) )
        {
            CString strErrorMsg;
            strErrorMsg.Format("Error Index:%d ",m_nCurIndex);
            m_pCurNode->ErrorMsg(strErrorMsg);
            AfxMessageBox(strErrorMsg);
            return false;
        }
    };

    return true;
}

void Cfyq_Interpreter::backInterpreter(Cfyq_node* startName, CString& backstr)
{
    startName->NextBackNode(startName, backstr, this, 0);
    pushback(startName, backstr);
    backstr += ";";
}

void Cfyq_Interpreter::pushback(Cfyq_node* startName, CString& backstr)
{
    int len = startName->m_vecSubNode.size();
    if (!len)
    {
        return;
    }
    for (int i = 0; i < startName->m_vecSubNode.size(); ++i)
    {
        if (i == startName->m_vecSubNode.size() - 1)
            startName->m_vecSubNode[i]->NextBackNode(startName->m_vecSubNode[i], backstr, this, 1);
        else
            startName->m_vecSubNode[i]->NextBackNode(startName->m_vecSubNode[i], backstr, this, 0);
        pushback(startName->m_vecSubNode[i], backstr);
    }
}

bool Cfyq_Interpreter::push(char input)
{
    Cfyq_node* pCurNode = GetCurNode();
    if( NULL == pCurNode)
        return false;

    switch( pCurNode->Accept( this, input ) )
    {
    case 1://可以接受
        return true;
    case 2://可以跳转
        return pCurNode->NextNode( this, input );
    case 3://忽略
        return true;
    default:
        return false;
    }
}

void Cfyq_Interpreter::ChangeNode(Cfyq_node* pNode)
{
    m_vecExpression.push_back(pNode);

    if( FNK_Name == pNode->GetNodeGrade() )
        m_pCurName = (Cfyq_Name*)pNode;

    m_pCurNode = pNode;
}

void Cfyq_Interpreter::ChangeBackNode(Cfyq_node* pstate)
{
    m_pCurBackNode = pstate;
}

bool Cfyq_Interpreter::IsTrueChar(char c)
{
    if(('a'<=c && 'z'>=c) || 
        ('0'<=c && '9'>=c) ||
        ('A'<=c && 'Z'>=c) ||
        c == ' ' || c == '.')
    {
        return true;
    }
    return false;
}

bool Cfyq_Interpreter::IsChineseChar(char c)
{
    if( c >= 0x80 || c<0 )
        return true;

    return false;
}

bool Cfyq_Interpreter::toString(CString& txt)
{

    return true;
}


bool Cfyq_Interpreter::NextStrIs(const CString& str)
{
    if(m_nCurIndex + 1 == m_strFormula.Find(str,m_nCurIndex))
        return true;

    return false;
}

bool Cfyq_Interpreter::NextStrIsIgnoreSpace(const CString& str)
{
    if(0 == str.GetLength())
        return true;
    int n = 0;
    for(int index = m_nCurIndex+1; index<m_strFormula.GetLength(); index++)
    {
        if(m_strFormula.GetAt(index)==' ')
            continue;
        if(m_strFormula.GetAt(index)!=str.GetAt(n++))
            return false;
        if(n >= str.GetLength())
            return true;
    }
    return false;
}

bool Cfyq_Interpreter::LastStrIsIgnoreSpace(const CString& str)
{
    if(0 == str.GetLength())
        return true;
    int n = str.GetLength()-1;
    for(int index = m_nCurIndex-1; index >= 0; index--)
    {
        if(m_strFormula.GetAt(index)==' ')
            continue;
        if(m_strFormula.GetAt(index)!=str.GetAt(n--))
            return false;
        if(n <= -1 )
            return true;
    }
    return false;
}

Cfyq_node* Cfyq_Interpreter::GetCurBackNode()
{
    return m_pCurBackNode;
}

Cfyq_node* Cfyq_Interpreter::CreateNode(CFyq_NodeKind kind)
{
    switch(kind)
    {
    case FNK_Name:
        return new Cfyq_Name();
    case FNK_Param:
        return new Cfyq_Param();
    case FNK_Scope:
        return new Cfyq_scope();
    case FNK_Const:
        return new Cfyq_const();
    case FNK_Value:
        return new Cfyq_Var();
    case FNK_Set:
        return new Cfyq_set();
    case FNK_Define:
        return new Cfyq_define();
    case FNK_Offset:
        return new Cfyq_offset();
    case FNK_Jzj:
        return new Cfyq_jzj();
    default:
        break;
    }
    return nullptr;
}

IMPLEMENT_SERIAL( Cfyq_Name, Cfyq_element, 0)

int Cfyq_Name::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return AppendChar(pInterpreter, input);

    switch( input )
    {
    case ':':
    case '(':
    case '[':
    case '=':
        {
            return 2;
        }
    case '-':
        {
            if(pInterpreter->NextStrIs(">"))
                return 2;
            else
                return 0;
        }
    }

    return 0;
}

bool Cfyq_Name::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!pInterpreter->CheckName(m_strContent))
    {
        return false;
    }
    switch( input )
    {
    case ':':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
            return true;
        }
    case '(':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Param));
            return true;
        }
    case '[':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Scope));
            return true;
        }
    case '=':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
            return true;
        }
    case '-':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
            return true;
        }
    default:
        return false;
    }
    return false;
}

CString Cfyq_Name::GetParam()
{
    return m_sParam;
}

void Cfyq_Name::SetParam(CString val)
{
    m_sParam = val;
}

Cfyq_scope* Cfyq_Name::GetScope()
{
    return m_pScope;
}

Cfyq_Name::Cfyq_Name()
{
    m_bcanSerial = 0;
    m_bcanSerialjzj = 0;
    m_pScope = NULL;
    m_pjzj = NULL;
    m_sParam = "";
}

Cfyq_Name::~Cfyq_Name()
{

}

void Cfyq_Name::SetScope(Cfyq_scope* val)
{
    m_pScope = val;
    m_bcanSerial = 1;
}

void Cfyq_Name::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    CString strTemp;
    str += m_strContent;
    if (!m_sParam.IsEmpty())
    {
        strTemp.Format("(%s)", m_sParam);
        str += strTemp;
    }
    if (m_pScope)
    {
        strTemp.Format("[%s]", m_pScope->m_strContent);
        str += strTemp;
    }
    if (m_pjzj)
    {
        strTemp.Format("{%s}", m_pjzj->m_strContent);
        str += strTemp;
    }
    pInterpreter->ChangeBackNode(node);
}

Cfyq_jzj* Cfyq_Name::Getjzj() const
{
    return m_pjzj;
}

void Cfyq_Name::Setjzj(Cfyq_jzj* jzj)
{
    m_bcanSerialjzj = 1;
    m_pjzj = jzj;
}

void Cfyq_Name::ErrorMsg(CString& str)
{
    CString strTmp = "名字出现错误！
";
    str += strTmp;
}

CFyq_NodeKind Cfyq_Name::GetNodeGrade()
{
    return FNK_Name;
}

void Cfyq_Name::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize(ar);
    
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
        ar << m_sParam;
        ar << m_bcanSerial;
        if(m_bcanSerial)
            m_pScope->Serialize(ar);
    }
    else 
    {
        ar >> rightcode;
        ar >> m_sParam;
        ar >> m_bcanSerial;
        if(m_bcanSerial)
        {
            m_pScope = new Cfyq_scope();
            m_pScope->Serialize(ar);
        }
    }
}

IMPLEMENT_SERIAL( Cfyq_Param, Cfyq_element, 0)

bool Cfyq_Param::SetParamToName(Cfyq_Interpreter* pInterpreter)
{
    pInterpreter->GetCurName()->SetParam(m_strContent);
    return true;
}

int Cfyq_Param::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return AppendChar(pInterpreter, input);

    switch( input )
    {
    case '[':
        {
            return 2;        
        }
    case '=':
        {
            return 2;
        }
    case ')':
        {
            SetClose(true);//闭合
            if(pInterpreter->NextStrIsIgnoreSpace("[")||pInterpreter->NextStrIsIgnoreSpace("="))
                return 3;
            else 
                return 0;    
        }
    }

    return 0;
}

bool Cfyq_Param::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!IsClose())
        return false;
    if(pInterpreter->CheckParam(m_strContent))
        SetParamToName(pInterpreter);
    else
        return false;

    switch( input )
    {
    case '[':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Scope));
            return true;
        }
    case '=':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
            return true;
        }
    default:
        return false;
    }
    return false;
}

CFyq_NodeKind Cfyq_Param::GetNodeGrade()
{
    return FNK_Param;
}

void Cfyq_Param::ErrorMsg(CString& str)
{
    CString strTmp = "参数出现错误！
";
    str += strTmp;
}

Cfyq_Param::Cfyq_Param()
{

}

void Cfyq_Param::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize(ar);
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
    }
    else 
    {
        ar >> rightcode;
    }
}

IMPLEMENT_SERIAL( Cfyq_set, Cfyq_opt, 0)

int Cfyq_set::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if(input == ' ')
        return 3;
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return 2;

    return 0;
}

bool Cfyq_set::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Name));
    pInterpreter->GetCurNode()->m_strContent.AppendChar(input);
    pInterpreter->GetCurNode()->m_bStateInputChar = true;
    return true;
}


void Cfyq_set::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    str += "=";
    pInterpreter->ChangeBackNode(node);
}

CFyq_NodeKind Cfyq_set::GetNodeGrade()
{
    return FNK_Set;
}

Cfyq_set::Cfyq_set()
{

}

Cfyq_set::~Cfyq_set()
{

}

void Cfyq_set::Serialize(CArchive& ar)
{
    int rightcode = 1;
    Cfyq_node::Serialize(ar);
    if( ar.IsStoring() )
    { 
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }
}

IMPLEMENT_SERIAL( Cfyq_define, Cfyq_opt, 0)

int Cfyq_define::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if(input == ' ')
        return 3;
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return 2;

    return 0;
}

bool Cfyq_define::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Const));
    pInterpreter->GetCurNode()->m_strContent.AppendChar(input);
    pInterpreter->GetCurNode()->m_bStateInputChar = true;
    return true;
}

CFyq_NodeKind Cfyq_define::GetNodeGrade()
{
    return FNK_Define;
}

void Cfyq_define::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
{
    str += ":";
    pInterpreter->ChangeBackNode(node);
}

Cfyq_define::Cfyq_define()
{

}


void Cfyq_define::Serialize(CArchive& ar)
{
    int rightcode = 1;
    Cfyq_node::Serialize(ar);
    if( ar.IsStoring() )
    { 
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }
}

IMPLEMENT_SERIAL( Cfyq_element, Cfyq_node, 0)
Cfyq_element::Cfyq_element() : m_bIsCloseFlag(false)
{

}

bool Cfyq_element::IsClose()
{
    return m_bIsCloseFlag;
}

void Cfyq_element::SetClose(bool val)
{
    m_bIsCloseFlag = val;
}

int Cfyq_element::AppendChar(Cfyq_Interpreter* pInterpreter, char input)
{
    //进入字符状态
    if(m_bStateInputChar)
    {
        if(input==' ')
            m_bStateInputChar = false;
        else
        {
            m_strContent += input;
            return 1;
        }
    }
    //非字符状态
    else
    {
        if(input != ' ')
        {
            if(m_strContent.GetLength() == 0)
            {
                m_bStateInputChar = true;
                m_strContent += input;
                return 1;
            }
            else
                return 0;
        }
    }
    return 3;
}

void Cfyq_element::Serialize(CArchive& ar)
{
    int rightcode = 1;
    if(ar.IsStoring())
    {
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }
}
IMPLEMENT_SERIAL( Cfyq_jzj, Cfyq_element, 0)


Cfyq_jzj::Cfyq_jzj()
{
    m_nkind = -1;
    m_strContent = "";
}

Cfyq_jzj::~Cfyq_jzj()
{

}

void Cfyq_jzj::Serialize(CArchive& ar)
{
    Cfyq_node::Serialize( ar );
    int rightcode = 1; 
    if( ar.IsStoring() )
    {
        ar << rightcode;
    }
    else
    {
        ar >> rightcode;
    }
}

bool Cfyq_jzj::SetjzjToName(Cfyq_Interpreter* pInterpreter)
{
    pInterpreter->GetCurName()->Setjzj(this);
    return true;
}

int Cfyq_jzj::Accept(Cfyq_Interpreter* pInterpreter, char input)
{
    if( Cfyq_Interpreter::IsTrueChar( input ) )
        return AppendChar(pInterpreter, input);
    switch( input )
    {
    case '}':
        {
            SetClose(true);
            if(pInterpreter->NextStrIsIgnoreSpace("->"))
                return 3;
            else
                return 0;
        }
    case '-':
        {
            if(pInterpreter->NextStrIs(">"))
                return 2;
            m_strContent += input;
            return 1;
        }
    }

    return 0;
}

bool Cfyq_jzj::NextNode(Cfyq_Interpreter* pInterpreter, char input)
{
    if(!IsClose())
        return false;
    else
        SetjzjToName(pInterpreter);
    switch( input )
    {
    case '-':
        {
            pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
            return true;
        }
    default:
        return false;
    }
}

CFyq_NodeKind Cfyq_jzj::GetNodeGrade()
{
    return FNK_Jzj;
}