kdelibs/khtml/xpath/predicate.cpp

/*
 * predicate.cc - Copyright 2005 Frerich Raabe   <raabe@kde.org>
 *                Copyright 2010 Maksim Orlovich <maksim@kde.org>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include "predicate.h"
#include "functions.h"

#include <QString>

#include "xml/dom_nodeimpl.h"
#include "xml/dom_nodelistimpl.h"
#include "kjs/operations.h"
#include "kjs/value.h"

#include <math.h>

using namespace DOM;
using namespace khtml;
using namespace khtml::XPath;

Number::Number( double value )
	: m_value( value )
{
}

bool Number::isConstant() const
{
	return true;
}

QString Number::dump() const
{
	return "<number>" + QString::number( m_value ) + "</number>";
}

Value Number::doEvaluate() const
{
	return Value( m_value );
}

String::String( const DOMString &value )
	: m_value( value )
{
}

bool String::isConstant() const
{
	return true;
}

QString String::dump() const
{
	return "<string>" + m_value.string() + "</string>";
}

Value String::doEvaluate() const
{
	return Value( m_value );
}

Value Negative::doEvaluate() const
{
	Value p( subExpr( 0 )->evaluate() );
	return Value( -p.toNumber() );
}

QString Negative::dump() const
{
	return "<negative>" + subExpr( 0 )->dump() + "</number>";
}

QString BinaryExprBase::dump() const
{
	QString s = "<" + opName() + ">";
	s += "<operand>" + subExpr( 0 )->dump() + "</operand>";
	s += "<operand>" + subExpr( 1 )->dump() + "</operand>";
	s += "</" + opName() + ">";
	return s;
}

NumericOp::NumericOp( int _opCode, Expression* lhs, Expression* rhs ) :
	opCode( _opCode )
{
	addSubExpression( lhs );
	addSubExpression( rhs );
}

Value NumericOp::doEvaluate() const
{
	Value lhs( subExpr( 0 )->evaluate() );
	Value rhs( subExpr( 1 )->evaluate() );
	double leftVal = lhs.toNumber(), rightVal = rhs.toNumber();

	switch (opCode) {
		case OP_Add:
			return Value( leftVal + rightVal );
		case OP_Sub:
			return Value( leftVal - rightVal );
		case OP_Mul:
			return Value( leftVal * rightVal );
		case OP_Div:
			if ( rightVal == 0.0 || rightVal == -0.0 ) {
				if ( leftVal == 0.0 || leftVal == -0.0) {
					return Value(); // 0/0 = NaN
				} else {
					// +/- Infinity.
					if (signbit(leftVal) == signbit(rightVal))
						return Value( KJS::Inf );
					else
						return Value( -KJS::Inf );
				}
			} else {
				return Value( leftVal / rightVal );
            }
		case OP_Mod:
			if ( rightVal == 0.0 || rightVal == -0.0 )
				return Value(); //Divide by 0;
			else
				return Value( remainder( leftVal, rightVal ) );
		default:
			assert(0);
		return Value();
	}
}

QString NumericOp::opName() const
{
	switch (opCode) {
		case OP_Add:
			return QLatin1String( "addition" );
		case OP_Sub:
			return QLatin1String( "subtraction" );
		case OP_Mul:
			return QLatin1String( "multiplication" );
		case OP_Div:
			return QLatin1String( "division" );
		case OP_Mod:
			return QLatin1String( "modulo" );
		default:
			assert(0);
			return QString();
	}
}

RelationOp::RelationOp( int _opCode, Expression* lhs, Expression* rhs ) :
	opCode( _opCode )
{
	addSubExpression( lhs );
	addSubExpression( rhs );
}

static void stringify(const Value& val, WTF::Vector<DOMString>* out)
{
	if (val.isString()) {
		out->append(val.toString());
	} else {
		assert(val.isNodeset());

		const DomNodeList& set = val.toNodeset();
		for (unsigned long i = 0; i < set->length(); ++i) {
			DOM::DOMString stringVal = stringValue(set->item(i));
			out->append(stringVal);
		}
	}
}

static void numify(const Value& val, WTF::Vector<double>* out)
{
	if (val.isNumber()) {
		out->append(val.toNumber());
	} else {
		assert(val.isNodeset());

		const DomNodeList& set = val.toNodeset();
		for (unsigned long i = 0; i < set->length(); ++i) {
			DOM::DOMString stringVal = stringValue(set->item(i));
			out->append(Value(stringVal).toNumber());
		}
	}
}

Value RelationOp::doEvaluate() const
{
	Value lhs( subExpr( 0 )->evaluate() );
	Value rhs( subExpr( 1 )->evaluate() );

	if (lhs.isNodeset() || rhs.isNodeset())
	{
		// If both are nodesets, or one is a string our
		// comparisons are based on strings.
		if ((lhs.isNodeset() && rhs.isNodeset()) ||
		    (lhs.isString()  || rhs.isString())) {

			WTF::Vector<DOM::DOMString> leftStrings;
			WTF::Vector<DOM::DOMString> rightStrings;

			stringify(lhs, &leftStrings);
			stringify(rhs, &rightStrings);

			for (unsigned pl = 0; pl < leftStrings.size(); ++pl) {
				for (unsigned pr = 0; pr < rightStrings.size(); ++pr) {
					if (compareStrings(leftStrings[pl], rightStrings[pr]))
						return Value(true);
				} // pr
			} // pl
			return Value(false);
		}

		// If one is a number, we do a number-based comparison
		if (lhs.isNumber() || rhs.isNumber()) {
			WTF::Vector<double> leftNums;
			WTF::Vector<double> rightNums;

			numify(lhs, &leftNums);
			numify(rhs, &rightNums);

			for (unsigned pl = 0; pl < leftNums.size(); ++pl) {
				for (unsigned pr = 0; pr < rightNums.size(); ++pr) {
					if (compareNumbers(leftNums[pl], rightNums[pr]))
						return Value(true);
				} // pr
			} // pl
			return Value(false);
		}

		// Has to be a boolean-based comparison.
		// These ones are simpler, since we just convert the nodeset to a bool		
		assert(lhs.isBoolean() || rhs.isBoolean());

		if (lhs.isNodeset())
			lhs = Value(lhs.toBoolean());
		else
			rhs = Value(rhs.toBoolean());
	} // nodeset comparisons
	

	if (opCode == OP_EQ || opCode == OP_NE) {
		bool equal;
		if ( lhs.isBoolean() || rhs.isBoolean() ) {
			equal = ( lhs.toBoolean() == rhs.toBoolean() );
		} else if ( lhs.isNumber() || rhs.isNumber() ) {
			equal = ( lhs.toNumber() == rhs.toNumber() );
		} else {
			equal = ( lhs.toString() == rhs.toString() );
		}

		if ( opCode == OP_EQ )
			return Value( equal );
		else
			return Value( !equal );

	}

	// For other ops, we always convert to numbers
	double leftVal = lhs.toNumber(), rightVal = rhs.toNumber();
	return Value(compareNumbers(leftVal, rightVal));
}


bool RelationOp::compareNumbers(double leftVal, double rightVal) const
{
	switch (opCode) {
		case OP_GT:
			return leftVal > rightVal;
		case OP_GE:
			return leftVal >= rightVal;
		case OP_LT:
			return leftVal < rightVal;
		case OP_LE:
			return leftVal <= rightVal;
		case OP_EQ:
			return leftVal == rightVal;
		case OP_NE:
			return leftVal != rightVal;
		default:
			assert(0);
			return false;
	}
}

bool RelationOp::compareStrings(const DOM::DOMString& l, const DOM::DOMString& r) const
{
	// String comparisons, as invoked within the nodeset case, are string-based
	// only for == and !=. Everything else still goes to numbers.
	if (opCode == OP_EQ)
		return (l == r);
	if (opCode == OP_NE)
		return (l != r);

	return compareNumbers(Value(l).toNumber(), Value(r).toNumber());
}

QString RelationOp::opName() const
{
	switch (opCode) {
		case OP_GT:
			return QLatin1String( "relationGT" );
		case OP_GE:
			return QLatin1String( "relationGE" );
		case OP_LT:
			return QLatin1String( "relationLT" );
		case OP_LE:
			return QLatin1String( "relationLE" );
		case OP_EQ:
			return QLatin1String( "relationEQ" );
		case OP_NE:
			return QLatin1String( "relationNE" );
		default:
			assert(0);
			return QString();
	}
}

LogicalOp::LogicalOp( int _opCode, Expression* lhs, Expression* rhs ) :
	opCode( _opCode )
{
	addSubExpression( lhs );
	addSubExpression( rhs );
}

bool LogicalOp::shortCircuitOn() const
{
	if (opCode == OP_And)
		return false; //false and foo
	else
		return true;  //true or bar
}

bool LogicalOp::isConstant() const
{
	return subExpr( 0 )->isConstant() &&
	       subExpr( 0 )->evaluate().toBoolean() == shortCircuitOn();
}

QString LogicalOp::opName() const
{
	if ( opCode == OP_And )
		return QLatin1String( "conjunction" );
	else
		return QLatin1String( "disjunction" );
}

Value LogicalOp::doEvaluate() const
{
	Value lhs( subExpr( 0 )->evaluate() );

	// This is not only an optimization, http://www.w3.org/TR/xpath
	// dictates that we must do short-circuit evaluation
	bool lhsBool = lhs.toBoolean();
	if ( lhsBool == shortCircuitOn() ) {
		return Value( lhsBool );
	}

	return Value( subExpr( 1 )->evaluate().toBoolean() );
}

QString Union::opName() const
{
	return QLatin1String("union");
}

Value Union::doEvaluate() const
{
	Value lhs = subExpr( 0 )->evaluate();
	Value rhs = subExpr( 1 )->evaluate();
	if ( !lhs.isNodeset() || !rhs.isNodeset() ) {
		kWarning(6011) << "Union operator '|' works only with nodesets.";
		Expression::reportInvalidExpressionErr();
		return Value( new StaticNodeListImpl );
	}

	DomNodeList lhsNodes = lhs.toNodeset();
	DomNodeList rhsNodes = rhs.toNodeset();
	DomNodeList result = new StaticNodeListImpl;

	for ( unsigned long n = 0; n < lhsNodes->length(); ++n )
		result->append( lhsNodes->item( n ) );

	for ( unsigned long n = 0; n < rhsNodes->length(); ++n )
		result->append( rhsNodes->item( n ) );
	
	return Value( result );
}

Predicate::Predicate( Expression *expr )
	: m_expr( expr )
{
}

Predicate::~Predicate()
{
	delete m_expr;
}

bool Predicate::evaluate() const
{
	Q_ASSERT( m_expr != 0 );

	Value result( m_expr->evaluate() );

	// foo[3] really means foo[position()=3]
	if ( result.isNumber() ) {
		return double( Expression::evaluationContext().position ) == result.toNumber();
	}

	return result.toBoolean();
}

void Predicate::optimize()
{
	m_expr->optimize();
}

QString Predicate::dump() const
{
	return QString() + "<predicate>" + m_expr->dump() + "</predicate>";
}

// kate: indent-width 4; replace-tabs off; tab-width 4; space-indent off;