/**
* Evaluates this Expr based on the given context node and processor state
* @param context the context node for evaluation of this Expr
* @param ps the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
* @see FunctionCall.h
**/
nsresult
GenerateIdFunctionCall::evaluate(txIEvalContext* aContext,
txAExprResult** aResult)
{
*aResult = nullptr;
if (!requireParams(0, 1, aContext))
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
txExecutionState* es =
static_cast<txExecutionState*>(aContext->getPrivateContext());
if (!es) {
NS_ERROR(
"called xslt extension function \"generate-id\" with wrong context");
return NS_ERROR_UNEXPECTED;
}
nsresult rv = NS_OK;
if (mParams.IsEmpty()) {
StringResult* strRes;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
txXPathNodeUtils::getXSLTId(aContext->getContextNode(),
es->getSourceDocument(),
strRes->mValue);
*aResult = strRes;
return NS_OK;
}
RefPtr<txNodeSet> nodes;
rv = evaluateToNodeSet(mParams[0], aContext,
getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
if (nodes->isEmpty()) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
StringResult* strRes;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
txXPathNodeUtils::getXSLTId(nodes->get(0), es->getSourceDocument(),
strRes->mValue);
*aResult = strRes;
return NS_OK;
}
/**
* Evaluates this Expr based on the given context node and processor state
* @param context the context node for evaluation of this Expr
* @param ps the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
* @see FunctionCall.h
**/
nsresult
GenerateIdFunctionCall::evaluate(txIEvalContext* aContext,
txAExprResult** aResult)
{
*aResult = nsnull;
if (!requireParams(0, 1, aContext))
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
nsresult rv = NS_OK;
if (mParams.IsEmpty()) {
StringResult* strRes;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
txXPathNodeUtils::getXSLTId(aContext->getContextNode(),
strRes->mValue);
*aResult = strRes;
return NS_OK;
}
nsRefPtr<txNodeSet> nodes;
rv = evaluateToNodeSet(mParams[0], aContext,
getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
if (nodes->isEmpty()) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
StringResult* strRes;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
txXPathNodeUtils::getXSLTId(nodes->get(0), strRes->mValue);
*aResult = strRes;
return NS_OK;
}
/*
* Evaluates this Expr based on the given context node and processor state
* @param context the context node for evaluation of this Expr
* @param ps the ContextState containing the stack information needed
* for evaluation
* @return the result of the evaluation
*/
nsresult
txCoreFunctionCall::evaluate(txIEvalContext* aContext, txAExprResult** aResult)
{
*aResult = nsnull;
if (!requireParams(descriptTable[mType].mMinParams,
descriptTable[mType].mMaxParams,
aContext)) {
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
}
nsresult rv = NS_OK;
switch (mType) {
case COUNT:
{
nsRefPtr<txNodeSet> nodes;
rv = evaluateToNodeSet(mParams[0], aContext,
getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
return aContext->recycler()->getNumberResult(nodes->size(),
aResult);
}
case ID:
{
nsRefPtr<txAExprResult> exprResult;
rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult));
NS_ENSURE_SUCCESS(rv, rv);
nsRefPtr<txNodeSet> resultSet;
rv = aContext->recycler()->getNodeSet(getter_AddRefs(resultSet));
NS_ENSURE_SUCCESS(rv, rv);
txXPathTreeWalker walker(aContext->getContextNode());
if (exprResult->getResultType() == txAExprResult::NODESET) {
txNodeSet* nodes = static_cast<txNodeSet*>
(static_cast<txAExprResult*>
(exprResult));
PRInt32 i;
for (i = 0; i < nodes->size(); ++i) {
nsAutoString idList;
txXPathNodeUtils::appendNodeValue(nodes->get(i), idList);
nsWhitespaceTokenizer tokenizer(idList);
while (tokenizer.hasMoreTokens()) {
if (walker.moveToElementById(tokenizer.nextToken())) {
resultSet->add(walker.getCurrentPosition());
}
}
}
}
else {
nsAutoString idList;
exprResult->stringValue(idList);
nsWhitespaceTokenizer tokenizer(idList);
while (tokenizer.hasMoreTokens()) {
if (walker.moveToElementById(tokenizer.nextToken())) {
resultSet->add(walker.getCurrentPosition());
}
}
}
*aResult = resultSet;
NS_ADDREF(*aResult);
return NS_OK;
}
case LAST:
{
return aContext->recycler()->getNumberResult(aContext->size(),
aResult);
}
case LOCAL_NAME:
case NAME:
case NAMESPACE_URI:
{
// Check for optional arg
nsRefPtr<txNodeSet> nodes;
if (!mParams.IsEmpty()) {
rv = evaluateToNodeSet(mParams[0], aContext,
getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
if (nodes->isEmpty()) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
}
const txXPathNode& node = nodes ? nodes->get(0) :
aContext->getContextNode();
switch (mType) {
case LOCAL_NAME:
{
StringResult* strRes = nsnull;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
*aResult = strRes;
txXPathNodeUtils::getLocalName(node, strRes->mValue);
return NS_OK;
}
case NAMESPACE_URI:
{
StringResult* strRes = nsnull;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
*aResult = strRes;
txXPathNodeUtils::getNamespaceURI(node, strRes->mValue);
return NS_OK;
}
case NAME:
{
// XXX Namespace: namespaces have a name
if (txXPathNodeUtils::isAttribute(node) ||
txXPathNodeUtils::isElement(node) ||
txXPathNodeUtils::isProcessingInstruction(node)) {
StringResult* strRes = nsnull;
rv = aContext->recycler()->getStringResult(&strRes);
NS_ENSURE_SUCCESS(rv, rv);
*aResult = strRes;
txXPathNodeUtils::getNodeName(node, strRes->mValue);
}
else {
aContext->recycler()->getEmptyStringResult(aResult);
}
return NS_OK;
}
default:
{
break;
}
}
}
case POSITION:
{
return aContext->recycler()->getNumberResult(aContext->position(),
aResult);
}
// String functions
case CONCAT:
{
nsRefPtr<StringResult> strRes;
rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 i, len = mParams.Length();
for (i = 0; i < len; ++i) {
rv = mParams[i]->evaluateToString(aContext, strRes->mValue);
NS_ENSURE_SUCCESS(rv, rv);
}
NS_ADDREF(*aResult = strRes);
return NS_OK;
}
case CONTAINS:
{
nsAutoString arg2;
rv = mParams[1]->evaluateToString(aContext, arg2);
NS_ENSURE_SUCCESS(rv, rv);
if (arg2.IsEmpty()) {
aContext->recycler()->getBoolResult(PR_TRUE, aResult);
}
else {
nsAutoString arg1;
rv = mParams[0]->evaluateToString(aContext, arg1);
NS_ENSURE_SUCCESS(rv, rv);
aContext->recycler()->getBoolResult(FindInReadable(arg2, arg1),
aResult);
}
return NS_OK;
}
case NORMALIZE_SPACE:
{
nsAutoString resultStr;
if (!mParams.IsEmpty()) {
rv = mParams[0]->evaluateToString(aContext, resultStr);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
txXPathNodeUtils::appendNodeValue(aContext->getContextNode(),
resultStr);
}
nsRefPtr<StringResult> strRes;
rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
NS_ENSURE_SUCCESS(rv, rv);
MBool addSpace = MB_FALSE;
MBool first = MB_TRUE;
strRes->mValue.SetCapacity(resultStr.Length());
PRUnichar c;
PRUint32 src;
for (src = 0; src < resultStr.Length(); src++) {
c = resultStr.CharAt(src);
if (XMLUtils::isWhitespace(c)) {
addSpace = MB_TRUE;
}
else {
if (addSpace && !first)
strRes->mValue.Append(PRUnichar(' '));
strRes->mValue.Append(c);
addSpace = MB_FALSE;
first = MB_FALSE;
}
}
*aResult = strRes;
NS_ADDREF(*aResult);
return NS_OK;
}
case STARTS_WITH:
{
nsAutoString arg2;
rv = mParams[1]->evaluateToString(aContext, arg2);
NS_ENSURE_SUCCESS(rv, rv);
PRBool result = PR_FALSE;
if (arg2.IsEmpty()) {
result = PR_TRUE;
}
else {
nsAutoString arg1;
rv = mParams[0]->evaluateToString(aContext, arg1);
NS_ENSURE_SUCCESS(rv, rv);
result = StringBeginsWith(arg1, arg2);
}
aContext->recycler()->getBoolResult(result, aResult);
return NS_OK;
}
case STRING:
{
nsRefPtr<StringResult> strRes;
rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
NS_ENSURE_SUCCESS(rv, rv);
if (!mParams.IsEmpty()) {
rv = mParams[0]->evaluateToString(aContext, strRes->mValue);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
txXPathNodeUtils::appendNodeValue(aContext->getContextNode(),
strRes->mValue);
}
NS_ADDREF(*aResult = strRes);
return NS_OK;
}
case STRING_LENGTH:
{
nsAutoString resultStr;
if (!mParams.IsEmpty()) {
rv = mParams[0]->evaluateToString(aContext, resultStr);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
txXPathNodeUtils::appendNodeValue(aContext->getContextNode(),
resultStr);
}
rv = aContext->recycler()->getNumberResult(resultStr.Length(),
aResult);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
case SUBSTRING:
{
nsAutoString src;
rv = mParams[0]->evaluateToString(aContext, src);
NS_ENSURE_SUCCESS(rv, rv);
double start;
rv = evaluateToNumber(mParams[1], aContext, &start);
NS_ENSURE_SUCCESS(rv, rv);
// check for NaN or +/-Inf
if (Double::isNaN(start) ||
Double::isInfinite(start) ||
start >= src.Length() + 0.5) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
start = floor(start + 0.5) - 1;
double end;
if (mParams.Length() == 3) {
rv = evaluateToNumber(mParams[2], aContext, &end);
NS_ENSURE_SUCCESS(rv, rv);
end += start;
if (Double::isNaN(end) || end < 0) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
if (end > src.Length())
end = src.Length();
else
end = floor(end + 0.5);
}
else {
end = src.Length();
}
if (start < 0)
start = 0;
if (start > end) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
return aContext->recycler()->getStringResult(
Substring(src, (PRUint32)start, (PRUint32)(end - start)),
aResult);
}
case SUBSTRING_AFTER:
{
nsAutoString arg1;
rv = mParams[0]->evaluateToString(aContext, arg1);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString arg2;
rv = mParams[1]->evaluateToString(aContext, arg2);
NS_ENSURE_SUCCESS(rv, rv);
if (arg2.IsEmpty()) {
return aContext->recycler()->getStringResult(arg1, aResult);
}
PRInt32 idx = arg1.Find(arg2);
if (idx == kNotFound) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
const nsSubstring& result = Substring(arg1, idx + arg2.Length());
return aContext->recycler()->getStringResult(result, aResult);
}
case SUBSTRING_BEFORE:
{
nsAutoString arg2;
rv = mParams[1]->evaluateToString(aContext, arg2);
NS_ENSURE_SUCCESS(rv, rv);
if (arg2.IsEmpty()) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
nsAutoString arg1;
rv = mParams[0]->evaluateToString(aContext, arg1);
NS_ENSURE_SUCCESS(rv, rv);
PRInt32 idx = arg1.Find(arg2);
if (idx == kNotFound) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
return aContext->recycler()->getStringResult(StringHead(arg1, idx),
aResult);
}
case TRANSLATE:
{
nsAutoString src;
rv = mParams[0]->evaluateToString(aContext, src);
NS_ENSURE_SUCCESS(rv, rv);
if (src.IsEmpty()) {
aContext->recycler()->getEmptyStringResult(aResult);
return NS_OK;
}
nsRefPtr<StringResult> strRes;
rv = aContext->recycler()->getStringResult(getter_AddRefs(strRes));
NS_ENSURE_SUCCESS(rv, rv);
strRes->mValue.SetCapacity(src.Length());
nsAutoString oldChars, newChars;
rv = mParams[1]->evaluateToString(aContext, oldChars);
NS_ENSURE_SUCCESS(rv, rv);
rv = mParams[2]->evaluateToString(aContext, newChars);
NS_ENSURE_SUCCESS(rv, rv);
PRUint32 i;
PRInt32 newCharsLength = (PRInt32)newChars.Length();
for (i = 0; i < src.Length(); i++) {
PRInt32 idx = oldChars.FindChar(src.CharAt(i));
if (idx != kNotFound) {
if (idx < newCharsLength)
strRes->mValue.Append(newChars.CharAt((PRUint32)idx));
}
else {
strRes->mValue.Append(src.CharAt(i));
}
}
NS_ADDREF(*aResult = strRes);
return NS_OK;
}
// Number functions
case NUMBER:
{
double res;
if (!mParams.IsEmpty()) {
rv = evaluateToNumber(mParams[0], aContext, &res);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
nsAutoString resultStr;
txXPathNodeUtils::appendNodeValue(aContext->getContextNode(),
resultStr);
res = Double::toDouble(resultStr);
}
return aContext->recycler()->getNumberResult(res, aResult);
}
case ROUND:
{
double dbl;
rv = evaluateToNumber(mParams[0], aContext, &dbl);
NS_ENSURE_SUCCESS(rv, rv);
if (!Double::isNaN(dbl) && !Double::isInfinite(dbl)) {
if (Double::isNeg(dbl) && dbl >= -0.5) {
dbl *= 0;
}
else {
dbl = floor(dbl + 0.5);
}
}
return aContext->recycler()->getNumberResult(dbl, aResult);
}
case FLOOR:
{
double dbl;
rv = evaluateToNumber(mParams[0], aContext, &dbl);
NS_ENSURE_SUCCESS(rv, rv);
if (!Double::isNaN(dbl) &&
!Double::isInfinite(dbl) &&
!(dbl == 0 && Double::isNeg(dbl))) {
dbl = floor(dbl);
}
return aContext->recycler()->getNumberResult(dbl, aResult);
}
case CEILING:
{
double dbl;
rv = evaluateToNumber(mParams[0], aContext, &dbl);
NS_ENSURE_SUCCESS(rv, rv);
if (!Double::isNaN(dbl) && !Double::isInfinite(dbl)) {
if (Double::isNeg(dbl) && dbl > -1) {
dbl *= 0;
}
else {
dbl = ceil(dbl);
}
}
return aContext->recycler()->getNumberResult(dbl, aResult);
}
case SUM:
{
nsRefPtr<txNodeSet> nodes;
nsresult rv = evaluateToNodeSet(mParams[0], aContext,
getter_AddRefs(nodes));
NS_ENSURE_SUCCESS(rv, rv);
double res = 0;
PRInt32 i;
for (i = 0; i < nodes->size(); ++i) {
nsAutoString resultStr;
txXPathNodeUtils::appendNodeValue(nodes->get(i), resultStr);
res += Double::toDouble(resultStr);
}
return aContext->recycler()->getNumberResult(res, aResult);
}
// Boolean functions
case BOOLEAN:
{
PRBool result;
nsresult rv = mParams[0]->evaluateToBool(aContext, result);
NS_ENSURE_SUCCESS(rv, rv);
aContext->recycler()->getBoolResult(result, aResult);
return NS_OK;
}
case _FALSE:
{
aContext->recycler()->getBoolResult(PR_FALSE, aResult);
return NS_OK;
}
case LANG:
{
txXPathTreeWalker walker(aContext->getContextNode());
nsAutoString lang;
PRBool found;
do {
found = walker.getAttr(txXMLAtoms::lang, kNameSpaceID_XML,
lang);
} while (!found && walker.moveToParent());
if (!found) {
aContext->recycler()->getBoolResult(PR_FALSE, aResult);
return NS_OK;
}
nsAutoString arg;
rv = mParams[0]->evaluateToString(aContext, arg);
NS_ENSURE_SUCCESS(rv, rv);
PRBool result =
StringBeginsWith(lang, arg,
txCaseInsensitiveStringComparator()) &&
(lang.Length() == arg.Length() ||
lang.CharAt(arg.Length()) == '-');
aContext->recycler()->getBoolResult(result, aResult);
return NS_OK;
}
case _NOT:
{
PRBool result;
rv = mParams[0]->evaluateToBool(aContext, result);
NS_ENSURE_SUCCESS(rv, rv);
aContext->recycler()->getBoolResult(!result, aResult);
return NS_OK;
}
case _TRUE:
{
aContext->recycler()->getBoolResult(PR_TRUE, aResult);
return NS_OK;
}
}
aContext->receiveError(NS_LITERAL_STRING("Internal error"),
NS_ERROR_UNEXPECTED);
return NS_ERROR_UNEXPECTED;
}
/*
* Evaluates this Expr based on the given context node and processor state
* NOTE: the implementation is incomplete since it does not make use of the
* second argument (base URI)
* @param context the context node for evaluation of this Expr
* @return the result of the evaluation
*/
nsresult
DocumentFunctionCall::evaluate(txIEvalContext* aContext,
txAExprResult** aResult)
{
*aResult = nsnull;
txExecutionState* es =
static_cast<txExecutionState*>(aContext->getPrivateContext());
nsRefPtr<txNodeSet> nodeSet;
nsresult rv = aContext->recycler()->getNodeSet(getter_AddRefs(nodeSet));
NS_ENSURE_SUCCESS(rv, rv);
// document(object, node-set?)
if (!requireParams(1, 2, aContext)) {
return NS_ERROR_XPATH_BAD_ARGUMENT_COUNT;
}
nsRefPtr<txAExprResult> exprResult1;
rv = mParams[0]->evaluate(aContext, getter_AddRefs(exprResult1));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString baseURI;
MBool baseURISet = MB_FALSE;
if (mParams.Length() == 2) {
// We have 2 arguments, get baseURI from the first node
// in the resulting nodeset
nsRefPtr<txNodeSet> nodeSet2;
rv = evaluateToNodeSet(mParams[1],
aContext, getter_AddRefs(nodeSet2));
NS_ENSURE_SUCCESS(rv, rv);
// Make this true, even if nodeSet2 is empty. For relative URLs,
// we'll fail to load the document with an empty base URI, and for
// absolute URLs, the base URI doesn't matter
baseURISet = MB_TRUE;
if (!nodeSet2->isEmpty()) {
txXPathNodeUtils::getBaseURI(nodeSet2->get(0), baseURI);
}
}
if (exprResult1->getResultType() == txAExprResult::NODESET) {
// The first argument is a NodeSet, iterate on its nodes
txNodeSet* nodeSet1 = static_cast<txNodeSet*>
(static_cast<txAExprResult*>
(exprResult1));
PRInt32 i;
for (i = 0; i < nodeSet1->size(); ++i) {
const txXPathNode& node = nodeSet1->get(i);
nsAutoString uriStr;
txXPathNodeUtils::appendNodeValue(node, uriStr);
if (!baseURISet) {
// if the second argument wasn't specified, use
// the baseUri of node itself
txXPathNodeUtils::getBaseURI(node, baseURI);
}
retrieveNode(es, uriStr, baseURI, nodeSet);
}
NS_ADDREF(*aResult = nodeSet);
return NS_OK;
}
// The first argument is not a NodeSet
nsAutoString uriStr;
exprResult1->stringValue(uriStr);
const nsAString* base = baseURISet ? &baseURI : &mBaseURI;
retrieveNode(es, uriStr, *base, nodeSet);
NS_ADDREF(*aResult = nodeSet);
return NS_OK;
}
