有限状态机

  1 #pragma once
  2 #include "....dscript	able.h"
  3 #include "....dscript	ableD_resEditListCtrl.h"
  4 #include "..PropertyGridExDrawLotsDlg.h"
  5 #include "..dbase_header.h"
  6 #include <afx.h>
  7 #include "....dscriptdscript_enum_header.h"
  8 #include "....dscriptgNewPbCalcRulecountDeal.h"
  9 
 10 using namespace std;
 11 class Cfyq_expression;
 12 class Cfyq_Name;
 13 class Cfyq_node;
 14 class Cfyq_Var;
 15 class Cfyq_scope;
 16 class Cfyq_const;
 17 class Cfyq_offset;
 18 class Cfyq_jzj;
 19 class Cfyq_opt;
 20 class Cfyq_set;
 21 typedef std::vector<Cfyq_node*>    vec_fyq_Node;
 22 typedef std::vector<Cfyq_Var*>    vec_fyq_Var;
 23 typedef std::vector<Cfyq_const*>    vec_fyq_Const;
 24 typedef std::vector<Cfyq_scope*>    vec_fyq_Scope;
 25 typedef std::vector<Cfyq_opt*>    vec_fyq_opt;
 26 typedef std::vector<Cfyq_set*>    vec_fyq_set;
 27 enum CFyq_NodeKind{FNK_Name, FNK_Param, FNK_Scope, FNK_Const, FNK_Value, FNK_Set, FNK_Define, FNK_Offset,FNK_Node,FNK_Jzj};
 28 
 29 class   Cfyq_Interpreter : public CTableRow
 30 {
 31 
 32 public:
 33     Cfyq_Interpreter();
 34     ~Cfyq_Interpreter();
 35 public:
 36     bool Interpreter(const CString& strFormula);
 37     void backInterpreter(Cfyq_node* startName,CString& backstr);
 38     void pushback(Cfyq_node* startName, CString& backstr);
 39     bool push( char input );
 40     void ChangeNode(Cfyq_node* pState);
 41     void ChangeBackNode(Cfyq_node* pstate);
 42 
 43     bool NextStrIs(const CString& str);
 44     bool NextStrIsIgnoreSpace(const CString& str);
 45     bool LastStrIsIgnoreSpace(const CString& str);
 46     static bool IsTrueChar(char c);
 47     static bool IsChineseChar(char c);
 48     virtual bool toString(CString& txt);
 49     bool CheckName(  CString& title );
 50     bool CheckParam( CString& title );
 51     bool CheckConst( CString& title );
 52 public:
 53     Cfyq_node* GetCurNode(){ return m_pCurNode; }
 54     Cfyq_Name* GetCurName(){ return m_pCurName; }
 55     Cfyq_node* GetCurBackNode();
 56     Cfyq_node* CreateNode(CFyq_NodeKind kind);
 57     vec_fyq_Node& GetvecExpression(){ return m_vecExpression; }
 58 public:
 59     //检查集合
 60     vecSysCodeKindDataInfo m_param_obj;
 61     vecSysCodeKindDataInfo m_name_obj;
 62     vecSysCodeKindDataInfo m_const_obj;
 63 private:
 64     CString m_strFormula;//公式
 65     UINT m_nCurIndex;//当前索引
 66     Cfyq_node* m_pCurNode;//当前状态
 67     Cfyq_Name* m_pCurName;//当前name
 68     Cfyq_node* m_pCurBackNode;//反解析当前状态
 69     vec_fyq_Node m_vecExpression;//State存放集合
 70 };
 71 //节点
 72 class  Cfyq_node : public CTableRow
 73 {
 74     DECLARE_SERIAL_EXTDLL( Cfyq_node )
 75 public:
 76     Cfyq_node();
 77     virtual ~Cfyq_node();
 78 public:
 79     virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
 80     virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
 81     virtual void NextBackNode(Cfyq_node* startName,CString& str, Cfyq_Interpreter* pInterpreter,bool bLast);
 82     virtual CFyq_NodeKind GetNodeGrade();
 83     virtual void ErrorMsg(CString& str);
 84     void Serialize(CArchive& ar);
 85 public:
 86     CString& GetContent();
 87 public:
 88     vec_fyq_Node m_vecSubNode;
 89     double m_dValue;
 90     CString m_sValue;
 91     CString m_strContent;
 92     bool m_bStateInputChar;
 93 protected:
 94     Cfyq_Interpreter* m_pInterpreter;
 95 };
 96 
 97 //元素
 98 class  Cfyq_element : public Cfyq_node
 99 {
100     DECLARE_SERIAL_EXTDLL( Cfyq_element )
101 public:
102     Cfyq_element();
103     ~Cfyq_element(){};
104 public:
105     bool IsClose();;
106     void SetClose(bool val);
107     int AppendChar( Cfyq_Interpreter* pInterpreter, char input );
108     void Serialize(CArchive& ar);
109 private:
110     bool m_bIsCloseFlag;
111 };
112 
113 //常量
114 class  Cfyq_const : public Cfyq_element
115 {
116     DECLARE_SERIAL_EXTDLL( Cfyq_const )
117 public:
118     Cfyq_const(){}
119     ~Cfyq_const(){}
120 public:
121     int Accept( Cfyq_Interpreter* pInterpreter, char input );
122     bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
123     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
124     virtual CFyq_NodeKind GetNodeGrade() {return FNK_Const;}
125     virtual void ErrorMsg(CString& str);
126     void Serialize(CArchive& ar);
127 };
128 
129 //用户变量 {kjb:正偏离扣减}
130 class  Cfyq_Var : public Cfyq_element
131 {
132     DECLARE_SERIAL_EXTDLL( Cfyq_Var )
133 public:
134     CString m_sEngName;//英文名
135     bool m_bInited;//是否被赋值
136     CString m_sExplain;//中文解释
137     CString m_dValueToStr; //数字字符串
138     int m_nLifePeriod;//生命周期 0是测试阶段 1是代理阶段
139 public:
140     Cfyq_Var();
141     ~Cfyq_Var(){};
142     void SetEngName(CString name);
143     void SetExplain(CString Explain);
144     int Accept( Cfyq_Interpreter* pInterpreter, char input );
145     bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
146 
147     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
148 
149     virtual CFyq_NodeKind GetNodeGrade() {return FNK_Value;}
150 
151     virtual void ErrorMsg(CString& str);
152 
153     void Serialize(CArchive& ar);
154 };
155 
156 //:取值范围
157 class  Cfyq_scope : public Cfyq_element
158 {
159     DECLARE_SERIAL_EXTDLL( Cfyq_scope )
160 public:
161     Cfyq_scope();
162     ~Cfyq_scope();
163 protected:
164     int m_bFlag;//0:- 范围用法；1：,去除用法
165     int  m_MinMax[105][4]; //最大可支持105个范围区间
166     int m_nrow;
167 public:
168 
169     int GetMinCount(int index);
170     int GetMaxCount(int index);
171     int GetMin(int index);
172     int GetMax(int index);
173 
174     void SetRow(int row);
175     int GetRow();
176     bool SetScope();
177     bool ReplaceScope(CString strTemp);
178     bool SetScopeToName(Cfyq_Interpreter* pInterpreter);
179     int GetFlag();
180     void Serialize(CArchive& ar);
181     virtual void ErrorMsg(CString& str);
182 public:
183     int Accept( Cfyq_Interpreter* pInterpreter, char input );
184     bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
185     virtual CFyq_NodeKind GetNodeGrade();
186 };
187 
188 
189 class  Cfyq_Name : public Cfyq_element
190 {
191     DECLARE_SERIAL_EXTDLL( Cfyq_Name )
192 public:
193     Cfyq_Name();
194     ~Cfyq_Name();
195 protected:
196     CString        m_sParam;
197     Cfyq_scope*    m_pScope;
198     Cfyq_jzj*   m_pjzj;
199 public:
200     virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
201     virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
202     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
203 
204     CString GetParam();
205     void SetParam(CString val);
206     Cfyq_scope* GetScope();
207     void SetScope(Cfyq_scope* val);
208     Cfyq_jzj* Getjzj() const;
209     void Setjzj(Cfyq_jzj* jzj);
210 
211     virtual void ErrorMsg(CString& str);
212 
213     virtual CFyq_NodeKind GetNodeGrade();
214 
215     void Serialize(CArchive& ar);
216 public:
217     int m_bcanSerial;
218     int m_bcanSerialjzj;
219 };
220 
221 class  Cfyq_jzj : public Cfyq_element
222 {
223     DECLARE_SERIAL_DSCRIPT( Cfyq_jzj )
224 public:
225     Cfyq_jzj();
226     ~Cfyq_jzj();
227     int Accept(Cfyq_Interpreter* pInterpreter, char input);
228     bool NextNode(Cfyq_Interpreter* pInterpreter, char  input);
229     virtual CFyq_NodeKind GetNodeGrade();
230     void Serialize(CArchive& ar);
231     bool SetjzjToName(Cfyq_Interpreter* pInterpreter);
232 public:
233     long m_nkind;
234 };
235 
236 //参数
237 class  Cfyq_Param: public Cfyq_element
238 {
239     DECLARE_SERIAL_EXTDLL( Cfyq_Param )
240 public:
241     Cfyq_Param();
242     ~Cfyq_Param(){}
243 public:
244     bool SetParamToName(Cfyq_Interpreter* pInterpreter);
245     virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
246     virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
247     virtual CFyq_NodeKind GetNodeGrade();
248     virtual void ErrorMsg(CString& str);
249     void Serialize(CArchive& ar);
250 };
251 
252 //操作符
253 class  Cfyq_opt: public Cfyq_node
254 {
255     DECLARE_SERIAL_EXTDLL( Cfyq_opt )
256 public:
257     Cfyq_opt();
258     ~Cfyq_opt();
259 protected:
260     vec_fyq_Node m_nodes; 
261 public:
262     void Serialize(CArchive& ar);
263 };
264 
265 
266 //:定义
267 class  Cfyq_define: public Cfyq_opt
268 {
269     DECLARE_SERIAL_EXTDLL( Cfyq_define )
270 public:
271     Cfyq_define();
272     ~Cfyq_define(){}
273 public:
274     virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
275     virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
276     virtual CFyq_NodeKind GetNodeGrade();
277     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
278     void Serialize(CArchive& ar);
279 };
280 
281 //=赋值
282 class  Cfyq_set: public Cfyq_opt
283 {
284     DECLARE_SERIAL_EXTDLL( Cfyq_set )
285 public:
286     Cfyq_set();
287     ~Cfyq_set();
288     virtual int Accept( Cfyq_Interpreter* pInterpreter, char input );
289     virtual bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
290     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
291     virtual CFyq_NodeKind GetNodeGrade();
292     void Serialize(CArchive& ar);
293 };
294 
295 
296 //=偏差计算： 左侧为引入的系统变量，右侧为固定的用户参数分别 偏离范围，正偏离扣分，右偏离扣分
297 class  Cfyq_offset: public Cfyq_opt
298 {
299     DECLARE_SERIAL_EXTDLL( Cfyq_offset )
300 public:
301     Cfyq_offset();
302     ~Cfyq_offset(){}
303     Cfyq_Name* m_pName;
304     int m_bcanSerial;
305 public:
306     int Accept( Cfyq_Interpreter* pInterpreter, char input );
307     bool NextNode( Cfyq_Interpreter* pInterpreter, char  input );
308     virtual CFyq_NodeKind GetNodeGrade() {return FNK_Offset;}
309     void Serialize(CArchive& ar);
310     void NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast);
311     void SetFyqName(Cfyq_Name* val);
312     Cfyq_Name* GetFyqName();
313 };
314 
315 /*
316 
317 =  赋值操作
318 +->偏差赋值 分两种形式，+>大于基准价，偏离;->小于基准价，偏离
319 [] 取值范围分两种形式：1、“，”标志去除 例如[1,2]去掉1个最高，2个最低分
320         “-”标志的范围[1,2]，例如[0-3]表示0-3分,可简写为[3]
321 ()入口参数
322 
323 */
324 
325 
326 /*表达式 名称 描述了表达式的基本功能界面
327 
328 文法示例：
329 zz(corp)[3]:pf,nomark;  
330 企业资质（暗标）3分  
331 xmbz:ml;                          项目班子成员目录
332 bj(tbbj)[10]=jzj(1,2) -> bj>jzj ? {kja}/{step} : {kjb}/{step};  
333 投标报价满分10，正偏离基准价{step}扣减{kja}，负偏离基准价{step}扣减{kjb}
334 
335 */
336 
337 class FLY_DBASE_API  Cfyq_expression : public Cfyq_Name
338 {
339     DECLARE_SERIAL_EXTDLL(Cfyq_expression)
340 public:
341     Cfyq_expression();
342     ~Cfyq_expression();
343     //字符串到对象
344     bool InitExpression(const CString& expression );
345     //对象到字符串
346     void BackExpression();
347     //将基准价范围用文字的形式表现出来
348     virtual bool toString();
349     //目前计算不通过表达式计算
350     virtual void Calc(CString& str);
351 
352     void Serialize(CArchive& ar);
353 
354     //范围相关-------去高去低
355     void FindScope(vec_fyq_Scope& m_vecScope, Cfyq_node* node);
356     vec_fyq_Scope& GetScopeFromTree();
357     double GetScopeFromVec(int Flag, int index, int row);
358     void SetVecVarNode(vecVarNode_ZBFileInfo& vecVarNode) { m_vecVarNode = vecVarNode; }
359     std::vector<std::vector<int>>& GetScopeMinMax();
360     vecCountDeal& GetCountDeal();
361 
362 
363     //变量相关
364     void FindVar(vec_fyq_Var& m_VecVar, Cfyq_node* node);
365     vec_fyq_Var& GetVarFromTree();
366     void AddVar(CString explain, CString doublestr);
367     void AddVar(vec_fyq_Var& m_VecVar, Cfyq_node* node, CString explain, CString doublestr);
368     double GetdVar(int index);
369     void ChangeVecVarFromTree(const CString& strVar, CString str);
370     void ChangeVecVarFromTree(const CString& strVar, double dval);
371 
372     //常量相关
373     bool IsExistConst(const CString& strVar);
374     void FindConst(vec_fyq_Const& m_VecConst,Cfyq_node *node);
375     vec_fyq_Const& GetConstFromTree();
376     //增加常量主要针对k,q,m
377     void AddConst(CString str);
378     void AddConst(vec_fyq_Const& m_vecConst, Cfyq_node* node, CString str);
379 
380     //显示当前的计算方法
381     void AddJzjKind(long kind);
382     void AddJzjKind(Cfyq_node* node,long kind);
383     long GetJzjKind() {    return m_njzjKind;}
384 
385 public:
386     vec_fyq_Var m_vecVar;
387     vec_fyq_Const m_vecConst;
388     vec_fyq_Scope m_vecScope;
389     Cfyq_Interpreter *m_pInterpreter;
390     std::vector<std::vector<int>> vecScope;
391     vecVarNode_ZBFileInfo m_vecVarNode;
392     vecCountDeal m_vecCountDeal;
393     int m_nrow;
394     int m_njzjKind;
395     CString m_strToDB;
396 };

   1 #include "StdAfx.h"
   2 #include "fyq_interpreter.h"
   3 #include <afx.h>
   4 
   5 
   6 IMPLEMENT_SERIAL( Cfyq_node, CTableRow, 0)
   7 Cfyq_node::Cfyq_node()
   8 {
   9     m_dValue = 0;        
  10     m_bStateInputChar = false;
  11     m_pInterpreter = NULL;
  12 };
  13 
  14 
  15 Cfyq_node::~Cfyq_node()
  16 {
  17 
  18 }
  19 
  20 //  1、没有必要空格是忽略的
  21 //     2、有必要（字符之间是有必要，符号之间->之间是有必要）
  22 //     3、开闭 ),] 状态 是否闭合 -》  
  23 //  
  24 //     进入字符状态，且未闭合
  25 int Cfyq_node::Accept(Cfyq_Interpreter* pInterpreter, char input)
  26 {
  27     return 0;
  28 }
  29 
  30 bool Cfyq_node::NextNode(Cfyq_Interpreter* pInterpreter, char input)
  31 {
  32     return false;
  33 }
  34 
  35 void Cfyq_node::NextBackNode(Cfyq_node* startName, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
  36 {
  37     return;
  38 }
  39 
  40 CFyq_NodeKind Cfyq_node::GetNodeGrade()
  41 {
  42     return FNK_Node;
  43 }
  44 
  45 void Cfyq_node::ErrorMsg(CString& str)
  46 {
  47     return;
  48 }
  49 
  50 void Cfyq_node::Serialize(CArchive& ar)
  51 {
  52     int rightcode = 1;
  53     if( ar.IsStoring() )
  54     { 
  55         ar << rightcode;
  56         ar << m_dValue;
  57         ar << m_sValue;
  58         ar << m_strContent;
  59         ar << m_vecSubNode;
  60     }
  61     else
  62     {
  63         ar >> rightcode;
  64         ar >> m_dValue;
  65         ar >> m_sValue;
  66         ar >> m_strContent;
  67         ar >> m_vecSubNode;
  68     }
  69 }
  70 
  71 CString& Cfyq_node::GetContent()
  72 {
  73     return m_strContent;
  74 }
  75 
  76 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  77 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  78 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  79 
  80 IMPLEMENT_SERIAL( Cfyq_const, Cfyq_element, 0)
  81 int Cfyq_const::Accept(Cfyq_Interpreter* pInterpreter, char input)
  82 {
  83     if( Cfyq_Interpreter::IsTrueChar( input ) )
  84         return AppendChar(pInterpreter, input);
  85 
  86     switch( input )
  87     {
  88     case ',':
  89     case ';':
  90             return 2;
  91     }
  92 
  93     return 0;
  94 }
  95 
  96 bool Cfyq_const::NextNode(Cfyq_Interpreter* pInterpreter, char input)
  97 {
  98     if(!pInterpreter->CheckConst(m_strContent))
  99         return false;
 100 
 101     switch( input )
 102     {
 103     case ',':
 104         {
 105             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Const));
 106             return true;
 107         }
 108     case ';':
 109         {
 110             return true;
 111         }
 112     default:
 113         return false;
 114     }
 115 }
 116 
 117 
 118 void Cfyq_const::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
 119 {
 120     CString strTemp;
 121     if (bLast)
 122         strTemp.Format("%s", m_strContent);
 123     else
 124         strTemp.Format("%s,", m_strContent);
 125     str += strTemp;
 126     pInterpreter->ChangeBackNode(node);
 127 }
 128 
 129 void Cfyq_const::ErrorMsg(CString& str)
 130 {
 131     CString strTmp = "常量出现错误！
";
 132     str += strTmp;
 133 }
 134 
 135 void Cfyq_const::Serialize(CArchive& ar)
 136 {
 137     Cfyq_node::Serialize(ar);
 138     int rightcode = 1;
 139     if(ar.IsStoring())
 140     {
 141         ar << rightcode;
 142     }
 143     else
 144     {
 145         ar >> rightcode;
 146     }
 147 }
 148 
 149 IMPLEMENT_SERIAL( Cfyq_Var, Cfyq_element, 0)
 150 Cfyq_Var::Cfyq_Var()
 151 {
 152     m_bInited = false;
 153     CString m_sEngName = "";
 154     CString m_sExplain = "";
 155     CString m_dValueToStr = "";
 156     m_nLifePeriod = 0;
 157 }
 158 
 159 
 160 
 161 void Cfyq_Var::SetEngName(CString name)
 162 {
 163     m_sEngName = name;
 164 }
 165 
 166 void Cfyq_Var::SetExplain(CString Explain)
 167 {
 168     m_sExplain = Explain;
 169 }
 170 
 171 int Cfyq_Var::Accept(Cfyq_Interpreter* pInterpreter, char input)
 172 {
 173     if( Cfyq_Interpreter::IsTrueChar( input ) || Cfyq_Interpreter::IsChineseChar( input ) || (':' == input && !IsClose()) )
 174         return AppendChar(pInterpreter, input);
 175 
 176     switch( input )
 177     {
 178     case ')':
 179         SetClose(true);
 180 
 181         
 182         if(m_strContent.Find(":") == -1)
 183         {
 184             SetEngName(m_strContent);
 185             SetExplain("");
 186         }
 187         else
 188         {
 189             CString strleft = m_strContent.Left(m_strContent.Find(":"));
 190             CString strRight = m_strContent.Mid(m_strContent.Find(":")+1,m_strContent.GetLength());
 191             SetEngName(strleft);
 192             SetExplain(strRight);
 193         }
 194         
 195 
 196         {
 197             if(pInterpreter->NextStrIsIgnoreSpace(",$(")||pInterpreter->NextStrIsIgnoreSpace(";")||pInterpreter->NextStrIsIgnoreSpace(":"))
 198                 return 3;
 199             else
 200                 return 0;
 201         }
 202     case ',':
 203         {
 204             if(pInterpreter->NextStrIsIgnoreSpace("$("))
 205                 return 3;
 206             else 
 207                 return 0;
 208         }
 209     case '$':
 210         {
 211             if(pInterpreter->NextStrIsIgnoreSpace("("))
 212                 return 2;
 213             else 
 214                 return 0;
 215         }
 216     case '(':
 217         {
 218             if(pInterpreter->LastStrIsIgnoreSpace("$"))
 219                 return 3;
 220             else
 221                 return 0;
 222         }
 223     case ':':
 224         {
 225             return 2;
 226         }
 227     case ';':
 228         {
 229             return 2;
 230         }
 231     }
 232 
 233     return 0;
 234 }
 235 
 236 bool Cfyq_Var::NextNode(Cfyq_Interpreter* pInterpreter, char input)
 237 {
 238     if(!IsClose())
 239         return false;
 240 
 241     switch( input )
 242     {
 243     case '$':
 244         {
 245             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Value));
 246             return true;
 247         }
 248     case ':':
 249         {
 250             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
 251             return true;
 252         }
 253     case ';':
 254         {
 255             return true;
 256         }
 257     default:
 258         return false;
 259     }
 260 }
 261 
 262 void Cfyq_Var::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
 263 {
 264     CString strTemp;
 265     if (bLast)
 266     {
 267         if (!m_dValueToStr.IsEmpty())
 268             strTemp.Format("$(%s:%s)", m_sExplain, m_dValueToStr);
 269         else
 270             strTemp.Format("$(%s:%s)", m_sExplain, m_sEngName);
 271     }
 272     else
 273     {
 274         if (!m_dValueToStr.IsEmpty())
 275             strTemp.Format("$(%s:%s),", m_sExplain, m_dValueToStr);
 276         else
 277             strTemp.Format("$(%s:%s),", m_sExplain, m_sEngName);
 278     }
 279     str += strTemp;
 280     pInterpreter->ChangeBackNode(node);
 281 }
 282 
 283 void Cfyq_Var::ErrorMsg(CString& str)
 284 {
 285     CString strTmp = "变量出现错误！
";
 286     str += strTmp;
 287 }
 288 
 289 void Cfyq_Var::Serialize(CArchive& ar)
 290 {
 291     Cfyq_node::Serialize(ar);
 292     int rightcode = 1;
 293     if(ar.IsStoring())
 294     {
 295         ar << rightcode;
 296         ar << m_sEngName;
 297         ar << m_sExplain;
 298         ar << m_nLifePeriod;
 299     }
 300     else
 301     {
 302         ar >> rightcode;
 303         ar >> m_sEngName;
 304         ar >> m_sExplain;
 305         ar >> m_nLifePeriod;
 306     }
 307 }
 308 
 309 int Cfyq_scope::GetMinCount(int index)
 310 {
 311     return m_MinMax[index][0];
 312 }
 313 
 314 int Cfyq_scope::GetMaxCount(int index)
 315 {
 316     return m_MinMax[index][1];
 317 }
 318 
 319 int Cfyq_scope::GetMin(int index)
 320 {
 321     return m_MinMax[index][2];
 322 }
 323 
 324 int Cfyq_scope::GetMax(int index)
 325 {
 326     return m_MinMax[index][3];
 327 }
 328 
 329 void Cfyq_scope::SetRow(int row)
 330 {
 331     m_nrow = row;
 332 }
 333 
 334 int Cfyq_scope::GetRow()
 335 {
 336     return m_nrow;
 337 }
 338 
 339 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 340 IMPLEMENT_SERIAL( Cfyq_scope, Cfyq_element, 0)
 341 //解析范围
 342 bool Cfyq_scope::SetScope()
 343 {
 344     CString strLeft,strMid,strRight,strLast;
 345     int nMidIndex;
 346     //上下限
 347     if(m_strContent == m_strContent.SpanIncluding("0123456789.-"))
 348     {
 349         if(m_strContent == m_strContent.SpanIncluding("0123456789."))
 350         {
 351             m_MinMax[0][0] = 0;
 352             m_MinMax[0][1] = atoi(m_strContent);
 353             return true;
 354         }
 355         else
 356         {    
 357             nMidIndex = m_strContent.Find("-");
 358             strLeft =  m_strContent.Left(nMidIndex);
 359             strRight = m_strContent.Mid(nMidIndex + 1,m_strContent.GetLength() -1 );
 360             if(strLeft == strLeft.SpanIncluding("0123456789.")
 361                 && strRight == strRight.SpanIncluding("0123456789."))
 362             {
 363                 m_MinMax[0][0] = atoi(strLeft);
 364                 m_MinMax[0][1] = atoi(strRight);
 365                 m_MinMax[0][2] = 0;
 366                 return true;
 367             }
 368             else
 369             {
 370                 return false;
 371             }
 372         }
 373         m_bFlag = 0;
 374         SetRow(0);
 375     }
 376     //数轴
 377     else
 378     {
 379         if(m_strContent.Find(";") == -1)
 380         {
 381             int nMidIndex = m_strContent.Find(',') == -1;
 382             if(nMidIndex != -1)
 383             {
 384                 SetRow(1);
 385                 if( m_strContent.Find(',') != -1)
 386                 {    
 387                     CString strTmp;
 388                     int ipos = 0;
 389                     while(AfxExtractSubString(strTmp,m_strContent,ipos,','))
 390                     {
 391                         ipos++;
 392                         switch(ipos)
 393                         {
 394                         case 1:
 395                             strLeft = strTmp;
 396                             break;
 397                         case 2:
 398                             strMid = strTmp;
 399                             break;
 400                         case 3:
 401                             strRight = strTmp;
 402                             break;
 403                         case 4:
 404                             strLast = strTmp;
 405                         }
 406                     }
 407                     if(strLeft == strLeft.SpanIncluding("0123456789.")
 408                         && strRight == strRight.SpanIncluding("0123456789.") 
 409                         && strMid == strMid.SpanIncluding("0123456789.")
 410                         && strLast == strLast.SpanIncluding("0123456789."))
 411                     {
 412                         m_MinMax[0][0] = atoi(strLeft);
 413                         m_MinMax[0][1] = atoi(strMid);
 414                         m_MinMax[0][2] = atoi(strRight);
 415                         m_MinMax[0][3] = atoi(strLast);
 416                         return true;
 417                     }
 418                     else
 419                     {
 420                         return false;
 421                     }
 422                 }
 423 
 424             }
 425 
 426             else
 427             {
 428                 return false;
 429             }
 430         }
 431         else
 432         {
 433             int i = 0;
 434             CString strTmp;
 435             while(AfxExtractSubString(strTmp,m_strContent,i,';'))
 436             {
 437                 CString strTmpdot;
 438                 int ipos = 0;
 439                 while(AfxExtractSubString(strTmpdot,strTmp,ipos,','))
 440                 {
 441                     ipos++;
 442                     switch(ipos)
 443                     {
 444                     case 1:
 445                         strLeft = strTmpdot;
 446                         break;
 447                     case 2:
 448                         strMid = strTmpdot;
 449                         break;
 450                     case 3:
 451                         strRight = strTmpdot;
 452                         break;
 453                     case 4:
 454                         strLast = strTmpdot;
 455                         break;
 456                     }
 457                 }
 458                 if (strLeft == strLeft.SpanIncluding("0123456789.")
 459                     && strRight == strRight.SpanIncluding("0123456789.")
 460                     && strMid == strMid.SpanIncluding("0123456789.")
 461                     && strLast == strLast.SpanIncluding("0123456789."))
 462                 {
 463                     m_MinMax[i][0] = atoi(strLeft);
 464                     m_MinMax[i][1] = atoi(strMid);
 465                     m_MinMax[i][2] = atoi(strRight);
 466                     m_MinMax[i][3] = atoi(strLast);
 467                     i++;
 468                     continue;
 469                 }
 470                 else
 471                 {
 472                     return false;
 473                 }
 474             }
 475             SetRow(i);
 476         }
 477         m_bFlag = 1;
 478     }
 479     return true;
 480 }
 481 
 482 bool Cfyq_scope::ReplaceScope(CString strTemp)
 483 {
 484     m_strContent = strTemp;
 485     memset(m_MinMax, -1, sizeof(m_MinMax));
 486     CString strLeft, strMid, strRight, strLast;
 487     int nMidIndex;
 488     //上下限
 489     if (m_strContent == m_strContent.SpanIncluding("0123456789.-"))
 490     {
 491         if (m_strContent == m_strContent.SpanIncluding("0123456789."))
 492         {
 493             m_MinMax[0][0] = 0;
 494             m_MinMax[0][1] = atoi(m_strContent);
 495             return true;
 496         }
 497         else
 498         {
 499             nMidIndex = m_strContent.Find("-");
 500             strLeft = m_strContent.Left(nMidIndex);
 501             strRight = m_strContent.Mid(nMidIndex + 1, m_strContent.GetLength() - 1);
 502             if (strLeft == strLeft.SpanIncluding("0123456789.")
 503                 && strRight == strRight.SpanIncluding("0123456789."))
 504             {
 505                 m_MinMax[0][0] = atoi(strLeft);
 506                 m_MinMax[0][1] = atoi(strRight);
 507                 m_MinMax[0][2] = 0;
 508                 return true;
 509             }
 510             else
 511             {
 512                 return false;
 513             }
 514         }
 515         m_bFlag = 0;
 516         SetRow(0);
 517     }
 518     //数轴
 519     else
 520     {
 521         if (m_strContent.Find(";") == -1)
 522         {
 523             int nMidIndex = m_strContent.Find(',') == -1;
 524             if (nMidIndex != -1)
 525             {
 526                 SetRow(1);
 527                 if (m_strContent.Find(',') != -1)
 528                 {
 529                     CString strTmp;
 530                     int ipos = 0;
 531                     while (AfxExtractSubString(strTmp, m_strContent, ipos, ','))
 532                     {
 533                         ipos++;
 534                         switch (ipos)
 535                         {
 536                         case 1:
 537                             strLeft = strTmp;
 538                             break;
 539                         case 2:
 540                             strMid = strTmp;
 541                             break;
 542                         case 3:
 543                             strRight = strTmp;
 544                             break;
 545                         case 4:
 546                             strLast = strTmp;
 547                         }
 548                     }
 549                     if (strLeft == strLeft.SpanIncluding("0123456789.")
 550                         && strRight == strRight.SpanIncluding("0123456789.")
 551                         && strMid == strMid.SpanIncluding("0123456789.")
 552                         && strLast == strLast.SpanIncluding("0123456789."))
 553                     {
 554                         m_MinMax[0][0] = atoi(strLeft);
 555                         m_MinMax[0][1] = atoi(strMid);
 556                         m_MinMax[0][2] = atoi(strRight);
 557                         m_MinMax[0][3] = atoi(strLast);
 558                         return true;
 559                     }
 560                     else
 561                     {
 562                         return false;
 563                     }
 564                 }
 565 
 566             }
 567 
 568             else
 569             {
 570                 return false;
 571             }
 572         }
 573         else
 574         {
 575             int i = 0;
 576             CString strTmp;
 577             while (AfxExtractSubString(strTmp, m_strContent, i, ';'))
 578             {
 579                 CString strTmpdot;
 580                 int ipos = 0;
 581                 while (AfxExtractSubString(strTmpdot, strTmp, ipos, ','))
 582                 {
 583                     ipos++;
 584                     switch (ipos)
 585                     {
 586                     case 1:
 587                         strLeft = strTmpdot;
 588                         break;
 589                     case 2:
 590                         strMid = strTmpdot;
 591                         break;
 592                     case 3:
 593                         strRight = strTmpdot;
 594                         break;
 595                     case 4:
 596                         strLast = strTmpdot;
 597                         break;
 598                     }
 599                 }
 600                 if (strLeft == strLeft.SpanIncluding("0123456789.")
 601                     && strRight == strRight.SpanIncluding("0123456789.")
 602                     && strMid == strMid.SpanIncluding("0123456789.")
 603                     && strLast == strLast.SpanIncluding("0123456789."))
 604                 {
 605                     m_MinMax[i][0] = atoi(strLeft);
 606                     m_MinMax[i][1] = atoi(strMid);
 607                     m_MinMax[i][2] = atoi(strRight);
 608                     m_MinMax[i][3] = atoi(strLast);
 609                     i++;
 610                     continue;
 611                 }
 612                 else
 613                 {
 614                     return false;
 615                 }
 616             }
 617             SetRow(i);
 618         }
 619         m_bFlag = 1;
 620     }
 621     return true;
 622 }
 623 
 624 bool Cfyq_scope::SetScopeToName(Cfyq_Interpreter* pInterpreter)
 625 {
 626     pInterpreter->GetCurName()->SetScope(this);
 627     return true;
 628 }
 629 
 630 int Cfyq_scope::GetFlag()
 631 {
 632     return m_bFlag;
 633 }
 634 
 635 void Cfyq_scope::Serialize(CArchive& ar)
 636 {
 637     Cfyq_node::Serialize(ar);
 638     int rightcode = 1;
 639     if(ar.IsStoring())
 640     {
 641         ar << rightcode;
 642         ar << m_bFlag;
 643         ar << m_nrow;
 644         if(m_nrow)
 645         for(int i = 0;i < m_nrow;++i)
 646             for(int j = 0;j < 4;++j)
 647         {
 648             ar << m_MinMax[i][j];
 649         }
 650     }
 651     else
 652     {
 653         ar >> rightcode;
 654         ar >> m_bFlag;
 655         ar >> m_nrow;
 656         if (m_nrow)
 657         for (int i = 0; i < m_nrow; ++i)
 658             for (int j = 0; j < 4; ++j)
 659             {
 660                 ar >> m_MinMax[i][j];
 661             }
 662     }
 663     
 664 }
 665 
 666 void Cfyq_scope::ErrorMsg(CString& str)
 667 {
 668     CString strTmp = "范围出现错误！
";
 669     str += strTmp;
 670 }
 671 
 672 int Cfyq_scope::Accept(Cfyq_Interpreter* pInterpreter, char input)
 673 {
 674     if( Cfyq_Interpreter::IsTrueChar( input ) )
 675         return AppendChar(pInterpreter, input);
 676 
 677     switch( input )
 678     {
 679     case '=':
 680     case ':':
 681     case '{':
 682             return 2;
 683     case ']':
 684         {
 685             SetClose(true);
 686 
 687             if(pInterpreter->NextStrIsIgnoreSpace("=")||pInterpreter->NextStrIsIgnoreSpace(":")||pInterpreter->NextStrIsIgnoreSpace("->")
 688             ||pInterpreter->NextStrIsIgnoreSpace("{"))
 689                 return 3;
 690             else
 691                 return 0;
 692         }
 693     case '-':
 694         {
 695             if(pInterpreter->NextStrIs(">"))
 696                 return 2;
 697             m_strContent += input;
 698             return 1;
 699         }
 700     case ',':
 701         {
 702             m_strContent += input;
 703             return 1;
 704         }
 705     case ';':
 706         {
 707             m_strContent += input;
 708             return 1;
 709         }
 710     }
 711 
 712     return 0;
 713 }
 714 
 715 bool Cfyq_scope::NextNode(Cfyq_Interpreter* pInterpreter, char input)
 716 {
 717     if(!IsClose())
 718         return false;
 719     if(!SetScope())
 720         return false;
 721     else
 722         SetScopeToName(pInterpreter);
 723     switch( input )
 724     {
 725     case '=':
 726         {
 727             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
 728             return true;
 729         }
 730     case '-':
 731         {
 732             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
 733             return true;
 734         }
 735     case ':':
 736         {
 737             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
 738             return true;
 739         }
 740     case '{':
 741         {
 742             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Jzj));
 743             return true;
 744         }
 745     default:
 746         return false;
 747     }
 748 }
 749 
 750 
 751 CFyq_NodeKind Cfyq_scope::GetNodeGrade()
 752 {
 753     return FNK_Scope;
 754 }
 755 
 756 Cfyq_scope::Cfyq_scope()
 757 {
 758     memset(m_MinMax,-1,sizeof(m_MinMax));
 759     m_bFlag = -1; 
 760     m_nrow = 0;
 761 }
 762 
 763 Cfyq_scope::~Cfyq_scope()
 764 {
 765 
 766 }
 767 
 768 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 769 
 770 IMPLEMENT_SERIAL( Cfyq_opt, Cfyq_node, 0)
 771 
 772 void Cfyq_opt::Serialize(CArchive& ar)
 773 {
 774     int rightcode = 1;
 775     if( ar.IsStoring() )
 776     { 
 777         ar << rightcode;
 778     }
 779     else
 780     {
 781         ar >> rightcode;
 782     }
 783 
 784 }
 785 
 786 Cfyq_opt::Cfyq_opt()
 787 {
 788 
 789 }
 790 
 791 Cfyq_opt::~Cfyq_opt()
 792 {
 793 
 794 }
 795 
 796 int Cfyq_offset::Accept(Cfyq_Interpreter* pInterpreter, char input)
 797 {
 798     if(input == ' ')
 799         return 3;
 800     if( Cfyq_Interpreter::IsTrueChar( input ) )
 801         return 0;
 802 
 803     switch( input )
 804     {
 805     case '>':
 806         {
 807             if(pInterpreter->NextStrIsIgnoreSpace("$("))
 808                 return 3;
 809             else
 810                 return 0;
 811         }
 812     case '$':
 813         {
 814             if(pInterpreter->NextStrIsIgnoreSpace("("))
 815                 return 2;
 816             else
 817                 return 0;
 818         }
 819     }
 820 
 821     return 0;
 822 }
 823 
 824 bool Cfyq_offset::NextNode(Cfyq_Interpreter* pInterpreter, char input)
 825 {
 826     switch( input )
 827     {
 828     case '$':
 829         {
 830             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Value));
 831             return true;
 832         }
 833     default:
 834         return false;
 835     }
 836 }
 837 IMPLEMENT_SERIAL( Cfyq_offset, Cfyq_opt, 0)
 838 Cfyq_offset::Cfyq_offset()
 839 {
 840     Cfyq_Name* m_pName = NULL;
 841     int m_bcanSerial = 0;
 842 }
 843 
 844 void Cfyq_offset::Serialize(CArchive& ar)
 845 {
 846     int rightcode = 1;
 847     Cfyq_node::Serialize(ar);
 848     CString tmpStr;
 849     if( ar.IsStoring() )
 850     { 
 851         ar << rightcode;
 852         ar << m_bcanSerial;
 853         if (m_bcanSerial)
 854         {
 855             m_pName->Serialize(ar);
 856         }
 857     }
 858     else
 859     {
 860         ar >> rightcode;
 861         ar >> m_bcanSerial;
 862         if (m_bcanSerial)
 863         {
 864             m_pName = new Cfyq_Name();
 865             m_pName->Serialize(ar);
 866         }
 867     }
 868 }
 869 
 870 void Cfyq_offset::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
 871 {
 872     if (m_pName)
 873     {
 874         m_pName->NextBackNode(node, str, pInterpreter, 1);
 875     }
 876     str += "->";
 877     pInterpreter->ChangeBackNode(node);
 878 }
 879 
 880 void Cfyq_offset::SetFyqName(Cfyq_Name* val)
 881 {
 882     m_pName = val;
 883     m_bcanSerial = 1;
 884 }
 885 
 886 Cfyq_Name* Cfyq_offset::GetFyqName()
 887 {
 888     return m_pName;
 889 }
 890 
 891 void Cfyq_expression::Calc(CString& str)
 892 {
 893 //     GetVarFromTree();
 894 //     double bj = 1010,jzj = 500;
 895 // 
 896 //     double Acost = (bj - jzj ) / jzj;//偏离率
 897 //     if ( bEqual(Acost, 0 ,MinE))
 898 //     {
 899 //         m_dValue = m_pInterpreter->GetScope(1,1);
 900 //         m_sValue.Format( "基准价：%s，无偏离 ，得分：%s" , GetForamtedNumber(m_dValue), GetForamtedNumber(m_dValue) );
 901 //         str = m_sValue;
 902 //         return;
 903 //     }
 904 // 
 905 //     CString sAcost,sbj,sjzj,sbdiv;
 906 //     sbj = GetForamtedNumber(bj),sjzj = GetForamtedNumber(jzj);
 907 //     sAcost.Format(  "(%s-%s)/%s" ,sbj, sjzj,sjzj );
 908 // 
 909 // 
 910 //     double step   = GetdVar(0);
 911 //     step = step / 100;
 912 //     int bdiv      = Keep0Bit( Acost / step );
 913 //     double kj_zpc = GetdVar(1);
 914 //     double kj_fpc = GetdVar(2);
 915 // 
 916 //     if (Acost > 0) 
 917 //     {
 918 //         m_dValue = m_pInterpreter->GetScope(0,1) - bdiv * kj_zpc;
 919 //         m_sValue.Format( "基准价：%s，偏离率：%s 报价得分：%s - %d*%s" , 
 920 //             GetForamtedNumber(jzj), 
 921 //             GetForamtedNumber(Acost), 
 922 //             GetForamtedNumber(m_pInterpreter->GetScope(0,1)), bdiv, GetForamtedNumber(kj_zpc) );
 923 //     }
 924 //     else
 925 //     {
 926 //         m_dValue = m_pInterpreter->GetScope(0,1) + bdiv * kj_zpc;
 927 //         m_sValue.Format( "基准价：%s，偏离率：%s 报价得分：%s + %d*%s" , 
 928 //             GetForamtedNumber(jzj), 
 929 //             GetForamtedNumber(Acost), 
 930 //             GetForamtedNumber(m_pInterpreter->GetScope(0,1)), bdiv, GetForamtedNumber(kj_zpc) );
 931 //     }
 932 // 
 933 // 
 934 //     if ( m_dValue < 0)
 935 //         m_dValue = 0;
 936 //     str = m_sValue;
 937 //     return ;
 938 };
 939 
 940 IMPLEMENT_SERIAL( Cfyq_expression, Cfyq_Name, 0)
 941 Cfyq_expression::Cfyq_expression()
 942 {
 943     m_pInterpreter = new Cfyq_Interpreter();
 944     m_nrow = 0;
 945 
 946     //m_pScoringSystemDefine = NULL;
 947 }
 948 
 949 Cfyq_expression::~Cfyq_expression()
 950 { 
 951     if ( m_pInterpreter )
 952     {
 953         delete m_pInterpreter;
 954         m_pInterpreter = NULL;
 955     }
 956     ClearVecPtr(m_vecVar);
 957 }
 958 
 959 bool Cfyq_expression::InitExpression(const CString& expression )
 960 {
 961     //解析公式
 962 
 963     if(!m_pInterpreter->Interpreter(expression))
 964         return false;        
 965 
 966     //拿到解析到的Vec
 967     vec_fyq_Node& vecExpression = m_pInterpreter->GetvecExpression();
 968 
 969     //获得根节点
 970     Cfyq_Name* FirstName = nullptr;
 971 
 972     Cfyq_node* root = this;
 973 
 974     Cfyq_node* pCurNode = root;
 975     Cfyq_Name* pCurName = nullptr;
 976     for(auto it = vecExpression.begin(); it!=vecExpression.end(); it++)
 977     {
 978         if(!FirstName)
 979         {
 980             FirstName = (Cfyq_Name*)(*it);
 981             this->m_strContent = FirstName->GetContent();
 982             this->m_sParam = FirstName->GetParam();
 983             this->m_pScope = FirstName->GetScope();
 984             continue;
 985         }
 986         if (FNK_Set == (*it)->GetNodeGrade())
 987         {
 988             root->m_vecSubNode.push_back(*it);
 989             pCurNode = *it;
 990         }
 991         else if( FNK_Define == (*it)->GetNodeGrade())
 992         {
 993             root->m_vecSubNode.push_back(*it);
 994             pCurNode = *it;
 995         }
 996         else if( FNK_Offset == (*it)->GetNodeGrade() )
 997         {
 998             pCurNode->m_vecSubNode.push_back(*it);
 999             pCurNode = (*it);
1000             Cfyq_offset* offset = (Cfyq_offset*)(*it);
1001             if(!pCurName)
1002                 return false;
1003             offset->SetFyqName(pCurName);
1004         }
1005         else if( FNK_Const == (*it)->GetNodeGrade() || FNK_Value == (*it)->GetNodeGrade() )
1006         {
1007             pCurNode->m_vecSubNode.push_back(*it);
1008         }
1009         else if( FNK_Name == (*it)->GetNodeGrade() )
1010         {
1011             pCurName =  (Cfyq_Name*)(*it);
1012             m_nrow = pCurName->GetScope()->GetRow();
1013             m_njzjKind = pCurName->Getjzj()->m_nkind;
1014         }
1015     }
1016     return true;
1017 };//初始化
1018 
1019 
1020 
1021 void Cfyq_expression::BackExpression()
1022 {
1023     m_strToDB = "";
1024     m_pInterpreter->backInterpreter(this, m_strToDB);
1025 }
1026 
1027 std::vector<std::vector<int>>& Cfyq_expression::GetScopeMinMax()
1028 {
1029     double dMinCount;
1030     double dMaxCount;
1031     double dMaxNumber;
1032     double dMinNumber;
1033     int k = 0;
1034     int curRow = 0;
1035     GetScopeFromTree();
1036     vecScope.clear();
1037     while(1)
1038     {
1039         dMinCount = GetScopeFromVec(1, 0, curRow);
1040         dMaxCount = GetScopeFromVec(1, 1, curRow);
1041         dMinNumber = GetScopeFromVec(1, 2, curRow);
1042         dMaxNumber = GetScopeFromVec(1, 3, curRow);
1043         if (dMinCount == -1 || dMaxCount == -1)
1044         {
1045             break;
1046         }
1047         vector<int> vec;
1048         vec.push_back(dMinCount);
1049         vec.push_back(dMaxCount);
1050         vec.push_back(dMaxNumber);
1051         vec.push_back(dMinNumber);
1052         vecScope.push_back(vec);
1053         curRow++;
1054     }
1055     return vecScope;
1056 }
1057 
1058 
1059 bool Cfyq_expression::toString()
1060 {
1061     GetVarFromTree();
1062     GetScopeFromTree();
1063     if(m_vecVar.empty())
1064     {
1065         m_sValue = "";
1066         return false;
1067     }
1068     double nStep = GetdVar(0);
1069     double nKja = GetdVar(1);
1070     double nKjb = GetdVar(2);
1071     double dMinCount;
1072     double dMaxCount;
1073     double dMaxNumber;
1074     double dMinNumber;
1075     CString txt1,txt2,txt3;
1076     CString str;
1077 
1078     int curRow = 0;
1079     if((dMaxCount = GetScopeFromVec(1,1,curRow++)) > -1)
1080     {
1081         str.Format("若有效标书小于等于%.0lf家,则不去掉最高最低价。
", dMaxCount);
1082         txt1 += str;
1083     }
1084     while(curRow < m_nrow)
1085     {
1086         dMinCount = GetScopeFromVec(1, 0, curRow);
1087         dMaxCount = GetScopeFromVec(1, 1, curRow);
1088         dMinNumber = GetScopeFromVec(1, 2, curRow);
1089         dMaxNumber = GetScopeFromVec(1, 3, curRow);
1090         if (curRow == m_nrow - 1)
1091         {
1092             str.Format("若有效标书大于等于%.0lf家,则去掉%.0lf个最高价和%.0lf个最低价。
", dMinCount, dMinNumber, dMaxNumber);
1093             txt1 += str;
1094             break;
1095         }
1096         curRow++;
1097         str.Format("若有效标书大于等于%.0lf家,小于%.0lf家,则去掉%.0lf个最高价和%.0lf个最低价。
", dMinCount,
1098             dMaxCount,dMaxNumber,dMinNumber);
1099         txt1 += str;
1100     }
1101     if( nKjb > 0 )
1102     {
1103         txt2.Format("每低于 %.2lf％扣 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKjb,nStep,nStep);
1104     }
1105     else
1106     {
1107         nKjb = 0 - nKjb;
1108         txt2.Format("每低于 %.2lf％加 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKjb,nStep,nStep);
1109     }
1110 
1111 
1112     if(nKja > 0 )
1113     {
1114         txt3.Format("每高于 %.2lf％扣 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKja,nStep,nStep);
1115     }
1116     else
1117     {
1118         nKja = 0 - nKja;
1119         txt3.Format("每高于 %.2lf％加 %.2lf 分（不足 %.2lf％按 %.2lf％计）。 
",nStep,nKja,nStep,nStep);
1120     }
1121     m_sValue = txt1 + txt2 + txt3;
1122     return true;
1123 }
1124 
1125 
1126 void Cfyq_expression::FindVar(vec_fyq_Var& m_VecVar,Cfyq_node *node)
1127 {
1128     if(node->GetNodeGrade() == FNK_Value)
1129     {
1130         if(std::find(m_VecVar.begin(), m_VecVar.end(), node) == m_VecVar.end())
1131             m_VecVar.push_back((Cfyq_Var*)node);
1132         return ;
1133     }
1134     for(int i  = 0;i < node->m_vecSubNode.size();++i)
1135     {
1136         FindVar(m_VecVar,node->m_vecSubNode[i]);
1137     }
1138 }
1139 
1140 vec_fyq_Var& Cfyq_expression::GetVarFromTree()
1141 {
1142     //ClearVecPtr(m_vecVar);
1143     FindVar(m_vecVar,this);
1144     return m_vecVar;
1145 }
1146 
1147 void Cfyq_expression::FindConst(vec_fyq_Const& m_VecConst,Cfyq_node *node)
1148 {
1149     if(node->GetNodeGrade() == FNK_Const)
1150     {
1151         if(std::find(m_vecConst.begin(), m_vecConst.end(), node) == m_vecConst.end())
1152             m_vecConst.push_back((Cfyq_const*)node);
1153         return ;
1154     }
1155     for(int i  = 0;i < node->m_vecSubNode.size();++i)
1156     {
1157         FindConst(m_vecConst,node->m_vecSubNode[i]);
1158     }
1159 }
1160 
1161 vec_fyq_Const& Cfyq_expression::GetConstFromTree()
1162 {
1163     FindConst(m_vecConst,this);
1164     return m_vecConst;
1165 }
1166 
1167 
1168 void Cfyq_expression::Serialize(CArchive& ar)
1169 {
1170     int rightcode = 1;
1171     Cfyq_node::Serialize(ar);
1172     if( ar.IsStoring() )
1173     { 
1174         ar << rightcode;
1175         ar << m_vecVar;
1176         ar << m_nrow;
1177     }
1178     else
1179     {
1180         ar >> rightcode;
1181         ar >> m_vecVar;
1182         ar >> m_nrow;
1183     }        
1184 }
1185 
1186 double Cfyq_expression::GetdVar(int index)
1187 {
1188     for(int i = 0;i < m_vecVar.size();++i)
1189     {
1190         if(i == index)
1191         {
1192             return m_vecVar[i]->m_dValue;
1193         }
1194     }
1195     return -1;
1196 }
1197 void Cfyq_expression::ChangeVecVarFromTree(const CString& strVar,double dval)
1198 {
1199     if (m_vecVar.empty())
1200     {
1201         GetVarFromTree();
1202     }
1203     auto it = find_if(m_vecVar.begin(), m_vecVar.end(), [strVar](const Cfyq_Var* var)
1204     {
1205         return var->m_sEngName.CompareNoCase(strVar) == 0;
1206     });
1207     if(it != m_vecVar.end())
1208     {
1209         CString strTemp;
1210         strTemp.Format("%lf", dval);
1211         (*it)->m_dValueToStr = strTemp;
1212         (*it)->m_dValue = dval;
1213     }
1214 }
1215 
1216 void Cfyq_expression::ChangeVecVarFromTree(const CString& strVar, CString str)
1217 {
1218     if (m_vecVar.empty())
1219     {
1220         GetVarFromTree();
1221     }
1222     auto it = find_if(m_vecVar.begin(), m_vecVar.end(), [strVar](const Cfyq_Var* var)
1223     {
1224         return var->m_sEngName.CompareNoCase(strVar) == 0;
1225     });
1226     if (it != m_vecVar.end())
1227     {
1228         (*it)->m_dValueToStr = str;
1229     }
1230 }
1231 
1232 void Cfyq_expression::FindScope(vec_fyq_Scope& m_vecScope, Cfyq_node* node)
1233 {
1234     if (node->GetNodeGrade() == FNK_Offset)
1235     {
1236         if (find(m_vecScope.begin(), m_vecScope.end(), ((Cfyq_offset*)node)->GetFyqName()->GetScope())
1237             == m_vecScope.end())
1238             m_vecScope.push_back(((Cfyq_offset*)node)->GetFyqName()->GetScope());
1239         return;
1240     }
1241     for_each(node->m_vecSubNode.begin(), node->m_vecSubNode.end(), [&](Cfyq_node* refer) {
1242         FindScope(m_vecScope, refer);
1243     });
1244 //     for each(Cfyq_node * tempnode in node->m_vecSubNode)
1245 //     {
1246 //         FindScope(m_vecScope, tempnode);
1247 //     }
1248 //     for (int i = 0; i < node->m_vecSubNode.size(); ++i)
1249 //     {
1250 //         FindScope(m_vecScope, node->m_vecSubNode[i]);
1251 //     }
1252 }
1253 
1254 vec_fyq_Scope& Cfyq_expression::GetScopeFromTree()
1255 {
1256     FindScope(m_vecScope, this);
1257     return m_vecScope;
1258 }
1259 
1260 double Cfyq_expression::GetScopeFromVec(int Flag, int index, int row)
1261 {
1262     for (auto it = m_vecScope.begin(); it != m_vecScope.end(); it++)
1263     {
1264         if ((*it) != NULL && Flag == ((Cfyq_scope*)(*it))->GetFlag())
1265         {
1266             switch (index)
1267             {
1268             case 0:
1269                 return ((Cfyq_scope*)(*it))->GetMinCount(row);
1270                 break;
1271             case 1:
1272                 return ((Cfyq_scope*)(*it))->GetMaxCount(row);
1273                 break;
1274             case 2:
1275                 return  ((Cfyq_scope*)(*it))->GetMin(row);
1276                 break;
1277             case 3:
1278                 return  ((Cfyq_scope*)(*it))->GetMax(row);
1279                 break;
1280             }
1281         }
1282     }
1283     return -1;
1284 }
1285 
1286 void Cfyq_expression::AddVar(vec_fyq_Var& m_VecVar, Cfyq_node* node, CString explain, CString doublestr)
1287 {
1288     if (node->GetNodeGrade() == FNK_Offset)
1289     {
1290         Cfyq_Var* var = new Cfyq_Var();
1291         var->m_sExplain = explain;
1292         var->m_dValueToStr = doublestr;
1293         var->m_strContent = explain + ":" + doublestr;
1294         auto vec = ((Cfyq_offset*)(node))->m_vecSubNode;
1295         auto it1 = find_if(vec.begin(), vec.end(), [var](Cfyq_node* node)
1296         {
1297             return var->m_strContent.CompareNoCase(node->m_strContent) == 0;
1298         });
1299         if (it1 == vec.end())
1300         {
1301             var->m_nLifePeriod = 1;
1302             ((Cfyq_offset*)(node))->m_vecSubNode.push_back(var);
1303         }
1304 
1305         auto it2 = find_if(m_VecVar.begin(), m_VecVar.end(), [var](Cfyq_node* node)
1306         {
1307             return var->m_strContent.CompareNoCase(node->m_strContent) == 0;
1308         });
1309         if (it2 == m_VecVar.end())
1310         {
1311             m_VecVar.push_back(var);
1312         }
1313         return;
1314     }
1315     for (int i = 0; i < node->m_vecSubNode.size(); ++i)
1316     {
1317         AddVar(m_VecVar, node->m_vecSubNode[i], explain, doublestr);
1318     }
1319 }
1320 
1321 void Cfyq_expression::AddVar(CString explain, CString doublestr)
1322 {
1323     GetVarFromTree();
1324     AddVar(m_vecVar, this, explain, doublestr);
1325 }
1326 
1327 vecCountDeal& Cfyq_expression::GetCountDeal()
1328 {
1329     m_vecCountDeal.clear();
1330     int dMinCount;
1331     int dMaxCount;
1332     int dMaxNumber;
1333     int dMinNumber;
1334     int curRow = 0;
1335     GetScopeFromTree();
1336     int start = 0;
1337     while (curRow < m_nrow)
1338     {
1339         dMinCount = GetScopeFromVec(1, 0, curRow);
1340         dMaxCount = GetScopeFromVec(1, 1, curRow);
1341         dMinNumber= GetScopeFromVec(1, 2, curRow);
1342         dMaxNumber= GetScopeFromVec(1, 3, curRow);
1343         CCountDeal deal(dMinCount, dMaxCount, dMinNumber, dMaxNumber);
1344         m_vecCountDeal.push_back(deal);
1345         curRow++;
1346     }
1347     return m_vecCountDeal;
1348 }
1349 
1350 void Cfyq_expression::AddJzjKind(Cfyq_node* node, long kind)
1351 {
1352     if (node->GetNodeGrade() == FNK_Offset)
1353     {
1354         CString str;
1355         str.Format("%d", kind);
1356         ((Cfyq_offset*)node)->GetFyqName()->Getjzj()->m_strContent = str;
1357         ((Cfyq_offset*)node)->GetFyqName()->Getjzj()->m_nkind = kind;
1358         return;
1359     }
1360     for (int i = 0; i < node->m_vecSubNode.size(); ++i)
1361     {
1362         AddJzjKind(node->m_vecSubNode[i], kind);
1363     }
1364 }
1365 
1366 void Cfyq_expression::AddJzjKind(long kind)
1367 {
1368     AddJzjKind(this, kind);
1369 }
1370 
1371 void Cfyq_expression::AddConst(vec_fyq_Const& m_vecConst, Cfyq_node* node, CString str)
1372 {
1373 
1374     if (node->GetNodeGrade() == FNK_Define)
1375     {
1376         Cfyq_const* pconst = new Cfyq_const();
1377         pconst->m_strContent = str;
1378         auto vec = ((Cfyq_offset*)(node))->m_vecSubNode;
1379         auto it1 = find_if(vec.begin(), vec.end(), [pconst](Cfyq_node* node)
1380         {
1381             return pconst->m_strContent.CompareNoCase(node->m_strContent) == 0;
1382         });
1383         if (it1 == vec.end())
1384         {
1385             ((Cfyq_offset*)(node))->m_vecSubNode.push_back(pconst);
1386         }
1387 
1388         auto it2 = find_if(m_vecConst.begin(), m_vecConst.end(), [pconst](Cfyq_node* node)
1389         {
1390             return pconst->m_strContent.CompareNoCase(node->m_strContent) == 0;
1391         });
1392         if (it2 == m_vecConst.end())
1393         {
1394             m_vecConst.push_back(pconst);
1395         }
1396         return;
1397     }
1398     for (int i = 0; i < node->m_vecSubNode.size(); ++i)
1399     {
1400         AddConst(m_vecConst, node->m_vecSubNode[i], str);
1401     }
1402 }
1403 
1404 void Cfyq_expression::AddConst(CString str)
1405 {
1406     GetConstFromTree();
1407     AddConst(m_vecConst, this, str);
1408     if (m_vecConst.empty())
1409     {
1410 
1411     }
1412 }
1413 
1414 bool Cfyq_expression::IsExistConst(const CString& strVar)
1415 {
1416     GetConstFromTree();
1417     auto it = find_if(m_vecConst.begin(), m_vecConst.end(), [strVar](Cfyq_const* pconst)
1418     {
1419         return strVar.CompareNoCase(pconst->m_strContent) == 0;
1420     });
1421     if(it == m_vecConst.end())
1422         return false;
1423     return true;
1424 }
1425 
1426 Cfyq_Interpreter::Cfyq_Interpreter( )
1427 {
1428     m_nCurIndex = 0;
1429     m_pCurNode = CreateNode(FNK_Name);
1430     m_pCurName = (Cfyq_Name*)m_pCurNode;
1431     m_vecExpression.push_back(GetCurNode());
1432     m_strFormula = "";
1433 
1434     m_name_obj.push_back( new CSysCodeKindDataInfo(  1, 1,"pdf", "pdf",0 ) );
1435     m_name_obj.push_back( new CSysCodeKindDataInfo(  2, 1,"rtf", "rtf",0 ) );
1436 
1437     //第二个参数为0不可复制
1438     m_name_obj.push_back( new CSysCodeKindDataInfo( 11, 0,"zz",     "资质/资格",0 ) );
1439     m_name_obj.push_back( new CSysCodeKindDataInfo( 12, 0,"yj",     "业绩",0 ) );
1440     m_name_obj.push_back( new CSysCodeKindDataInfo( 13, 0,"db",     "答辩",0 ) );
1441     m_name_obj.push_back( new CSysCodeKindDataInfo( 14, 0,"bj",     "报价得分",0 ) );
1442     m_name_obj.push_back( new CSysCodeKindDataInfo( 15, 0,"jzj", "基准价",0 ) );
1443     m_name_obj.push_back( new CSysCodeKindDataInfo( 16, 0,"hjqk", "获奖情况",0 ) );
1444     m_name_obj.push_back( new CSysCodeKindDataInfo( 17, 0,"tbxx", "投标信息",0 ) );
1445     m_name_obj.push_back( new CSysCodeKindDataInfo( 18, 0,"cgmx", "采购明细",0 ) );
1446     m_name_obj.push_back( new CSysCodeKindDataInfo( 19, 0,"khscore", "获奖情况",0 ) );
1447 
1448     m_param_obj.push_back( new CSysCodeKindDataInfo( 1, 1,"tbbj", "投标报价",0 ) );
1449     m_param_obj.push_back( new CSysCodeKindDataInfo( 2, 1,"csbj", "措施费用",0 ) );
1450     m_param_obj.push_back( new CSysCodeKindDataInfo( 3, 1,"qtbj", "其他费用",0 ) );
1451     m_param_obj.push_back( new CSysCodeKindDataInfo( 4, 1,"qd", "清单",0 ) );
1452     m_param_obj.push_back( new CSysCodeKindDataInfo( 5, 1,"kzj" , "控制价",0 ) );
1453 
1454     m_param_obj.push_back( new CSysCodeKindDataInfo( 11, 2,"corp", "单位",    0 ) );
1455     m_param_obj.push_back( new CSysCodeKindDataInfo( 12, 2,"emp" , "人员",    0 ) );
1456     m_param_obj.push_back( new CSysCodeKindDataInfo( 13, 2,"fzr" , "负责人",0 ) );
1457 
1458     m_param_obj.push_back( new CSysCodeKindDataInfo( 21, 3,"pf", "打分" ,0 ) );
1459     m_param_obj.push_back( new CSysCodeKindDataInfo( 22, 3,"hg" , "合格",0 ) );
1460     m_param_obj.push_back( new CSysCodeKindDataInfo( 23, 3,"pfml" , "打分+目录",0 ) );
1461     m_param_obj.push_back( new CSysCodeKindDataInfo( 24, 3,"hgml" , "合格+目录",0 ) );
1462 
1463 
1464     //const
1465     //m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"NoCopy" , "不可复制",0 ) );
1466     m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"OnlyOne" , "重复性检查",0 ) );
1467     m_const_obj.push_back( new CSysCodeKindDataInfo( 1, 0,"CheckQDZFile" , "检查QDZ是否存在",0 ) );
1468     m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "ParamChange", "参数是否可以修改", 0));
1469     m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "CalMethod", "计算方法", 0));
1470     m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "MaxMin", "去高去低", 0));
1471     m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "mb", "明标", 0));
1472     m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "ab", "暗标", 0));
1473     //m_const_obj.push_back(new CSysCodeKindDataInfo(1, 0, "Can", "去高去低", 0));
1474 };
1475 
1476 Cfyq_Interpreter::~Cfyq_Interpreter()
1477 {
1478     ClearVecPtr( m_name_obj  );
1479     ClearVecPtr( m_param_obj );
1480     ClearVecPtr( m_const_obj );
1481 };
1482 
1483 bool Cfyq_Interpreter::CheckName(  CString& title )
1484 {
1485     for( UINT i=0; i< m_name_obj.size(); i++ )
1486     {
1487         if( 0 == title.CompareNoCase( m_name_obj[i]->GetCode() ) )
1488         {
1489             return true;
1490         }
1491     }
1492     return false;
1493 };
1494 
1495 bool Cfyq_Interpreter::CheckParam( CString& title )
1496 {
1497     for( UINT i=0; i< m_param_obj.size(); i++ )
1498     {
1499         if( 0 == title.CompareNoCase( m_param_obj[i]->GetCode() ) )
1500         {
1501             return true;
1502         }
1503     }
1504     return false;    
1505 };
1506 
1507 bool Cfyq_Interpreter::CheckConst(CString& title)
1508 {
1509     for( UINT i=0; i< m_const_obj.size(); i++ )
1510     {
1511         if( 0 == title.CompareNoCase( m_const_obj[i]->GetCode() ) )
1512         {
1513             return true;
1514         }
1515     }
1516     return false;    
1517 }
1518 
1519 bool Cfyq_Interpreter::Interpreter(const CString& strFormula)
1520 {
1521     ClearVecPtr(m_vecExpression);
1522     m_strFormula = strFormula;
1523 
1524     m_nCurIndex = 0;
1525     m_pCurNode = CreateNode(FNK_Name);
1526     m_pCurName = (Cfyq_Name*)m_pCurNode;
1527     
1528     m_vecExpression.push_back(GetCurNode());
1529 
1530 
1531 
1532     if ( m_strFormula.IsEmpty())
1533         return false;
1534 
1535     m_strFormula.Trim();
1536     if(m_strFormula[m_strFormula.GetLength() - 1] != ';')
1537     {
1538         AfxMessageBox("表达式没有结束符!");
1539         return false;
1540     }
1541 
1542     for( m_nCurIndex=0; m_nCurIndex < m_strFormula.GetLength(); m_nCurIndex++  )
1543     {
1544         if( !push( m_strFormula[m_nCurIndex] ) )
1545         {
1546             CString strErrorMsg;
1547             strErrorMsg.Format("Error Index:%d ",m_nCurIndex);
1548             m_pCurNode->ErrorMsg(strErrorMsg);
1549             AfxMessageBox(strErrorMsg);
1550             return false;
1551         }
1552     };
1553 
1554     return true;
1555 }
1556 
1557 void Cfyq_Interpreter::backInterpreter(Cfyq_node* startName, CString& backstr)
1558 {
1559     startName->NextBackNode(startName, backstr, this, 0);
1560     pushback(startName, backstr);
1561     backstr += ";";
1562 }
1563 
1564 void Cfyq_Interpreter::pushback(Cfyq_node* startName, CString& backstr)
1565 {
1566     int len = startName->m_vecSubNode.size();
1567     if (!len)
1568     {
1569         return;
1570     }
1571     for (int i = 0; i < startName->m_vecSubNode.size(); ++i)
1572     {
1573         if (i == startName->m_vecSubNode.size() - 1)
1574             startName->m_vecSubNode[i]->NextBackNode(startName->m_vecSubNode[i], backstr, this, 1);
1575         else
1576             startName->m_vecSubNode[i]->NextBackNode(startName->m_vecSubNode[i], backstr, this, 0);
1577         pushback(startName->m_vecSubNode[i], backstr);
1578     }
1579 }
1580 
1581 bool Cfyq_Interpreter::push(char input)
1582 {
1583     Cfyq_node* pCurNode = GetCurNode();
1584     if( NULL == pCurNode)
1585         return false;
1586 
1587     switch( pCurNode->Accept( this, input ) )
1588     {
1589     case 1://可以接受
1590         return true;
1591     case 2://可以跳转
1592         return pCurNode->NextNode( this, input );
1593     case 3://忽略
1594         return true;
1595     default:
1596         return false;
1597     }
1598 }
1599 
1600 void Cfyq_Interpreter::ChangeNode(Cfyq_node* pNode)
1601 {
1602     m_vecExpression.push_back(pNode);
1603 
1604     if( FNK_Name == pNode->GetNodeGrade() )
1605         m_pCurName = (Cfyq_Name*)pNode;
1606 
1607     m_pCurNode = pNode;
1608 }
1609 
1610 void Cfyq_Interpreter::ChangeBackNode(Cfyq_node* pstate)
1611 {
1612     m_pCurBackNode = pstate;
1613 }
1614 
1615 bool Cfyq_Interpreter::IsTrueChar(char c)
1616 {
1617     if(('a'<=c && 'z'>=c) || 
1618         ('0'<=c && '9'>=c) ||
1619         ('A'<=c && 'Z'>=c) ||
1620         c == ' ' || c == '.')
1621     {
1622         return true;
1623     }
1624     return false;
1625 }
1626 
1627 bool Cfyq_Interpreter::IsChineseChar(char c)
1628 {
1629     if( c >= 0x80 || c<0 )
1630         return true;
1631 
1632     return false;
1633 }
1634 
1635 bool Cfyq_Interpreter::toString(CString& txt)
1636 {
1637 
1638     return true;
1639 }
1640 
1641 
1642 bool Cfyq_Interpreter::NextStrIs(const CString& str)
1643 {
1644     if(m_nCurIndex + 1 == m_strFormula.Find(str,m_nCurIndex))
1645         return true;
1646 
1647     return false;
1648 }
1649 
1650 bool Cfyq_Interpreter::NextStrIsIgnoreSpace(const CString& str)
1651 {
1652     if(0 == str.GetLength())
1653         return true;
1654     int n = 0;
1655     for(int index = m_nCurIndex+1; index<m_strFormula.GetLength(); index++)
1656     {
1657         if(m_strFormula.GetAt(index)==' ')
1658             continue;
1659         if(m_strFormula.GetAt(index)!=str.GetAt(n++))
1660             return false;
1661         if(n >= str.GetLength())
1662             return true;
1663     }
1664     return false;
1665 }
1666 
1667 bool Cfyq_Interpreter::LastStrIsIgnoreSpace(const CString& str)
1668 {
1669     if(0 == str.GetLength())
1670         return true;
1671     int n = str.GetLength()-1;
1672     for(int index = m_nCurIndex-1; index >= 0; index--)
1673     {
1674         if(m_strFormula.GetAt(index)==' ')
1675             continue;
1676         if(m_strFormula.GetAt(index)!=str.GetAt(n--))
1677             return false;
1678         if(n <= -1 )
1679             return true;
1680     }
1681     return false;
1682 }
1683 
1684 Cfyq_node* Cfyq_Interpreter::GetCurBackNode()
1685 {
1686     return m_pCurBackNode;
1687 }
1688 
1689 Cfyq_node* Cfyq_Interpreter::CreateNode(CFyq_NodeKind kind)
1690 {
1691     switch(kind)
1692     {
1693     case FNK_Name:
1694         return new Cfyq_Name();
1695     case FNK_Param:
1696         return new Cfyq_Param();
1697     case FNK_Scope:
1698         return new Cfyq_scope();
1699     case FNK_Const:
1700         return new Cfyq_const();
1701     case FNK_Value:
1702         return new Cfyq_Var();
1703     case FNK_Set:
1704         return new Cfyq_set();
1705     case FNK_Define:
1706         return new Cfyq_define();
1707     case FNK_Offset:
1708         return new Cfyq_offset();
1709     case FNK_Jzj:
1710         return new Cfyq_jzj();
1711     default:
1712         break;
1713     }
1714     return nullptr;
1715 }
1716 
1717 IMPLEMENT_SERIAL( Cfyq_Name, Cfyq_element, 0)
1718 
1719 int Cfyq_Name::Accept(Cfyq_Interpreter* pInterpreter, char input)
1720 {
1721     if( Cfyq_Interpreter::IsTrueChar( input ) )
1722         return AppendChar(pInterpreter, input);
1723 
1724     switch( input )
1725     {
1726     case ':':
1727     case '(':
1728     case '[':
1729     case '=':
1730         {
1731             return 2;
1732         }
1733     case '-':
1734         {
1735             if(pInterpreter->NextStrIs(">"))
1736                 return 2;
1737             else
1738                 return 0;
1739         }
1740     }
1741 
1742     return 0;
1743 }
1744 
1745 bool Cfyq_Name::NextNode(Cfyq_Interpreter* pInterpreter, char input)
1746 {
1747     if(!pInterpreter->CheckName(m_strContent))
1748     {
1749         return false;
1750     }
1751     switch( input )
1752     {
1753     case ':':
1754         {
1755             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Define));
1756             return true;
1757         }
1758     case '(':
1759         {
1760             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Param));
1761             return true;
1762         }
1763     case '[':
1764         {
1765             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Scope));
1766             return true;
1767         }
1768     case '=':
1769         {
1770             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
1771             return true;
1772         }
1773     case '-':
1774         {
1775             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
1776             return true;
1777         }
1778     default:
1779         return false;
1780     }
1781     return false;
1782 }
1783 
1784 CString Cfyq_Name::GetParam()
1785 {
1786     return m_sParam;
1787 }
1788 
1789 void Cfyq_Name::SetParam(CString val)
1790 {
1791     m_sParam = val;
1792 }
1793 
1794 Cfyq_scope* Cfyq_Name::GetScope()
1795 {
1796     return m_pScope;
1797 }
1798 
1799 Cfyq_Name::Cfyq_Name()
1800 {
1801     m_bcanSerial = 0;
1802     m_bcanSerialjzj = 0;
1803     m_pScope = NULL;
1804     m_pjzj = NULL;
1805     m_sParam = "";
1806 }
1807 
1808 Cfyq_Name::~Cfyq_Name()
1809 {
1810 
1811 }
1812 
1813 void Cfyq_Name::SetScope(Cfyq_scope* val)
1814 {
1815     m_pScope = val;
1816     m_bcanSerial = 1;
1817 }
1818 
1819 void Cfyq_Name::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
1820 {
1821     CString strTemp;
1822     str += m_strContent;
1823     if (!m_sParam.IsEmpty())
1824     {
1825         strTemp.Format("(%s)", m_sParam);
1826         str += strTemp;
1827     }
1828     if (m_pScope)
1829     {
1830         strTemp.Format("[%s]", m_pScope->m_strContent);
1831         str += strTemp;
1832     }
1833     if (m_pjzj)
1834     {
1835         strTemp.Format("{%s}", m_pjzj->m_strContent);
1836         str += strTemp;
1837     }
1838     pInterpreter->ChangeBackNode(node);
1839 }
1840 
1841 Cfyq_jzj* Cfyq_Name::Getjzj() const
1842 {
1843     return m_pjzj;
1844 }
1845 
1846 void Cfyq_Name::Setjzj(Cfyq_jzj* jzj)
1847 {
1848     m_bcanSerialjzj = 1;
1849     m_pjzj = jzj;
1850 }
1851 
1852 void Cfyq_Name::ErrorMsg(CString& str)
1853 {
1854     CString strTmp = "名字出现错误！
";
1855     str += strTmp;
1856 }
1857 
1858 CFyq_NodeKind Cfyq_Name::GetNodeGrade()
1859 {
1860     return FNK_Name;
1861 }
1862 
1863 void Cfyq_Name::Serialize(CArchive& ar)
1864 {
1865     Cfyq_node::Serialize(ar);
1866     
1867     int rightcode = 1;
1868     if(ar.IsStoring())
1869     {
1870         ar << rightcode;
1871         ar << m_sParam;
1872         ar << m_bcanSerial;
1873         if(m_bcanSerial)
1874             m_pScope->Serialize(ar);
1875     }
1876     else 
1877     {
1878         ar >> rightcode;
1879         ar >> m_sParam;
1880         ar >> m_bcanSerial;
1881         if(m_bcanSerial)
1882         {
1883             m_pScope = new Cfyq_scope();
1884             m_pScope->Serialize(ar);
1885         }
1886     }
1887 }
1888 
1889 IMPLEMENT_SERIAL( Cfyq_Param, Cfyq_element, 0)
1890 
1891 bool Cfyq_Param::SetParamToName(Cfyq_Interpreter* pInterpreter)
1892 {
1893     pInterpreter->GetCurName()->SetParam(m_strContent);
1894     return true;
1895 }
1896 
1897 int Cfyq_Param::Accept(Cfyq_Interpreter* pInterpreter, char input)
1898 {
1899     if( Cfyq_Interpreter::IsTrueChar( input ) )
1900         return AppendChar(pInterpreter, input);
1901 
1902     switch( input )
1903     {
1904     case '[':
1905         {
1906             return 2;        
1907         }
1908     case '=':
1909         {
1910             return 2;
1911         }
1912     case ')':
1913         {
1914             SetClose(true);//闭合
1915             if(pInterpreter->NextStrIsIgnoreSpace("[")||pInterpreter->NextStrIsIgnoreSpace("="))
1916                 return 3;
1917             else 
1918                 return 0;    
1919         }
1920     }
1921 
1922     return 0;
1923 }
1924 
1925 bool Cfyq_Param::NextNode(Cfyq_Interpreter* pInterpreter, char input)
1926 {
1927     if(!IsClose())
1928         return false;
1929     if(pInterpreter->CheckParam(m_strContent))
1930         SetParamToName(pInterpreter);
1931     else
1932         return false;
1933 
1934     switch( input )
1935     {
1936     case '[':
1937         {
1938             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Scope));
1939             return true;
1940         }
1941     case '=':
1942         {
1943             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Set));
1944             return true;
1945         }
1946     default:
1947         return false;
1948     }
1949     return false;
1950 }
1951 
1952 CFyq_NodeKind Cfyq_Param::GetNodeGrade()
1953 {
1954     return FNK_Param;
1955 }
1956 
1957 void Cfyq_Param::ErrorMsg(CString& str)
1958 {
1959     CString strTmp = "参数出现错误！
";
1960     str += strTmp;
1961 }
1962 
1963 Cfyq_Param::Cfyq_Param()
1964 {
1965 
1966 }
1967 
1968 void Cfyq_Param::Serialize(CArchive& ar)
1969 {
1970     Cfyq_node::Serialize(ar);
1971     int rightcode = 1;
1972     if(ar.IsStoring())
1973     {
1974         ar << rightcode;
1975     }
1976     else 
1977     {
1978         ar >> rightcode;
1979     }
1980 }
1981 
1982 IMPLEMENT_SERIAL( Cfyq_set, Cfyq_opt, 0)
1983 
1984 int Cfyq_set::Accept(Cfyq_Interpreter* pInterpreter, char input)
1985 {
1986     if(input == ' ')
1987         return 3;
1988     if( Cfyq_Interpreter::IsTrueChar( input ) )
1989         return 2;
1990 
1991     return 0;
1992 }
1993 
1994 bool Cfyq_set::NextNode(Cfyq_Interpreter* pInterpreter, char input)
1995 {
1996     pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Name));
1997     pInterpreter->GetCurNode()->m_strContent.AppendChar(input);
1998     pInterpreter->GetCurNode()->m_bStateInputChar = true;
1999     return true;
2000 }
2001 
2002 
2003 void Cfyq_set::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
2004 {
2005     str += "=";
2006     pInterpreter->ChangeBackNode(node);
2007 }
2008 
2009 CFyq_NodeKind Cfyq_set::GetNodeGrade()
2010 {
2011     return FNK_Set;
2012 }
2013 
2014 Cfyq_set::Cfyq_set()
2015 {
2016 
2017 }
2018 
2019 Cfyq_set::~Cfyq_set()
2020 {
2021 
2022 }
2023 
2024 void Cfyq_set::Serialize(CArchive& ar)
2025 {
2026     int rightcode = 1;
2027     Cfyq_node::Serialize(ar);
2028     if( ar.IsStoring() )
2029     { 
2030         ar << rightcode;
2031     }
2032     else
2033     {
2034         ar >> rightcode;
2035     }
2036 }
2037 
2038 IMPLEMENT_SERIAL( Cfyq_define, Cfyq_opt, 0)
2039 
2040 int Cfyq_define::Accept(Cfyq_Interpreter* pInterpreter, char input)
2041 {
2042     if(input == ' ')
2043         return 3;
2044     if( Cfyq_Interpreter::IsTrueChar( input ) )
2045         return 2;
2046 
2047     return 0;
2048 }
2049 
2050 bool Cfyq_define::NextNode(Cfyq_Interpreter* pInterpreter, char input)
2051 {
2052     pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Const));
2053     pInterpreter->GetCurNode()->m_strContent.AppendChar(input);
2054     pInterpreter->GetCurNode()->m_bStateInputChar = true;
2055     return true;
2056 }
2057 
2058 CFyq_NodeKind Cfyq_define::GetNodeGrade()
2059 {
2060     return FNK_Define;
2061 }
2062 
2063 void Cfyq_define::NextBackNode(Cfyq_node* node, CString& str, Cfyq_Interpreter* pInterpreter, bool bLast)
2064 {
2065     str += ":";
2066     pInterpreter->ChangeBackNode(node);
2067 }
2068 
2069 Cfyq_define::Cfyq_define()
2070 {
2071 
2072 }
2073 
2074 
2075 void Cfyq_define::Serialize(CArchive& ar)
2076 {
2077     int rightcode = 1;
2078     Cfyq_node::Serialize(ar);
2079     if( ar.IsStoring() )
2080     { 
2081         ar << rightcode;
2082     }
2083     else
2084     {
2085         ar >> rightcode;
2086     }
2087 }
2088 
2089 IMPLEMENT_SERIAL( Cfyq_element, Cfyq_node, 0)
2090 Cfyq_element::Cfyq_element() : m_bIsCloseFlag(false)
2091 {
2092 
2093 }
2094 
2095 bool Cfyq_element::IsClose()
2096 {
2097     return m_bIsCloseFlag;
2098 }
2099 
2100 void Cfyq_element::SetClose(bool val)
2101 {
2102     m_bIsCloseFlag = val;
2103 }
2104 
2105 int Cfyq_element::AppendChar(Cfyq_Interpreter* pInterpreter, char input)
2106 {
2107     //进入字符状态
2108     if(m_bStateInputChar)
2109     {
2110         if(input==' ')
2111             m_bStateInputChar = false;
2112         else
2113         {
2114             m_strContent += input;
2115             return 1;
2116         }
2117     }
2118     //非字符状态
2119     else
2120     {
2121         if(input != ' ')
2122         {
2123             if(m_strContent.GetLength() == 0)
2124             {
2125                 m_bStateInputChar = true;
2126                 m_strContent += input;
2127                 return 1;
2128             }
2129             else
2130                 return 0;
2131         }
2132     }
2133     return 3;
2134 }
2135 
2136 void Cfyq_element::Serialize(CArchive& ar)
2137 {
2138     int rightcode = 1;
2139     if(ar.IsStoring())
2140     {
2141         ar << rightcode;
2142     }
2143     else
2144     {
2145         ar >> rightcode;
2146     }
2147 }
2148 IMPLEMENT_SERIAL( Cfyq_jzj, Cfyq_element, 0)
2149 
2150 
2151 Cfyq_jzj::Cfyq_jzj()
2152 {
2153     m_nkind = -1;
2154     m_strContent = "";
2155 }
2156 
2157 Cfyq_jzj::~Cfyq_jzj()
2158 {
2159 
2160 }
2161 
2162 void Cfyq_jzj::Serialize(CArchive& ar)
2163 {
2164     Cfyq_node::Serialize( ar );
2165     int rightcode = 1; 
2166     if( ar.IsStoring() )
2167     {
2168         ar << rightcode;
2169     }
2170     else
2171     {
2172         ar >> rightcode;
2173     }
2174 }
2175 
2176 bool Cfyq_jzj::SetjzjToName(Cfyq_Interpreter* pInterpreter)
2177 {
2178     pInterpreter->GetCurName()->Setjzj(this);
2179     return true;
2180 }
2181 
2182 int Cfyq_jzj::Accept(Cfyq_Interpreter* pInterpreter, char input)
2183 {
2184     if( Cfyq_Interpreter::IsTrueChar( input ) )
2185         return AppendChar(pInterpreter, input);
2186     switch( input )
2187     {
2188     case '}':
2189         {
2190             SetClose(true);
2191             if(pInterpreter->NextStrIsIgnoreSpace("->"))
2192                 return 3;
2193             else
2194                 return 0;
2195         }
2196     case '-':
2197         {
2198             if(pInterpreter->NextStrIs(">"))
2199                 return 2;
2200             m_strContent += input;
2201             return 1;
2202         }
2203     }
2204 
2205     return 0;
2206 }
2207 
2208 bool Cfyq_jzj::NextNode(Cfyq_Interpreter* pInterpreter, char input)
2209 {
2210     if(!IsClose())
2211         return false;
2212     else
2213         SetjzjToName(pInterpreter);
2214     switch( input )
2215     {
2216     case '-':
2217         {
2218             pInterpreter->ChangeNode(pInterpreter->CreateNode(FNK_Offset));
2219             return true;
2220         }
2221     default:
2222         return false;
2223     }
2224 }
2225 
2226 CFyq_NodeKind Cfyq_jzj::GetNodeGrade()
2227 {
2228     return FNK_Jzj;
2229 }