LeftType
operator()(
LeftType left_,
RightType right_,
typename boost::enable_if<
at_least_one_operand_is_llvm_value< LeftType >
>::type* = 0
) {
plus< Context > oper_( tools );
assign< Context > assign_( tools );
return assign_( left_, oper_( left_, right_ ) );
}
Number Node::evaluteNode(List<Data> &var)
{
Number ret(0,0);
ret.decimalSystem = -1;
ret.ifInited = false;
ret.ifINF = false;
static int recursiveDepth = 0;
if (recursiveDepth == 25){
ret.decimalSystem = -1;
return ret;
}
if (this==nullptr){
ret.decimalSystem = 0;
return ret;
}
if (this->data.type == Word::cast::number)
return this->getValue();
if (this->data.type == Word::cast::variable){
//TODO: Find by name, not by value!
List<Data>::Node* mem = var.search(this->data);
if (mem!=nullptr){
recursiveDepth++;
Number ret;
if (mem->data.tree == nullptr) {
ret.setValue(0,1);
ret.decimalSystem = 10;
ret.ifInited = true;
ret.ifNumber = true;
} else
ret = mem->data.tree->evaluteNode(var);
recursiveDepth--;
return ret;
}else{
Number res(0,1);
res.decimalSystem = -2;
return res;
}
}
if (this->data.type == Word::cast::delimiter){
//Special construction for "="
bool isAssign = !strncmp(this->data.name,"=",1);
if (!strncmp(this->data.name,"==",2))
isAssign = false;
if (!strncmp(this->data.name,"]=",2))
isAssign = true;
if (!strncmp(this->data.name,"=[",2))
isAssign = true;
if (isAssign){
recursiveDepth++;
Node* ret = assign_(this->left,this->right,var);
Number result = ret->evaluteNode(var);
recursiveDepth--;
return result;
}
Number a,b;
if(this->left!=nullptr){
recursiveDepth++;
a = this->left->evaluteNode(var);
recursiveDepth--;
}else
a.decimalSystem=-1;
if(this->right!=nullptr){
recursiveDepth++;
b = this->right->evaluteNode(var);
recursiveDepth--;
} else
b.decimalSystem=-1;
recursiveDepth++;
Number ret = this->data.evalute(a,b);
recursiveDepth--;
return ret;
}
return ret;
}
Node * assign_( Node*l,Node*r,List<Data>& var)
{
Node* result;
if (l == nullptr || r==nullptr){
result = (r==nullptr)? l : r;
if (result == nullptr) {
result = new Node;
strcpy(result->data.name,"undef");
result->data.doesDataInited = true;
result->data.storedData.setValue(0,0);
result->data.priority = 30;
result->data.storedData.decimalSystem = -1;
return result;
} else
return result;
}
if (l->data.type != Word::variable && r->data.type != Word::variable)
{
result = new Node;
strcpy(result->data.name,"undef");
result->data.doesDataInited = true;
result->data.storedData.setValue(0,0);
result->data.storedData.ifBool = true;
result->data.priority = 30;
result->data.storedData.decimalSystem = -1;
return result;
}
if (l->data.type == Word::number || r->data.type == Word::number)
{
if (l->data.type == Word::number){
Node* temp = l; l = r; r = temp;
}
List<Data>::Node* mem = var.search(l->data);
if (mem!=nullptr){
result = r;
if (r->ifHasAssign())
mem->data.tree = assign_(r->left,r->right,var);
else {
mem->data.tree = r;
r->cutNode();
}
return mem->data.tree;
} else {
var.add(l->data);
mem = var.head;
mem->data.doesDataInited=false;
mem->data.doesTreeInited=true;
if (r->ifHasAssign())
mem->data.tree = assign_(r->left,r->right,var);
else {
mem->data.tree = r;
r->cutNode();
}
return mem->data.tree;
}
} else if (l->data.type == Word::delimiter || r->data.type == Word::delimiter)
{
if (l->data.type == Word::delimiter){
Node* temp = l; l = r; r = temp;
}
List<Data>::Node* mem = var.search(l->data);
if (mem!=nullptr){
result = r;
if (r->ifHasAssign())
mem->data.tree = assign_(r->left,r->right,var);
else{
mem->data.tree = r;
r->cutNode();
}
return mem->data.tree;
} else {
var.add(l->data);
mem = var.head;
mem->data.doesDataInited=false;
mem->data.doesTreeInited=true;
if (r->ifHasAssign())
mem->data.tree = assign_(r->left,r->right,var);
else {
mem->data.tree = r;
r->cutNode();
}
return mem->data.tree;
}
} else if (l->data.type == Word::variable && r->data.type == Word::variable)
{
List<Data>::Node* memL = var.search(l->data);
List<Data>::Node* memR = var.search(r->data);
if (memL == nullptr && memR == nullptr){
var.add(l->data);
var.head->data.tree= r;
r->cutNode();
return r;
} else if (memL != nullptr && memR != nullptr){
memL->data.tree = r;
r->cutNode();
return memL->data.tree;
} else if (memL == nullptr && memR != nullptr){
var.add(l->data);
var.head->data.tree = r;
r->cutNode();
return var.head->data.tree;
} else{
memL->data.tree = r;
r->cutNode();
return r;
}
} else {
result = new Node;
result->data.doesDataInited = true;
result->data.storedData.setValue(0,0);
result->data.storedData.ifBool = true;
result->data.priority = 30;
result->data.storedData.decimalSystem = -1;
return result;
}
return result;
}
