fart/parser/nodes.cc

#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() )
    {
        return m_elses->evaluate();
    }

    return eval;
}

NodeRef ElseNode::evaluate()
{
    NodeRef eval = new EvaluatePropagateNode();
    evaluateChildren(eval);
    return eval;
}