nodes.cpp

表达式计算expression evaluate expression evaluate expression evaluate

    // Determine variable name
    ::std::string ident = parser[start].GetIdentifier();
    
    // Make sure it is not a constant
    if(vlist->IsConstant(ident))
    {
        ConstantAssignException e(ident);
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[v1].GetEnd());
        throw(e);
    }
        
    // Get address
    double *vaddr = vlist->GetAddress(ident);
    
    if(vaddr == 0)
    {
        // If it does not already exist, try to create it
        vlist->Add(ident);
        vaddr = vlist->GetAddress(ident);
    }
        
    if(vaddr == 0)
    {
        NotFoundException e(ident);
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[start].GetEnd());
        throw(e);
    }
        
    // Parse the node (will throw if it can not parse)
    auto_ptr<CNode> n(parser.ParseRegion(v1 + 1, end));
    
    // Set data
    m_var = vaddr;
    m_rhs = n.release();
}    
    

// Add node
//------------------------------------------------------------------------------

// Constructor
CAddNode::CAddNode(CExpression *expr) : CNode(expr), m_lhs(0), m_rhs(0)
{
}
    
// Destructor
CAddNode::~CAddNode()
{
    // Free child nodes
    delete m_lhs;
    delete m_rhs;
}
        
// Evaluate
double CAddNode::DoEvaluate()
{
    return m_lhs->Evaluate() + m_rhs->Evaluate();        
}
    
// Parse
void CAddNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(v1 <= start || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> left(parser.ParseRegion(start, v1 - 1));
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_lhs = left.release();
    m_rhs = right.release();
}
    
// Subtract node
//------------------------------------------------------------------------------

// Constructor
CSubtractNode::CSubtractNode(CExpression *expr) : CNode(expr), m_lhs(0), m_rhs(0)
{
}
    
// Destructor
CSubtractNode::~CSubtractNode()
{
    // Free child nodes
    delete m_lhs;
    delete m_rhs;
}
        
// Evaluate
double CSubtractNode::DoEvaluate()
{
    return m_lhs->Evaluate() - m_rhs->Evaluate();        
}
    
// Parse
void CSubtractNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(v1 <= start || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> left(parser.ParseRegion(start, v1 - 1));
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_lhs = left.release();
    m_rhs = right.release();
}    
    
// Multiply node
//------------------------------------------------------------------------------

// Constructor
CMultiplyNode::CMultiplyNode(CExpression *expr) : CNode(expr), m_lhs(0), m_rhs(0)
{
}
    
// Destructor
CMultiplyNode::~CMultiplyNode()
{
    // Free child nodes
    delete m_lhs;
    delete m_rhs;
}
        
// Evaluate
double CMultiplyNode::DoEvaluate()
{
    return m_lhs->Evaluate() * m_rhs->Evaluate();        
}
    
// Parse
void CMultiplyNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end,
        CParser::size_type v1)
{
    // Check some basic syntax
    if(v1 <= start || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> left(parser.ParseRegion(start, v1 - 1));
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_lhs = left.release();
    m_rhs = right.release();
}    
    
// Divide node
//------------------------------------------------------------------------------

// Constructor
CDivideNode::CDivideNode(CExpression *expr) : CNode(expr), m_lhs(0), m_rhs(0)
{
}
    
// Destructor
CDivideNode::~CDivideNode()
{
    // Free child nodes
    delete m_lhs;
    delete m_rhs;
}
        
// Evaluate
double CDivideNode::DoEvaluate()
{
    double r2 = m_rhs->Evaluate();
    
    if(r2 != 0.0)
    {
        return m_lhs->Evaluate() / r2;
    }
    else
    {
        throw(DivideByZeroException());
    }
}
    
// Parse
void CDivideNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(v1 <= start || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> left(parser.ParseRegion(start, v1 - 1));
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_lhs = left.release();
    m_rhs = right.release();
}    
    
// Negate node
//------------------------------------------------------------------------------

// Constructor
CNegateNode::CNegateNode(CExpression *expr) : Node(expr), m_rhs(0)
{
}
    
// Destructor
CNegateNode::~CNegateNode()
{
    // Free child nodes
    delete m_rhs;
}
        
// Evaluate
double CNegateNode::DoEvaluate()
{
    return -(m_rhs->Evaluate());        
}
    
// Parse
void CNegateNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(start != v1 || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_rhs = right.release();
}
    
// Exponent node
//------------------------------------------------------------------------------

// Constructor
CExponentNode::CExponentNode(CExpression *expr) : Node(expr), m_lhs(0), m_rhs(0)
{
}
    
// Destructor
CExponentNode::~CExponentNode()
{
    // Free child nodes
    delete m_lhs;
    delete m_rhs;
}
        
// Evaluate
double CExponentNode::DoEvaluate()
{
    errno = 0;
    
    double result =  pow(m_lhs->Evaluate(), m_rhs->Evaluate());
    
    if(errno)
    {
        throw(CMathException("^"));
    }       
    return result;        
}
    
// Parse
void CExponentNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(v1 <= start || v1 >= end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Parse sides
    auto_ptr<CNode> left(parser.ParseRegion(start, v1 - 1));
    auto_ptr<CNode> right(parser.ParseRegion(v1 + 1, end));
    
    m_lhs = left.release();
    m_rhs = right.release();
}    
    
// Variable node
//------------------------------------------------------------------------------

// Constructor
CVariableNode::CVariableNode(CExpression *expr) : CNode(expr), m_var(0)
{
}
    
// Destructor
CVariableNode::~CVariableNode()
{
}
        
// Evaluate
double CVariableNode::DoEvaluate()
{
    return *m_var;        
}
    
// Parse
void CVariableNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check some basic syntax
    if(start != end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Get value list
    CValueList *vlist = m_expr->GetValueList();
    if(vlist == 0)
    {
        CNoValueListException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[start].GetEnd());
        throw(e);
    }
    
    // Get name
    ::std::string ident = parser[start].GetIdentifier();
    
    // Get address
    double *vaddr = vlist->GetAddress(ident);
    
    if(vaddr == 0)
    {
        // If it does not already exist, try to create it
        vlist->Add(ident);
        vaddr = vlist->GetAddress(ident);
    }
        
    if(vaddr == 0)
    {
        CNotFoundException e(ident);
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[start].GetEnd());
        throw(e);
    }
        
    // Set information
    m_var = vaddr;
}            
    
// Value node
//------------------------------------------------------------------------------

// Constructor
CValueNode::CValueNode(CExpression *expr) : CNode(expr), m_val(0)
{
}
    
// Destructor
CValueNode::~CValueNode()
{
}
        
// Evaluate
double CValueNode::DoEvaluate()
{
    return m_val;        
}
    
// Parse
void CValueNode::Parse(CParser &parser, CParser::size_type start, CParser::size_type end, CParser::size_type v1)
{
    // Check basic syntax
    if(start != end)
    {
        CSyntaxException e;
        
        e.SetStart(parser[start].GetStart());
        e.SetEnd(parser[end].GetEnd());
        throw(e);
    }
        
    // Set info
    m_val = parser[start].GetValue();
}