修正变量求值的若干问题

sg-first · sg-first · commit 21b579613767 · 2018-10-16T23:54:57.000+08:00
diff --git a/ast.cpp b/ast.cpp
@@ -9,6 +9,8 @@ void ast::Init()
     BinOpPriority['*'] = 20;
     BinOpPriority['/'] = 20;
     BinOpPriority['^'] = 30;*/
+
+
 }
 
 bool isNum(const char &c) {
diff --git a/nodetype.cpp b/nodetype.cpp
@@ -14,9 +14,15 @@ BasicNode::~BasicNode()
     }
 }
 
-void VariableNode::setVal(BasicNode num)
+
+VariableNode::~VariableNode()
+{
+    delete this->val; //然后BasicNode析构
+}
+
+void VariableNode::setVal(BasicNode* num)
 {
-    if(isLiteral(&num))
+    if(isLiteral(num))
     {
         this->isEmpty=false;
         this->num=num;
@@ -25,6 +31,20 @@ void VariableNode::setVal(BasicNode num)
         throw string("The value of a variable must be literal");
 }
 
+BasicNode* VariableNode::eval()
+{
+    if(this->isEmpty)
+        return dynamic_cast<BasicNode*>(this);
+    else
+        return this->val;
+}
+
+void VariableNode::clearVal()
+{
+    this->isempty=true;
+    delete this->val;
+}
+
 
 void FunNode::addNode(BasicNode *node)
 {
@@ -41,13 +61,16 @@ void iterEval(BasicNode* &node)
         throw string("ProNode cannot be function's sonNode");
     else
     {
-        if(isLiteral(node)||node->getType()==Variable)
-            return; //如果是字面量和变量，自己就是求值结果，下面再重新赋值一次就重复了
+        if(isLiteral(node))
+            return; //如果是字面量，自己就是求值结果，下面再重新赋值一次就重复了
         else
         {
             BasicNode* result=node->eval();
-            delete node;
+            if(node->getType()!=Variable)
+                delete node;
             node=result; //节点的替换在这里（父节点）完成，子节点只需要返回即可
+            //对于已经赋值的变量，整体过程是用值替代本身变量在AST中的位置，不过变量本身并没有被析构，因为变量的所有权在scope（后面可能还要访问）
+            //对于未赋值的变量，求值结果是变量本身，AST没有变化
         }
     }
 }
diff --git a/nodetype.h b/nodetype.h
@@ -56,17 +56,17 @@ class StringNode : public BasicNode
 class VariableNode : public BasicNode
 {
 protected:
-    BasicNode val;
+    BasicNode* val=nullptr;
     bool isempty=true;
 public:
     virtual int getType() {return Variable;}
     virtual void addNode(BasicNode* node) {throw string("VariableNode no sonNode");}
-    virtual BasicNode* eval() {return dynamic_cast<BasicNode*>(this);}
+    virtual BasicNode* eval();
+    virtual ~VariableNode();
 
     bool isEmpty() {return this->isempty;}
-    void setVal(BasicNode val);
-    BasicNode getVal() {return this->val;}
-    void clearVal() {this->isempty=true;}
+    void setVal(BasicNode* val); //注意，传进来的应该是new出来的，传进来意味着转移所有权到本类
+    void clearVal();
 };
 
 
@@ -85,7 +85,7 @@ class Function
 {
 private:
     int parnum; //参数个数
-    ProNode* pronode; //是ret节点返回，最后一个元素视为返回值（如果没有填nullptr）
+    ProNode* pronode; //是ret节点返回，最后一个元素视为返回值（如果没有填nullptr）（fix:这个路子是错的，ret方式需要更改）
     bool VLP; //是否不进行参数个数检查
     //关于基础求值
     canBE canBEfun;
@@ -98,7 +98,7 @@ class Function
         parnum(parnum),canBEfun(canBEfun),BEfun(BEfun),VLP(VLP),iscanBE(true){} //调用到函数接口
     ~Function() {delete pronode;}
 
-    ProNode* getPronode() {return this->pronode;}
+    ProNode* getFunBody() {return this->pronode;}
     int getParnum() {return this->parnum;}
     bool isVLP() {return this->VLP;}
     BasicNode* eval(vector<BasicNode *> &sonNode);
@@ -115,5 +115,5 @@ class FunNode : public BasicNode
     virtual BasicNode* eval();
     FunNode(Function* funEntity):funEntity(funEntity){}
 
-    ProNode* getFunBody() {return this->funEntity->getPronode();}
+    ProNode* getFunBody() {return this->funEntity->getFunBody();}
 };
diff --git a/scope.cpp b/scope.cpp
@@ -4,7 +4,7 @@ Scope::~Scope()
 {
     for(auto i:this->functionList)
         delete i.second;
-    for(auto i:this->sonScope)
+    for(auto i:this->variableList)
         delete i.second;
     for(Scope* i:this->sonScope)
         delete i;
diff --git a/scope.h b/scope.h
@@ -6,7 +6,10 @@ class Scope
 {
 public:
     ~Scope();
-    map<string,VariableNode*> valueList;
+    map<string,VariableNode*> variableList;
     map<string,Function*> functionList;
     vector<Scope*> sonScope;
+
+    void addValue(string name) {this->variableList.insert(name,new VariableNode);} //先插进去后赋值
+    void addFunction(string name,Function* fun) {this->functionList.insert(name,fun);} //这个Function必须在外面先new好，因为参数比较多
 };

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ void ast::Init()`
`9`	`9`	`BinOpPriority['*'] = 20;`
`10`	`10`	`BinOpPriority['/'] = 20;`
`11`	`11`	`BinOpPriority['^'] = 30;*/`
	`12`	`+`
	`13`	`+`
`12`	`14`	`}`
`13`	`15`
`14`	`16`	`bool isNum(const char &c) {`
Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,15 @@ BasicNode::~BasicNode()`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`
`17`		`-void VariableNode::setVal(BasicNode num)`
	`17`	`+`
	`18`	`+VariableNode::~VariableNode()`
	`19`	`+{`
	`20`	`+ delete this->val; //然后BasicNode析构`
	`21`	`+}`
	`22`	`+`
	`23`	`+void VariableNode::setVal(BasicNode* num)`
`18`	`24`	`{`
`19`		`- if(isLiteral(&num))`
	`25`	`+ if(isLiteral(num))`
`20`	`26`	`{`
`21`	`27`	`this->isEmpty=false;`
`22`	`28`	`this->num=num;`
`@@ -25,6 +31,20 @@ void VariableNode::setVal(BasicNode num)`
`25`	`31`	`throw string("The value of a variable must be literal");`
`26`	`32`	`}`
`27`	`33`
	`34`	`+BasicNode* VariableNode::eval()`
	`35`	`+{`
	`36`	`+ if(this->isEmpty)`
	`37`	`+ return dynamic_cast<BasicNode*>(this);`
	`38`	`+ else`
	`39`	`+ return this->val;`
	`40`	`+}`
	`41`	`+`
	`42`	`+void VariableNode::clearVal()`
	`43`	`+{`
	`44`	`+ this->isempty=true;`
	`45`	`+ delete this->val;`
	`46`	`+}`
	`47`	`+`
`28`	`48`
`29`	`49`	`void FunNode::addNode(BasicNode *node)`
`30`	`50`	`{`
`@@ -41,13 +61,16 @@ void iterEval(BasicNode* &node)`
`41`	`61`	`throw string("ProNode cannot be function's sonNode");`
`42`	`62`	`else`
`43`	`63`	`{`
`44`		`- if(isLiteral(node)\|\|node->getType()==Variable)`
`45`		`- return; //如果是字面量和变量，自己就是求值结果，下面再重新赋值一次就重复了`
	`64`	`+ if(isLiteral(node))`
	`65`	`+ return; //如果是字面量，自己就是求值结果，下面再重新赋值一次就重复了`
`46`	`66`	`else`
`47`	`67`	`{`
`48`	`68`	`BasicNode* result=node->eval();`
`49`		`- delete node;`
	`69`	`+ if(node->getType()!=Variable)`
	`70`	`+ delete node;`
`50`	`71`	`node=result; //节点的替换在这里（父节点）完成，子节点只需要返回即可`
	`72`	`+ //对于已经赋值的变量，整体过程是用值替代本身变量在AST中的位置，不过变量本身并没有被析构，因为变量的所有权在scope（后面可能还要访问）`
	`73`	`+ //对于未赋值的变量，求值结果是变量本身，AST没有变化`
`51`	`74`	`}`
`52`	`75`	`}`
`53`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ Scope::~Scope()`
`4`	`4`	`{`
`5`	`5`	`for(auto i:this->functionList)`
`6`	`6`	`delete i.second;`
`7`		`- for(auto i:this->sonScope)`
	`7`	`+ for(auto i:this->variableList)`
`8`	`8`	`delete i.second;`
`9`	`9`	`for(Scope* i:this->sonScope)`
`10`	`10`	`delete i;`