165 lines
3.3 KiB
C++
165 lines
3.3 KiB
C++
|
|
#include <stdlib.h>
|
|
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <typeinfo>
|
|
|
|
#include "nodes.h"
|
|
|
|
using namespace std;
|
|
|
|
void Node::evaluateChildren(refptr<Node> parent)
|
|
{
|
|
/* recursively evaluate all children nodes */
|
|
for (std::vector< refptr<Node> >::iterator it = m_children.begin();
|
|
it != m_children.end();
|
|
it++)
|
|
{
|
|
refptr<Node> evaluated = (*it)->evaluate();
|
|
if ( ! evaluated.isNull() )
|
|
{
|
|
if (typeid(*evaluated) == typeid(EvaluatePropagateNode))
|
|
{
|
|
for (vector<NodeRef>::iterator it2
|
|
= evaluated->getChildren().begin();
|
|
it2 != evaluated->getChildren().end();
|
|
it2++)
|
|
{
|
|
parent->addChild(*it2);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
(*it)->evaluateChildren(evaluated);
|
|
parent->addChild(evaluated);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Node::addChildren(NodeRef other)
|
|
{
|
|
if (other.isNull())
|
|
return;
|
|
|
|
for (vector<NodeRef>::const_iterator it = other->m_children.begin();
|
|
it != other->m_children.end();
|
|
it++)
|
|
{
|
|
addChild(*it);
|
|
}
|
|
}
|
|
|
|
Node::~Node()
|
|
{
|
|
}
|
|
|
|
NodeRef BinOpNode::evaluate()
|
|
{
|
|
double o = one->evaluate()->getNumber();
|
|
double t = two->evaluate()->getNumber();
|
|
double r = 0.0;
|
|
switch (m_op)
|
|
{
|
|
case '*':
|
|
r = o * t;
|
|
break;
|
|
case '/':
|
|
r = o / t;
|
|
break;
|
|
case '+':
|
|
r = o + t;
|
|
break;
|
|
case '-':
|
|
r = o - t;
|
|
break;
|
|
case '%':
|
|
r = (int) o % (int) t;
|
|
break;
|
|
default:
|
|
cerr << "Error: BinOpNode created with op '" << m_op << "'" << endl;
|
|
exit(-3);
|
|
}
|
|
return new NumberNode(r);
|
|
}
|
|
|
|
NodeRef BoolExpressionNode::evaluate()
|
|
{
|
|
double o, t;
|
|
double r = 0;
|
|
if (m_op != '!')
|
|
{
|
|
o = one->evaluate()->getNumber();
|
|
t = two->evaluate()->getNumber();
|
|
}
|
|
switch (m_op)
|
|
{
|
|
case '<':
|
|
r = o < t ? 1 : 0;
|
|
break;
|
|
case 'l':
|
|
r = o <= t ? 1 : 0;
|
|
break;
|
|
case '>':
|
|
r = o > t ? 1 : 0;
|
|
break;
|
|
case 'g':
|
|
r = o >= t ? 1 : 0;
|
|
break;
|
|
case '=':
|
|
r = o == t ? 1 : 0;
|
|
break;
|
|
case 'n':
|
|
r = o != t ? 1 : 0;
|
|
break;
|
|
case '!':
|
|
r = ! one->evaluate()->getInteger();
|
|
break;
|
|
case 'T':
|
|
r = 1;
|
|
break;
|
|
}
|
|
return new NumberNode(r);
|
|
}
|
|
|
|
NodeRef ForNode::evaluate()
|
|
{
|
|
NodeRef eval = new EvaluatePropagateNode();
|
|
|
|
if (!m_nodes[0].isNull())
|
|
{
|
|
m_nodes[0]->evaluate();
|
|
}
|
|
|
|
while (m_nodes[1]->evaluate()->getInteger() != 0)
|
|
{
|
|
evaluateChildren(eval);
|
|
|
|
if (!m_nodes[2].isNull())
|
|
{
|
|
m_nodes[2]->evaluate();
|
|
}
|
|
}
|
|
|
|
return eval;
|
|
}
|
|
|
|
NodeRef IfNode::evaluate()
|
|
{
|
|
NodeRef eval = new EvaluatePropagateNode();
|
|
|
|
int if_val = m_test_expr->evaluate()->getInteger();
|
|
|
|
if (if_val != 0)
|
|
{
|
|
evaluateChildren(eval);
|
|
}
|
|
else if ( ! m_elses.isNull() )
|
|
{
|
|
eval->addChild(m_elses->evaluate());
|
|
}
|
|
|
|
return eval;
|
|
}
|